Từ mô hình ngôn ngữ đến trí tuệ đa phương thức: Một sự chuyển đổi
Trong hành trình phát triển của trí tuệ nhân tạo, chúng ta đã chứng kiến sự tiến hóa từ các hệ thống dựa trên quy tắc đến học thống kê, và sau đó là học sâu. Hiện tại, chúng ta đang đứng trước một bước ngoặt mới: chuyển từ các hệ thống AI tập trung vào một phương thức đơn lẻ (như văn bản, hình ảnh hoặc giọng nói) sang trí tuệ đa phương thức tổng quát, có khả năng hiểu và tổng hợp nhiều dạng thông tin khác nhau. Dòng mô hình Gemini của Google và API của chúng chính là đại diện nổi bật cho xu hướng này. Đây không chỉ là một API mô hình ngôn ngữ lớn khác, mà là một nền tảng trí tuệ đa phương thức định nghĩa lại mô hình tương tác giữa con người và máy tính.
Các API truyền thống, như dòng GPT của OpenAI, dù mạnh mẽ nhưng chủ yếu xử lý đầu vào và đầu ra dạng văn bản. Điểm cách mạng của Gemini nằm ở kiến trúc đa phương thức nguyên bản của nó—ngay từ giai đoạn huấn luyện, nó đã xử lý nhiều loại dữ liệu như văn bản, hình ảnh, âm thanh, và video. Triết lý thiết kế này mang lại cho Gemini lợi thế độc đáo trong các tác vụ hiểu và tạo nội dung đa phương thức. Bài viết này sẽ đi sâu vào kiến trúc kỹ thuật của Gemini API, các kịch bản ứng dụng thực tế, và cách khai thác tối đa khả năng đa phương thức của nó trong quá trình phát triển.
Kiến trúc mô hình Gemini: Phân tích thiết kế đa phương thức nguyên bản
Đổi mới kiến trúc cốt lõi
Đổi mới cốt lõi của Gemini nằm ở kiến trúc "đa phương thức nguyên bản". Không giống như phương pháp "đa phương thức kết hợp" xử lý riêng biệt từng phương thức rồi hợp nhất, Gemini thống nhất xử lý nhiều loại dữ liệu ngay từ lớp đầu vào. Ưu điểm của thiết kế này bao gồm:
- Hiểu sâu rộng giữa các phương thức: Mô hình có thể thực sự hiểu mối quan hệ ngữ nghĩa giữa các đối tượng trong hình ảnh và mô tả văn bản.
- Truyền tải thông tin hiệu quả: Tránh mất mát thông tin trong quá trình xử lý nhiều giai đoạn.
- Kết hợp đầu vào linh hoạt: Hỗ trợ bất kỳ sự kết hợp nào của đầu vào văn bản, hình ảnh, âm thanh.
Dưới đây là một ví dụ minh họa cách Gemini xử lý đầu vào đa phương thức:
import google.generativeai as genai
from PIL import Image
import json
# Cấu hình API key của bạn
genai.configure(api_key="YOUR_API_KEY")
def tao_yeu_cau_da_phuong_thuc():
"""Tạo một yêu cầu đa phương thức phức tạp bao gồm văn bản và hình ảnh."""
# Tải hình ảnh (ví dụ: một sơ đồ kỹ thuật)
hinh_anh_ky_thuat = Image.open("so_do_ky_thuat.png")
# Xây dựng các phần của yêu cầu
cac_phan_yeu_cau = [
"Phân tích sơ đồ kiến trúc này:", hinh_anh_ky_thuat,
"\nDựa trên kiến trúc này, hãy trả lời các câu hỏi sau:",
"1. Mô tả luồng dữ liệu chính.",
"2. Xác định các điểm nghẽn hiệu suất tiềm ẩn.",
"3. Đề xuất hai cải tiến tối ưu.",
"4. Tạo mô tả về sơ đồ kiến trúc đã cải tiến."
]
return cac_phan_yeu_cau
# Khởi tạo mô hình Gemini
mo_hinh_gemini = genai.GenerativeModel('gemini-1.5-pro')
phan_hoi = mo_hinh_gemini.generate_content(tao_yeu_cau_da_phuong_thuc())
def phan_tich_phan_hoi_ky_thuat(chuoi_phan_hoi):
"""Phân tích nội dung phản hồi kỹ thuật từ mô hình Gemini."""
# Gemini có thể trả về nội dung có cấu trúc hoặc bán cấu trúc
cac_dong = chuoi_phan_hoi.split('\n')
ket_qua_phan_tich = {
'luong_du_lieu': '',
'diem_nghen': [],
'de_xuat_cai_tien': [],
'mo_ta_kien_truc_cai_tien': ''
}
# Logic phân tích thực tế sẽ tùy chỉnh theo định dạng phản hồi
# Đoạn này minh họa ý tưởng phân tích cơ bản
phan_hien_tai = None
for dong in cac_dong:
if 'luồng dữ liệu' in dong:
phan_hien_tai = 'luong_du_lieu'
elif 'điểm nghẽn hiệu suất' in dong:
phan_hien_tai = 'diem_nghen'
elif 'tối ưu' in dong:
phan_hien_tai = 'de_xuat_cai_tien'
elif 'kiến trúc đã cải tiến' in dong:
phan_hien_tai = 'mo_ta_kien_truc_cai_tien'
elif phan_hien_tai and dong.strip():
if phan_hien_tai in ['diem_nghen', 'de_xuat_cai_tien']:
ket_qua_phan_tich[phan_hien_tai].append(dong.strip())
else:
ket_qua_phan_tich[phan_hien_tai] += dong + '\n'
return ket_qua_phan_tich
Ngữ cảnh dài và khả năng suy luận nâng cao
Phiên bản Gemini 1.5 Pro giới thiệu cửa sổ ngữ cảnh đột phá lên tới 1 triệu token, mang lại lợi thế đáng kể khi xử lý các tài liệu dài, kho mã phức tạp hoặc các cuộc hội thoại nhiều lượt:
import google.generativeai as genai
import re
import io
# Cấu hình API key của bạn
genai.configure(api_key="YOUR_API_KEY")
def xu_ly_tai_lieu_lon_voi_gemini(duong_dan_tai_lieu):
"""
Xử lý một tài liệu kỹ thuật lớn bằng Gemini để trích xuất thông tin cấu trúc.
"""
# Mô phỏng tải tài liệu dài (ví dụ: đặc tả kỹ thuật, bài báo khoa học)
# Trong thực tế, bạn sẽ đọc toàn bộ nội dung từ duong_dan_tai_lieu
# Đối với PDF, bạn sẽ cần thư viện như PyPDF2 để trích xuất văn bản
noi_dung_tai_lieu = ""
try:
with open(duong_dan_tai_lieu, "r", encoding="utf-8") as f: # Giả định là file text
noi_dung_tai_lieu = f.read()
except FileNotFoundError:
print(f"Lỗi: Không tìm thấy file tại {duong_dan_tai_lieu}")
return None
# Giới hạn nội dung nếu quá lớn cho ví dụ (1 triệu token là rất lớn)
noi_dung_da_cat = noi_dung_tai_lieu[:min(len(noi_dung_tai_lieu), 1000000 * 4)] # Ước tính 1 token ~ 4 ký tự
# Tạo thể hiện mô hình, kích hoạt hỗ trợ ngữ cảnh dài
mo_hinh_ngu_canh_dai = genai.GenerativeModel(
'gemini-1.5-pro',
generation_config={
"max_output_tokens": 8192,
"temperature": 0.2, # Nhiệt độ thấp cho phản hồi chính xác hơn
}
)
# Xây dựng tác vụ phân tích phức tạp
yeu_cau_phan_tich = f"""
Hãy phân tích tài liệu đặc tả kỹ thuật sau đây và hoàn thành các nhiệm vụ:
1. Trích xuất tất cả các định nghĩa giao diện API, bao gồm:
- Đường dẫn endpoint
- Phương thức HTTP
- Tham số yêu cầu
- Định dạng phản hồi
- Mã lỗi
2. Xác định các yêu cầu và đề xuất bảo mật.
3. Tạo một danh sách kiểm tra tuân thủ.
Nội dung tài liệu:
{noi_dung_da_cat}
"""
phan_hoi = mo_hinh_ngu_canh_dai.generate_content(yeu_cau_phan_tich)
# Hậu xử lý: chuyển phản hồi thành dữ liệu có cấu trúc
return trich_xuat_du_lieu_cau_truc(phan_hoi.text)
def trich_xuat_du_lieu_cau_truc(chuoi_phan_hoi):
"""Chuyển đổi phản hồi ngôn ngữ tự nhiên của Gemini thành dữ liệu có cấu trúc."""
# Sử dụng biểu thức chính quy hoặc bộ phân tích cú pháp tùy chỉnh để trích xuất thông tin
mau_API = {
'endpoint': r'Đường dẫn endpoint[:：]\s*(.*?)(?:\n|$)',
'phuong_thuc': r'Phương thức HTTP[:：]\s*(GET|POST|PUT|DELETE|PATCH)',
'tham_so': r'Tham số yêu cầu[:：]\s*(.*?)(?:\n\n|\Z)',
'phan_hoi': r'Định dạng phản hồi[:：]\s*(.*?)(?:\n\n|\Z)',
'ma_loi': r'Mã lỗi[:：]\s*(.*?)(?:\n\n|\Z)',
}
cac_API_tim_thay = []
API_hien_tai = {}
cac_dong = chuoi_phan_hoi.split('\n')
for dong in cac_dong:
for key, pattern in mau_API.items():
match = re.search(pattern, dong)
if match:
API_hien_tai[key] = match.group(1).strip()
# Một dòng phân tách hoặc khi một API hoàn chỉnh đã được tìm thấy
if dong.strip() == "---" and API_hien_tai: # Hoặc logic phân tách khác
cac_API_tim_thay.append(API_hien_tai.copy())
API_hien_tai = {} # Reset cho API tiếp theo
elif "Endpoint:" in dong and API_hien_tai: # Reset nếu gặp endpoint mới mà chưa hoàn thành API trước
cac_API_tim_thay.append(API_hien_tai.copy())
API_hien_tai = {}
if API_hien_tai: # Đảm bảo thêm API cuối cùng nếu có
cac_API_tim_thay.append(API_hien_tai)
return {'cac_API': cac_API_tim_thay}
Kịch bản ứng dụng thực tế: Giải pháp đa phương thức vượt xa chatbot
Hệ thống xử lý tài liệu kỹ thuật thông minh
Xử lý tài liệu kỹ thuật truyền thống thường dựa vào OCR và phân tích văn bản đơn giản. Khả năng đa phương thức của Gemini cho phép nó thực sự hiểu các biểu đồ, sơ đồ quy trình và hình minh họa kỹ thuật trong tài liệu, mang lại sự hiểu biết sâu sắc hơn.
import google.generativeai as genai
from PIL import Image
import json
import os
class BoXuLyTaiLieuKyThuat:
def __init__(self, key_api):
genai.configure(api_key=key_api)
self.mo_hinh = genai.GenerativeModel('gemini-1.5-pro')
def phan_tich_so_do_voi_ngu_canh(self, duong_dan_so_do, tai_lieu_ngu_canh):
"""
Phân tích sơ đồ kiến trúc kỹ thuật kết hợp với các tài liệu ngữ cảnh liên quan.
"""
# Đọc sơ đồ
so_do_hinh_anh = Image.open(duong_dan_so_do)
# Xây dựng yêu cầu với ngữ cảnh
yeu_cau = f"""
Với vai trò kiến trúc sư hệ thống, hãy phân tích sơ đồ kiến trúc này.
Thông tin nền tảng liên quan:
{tai_lieu_ngu_canh}
Nhiệm vụ cụ thể:
1. Xác định tất cả các thành phần trong sơ đồ và mối quan hệ của chúng.
2. Đánh giá liệu kiến trúc có tuân thủ các thực tiễn tốt nhất của microservices không.
3. Tìm ra các rủi ro điểm lỗi duy nhất.
4. Đề xuất các cải tiến cụ thể.
Vui lòng trả về kết quả phân tích dưới định dạng JSON.
"""
phan_hoi = self.mo_hinh.generate_content([yeu_cau, so_do_hinh_anh])
# Phân tích và xác thực phản hồi
try:
ket_qua_phan_tich = json.loads(phan_hoi.text)
return self._xac_thuc_phan_tich(ket_qua_phan_tich)
except json.JSONDecodeError:
# Nếu phản hồi không phải JSON chuẩn, sử dụng phương pháp dự phòng
return self._phan_tich_du_phong(phan_hoi.text)
def tao_tai_lieu_tu_ma_nguon(self, duong_dan_kho_ma):
"""
Tạo tài liệu kỹ thuật hoàn chỉnh từ một kho mã nguồn.
"""
# Đọc các tệp mã nguồn
cac_tep_ma = self._doc_cac_tep_ma(duong_dan_kho_ma)
yeu_cau_tai_lieu = """
Dựa trên kho mã nguồn dưới đây, hãy tạo tài liệu kỹ thuật hoàn chỉnh:
1. Tổng quan kiến trúc hệ thống
2. Mô tả các module cốt lõi
3. Tài liệu API
4. Hướng dẫn triển khai
5. Hướng dẫn xử lý sự cố
Vui lòng sử dụng định dạng tài liệu kỹ thuật chuyên nghiệp.
"""
phan_hoi = self.mo_hinh.generate_content([yeu_cau_tai_lieu, *cac_tep_ma])
return self._dinh_dang_tai_lieu(phan_hoi.text)
def _doc_cac_tep_ma(self, duong_dan):
"""Đọc nội dung từ tất cả các tệp mã trong một thư mục."""
# Đây là một hàm giả định, trong thực tế bạn sẽ cần duyệt qua thư mục
# và đọc nội dung của các tệp (ví dụ: .py, .java, .js)
noi_dung_cac_tep = []
# Ví dụ đơn giản: đọc một file giả định
if os.path.exists(duong_dan) and os.path.isfile(duong_dan):
with open(duong_dan, 'r', encoding='utf-8') as f:
noi_dung_cac_tep.append(f.read())
elif os.path.isdir(duong_dan):
for root, _, files in os.walk(duong_dan):
for file_name in files:
if file_name.endswith(('.py', '.java', '.js', '.ts', '.cs')): # Chỉ đọc các loại file mã
file_path = os.path.join(root, file_name)
try:
with open(file_path, 'r', encoding='utf-8') as f:
noi_dung_cac_tep.append(f"File: {file_name}\n```\n{f.read()}\n```\n")
except Exception as e:
print(f"Không thể đọc file {file_path}: {e}")
return noi_dung_cac_tep
def _xac_thuc_phan_tich(self, phan_tich):
"""Xác thực tính toàn vẹn của kết quả phân tích."""
cac_truong_bat_buoc = ['thanh_phan', 'thuc_tien_tot_nhat', 'rui_ro', 'de_xuat_cai_tien']
for truong in cac_truong_bat_buoc:
if truong not in phan_tich:
phan_tich[truong] = [] # Đảm bảo các trường tồn tại
return phan_tich
def _phan_tich_du_phong(self, van_ban):
"""Phân tích dự phòng nếu phản hồi không phải JSON."""
# Logic phân tích ngôn ngữ tự nhiên cơ bản
ket_qua = {
'tong_quan': 'Không thể phân tích JSON, đây là phản hồi thô:',
'noi_dung_tho': van_ban
}
# Có thể thêm logic regex để cố gắng trích xuất một số phần
return ket_qua
def _dinh_dang_tai_lieu(self, van_ban):
"""Định dạng phản hồi tài liệu đã tạo."""
# Có thể thêm định dạng Markdown, tiêu đề, v.v.
return f"<h1>Tài liệu Kỹ thuật Tự Động Tạo</h1>\n{van_ban}"
Phương pháp đa phương thức trong tạo và đánh giá mã
Gemini không chỉ có khả năng tạo mã mà còn hiểu mối quan hệ giữa mã, tài liệu thiết kế liên quan và sơ đồ kiến trúc, từ đó cung cấp các đề xuất mã chính xác hơn.
import com.google.cloud.generativeai.v1beta.Content;
import com.google.cloud.generativeai.v1beta.ContentPart;
import com.google.cloud.generativeai.v1beta.GenerateContentResponse;
import com.google.cloud.generativeai.v1beta.GenerativeModelServiceClient;
import com.google.protobuf.ByteString;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.List;
// Giả định có một GeminiService bao bọc GenerativeModelServiceClient
// để đơn giản hóa việc gọi API.
public class TroLyMaGemini {
private final GenerativeModelServiceClient geminiClient; // Sử dụng Client SDK thực tế
public TroLyMaGemini() throws IOException {
// Khởi tạo client Gemini. Trong môi trường thực, bạn sẽ quản lý API Key/Auth an toàn hơn.
this.geminiClient = GenerativeModelServiceClient.create();
}
/**
* Tạo mã nguồn dựa trên sơ đồ kiến trúc và yêu cầu.
*/
public String taoMaTuKienTruc(File soDoKienTruc,
String yeuCauChucNang) throws IOException {
// Tạo các phần nội dung đa phương thức
List<ContentPart> cacPhanNoiDung = new ArrayList<>();
cacPhanNoiDung.add(ContentPart.newBuilder()
.setText("Dựa trên sơ đồ kiến trúc và các yêu cầu sau, hãy tạo mã nguồn:\n" + yeuCauChucNang)
.build());
cacPhanNoiDung.add(ContentPart.newBuilder()
.setInlineData(ContentPart.InlineData.newBuilder()
.setMimeType("image/png")
.setData(ByteString.copyFrom(Files.readAllBytes(
soDoKienTruc.toPath())))
.build())
.build());
// Chỉ định tạo mã Java với các yêu cầu cụ thể
cacPhanNoiDung.add(ContentPart.newBuilder()
.setText("""
Vui lòng tạo mã Java tuân thủ các yêu cầu sau:
1. Tuân thủ các thực tiễn tốt nhất của Spring Boot.
2. Bao gồm xử lý lỗi đầy đủ.
3. Thêm các chú thích cần thiết.
4. Đảm bảo mã có thể kiểm thử.
Chỉ trả về mã nguồn, không bao gồm giải thích.
""")
.build());
Content requestContent = Content.newBuilder().addAllParts(cacPhanNoiDung).build();
GenerateContentResponse phanHoi = geminiClient.generateContent(
"models/gemini-1.5-pro", // Tên mô hình
requestContent
);
return phanHoi.getCandidates(0).getContent().getParts(0).getText(); // Trả về mã nguồn
}
/**
* Đánh giá mã nguồn, kết hợp với các quy định kiến trúc.
*/
public KetQuaDanhGiaMa danhGiaMaVoiKienTruc(String maNguon,
File quyDinhKienTruc) throws IOException {
// Xây dựng yêu cầu đa phương thức bao gồm mã và quy định kiến trúc
String yeuCauDanhGia = """
Vui lòng đánh giá mã Java sau đây để đảm bảo nó tuân thủ các quy định kiến trúc:
Các điểm đánh giá mã:
1. Có tuân thủ thiết kế trong sơ đồ kiến trúc không?
2. Có tồn tại vấn đề về hiệu suất không?
3. Kiểm tra các lỗ hổng bảo mật.
4. Đánh giá khả năng bảo trì của mã.
Vui lòng cung cấp các đề xuất sửa đổi cụ thể.
""";
Content requestContent = Content.newBuilder()
.addParts(ContentPart.newBuilder().setText(yeuCauDanhGia).build())
.addParts(ContentPart.newBuilder().setText(maNguon).build())
.addParts(ContentPart.newBuilder()
.setInlineData(ContentPart.InlineData.newBuilder()
.setMimeType("application/pdf") // Có thể là PDF hoặc các định dạng tài liệu khác
.setData(ByteString.copyFrom(
Files.readAllBytes(quyDinhKienTruc.toPath())))
.build())
.build())
.build();
GenerateContentResponse phanHoi = geminiClient.generateContent(
"models/gemini-1.5-pro",
requestContent
);
return phanTichKetQuaDanhGia(phanHoi.getCandidates(0).getContent().getParts(0).getText());
}
// Lớp giả định cho kết quả đánh giá
static class KetQuaDanhGiaMa {
public String tongQuan;
public List<String> vanDe;
public List<String> deXuat;
// Constructor, getters/setters...
public KetQuaDanhGiaMa(String tongQuan, List<String> vanDe, List<String> deXuat) {
this.tongQuan = tongQuan;
this.vanDe = vanDe;
this.deXuat = deXuat;
}
}
private KetQuaDanhGiaMa phanTichKetQuaDanhGia(String vanBanPhanHoi) {
// Logic để phân tích chuỗi văn bản thành đối tượng KetQuaDanhGiaMa
// Có thể sử dụng regex hoặc các thư viện phân tích JSON nếu Gemini được hướng dẫn trả về JSON
String tongQuan = "Tổng quan đánh giá: " + vanBanPhanHoi.substring(0, Math.min(vanBanPhanHoi.length(), 100)) + "...";
List<String> vanDe = new ArrayList<>();
List<String> deXuat = new ArrayList<>();
// Một cách đơn giản để trích xuất: tìm các dòng bắt đầu với số hoặc dấu gạch đầu dòng
for (String dong : vanBanPhanHoi.split("\n")) {
if (dong.startsWith("1.") || dong.startsWith("- Vấn đề:") || dong.startsWith("Vấn đề:")) {
vanDe.add(dong.trim());
} else if (dong.startsWith("1.") || dong.startsWith("- Đề xuất:") || dong.startsWith("Đề xuất:")) {
deXuat.add(dong.trim());
}
}
if (vanDe.isEmpty() && deXuat.isEmpty()) { // Fallback nếu không tìm thấy mẫu cụ thể
vanDe.add("Xem xét toàn bộ phản hồi để biết chi tiết: " + vanBanPhanHoi);
}
return new KetQuaDanhGiaMa(tongQuan, vanDe, deXuat);
}
}
Tính năng nâng cao: Tinh chỉnh và tích hợp kiến thức tùy chỉnh
Khả năng tinh chỉnh của Gemini API
Mặc dù Gemini API hiện không cung cấp API tinh chỉnh (fine-tuning) tương tự như GPT-3.5/4, nó cung cấp khả năng tùy chỉnh mạnh mẽ thông qua các chỉ thị hệ thống (system instructions) và học theo ngữ cảnh (in-context learning).
import google.generativeai as genai
from PIL import Image
import json
import os
class TroLyGeminiTuyChinh:
def __init__(self, key_api, duong_dan_co_so_tri_thuc):
self.key_api = key_api
genai.configure(api_key=key_api)
# Tải cơ sở tri thức tùy chỉnh
self.co_so_tri_thuc = self._tai_co_so_tri_thuc(duong_dan_co_so_tri_thuc)
# Tạo mô hình với chỉ thị hệ thống
self.mo_hinh_tuy_chinh = genai.GenerativeModel(
'gemini-1.5-pro',
system_instruction=self._tao_chi_thi_he_thong()
)
def _tai_co_so_tri_thuc(self, duong_dan):
"""Tải cơ sở tri thức từ một tệp JSON hoặc khác."""
# Ví dụ: một tệp JSON chứa các tiêu chuẩn, quy tắc của công ty
if os.path.exists(duong_dan):
with open(duong_dan, 'r', encoding='utf-8') as f:
return json.load(f)
return {'company_standards': 'Không có tiêu chuẩn cụ thể được tải.'}
def _tao_chi_thi_he_thong(self):
"""Tạo chỉ thị hệ thống chứa kiến thức và quy tắc cụ thể cho miền."""
huong_dan = f"""
Bạn là một trợ lý hệ thống FinTech chuyên nghiệp, có kiến thức chuyên môn sau:
Kiến thức miền:
1. Kiến trúc hệ thống thanh toán.
2. Mô hình quản lý rủi ro.
3. Yêu cầu tuân thủ (PCI-DSS, GDPR).
4. Thiết kế hệ thống giao dịch hiệu suất cao.
Quy định cụ thể của công ty:
{self.co_so_tri_thuc.get('company_standards', 'N/A')}
Nguyên tắc trả lời:
1. Ưu tiên tham khảo cơ sở tri thức của công ty.
2. Yêu cầu làm rõ khi không chắc chắn.
3. Cung cấp các đề xuất cụ thể, có thể thực hiện được.
4. Luôn xem xét bảo mật và tuân thủ.
Định dạng phản hồi:
- Sử dụng thuật ngữ kỹ thuật chuyên nghiệp.
- Bao gồm các ví dụ mã cụ thể.
- Cung cấp mô tả sơ đồ kiến trúc.
- Ghi chú các giả định và hạn chế.
"""
return huong_dan
def truy_van_voi_ngu_canh(self, cau_hoi, cac_tep_ngu_canh=None):
"""Thực hiện truy vấn dựa trên ngữ cảnh và các tệp liên quan."""
cac_noi_dung = [cau_hoi]
# Thêm các tệp ngữ cảnh (hình ảnh, văn bản)
if cac_tep_ngu_canh:
for duong_dan_tep in cac_tep_ngu_canh:
if duong_dan_tep.lower().endswith(('.png', '.jpg', '.jpeg')):
img = Image.open(duong_dan_tep)
cac_noi_dung.append(img)
else:
try:
with open(duong_dan_tep, 'r', encoding='utf-8') as f:
cac_noi_dung.append(f.read())
except Exception as e:
print(f"Lỗi khi đọc tệp ngữ cảnh {duong_dan_tep}: {e}")
# Thiết lập cấu hình tạo nội dung
cau_hinh_tao_noi_dung = {
"temperature": 0.1, # Nhiệt độ thấp cho phản hồi chắc chắn hơn
"top_p": 0.95,
"top_k": 40,
"max_output_tokens": 4096,
}
phan_hoi = self.mo_hinh_tuy_chinh.generate_content(
cac_noi_dung,
generation_config=cau_hinh_tao_noi_dung,
stream=False
)
return self._hau_xu_ly_phan_hoi(phan_hoi.text)
def _hau_xu_ly_phan_hoi(self, phan_hoi_tho):
"""Thực hiện các bước hậu xử lý trên phản hồi của mô hình."""
# Có thể bao gồm kiểm tra tính hợp lệ, định dạng lại, v.v.
return phan_hoi_tho
Thực hiện Kiến trúc RAG (Retrieval-Augmented Generation) cấp doanh nghiệp
Để nâng cao hơn nữa khả năng của Gemini, chúng ta có thể tích hợp nó với một hệ thống RAG (Retrieval-Augmented Generation) cấp doanh nghiệp. Điều này cho phép mô hình truy cập và tổng hợp thông tin từ một kho kiến thức lớn, độc quyền và luôn cập nhật, vượt qua giới hạn của dữ liệu huấn luyện ban đầu.
import google.generativeai as genai
import asyncio # Đối với các hoạt động bất đồng bộ
from PIL import Image # Để xử lý hình ảnh liên quan
import os # Để kiểm tra sự tồn tại của file
# Giả định có một VectorStoreClient đã được cấu hình
class VectorStoreClient:
async def tim_kiem_tai_lieu(self, truy_van_van_ban, so_luong=3):
"""Mô phỏng tìm kiếm tài liệu liên quan từ vector database."""
# Trong thực tế, bạn sẽ gửi truy vấn đến một vector DB như ChromaDB, Pinecone, Weaviate
# và nhận về các đoạn văn bản liên quan.
print(f"Đang tìm kiếm tài liệu cho: '{truy_van_van_ban}'...")
await asyncio.sleep(0.5) # Mô phỏng độ trễ I/O
return [
f"Tài liệu kỹ thuật A: Chi tiết triển khai microservice X. Đoạn văn liên quan đến '{truy_van_van_ban}'.",
f"Hướng dẫn vận hành B: Cách xử lý lỗi trong hệ thống Y. Đoạn văn liên quan đến '{truy_van_van_ban}'.",
f"Báo cáo thiết kế C: Phân tích hiệu suất của mô-đun Z. Đoạn văn liên quan đến '{truy_van_van_ban}'."
]
async def tim_kiem_media_lien_quan(self, tai_lieu_lien_quan):
"""Mô phỏng tìm kiếm hình ảnh/biểu đồ liên quan dựa trên tài liệu."""
# Trong thực tế, bạn có thể lưu trữ nhúng của hình ảnh và tìm kiếm chúng
print(f"Đang tìm kiếm media liên quan đến tài liệu...")
await asyncio.sleep(0.3)
# Giả định trả về một đối tượng hình ảnh hoặc đường dẫn
if "microservice X" in tai_lieu_lien_quan[0]:
try:
# Đảm bảo có file 'so_do_microservice_X.png' trong cùng thư mục để ví dụ này chạy
if os.path.exists("so_do_microservice_X.png"):
return [Image.open("so_do_microservice_X.png")]
else:
print("Lưu ý: Không tìm thấy 'so_do_microservice_X.png' cho ví dụ RAG.")
return []
except Exception as e:
print(f"Lỗi khi tải hình ảnh: {e}")
return []
return []
class HeThongRAGDoanhNghiep:
def __init__(self, key_api_gemini, duong_dan_db_vector_gia):
genai.configure(api_key=key_api_gemini)
self.mo_hinh_gemini = genai.GenerativeModel('gemini-1.5-pro')
self.kho_vector = VectorStoreClient() # Khởi tạo client vector store giả định
async def truy_van_va_tao_noi_dung(self, truy_van, su_dung_da_phuong_thuc=True):
"""
Thực hiện truy vấn nâng cao bằng cách kết hợp truy xuất thông tin và tạo nội dung.
"""
# 1. Truy xuất các tài liệu liên quan
cac_tai_lieu_da_truy_xuat = await self.kho_vector.tim_kiem_tai_lieu(truy_van)
# 2. Nếu bật chế độ đa phương thức, xử lý hình ảnh/biểu đồ liên quan
cac_noi_dung_da_phuong_thuc = []
if su_dung_da_phuong_thuc:
cac_noi_dung_da_phuong_thuc = await self.kho_vector.tim_kiem_media_lien_quan(cac_tai_lieu_da_truy_xuat)
# 3. Xây dựng yêu cầu được bổ sung
yeu_cau_tang_cuong = self._xay_dung_yeu_cau_tang_cuong(
truy_van, cac_tai_lieu_da_truy_xuat, cac_noi_dung_da_phuong_thuc
)
# 4. Gọi Gemini để tạo phản hồi
phan_hoi_gemini = self.mo_hinh_gemini.generate_content(yeu_cau_tang_cuong)
# 5. Thêm nguồn trích dẫn
phan_hoi_cuoi_cung = self._them_nguon_trich_dan(phan_hoi_gemini.text, cac_tai_lieu_da_truy_xuat)
return phan_hoi_cuoi_cung
def _xay_dung_yeu_cau_tang_cuong(self, truy_van, tai_lieu, media=None):
"""Xây dựng yêu cầu được bổ sung cho mô hình Gemini."""
cac_phan_yeu_cau = [
"Dựa trên các thông tin tham khảo dưới đây, hãy trả lời câu hỏi:\n\n",
"Tài liệu tham khảo:\n",
*[f"[Tài liệu {i+1}]: {doc}\n\n" for i, doc in enumerate(tai_lieu)],
"\nCâu hỏi: ", truy_van,
"\n\nYêu cầu:",
"1. Trả lời nghiêm ngặt dựa trên thông tin tham khảo được cung cấp.",
"2. Nếu thông tin không đủ, hãy nêu rõ.",
"3. Trích dẫn số tài liệu cụ thể.",
"4. Giữ câu trả lời chuyên nghiệp và chính xác."
]
if media:
cac_phan_yeu_cau.extend(["\n\nHình ảnh tham khảo liên quan:", *media])
return cac_phan_yeu_cau
def _them_nguon_trich_dan(self, phan_hoi_text, tai_lieu_tham_khao):
"""Thêm các trích dẫn vào phản hồi cuối cùng."""
# Logic đơn giản để thêm "Nguồn: [Tài liệu X], [Tài liệu Y]"
citations = ", ".join([f"Tài liệu {i+1}" for i, _ in enumerate(tai_lieu_tham_khao)])
return f"{phan_hoi_text}\n\nNguồn tham khảo: {citations}"
Tối ưu hóa hiệu suất và thực tiễn tốt nhất
Các chiến lược tối ưu hóa chi phí
Khi làm việc với Gemini API, việc quản lý chi phí là rất quan trọng. Các chiến lược tối ưu hóa sau đây có thể giúp giảm thiểu chi phí mà vẫn duy trì hiệu quả:
- Lựa chọn mô hình phù hợp: Sử dụng các mô hình nhẹ hơn như
gemini-1.5-flashcho các tác vụ đơn giản hơn để giảm chi phí token. - Tối ưu hóa lời nhắc (Prompt Engineering): Thiết kế lời nhắc ngắn gọn, rõ ràng để giảm số lượng token đầu vào và đầu ra không cần thiết.
- Quản lý ngữ cảnh: Chỉ đưa những thông tin thực sự cần thiết vào ngữ cảnh. Đối với các cuộc hội thoại dài, hãy sử dụng kỹ thuật tóm tắt hoặc cửa sổ trượt (sliding window) để giữ ngữ cảnh luôn ở mức tối thiểu.
- Caching phản hồi: Lưu trữ các phản hồi từ Gemini cho các truy vấn lặp lại để tránh gọi API nhiều lần.
- Giám sát và phân tích mức sử dụng: Sử dụng công cụ giám sát để theo dõi số lượng token đã sử dụng, số lượng hình ảnh/video được xử lý và ước tính chi phí.
Dưới đây là một công cụ giả định để hỗ trợ tối ưu hóa chi phí:
import google.generativeai as genai
class BoToiUuChiPhiGemini:
def __init__(self, key_api):
self.api_key = key_api
genai.configure(api_key=key_api)
self.thong_ke_su_dung = {
'tong_tokens_su_dung': 0,
'so_hinh_anh_xu_ly': 0,
'uoc_tinh_chi_phi': 0.0,
'mo_hinh_hien_tai': 'gemini-1.5-pro' # Mặc định
}
# Giá giả định (cần cập nhật theo giá thực tế của Google)
self.gia_moi_token_input_pro = 0.000007 / 1000 # Ví dụ: $0.007 / 1K input tokens
self.gia_moi_token_output_pro = 0.000021 / 1000 # Ví dụ: $0.021 / 1K output tokens
self.gia_moi_token_input_flash = 0.00000035 / 1000 # Ví dụ: $0.00035 / 1K input tokens
self.gia_moi_token_output_flash = 0.00000105 / 1000 # Ví dụ: $0.00105 / 1K output tokens
def cap_nhat_su_dung(self, tokens_input, tokens_output, mo_hinh_su_dung):
"""Cập nhật thống kê sử dụng và ước tính chi phí."""
self.thong_ke_su_dung['tong_tokens_su_dung'] += (tokens_input + tokens_output)
gia_input = 0
gia_output = 0
if mo_hinh_su_dung == 'gemini-1.5-pro':
gia_input = tokens_input * self.gia_moi_token_input_pro
gia_output = tokens_output * self.gia_moi_token_output_pro
elif mo_hinh_su_dung == 'gemini-1.5-flash':
gia_input = tokens_input * self.gia_moi_token_input_flash
gia_output = tokens_output * self.gia_moi_token_output_flash
self.thong_ke_su_dung['uoc_tinh_chi_phi'] += (gia_input + gia_output)
print(f"Sử dụng: Input {tokens_input} tokens, Output {tokens_output} tokens. Ước tính chi phí hiện tại: ${self.thong_ke_su_dung['uoc_tinh_chi_phi']:.6f}")
def toi_uu_noi_dung_cho_mo_hinh(self, noi_dung, mo_hinh_muc_tieu='gemini-1.5-flash'):
"""
Tối ưu hóa nội dung (ví dụ: tóm tắt văn bản dài) dựa trên mô hình mục tiêu
để giảm chi phí hoặc cải thiện hiệu suất.
"""
# Đây là một ví dụ đơn giản; trong thực tế, bạn sẽ cần một mô hình khác
# hoặc logic phức tạp hơn để tóm tắt hoặc rút gọn
if mo_hinh_muc_tieu == 'gemini-1.5-flash' and len(noi_dung) > 1000:
print("Nội dung quá dài cho mô hình Flash, đang cố gắng tóm tắt...")
try:
# Sử dụng Gemini Flash để tóm tắt chính nó (một kịch bản tự tham chiếu)
mo_hinh_flash = genai.GenerativeModel('gemini-1.5-flash')
yeu_cau_tom_tat = f"Hãy tóm tắt ngắn gọn nội dung sau để giảm số lượng token: {noi_dung[:5000]}..." # Giới hạn đầu vào
phan_hoi_tom_tat = mo_hinh_flash.generate_content(yeu_cau_tom_tat)
tom_tat = phan_hoi_tom_tat.text
# Cập nhật số liệu sử dụng cho tác vụ tóm tắt
prompt_tokens = mo_hinh_flash.count_tokens(yeu_cau_tom_tat).total_tokens
completion_tokens = mo_hinh_flash.count_tokens(tom_tat).total_tokens
self.cap_nhat_su_dung(prompt_tokens, completion_tokens, 'gemini-1.5-flash')
return tom_tat
except Exception as e:
print(f"Không thể tóm tắt nội dung: {e}. Trả về nội dung gốc.")
return noi_dung
return noi_dung
def lay_thong_ke_hien_tai(self):
"""Trả về thống kê sử dụng và chi phí hiện tại."""
return self.thong_ke_su_dung
def thuc_hien_yeu_cau(self, cac_phan_noi_dung, mo_hinh='gemini-1.5-pro', cau_hinh_tao=None):
"""
Một phương thức wrapper để gọi Gemini và theo dõi chi phí.
"""
# Đếm token đầu vào
so_token_dau_vao = 0
try:
so_token_dau_vao = genai.GenerativeModel(mo_hinh).count_tokens(cac_phan_noi_dung).total_tokens
except Exception as e:
print(f"Lỗi khi đếm token đầu vào: {e}. Ước tính 0 token.")
mo_hinh_can_dung = genai.GenerativeModel(mo_hinh)
phan_hoi = mo_hinh_can_dung.generate_content(cac_phan_noi_dung, generation_config=cau_hinh_tao)
# Đếm token đầu ra
so_token_dau_ra = 0
try:
so_token_dau_ra = mo_hinh_can_dung.count_tokens(phan_hoi.text).total_tokens
except Exception as e:
print(f"Lỗi khi đếm token đầu ra: {e}. Ước tính 0 token.")
self.cap_nhat_su_dung(so_token_dau_vao, so_token_dau_ra, mo_hinh)
return phan_hoi.text