AI Builder
LoRA - Tinh chỉnh hạng thấp
Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.Kỹ thuật tinh chỉnh hiệu quả, chỉ huấn luyện ma trận nhỏ thay vì toàn bộ mô hình.
Adapter LoRA: tham số và VRAM
Các con số dưới đây tính từ công thức LoRA với một ma trận W kích thước d × d.
| Thông số | Ảnh hưởng |
|---|---|
| Rank r | Càng lớn, adapter càng nhiều tham số và biểu diễn mạnh hơn |
| Chiều d | Quyết định kích thước ma trận gốc và adapter |
| Alpha α | Hệ số scale α / r; giữ ổn định khi đổi r |
| Target modules | Số module áp dụng LoRA trong mỗi tầng (q, k, v, o proj) |
| Số tầng transformer | Nhân số tham số adapter theo số tầng |
| Chế độ QLoRA | Lượng tử hoá W gốc xuống 4-bit để fit mô hình lớn trên một GPU |
Thí dụ tính: ma trận W 4096 × 4096 có 16,7 triệu tham số. Với rank r = 8, A và B cộng lại 65.536 tham số, chỉ khoảng 0,39% so với ma trận gốc. Áp dụng cho 4 module và 32 tầng, tổng adapter vẫn dưới 10 triệu tham số.
Khoảnh khắc aha
Thay đổi trọng số khi fine-tune thực ra nằm trong không gian hạng thấp, giống bức tranh phong cảnh: dù có hàng triệu điểm ảnh, vài nét cọ chính đã nắm bắt được bản chất. LoRA khai thác điều này: thay vì cập nhật ma trận khổng lồ W, chỉ học hai ma trận mỏng A và B mà tích của chúng xấp xỉ thay đổi cần thiết. Tri thức đã có trong W₀ không bị đụng vào; nó chỉ được bẻ lái bằng một cú hích hạng thấp.
Thử thách 1
Lý thuyết
LoRA (Low-Rank Adaptation) dựa trên giả thuyết rằng sự thay đổi trọng số khi fine-tune có intrinsic rank thấp. Thay vì cập nhật toàn bộ ma trận W, LoRA phân tích phần thay đổi thành tích của hai ma trận mỏng:
W₀ có kích thước d_out × d_in và bị đóng băng. B có kích thước d_out × r và A có kích thước r × d_in là hai ma trận huấn luyện được, với r nhỏ hơn nhiều so với d. Hệ số α điều khiển độ lớn đóng góp của adapter; chia cho r để tác động tổng không phụ thuộc nhiều vào r.
Ba bước cốt lõi
- Đóng băng W gốc: ma trận pre-train không đổi, bảo toàn toàn bộ kiến thức nền.
- Thêm adapter: khởi tạo A ngẫu nhiên (Gaussian), B = 0. Lúc đầu ΔW = BA = 0, nên mô hình hoạt động như cũ. Khi gradient chạy vào B, nó học hướng cần thiết.
- Gộp khi triển khai: sau huấn luyện, tính W' = W + (α/r)·BA một lần và lưu. Không tăng chi phí suy luận so với mô hình gốc.
Vì sao α/r ổn định khi đổi r?
Khi khởi tạo A với phương sai khoảng 1/r và B = 0, kỳ vọng chuẩn của BA tỉ lệ với r. Nếu không chia cho r, tăng r sẽ làm delta lớn bất thường và phá pre-train. Chia cho r giúp độ lớn ổn định, nên có thể thử các r khác nhau mà không tune lại learning rate hay alpha.
Với scale s = α/r, công thức cập nhật là W' = W + s·BA. Khi r tăng gấp đôi, s giảm một nửa, tổng tác động vẫn giữ nguyên về mặt chuẩn; chỉ khả năng biểu diễn tăng lên.
Code LoRA với PEFT
lora_peft.py
from peft import LoraConfig, get_peft_model, TaskType
from transformers import AutoModelForCausalLM
# 1. Load base model (fp16 trên GPU)
base_model = AutoModelForCausalLM.from_pretrained(
"meta-llama/Llama-3-8B",
torch_dtype="float16",
device_map="auto",
)
# 2. Cấu hình LoRA
config = LoraConfig(
task_type=TaskType.CAUSAL_LM,
r=8, # Rank — trade-off giữa chất lượng/chi phí
lora_alpha=16, # Scaling: W' = W + (16/8)·BA = W + 2·BA
target_modules=[ # Áp dụng cho attention projections
"q_proj", "v_proj", # Tối thiểu: Q và V
# "k_proj", "o_proj" # Tùy chọn: K và O cho biểu diễn mạnh hơn
],
lora_dropout=0.05, # Regularization
bias="none", # Không huấn luyện bias
modules_to_save=None, # Không có module full-trainable
)
# 3. Gắn adapter
model = get_peft_model(base_model, config)
model.print_trainable_parameters()
# → trainable params: 4,194,304 || all params: 8,034,078,720
# → trainable%: 0.0522
# 4. Huấn luyện như bình thường
# trainer = Trainer(model=model, ...)
# trainer.train()
# 5. Lưu adapter (chỉ vài MB, không phải 14GB mô hình gốc!)
model.save_pretrained("./my-lora-adapter")
# 6. Nạp lại khi inference
from peft import PeftModel
base = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3-8B")
model = PeftModel.from_pretrained(base, "./my-lora-adapter")
# 7. (Tùy chọn) Gộp để tăng tốc inference
model = model.merge_and_unload() # W' = W + BA, xoá adapterLoRA và QLoRA
LoRA đã tiết kiệm phần lớn tham số huấn luyện, nhưng vẫn phải giữ W gốc ở fp16 trên GPU. Với mô hình 65B, chỉ load W₀ đã cần khoảng 130 GB. QLoRA = LoRA + lượng tử hoá 4-bit để cắt khoảng 4 lần footprint của base model.
| Tiêu chí | LoRA | QLoRA |
|---|---|---|
| Base model | fp16 hoặc bf16 (2 byte mỗi tham số) | 4-bit NF4 (0,5 byte mỗi tham số) |
| Adapter A và B | fp16 | fp16 (không lượng tử hoá) |
| Trạng thái optimizer | Adam fp32 trên GPU | Paged Adam (đẩy sang CPU khi cần) |
| VRAM cho Llama 65B | Khoảng 130 GB (8 GPU A100) | Khoảng 48 GB (1 GPU A100) |
| Tốc độ | Nhanh nhất | Chậm hơn khoảng 25% (giải lượng tử hoá khi chạy), theo nguồn bài |
| Chất lượng | Gần full fine-tuning | Gần full fine-tuning |
Khi nào KHÔNG nên dùng LoRA hoặc QLoRA?
- Continued pre-training quy mô lớn: với hàng tỷ token mới (ví dụ huấn luyện cho một ngôn ngữ hoàn toàn mới), full fine-tuning vẫn an toàn hơn. Rank thấp không đủ biểu diễn sự dịch chuyển phân phối lớn.
- Thay đổi kiến trúc: thêm token mới vào vocab hoặc thay đổi hidden size cần full fine-tuning lớp embedding và output head.
- Dữ liệu cực nhỏ (dưới 100 mẫu): prefix hoặc prompt tuning có thể tốt hơn, vì LoRA với r = 8 vẫn có khoảng 4 triệu tham số, quá nhiều cho 100 mẫu.
Code QLoRA
Cấu hình QLoRA đầy đủ. Ba chỗ khác biệt so với LoRA thuần: BitsAndBytesConfig, prepare_model_for_kbit_training và optimizer paged_adamw_32bit.
qlora_fine_tune.py
import torch
from transformers import (
AutoModelForCausalLM,
AutoTokenizer,
BitsAndBytesConfig,
TrainingArguments,
Trainer,
)
from peft import (
LoraConfig,
get_peft_model,
prepare_model_for_kbit_training,
TaskType,
)
# ===== 1. 4-bit quantization config =====
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4", # NormalFloat 4-bit
bnb_4bit_compute_dtype=torch.bfloat16, # Tính toán ở bf16
bnb_4bit_use_double_quant=True, # Double quantization
)
# ===== 2. Load model 4-bit =====
model = AutoModelForCausalLM.from_pretrained(
"meta-llama/Llama-3-70B",
quantization_config=bnb_config,
device_map="auto",
trust_remote_code=True,
)
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3-70B")
# ===== 3. Chuẩn bị cho k-bit training =====
# Bật gradient checkpointing, cast layer norm về fp32,
# đóng băng mọi tham số non-LoRA
model = prepare_model_for_kbit_training(
model,
use_gradient_checkpointing=True,
)
# ===== 4. Gắn LoRA adapter =====
lora_config = LoraConfig(
task_type=TaskType.CAUSAL_LM,
r=16, # Rank cao hơn LoRA thường
lora_alpha=32, # α = 2r
target_modules=[ # Tất cả linear layer trong attention
"q_proj", "k_proj",
"v_proj", "o_proj",
# "gate_proj", "up_proj", # Cũng có thể thêm MLP
# "down_proj",
],
lora_dropout=0.05,
bias="none",
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# → trainable: 40M / 70B = 0.057%
# ===== 5. Training với paged optimizer =====
args = TrainingArguments(
output_dir="./qlora-llama3-70b",
num_train_epochs=3,
per_device_train_batch_size=1,
gradient_accumulation_steps=16,
optim="paged_adamw_32bit", # Offload optimizer state
learning_rate=2e-4,
bf16=True,
logging_steps=10,
save_strategy="epoch",
warmup_ratio=0.03,
lr_scheduler_type="cosine",
)
# trainer = Trainer(model=model, args=args, ...)
# trainer.train()
# ===== 6. Lưu adapter (~100MB thay vì 140GB!) =====
model.save_pretrained("./qlora-llama3-adapter")Thử thách 2
Tóm tắt
- LoRA đóng băng W gốc, chỉ học hai ma trận hạng thấp A (r × d_in) và B (d_out × r), giảm trên 99% tham số huấn luyện.
- Rank r là tham số quan trọng nhất: r từ 4 đến 16 đủ cho hầu hết tác vụ; r từ 32 đến 64 khi cần biểu diễn mạnh hơn.
- Khởi tạo B = 0 và A ngẫu nhiên, nên mô hình ban đầu hoạt động như cũ. Scale α/r giúp ổn định khi đổi r.
- Sau huấn luyện gộp W' = W + (α/r)·BA, không tăng độ trễ khi triển khai.
- QLoRA = LoRA + base 4-bit NF4 + double quantization + paged optimizer, giúp fit mô hình 65B trên một GPU 48 GB.
- Multi-tenant: một base model với nhiều adapter (vài MB mỗi cái) thay cho nhiều bản sao model hàng chục GB.