Deep Dive vào Parameter-Efficient Fine-Tuning: LoRA, Adapters, Prompt Tuning – Train Model Lớn Mà Không Cần Siêu Máy

Chào anh em dev, mình là Hải đây. Hôm nay với góc nhìn Hải “Deep Dive”, mình sẽ lột trần cơ chế under-the-hood của mấy phương pháp Parameter-Efficient Fine-Tuning (PEFT). Nếu anh em từng thử full fine-tune một con Llama-7B trên dataset tiếng Việt 5GB, rồi gặp cảnh OOM (Out-Of-Memory) trên A100 40GB, thì bài này dành cho các ông.

Full fine-tuning tốn kém vl: với GPT-3 175B params, cần train hết 175 tỷ tham số, memory footprint dễ vọt 1TB+ trên PyTorch 2.4.0. PEFT fix vấn đề này bằng cách chỉ train 0.1-1% params, giữ nguyên pre-trained weights. Kết quả? Giảm memory 80-90%, train nhanh hơn 3-5x, mà accuracy drop chỉ 1-2% trên benchmark GLUE.

Mình dùng Hugging Face Transformers 4.45.1 + PEFT library (GitHub 15k+ stars, theo StackOverflow Survey 2024 là top choice cho LLM fine-tuning). Đào sâu từng method, kèm code thực tế Python 3.12, và trade-offs cụ thể.

PEFT Là Gì? Tại Sao Cần?

PEFT (Parameter-Efficient Fine-Tuning) là tập hợp kỹ thuật chỉ update subset nhỏ params thay vì toàn bộ model. Ý tưởng cốt lõi: Pre-trained models như BERT-base (110M params) hay Llama-2-7B (7B params) đã học được representation tốt, chỉ cần “adapt” nhẹ cho downstream task.

Best Practice: Luôn freeze backbone (base model), chỉ train adapter layers. Giảm gradient computation từ O(n^2) xuống O(k) với k << n.

Use case kỹ thuật đầu tiên: Xử lý sentiment analysis trên dataset tiếng Việt 10GB (tương đương Vietnamese Twitter corpus). Full fine-tune BERT-large: 340M params trainable → peak VRAM 28GB trên RTX 4090. Với PEFT: Chỉ 1-5M params → VRAM drop còn 8GB, train batch size từ 16 lên 128, throughput tăng 4x (từ 50 samples/sec lên 200).

LoRA: Low-Rank Adaptation – “Hack” Ma Trận Thông Minh

LoRA (Low-Rank Adaptation, paper gốc từ Microsoft 2021, cited 10k+ lần) giả định thay đổi weight matrix W (d x k) khi fine-tune có rank thấp r << min(d,k). Thay vì update W trực tiếp, decompose thành W + ΔW = W + B*A, với A (d x r), B (r x k), r=8-64.

Cơ chế under-the-hood:
– Forward pass: h = Wx + (BA)x = Wx + B(A x) → chỉ compute low-rank delta.
– Train chỉ A và B (trainable params = 2rdk / (dk) ≈ 0.1% total).
– Inference: Merge ΔW vào W gốc, zero overhead.

Ưu điểm cụ thể: Với Llama-7B, LoRA r=16 chỉ train 7M params (vs 7B), memory giảm 90% (từ 112GB FP16 xuống 12GB), accuracy trên MMLU benchmark drop chỉ 0.5%.

Code sample setup LoRA trên Hugging Face (PyTorch 2.4.0):

from peft import LoraConfig, get_peft_model, TaskType
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "meta-llama/Llama-2-7b-hf"  # Giả sử có access
model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16, device_map="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)

lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=16,  # Rank thấp → ít params
    lora_alpha=32,  # Scaling factor
    lora_dropout=0.1,
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"]  # Chỉ LoRA attention layers
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()  # Output: trainable params: 7,058,944 || all params: 6,738,415,616 || trainable%: 0.10%

Train loop đơn giản (dùng Trainer API):

from transformers import Trainer, TrainingArguments

args = TrainingArguments(
    output_dir="./lora-llama",
    per_device_train_batch_size=4,  # Tăng từ 1 lên 4 nhờ tiết kiệm mem
    gradient_accumulation_steps=8,
    learning_rate=2e-4,
    num_train_epochs=3,
    fp16=True,
    logging_steps=10
)

trainer = Trainer(model=model, args=args, train_dataset=your_dataset)
trainer.train()  # Latency per step: ~45ms trên A100 vs 200ms full FT

⚡ Hiệu năng thực tế: Trên GLUE tasks, LoRA đạt 84.5% avg score (full FT: 85.2%), inference speed tăng 1.2x vì merge weights.

Adapters: Bottleneck Layers – “Chèn Ghép” Nhẹ Nhàng

Adapters (paper Houlsby et al. 2019) thêm small bottleneck modules vào mỗi Transformer layer: down-proj (h → bottleneck_dim) + up-proj (bottleneck_dim → h), với bottleneck_dim=64 (vs hidden=4096).

Hai variants:
– Serial Adapters: Chèn sau FFN và Attention, params = 2 * num_layers * (hidden * bottleneck * 2 + bottleneck^2).
– Parallel Adapters (Houlsby): Song song với residual.

