Fine-tuning

┌─────────────────────────────────────────────────────────────────┐
│                    Prompt Engineering                            │
│  Nhanh, dễ, không tốn chi phí. Thử TRƯỚC KHI fine-tune.        │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│                         RAG                                      │
│  Kết hợp data riêng mà không cần train. Dùng cho facts mới.    │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│                      Fine-tuning                                 │
│  Thay đổi behavior của model. Dùng cho style, format, domain.  │
└─────────────────────────────────────────────────────────────────┘

Pros:
✅ Kết quả tốt nhất
✅ Model adapt hoàn toàn

Cons:
❌ Cần GPU mạnh (nhiều VRAM)
❌ Dễ overfitting
❌ Tốn thời gian
❌ Chi phí cao

Pros:
✅ Tiết kiệm VRAM (giảm ~10x)
✅ Train nhanh hơn
✅ Có thể switch giữa nhiều adapters
✅ Ít overfitting hơn

Cons:
❌ Kết quả có thể kém hơn full fine-tune
❌ Cần tune hyperparameters

Original weights: W (frozen)
LoRA adapters: A, B (trainable)

Output = W·x + A·B·x

Chỉ train A và B (rất nhỏ so với W)

Pros:
✅ Cực kỳ tiết kiệm VRAM
✅ Fine-tune model 65B trên GPU 24GB
✅ Kết quả gần bằng full fine-tune

Cons:
❌ Chậm hơn 1 chút
❌ Setup phức tạp hơn

{"messages": [{"role": "system", "content": "Bạn là trợ lý lập trình Python."}, {"role": "user", "content": "Viết hàm tính giai thừa"}, {"role": "assistant", "content": "```python\ndef factorial(n: int) -> int:\n    if n <= 1:\n        return 1\n    return n * factorial(n - 1)\n```"}]}
{"messages": [{"role": "system", "content": "Bạn là trợ lý lập trình Python."}, {"role": "user", "content": "Viết hàm tính Fibonacci"}, {"role": "assistant", "content": "```python\ndef fibonacci(n: int) -> int:\n    if n <= 1:\n        return n\n    return fibonacci(n-1) + fibonacci(n-2)\n```"}]}

from openai import OpenAI
 
client = OpenAI()
 
# 1. Upload file
file = client.files.create(
    file=open("training_data.jsonl", "rb"),
    purpose="fine-tune"
)
 
# 2. Tạo fine-tuning job
job = client.fine_tuning.jobs.create(
    training_file=file.id,
    model="gpt-4o-mini-2024-07-18",
    hyperparameters={
        "n_epochs": 3
    }
)
 
# 3. Kiểm tra status
status = client.fine_tuning.jobs.retrieve(job.id)
print(status.status)  # "running" → "succeeded"
 
# 4. Sử dụng fine-tuned model
response = client.chat.completions.create(
    model="ft:gpt-4o-mini-2024-07-18:your-org::job-id",
    messages=[
        {"role": "user", "content": "Viết hàm sort list"}
    ]
)

pip install transformers peft datasets accelerate bitsandbytes

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
import torch
 
# 1. Load model với quantization
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-7b-hf",
    load_in_4bit=True,
    device_map="auto"
)
 
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")
 
# 2. Cấu hình LoRA
lora_config = LoraConfig(
    r=16,                    # Rank của adapter
    lora_alpha=32,           # Scaling factor
    target_modules=["q_proj", "v_proj"],  # Layers to adapt
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)
 
# 3. Prepare model
model = prepare_model_for_kbit_training(model)
model = get_peft_model(model, lora_config)
 
# 4. Training (sử dụng Trainer hoặc custom loop)
# ...

from peft import PeftModel
 
# Load base model
base_model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-7b-hf",
    load_in_4bit=True
)
 
# Load adapter
model = PeftModel.from_pretrained(base_model, "path/to/adapter")
 
# Inference
inputs = tokenizer("Hello, how are you?", return_tensors="pt")
outputs = model.generate(**inputs)
print(tokenizer.decode(outputs[0]))

from sentence_transformers import SentenceTransformer, InputExample, losses
from torch.utils.data import DataLoader
 
# 1. Load model
model = SentenceTransformer('all-MiniLM-L6-v2')
 
# 2. Prepare data
train_examples = [
    InputExample(texts=["Python tutorial", "Learn Python programming"], label=0.9),
    InputExample(texts=["Python tutorial", "Best restaurants nearby"], label=0.1),
]
 
train_dataloader = DataLoader(train_examples, shuffle=True, batch_size=16)
 
# 3. Loss function
train_loss = losses.CosineSimilarityLoss(model)
 
# 4. Training
model.fit(
    train_objectives=[(train_dataloader, train_loss)],
    epochs=3,
    warmup_steps=100
)
 
# 5. Save
model.save("my-fine-tuned-model")

# Chia data: 80% train, 10% validation, 10% test
# KHÔNG dùng test set trong quá trình training
 
from sklearn.model_selection import train_test_split
 
train, temp = train_test_split(data, test_size=0.2)
val, test = train_test_split(temp, test_size=0.5)

50% users → Base model
50% users → Fine-tuned model

Đo: Response quality, User satisfaction, Task completion

Dataset: 1000 examples × ~500 tokens/example = 500K tokens
Epochs: 3
Total training tokens: 1.5M

Cost (gpt-4o-mini): 1.5M × $3/1M = $4.50
Cost (gpt-4o): 1.5M × $25/1M = $37.50

+ Inference cost (higher than base model)

GPU rental (A100 80GB): ~$2-3/hour
Training time: 4-8 hours
Total: $8-24

+ Infra costs (hosting, monitoring)

Cần customize model behavior?
    │
    ├─ NO → Prompt Engineering / RAG
    │
    └─ YES → Có đủ budget & data?
                │
                ├─ NO → Few-shot prompting
                │
                └─ YES → Fine-tuning
                            │
                            ├─ API (OpenAI) → Không cần GPU
                            │
                            └─ Open Source → LoRA/QLoRA