Dự đoán
Bài này đưa ra bốn chiến lược tùy chỉnh LLM và cách chọn đúng chiến lược cho dự án, qua một cây quyết định gồm năm câu hỏi.
Evaluating routing across providers.
AI Builder
Khi nào nên tinh chỉnh model, khi nào chỉ cần kỹ thuật prompt — hướng dẫn chọn chiến lược phù hợp cho dự án AI của bạn.
Bài này đưa ra bốn chiến lược tùy chỉnh LLM và cách chọn đúng chiến lược cho dự án, qua một cây quyết định gồm năm câu hỏi.
Hãy tưởng tượng bạn là chủ một chuỗi quán phở mới và cần một đầu bếp. Có bốn lựa chọn:
| Cách | Ẩn dụ | Đặc điểm |
|---|---|---|
| Few-shot prompting | Thuê đầu bếp giỏi sẵn, đưa công thức phở trước mỗi ca làm | Rẻ, linh hoạt; công thức phải đủ ngắn và rõ |
| RAG | Đầu bếp có cuốn sổ công thức, khi gặp món lạ thì giở sổ tra | Cập nhật sổ dễ; cần thời gian tra cứu |
| LoRA | Cho đầu bếp học khóa ngắn về phở Hà Nội | Học đủ sâu mà không đào tạo lại từ đầu |
| Full fine-tuning | Tuyển đầu bếp mới, dạy phở từ con số 0 trong ba năm | Tốn kém nhất, nhưng giỏi nhất |
Nguyên tắc: luôn thử cấp thấp trước. Thử prompting và đánh giá; nếu chưa đạt thì leo thang RAG, rồi LoRA, cuối cùng mới full fine-tuning. Không nên nhảy thẳng vào fine-tuning khi chưa thử prompting.
Trả lời năm câu hỏi về dataset, miền dữ liệu, ngân sách, độ trễ và định dạng đầu ra để xem chiến lược phù hợp. Bảng so sánh bốn chiến lược:
| Tiêu chí | Prompting | RAG | LoRA | Full fine-tuning |
|---|---|---|---|---|
| Chi phí setup | Gần bằng 0 | Thấp đến vừa | Vừa | Cao |
| Thời gian | Vài giờ | Vài ngày | Vài ngày | Vài tuần |
| Dữ liệu cần | Vài ví dụ | Tài liệu nguồn | Vài trăm đến vài nghìn ví dụ | Từ 10 nghìn ví dụ |
| Thay đổi model? | Không | Không | Có (adapter) | Có (toàn bộ) |
| Đổi sang model mới? | Một dòng code | Gần như không đổi | Cần huấn luyện lại adapter | Huấn luyện lại từ đầu |
| Độ trễ suy luận | Prompt dài hơn | Thêm bước truy xuất | Gần như không đổi | Gần như không đổi |
| Chất lượng miền hẹp | Khá | Tốt khi cần kiến thức ngoài | Tốt | Tốt nhất |
Prompting là dạy AI bằng hướng dẫn: nhanh, rẻ, linh hoạt. Fine-tuning là đào tạo một chuyên gia: tốn kém, mạnh cho miền chuyên biệt. Luôn leo thang từ rẻ đến đắt, đừng nhảy thẳng vào fine-tuning khi chưa thử prompting.
Chi phí ẩn lớn nhất của fine-tuning xuất hiện khi có model mới. Prompting thì đổi model trong một dòng code; fine-tuning phải huấn luyện lại, có thể tốn hàng chục triệu và vài tuần.
Zero-shot: chỉ đưa hướng dẫn, không có ví dụ, ví dụ: “Phân loại cảm xúc của câu sau”. LLM hiện đại thường xử lý tốt tác vụ phổ biến mà không cần ví dụ.
Few-shot: đưa 2 đến 10 cặp (đầu vào, đầu ra) làm mẫu. Mô hình nhìn vào mẫu để suy ra cách trả lời. Đây là học trong ngữ cảnh (in-context learning). Mạnh cho tác vụ có mẫu rõ; nhược điểm là prompt dài tốn token và giới hạn bởi context window.
RAG tách kiến thức khỏi mô hình: lưu tài liệu trong cơ sở dữ liệu vector, khi có câu hỏi thì tìm tài liệu liên quan, đưa vào prompt rồi gọi LLM. Ưu điểm: cập nhật kiến thức không cần huấn luyện lại, dễ trích dẫn nguồn, giảm hallucination. Nhược điểm: cần xây pipeline (chia đoạn, nhúng, xếp hạng lại).
RAG đặc biệt hiệu quả cho chatbot nội bộ, hỗ trợ khách hàng, tài liệu kỹ thuật và các hệ thống cần trích dẫn như pháp lý, y tế, nghiên cứu.
LoRA chỉ huấn luyện hai ma trận nhỏ A và B:
A có kích thước d × r và B có kích thước r × d, với r nhỏ hơn nhiều so với d (thường 4, 8 hoặc 16). Số tham số huấn luyện giảm khoảng 100 đến 1000 lần, và bộ nhớ GPU giảm tương ứng.
Huấn luyện lại toàn bộ mô hình trên dữ liệu riêng. Chi phí cao (GPU, thời gian, kỹ sư ML), nhưng có thể thay đổi hành vi cốt lõi. Chỉ dùng khi dữ liệu rất lớn và chất lượng (từ 10 nghìn ví dụ trở lên), miền cực chuyên biệt, và có đội MLOps để duy trì.
Khi fine-tune một mô hình đã pre-train, sự thay đổi ΔW = W_new − W_pretrained có rank thấp trong thực tế. Do đó có thể phân tích:
Với d = 4096 và r = 8, số tham số huấn luyện giảm 256 lần. Khi suy luận, cộng A · B vào W_pretrained, nên không có chi phí thêm so với mô hình gốc.
Câu hỏi thường bị bỏ qua: chiến lược nào rẻ nhất về tổng chi phí sở hữu (TCO)? Câu trả lời phụ thuộc vào khối lượng request.
Theo công thức trong ví dụ dưới đây (chi phí setup và chi phí mỗi request là giả định của ví dụ), LoRA bắt đầu rẻ hơn prompting khi khối lượng đạt khoảng 10 nghìn request mỗi tháng. Full fine-tuning với setup 10 nghìn USD và cùng chi phí mỗi request như LoRA không bao giờ rẻ hơn LoRA trong mô hình này.
# Tính toán TCO (Total Cost of Ownership) để chọn chiến lược
# Input: volume dự kiến, chi phí setup, chi phí mỗi request
def total_cost(strategy, monthly_requests, months=12):
if strategy == "prompting":
setup = 0
per_request = 0.01 # USD, prompt dài
elif strategy == "rag":
setup = 500 # vector DB setup
per_request = 0.012 # embedding + LLM
elif strategy == "lora":
setup = 500 # train LoRA
per_request = 0.006 # prompt ngắn hơn
elif strategy == "full-ft":
setup = 10000 # full training
per_request = 0.006
else:
raise ValueError(f"Unknown: {strategy}")
return setup + per_request * monthly_requests * months
# Ví dụ:
for volume in [1_000, 100_000, 10_000_000]:
print(f"\nVolume: {volume:,}/month")
for s in ["prompting", "rag", "lora", "full-ft"]:
cost = total_cost(s, volume)
print(f" {s:12} = ${cost:>12,.0f}")
# Output theo công thức trên (phép tính đã kiểm tra lại):
# Volume: 1,000/month — prompting rẻ nhất ($120)
# Volume: 100,000/month — LoRA rẻ nhất (~$7.700; prompting ~$12.000; full FT ~$17.200)
# Volume: 10,000,000/month — LoRA rẻ nhất (~$720.500; full FT ~$730.000; prompting ~$1,2 triệu)# Few-shot prompting — không train gì
# Chỉ cần prompt tốt + vài ví dụ mẫu
prompt = """Phân loại sentiment của bình luận tiếng Việt.
Chỉ trả lời: positive, negative, hoặc neutral.
Ví dụ:
- "Phở ngon lắm!" → positive
- "Giao hàng chậm quá" → negative
- "Giá tầm trung" → neutral
Bình luận: "Shop bán hàng chất lượng!"
Kết quả:"""
response = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=50,
messages=[{"role": "user", "content": prompt}]
)
print(response.content[0].text) # "positive"# Pipeline đề xuất: leo thang từ rẻ đến đắt
# Mỗi bước đều đo trên cùng 1 eval set để so sánh công bằng
from anthropic import Anthropic
from my_eval import evaluate_on_eval_set
client = Anthropic()
# ─── Bước 1: Zero-shot ───
def zero_shot(sample):
return client.messages.create(
model="claude-sonnet-4-6",
max_tokens=500,
messages=[{
"role": "user",
"content": f"Phân loại sentiment: {sample['input']}"
}]
)
score_zero = evaluate_on_eval_set(zero_shot)
print(f"Zero-shot: {score_zero:.1%}")
# ─── Bước 2: Few-shot (nếu zero-shot chưa đủ) ───
FEW_SHOT_EXAMPLES = [
{"input": "Giao hàng chậm quá!", "label": "negative"},
{"input": "Phở ngon tuyệt!", "label": "positive"},
{"input": "Giá tầm trung, chất lượng ổn.", "label": "neutral"},
]
def few_shot(sample):
examples = "\n".join(
f"Input: {e['input']}\nOutput: {e['label']}"
for e in FEW_SHOT_EXAMPLES
)
prompt = f"{examples}\n\nInput: {sample['input']}\nOutput:"
return client.messages.create(
model="claude-sonnet-4-6",
max_tokens=50,
messages=[{"role": "user", "content": prompt}]
)
score_few = evaluate_on_eval_set(few_shot)
print(f"Few-shot: {score_few:.1%}")
# ─── Bước 3: RAG (nếu cần kiến thức external) ───
# ... (pipeline chunking + embedding + retrieval)
# ─── Bước 4: LoRA (nếu vẫn chưa đủ) ───
from peft import LoraConfig, get_peft_model
from transformers import AutoModelForCausalLM, Trainer
base_model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B")
peft_config = LoraConfig(
r=16, # rank thấp
lora_alpha=32, # scaling
target_modules=["q_proj", "v_proj"],
lora_dropout=0.05,
)
model = get_peft_model(base_model, peft_config)
# Chỉ ~0.3% tham số được train!
# trainer.train() với dataset 500-2000 ví dụ
# Sau đó lưu adapter (chỉ vài MB)
# ─── Bước 5: Full fine-tune (cuối cùng) ───
# Chỉ khi các bước trên KHÔNG đạt yêu cầu VÀ có 10k+ ví dụ chất lượng# RAG — truy xuất tài liệu trước khi gọi LLM
from sentence_transformers import SentenceTransformer
import chromadb
# 1. Index tài liệu một lần
encoder = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')
client_db = chromadb.Client()
collection = client_db.create_collection("docs")
for doc in company_documents:
emb = encoder.encode(doc.text).tolist()
collection.add(embeddings=[emb], documents=[doc.text], ids=[doc.id])
# 2. Khi có câu hỏi: retrieve + gọi LLM
def rag_answer(question):
q_emb = encoder.encode(question).tolist()
results = collection.query(query_embeddings=[q_emb], n_results=5)
context = "\n".join(results["documents"][0])
prompt = f"""Dựa trên tài liệu:
{context}
Câu hỏi: {question}
Trả lời:"""
return client.messages.create(
model="claude-sonnet-4-6",
max_tokens=500,
messages=[{"role": "user", "content": prompt}]
).content[0].text
answer = rag_answer("Chính sách nghỉ phép của công ty?")# LoRA — fine-tune hiệu quả, chỉ ~0.3% tham số
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import LoraConfig, get_peft_model, TaskType
from trl import SFTTrainer
model_name = "meta-llama/Llama-3.1-8B-Instruct"
base = AutoModelForCausalLM.from_pretrained(model_name)
tokenizer = AutoTokenizer.from_pretrained(model_name)
# Config LoRA
lora_config = LoraConfig(
task_type=TaskType.CAUSAL_LM,
r=16, # rank (lower = fewer params, higher = more capacity)
lora_alpha=32, # scaling factor
lora_dropout=0.05,
target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
)
model = get_peft_model(base, lora_config)
model.print_trainable_parameters()
# trainable params: 20,971,520 || all params: 8,051,232,768 || ratio: 0.26%
# Train trên dataset 1000 ví dụ
trainer = SFTTrainer(
model=model,
tokenizer=tokenizer,
train_dataset=my_dataset,
max_seq_length=2048,
args=TrainingArguments(
output_dir="./lora-ckpt",
num_train_epochs=3,
per_device_train_batch_size=4,
learning_rate=2e-4,
),
)
trainer.train()
# Lưu adapter (chỉ vài MB)
model.save_pretrained("./my-lora-adapter")# Full fine-tuning — tốn kém, chỉ khi thật cần
from transformers import (
AutoModelForCausalLM,
AutoTokenizer,
Trainer,
TrainingArguments,
DataCollatorForLanguageModeling,
)
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B")
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B")
# TẤT CẢ tham số đều được train
for param in model.parameters():
param.requires_grad = True
# Cần GPU rất mạnh (A100 80GB hoặc H100)
training_args = TrainingArguments(
output_dir="./full-ft-ckpt",
num_train_epochs=3,
per_device_train_batch_size=1, # Batch nhỏ vì model lớn
gradient_accumulation_steps=16, # Tích lũy để có effective batch = 16
learning_rate=1e-5, # Thấp để tránh catastrophic forgetting
warmup_steps=200,
logging_steps=10,
save_strategy="epoch",
fp16=True, # Hoặc bf16 trên H100
gradient_checkpointing=True, # Tiết kiệm bộ nhớ, chậm hơn một chút
)
trainer = Trainer(
model=model,
args=training_args,
train_dataset=my_big_dataset, # 10k+ ví dụ chất lượng cao
eval_dataset=my_eval_set, # Eval set chuẩn
data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
)
trainer.train()
# Checkpoint ~16GB cho Llama-8B, ~140GB cho Llama-70B
# Chi phí: có thể tới hàng chục nghìn USD trên cloud GPUSai lầm nghiêm trọng nhất: tinh chỉnh (fine-tune hoặc chỉnh prompt) mà không có eval set chuẩn. Khi đó không biết thay đổi có tốt hơn không. Trước mọi quyết định, hãy xây 50 đến 500 ví dụ eval có người kiểm tra, rồi đo mọi chiến lược trên chính bộ đó.