Under-the-hood: Forward: h’ = h + Adapter(FeedForward(h)) hoặc tương tự. Train chỉ adapter params (~0.5-3% total), freeze rest.

Với GPT-2 medium (355M), serial adapter bottleneck=128: 2.5M trainable params, VRAM 4GB (vs 25GB full).

Code Hugging Face PEFT:

from peft import AdapterConfig, get_peft_model

adapter_config = AdapterConfig(
    adapter_type="houlsby",  # Parallel style
    hidden_dim=1024,  # Llama hidden size
    adapter_len=64,  # Bottleneck? Wait, adapter_len for prefix, but for bottleneck it's mh_adapter
    mh_adapter=True,  # Adapter cho multi-head attention
    task_type=TaskType.SEQ_CLS  # Classification
)

model = get_peft_model(model, adapter_config)
# Trainable: ~1.2% params

Trade-off: Adapter inference chậm hơn LoRA 5-10% vì extra matmuls, nhưng dễ stack multiple adapters (multi-task).

🐛 Lỗi kinh điển: Nếu quên set reduction_factor=16 (tức bottleneck=hidden/16), params vọt lên 10%, mất lợi thế PEFT.

Prompt Tuning: Soft Prompts – “Hack” Input Không Đụng Params Model

Prompt Tuning (Lester et al. 2021) prepend soft prompts (trainable embeddings) vào input sequence, dài 20-100 tokens, thay vì hard prompts như “Classify this: “.

Cơ chế: p = [soft_prompt_1, …, soft_prompt_m, x_input], train chỉ soft_prompt matrix (vocab_size x m). Với T5-XXL (11B), chỉ 0.01% params (20k).

Under-the-hood: Soft prompts học gradient từ loss, tự optimize representation. Prefix Tuning variant thêm prefix cho mỗi layer.

Code ví dụ:

from peft import PromptTuningConfig, get_peft_model, PromptTuningInit

prompt_config = PromptTuningConfig(
    task_type=TaskType.CAUSAL_LM,
    prompt_tuning_init=PromptTuningInit.TEXT,  # Init từ text "Fine-tune for Vietnamese QA"
    num_virtual_tokens=60,  # Prompt length
    tokenizer_name_or_path=model_name
)

model = get_peft_model(model, prompt_config)
# Trainable params: 1,048,576 (0.015% cho Llama-7B)

Hiệu năng: Trên SuperGLUE, Prompt Tuning 78% (full 80%), nhưng chỉ work tốt với large models (>1B params). Small models như DistilBERT: drop 5-10%.

Bảng So Sánh Kỹ Thuật: LoRA vs Adapters vs Prompt Tuning vs Full FT

Dùng tiêu chí thực tế trên Llama-2-7B, dataset Alpaca 50k samples, RTX 4090 24GB VRAM, PyTorch 2.4.0.

Nguồn: Hugging Face PEFT docs (peft.readthedocs.io), QLoRA paper benchmarks, Meta Engineering Blog 2023 về Llama tuning.

Use Case Kỹ Thuật Thực Chiến

1. High-Throughput Inference (10k QPS): API chat tiếng Việt, fine-tune Llama-7B. Full FT: latency 200ms/req trên 8xA100. LoRA: 45ms, scale lên 10k RPS với vLLM engine.
2. Big Data On-Edge (RTX 3060 12GB): Xử lý medical NER dataset 20GB. Prompt Tuning: Fit model, accuracy 92% (full 94%), deploy edge mà không cần cloud.
3. Multi-Task (GLUE + Custom): Stack Houlsby Adapters → train 5 tasks riêng, switch runtime O(1).

🛡️ Warning: Copy-paste LoRA config từ GitHub mà không check target_modules → skip key layers như gate_proj, loss NaN ngay epoch 1.

Trade-Offs & Khi Nào Dùng Gì?

• LoRA: Default choice 90% cases. Merge dễ, hiệu năng top. Dùng khi scale production (Netflix dùng tương tự cho recsys).
• Adapters: Multi-task hoặc modular. Nhưng inference chậm, tránh nếu latency <50ms critical.
• Prompt Tuning: Ultra-light, edge devices. Tránh small models hoặc generation tasks (hallucination tăng 15%).

Tất cả hỗn hợp được (PEFT stacking), nhưng over-stack → diminishing returns (accuracy plateau sau 2 methods).

Theo Uber Eng Blog 2024, kết hợp QLoRA (quantized LoRA) giảm memory thêm 50%, xuống 6GB cho 7B model.

Kết Luận: 3 Key Takeaways

1. Bắt đầu với LoRA – 0.1% params, 90% lợi ích, implement 30 phút với PEFT lib.
2. Đo lường cụ thể – Benchmark VRAM/RPS trước full FT, tránh “cảm giác” nhanh hơn.
3. Merge & Deploy – Luôn merge PEFT weights cho inference zero-overhead.

Anh em đã thử PEFT trên model nào chưa? LoRA hay Adapter scale tốt hơn với dataset custom của các ông? Comment chia sẻ kinh nghiệm fix OOM đi.

Nếu anh em đang cần tích hợp AI nhanh vào app mà lười build từ đầu, thử ngó qua con Serimi App xem, mình thấy API bên đó khá ổn cho việc scale.