Dự đoán
Trước QLoRA (tháng 5/2023), fine-tune mô hình 65B là đặc quyền của ai có cluster từ 8 GPU trở lên. QLoRA đưa việc này xuống một GPU.
Evaluating routing across providers.
AI Builder
Kết hợp lượng tử hóa 4-bit với LoRA, cho phép fine-tune mô hình 65B trên GPU 48GB.
Trước QLoRA (tháng 5/2023), fine-tune mô hình 65B là đặc quyền của ai có cluster từ 8 GPU trở lên. QLoRA đưa việc này xuống một GPU.
Hãy tưởng tượng bạn được giao chỉnh lại một bảo tàng 70.000 bức tranh (mô hình 70B), nhưng phòng làm việc chỉ rộng bằng một phần ba bảo tàng. Có ba chiến lược:
| Chiến lược | Cách làm | Nhận xét |
|---|---|---|
| Full fine-tuning | Mang từng bức tranh gốc về phòng và sơn lại | Cần kho lớn gấp khoảng 4 lần bảo tàng (tranh gốc, bản thử, giấy nháp Adam). Không khả thi |
| LoRA | Đặt một lớp kính mỏng lên mỗi bức và chỉ vẽ phần cần đổi lên kính | Không đụng bức gốc. Kho cần là bảo tàng cộng vài kilogam kính, vẫn hơi chật |
| QLoRA | Chụp ảnh nén 4-bit của mỗi bức để giữ gọn, vẽ chi tiết mới trên lớp kính | Phòng vừa. Khi cần so sánh thì phóng ảnh lên (giải nén) |
Nén bức tranh gốc (lượng tử hoá 4-bit) để vừa căn phòng nhỏ, rồi vẽ chi tiết mới trên lớp kính mỏng (LoRA adapter). Đó chính là QLoRA.
Bảng dưới so sánh bộ nhớ khi fine-tune Llama 70B theo ba cách, với số liệu theo tính toán trong bài:
| Phương pháp | Trọng số base | Ghi chú |
|---|---|---|
| Full fine-tuning | Khoảng 140 GB ở FP16, cộng gradient và Adam | Khoảng 840 GB tổng cộng |
| LoRA | Khoảng 140 GB ở FP16 | Chỉ adapter được huấn luyện |
| QLoRA | Khoảng 35 GB ở 4-bit NF4 | Adapter BF16; tổng khoảng 48 GB |
NF4 đặt 16 mức lượng tử hoá dày đặc gần 0, nơi mật độ trọng số cao nhất, và thưa ở đuôi. INT4 đều thì kém hơn với cùng 4 bit, vì nhiều mức bị lãng phí ở vùng ít trọng số.
Double quantization: mỗi block 64 trọng số có một hằng số scale FP32. Nén thêm các scale này xuống FP8 tiết kiệm khoảng 0,37 bit mỗi tham số, tương đương khoảng 3 GB trên 70B.
QLoRA kết hợp hai ý tưởng tưởng chừng mâu thuẫn: lượng tử hoá xuống 4-bit làm mất thông tin, nhưng vẫn cần gradient chính xác để học. Bí quyết: chỉ nén phần đóng băng (base model), còn phần học (LoRA adapter) giữ ở BF16. Gradient chạy qua base model đã giải nén khi cần, nhưng chỉ cập nhật adapter. Kết quả: fine-tune 65B trên một GPU duy nhất, chất lượng gần với cách dùng nhiều GPU.
QLoRA (Dettmers và cộng sự, 2023) là phương pháp parameter-efficient fine-tuning: nén base model xuống NF4 và đóng băng, rồi huấn luyện LoRA adapter ở BF16. Có ba đổi mới chính:
Bộ nhớ lưu trọng số sau NF4, với N là số tham số và b là kích thước block (mặc định 64):
Với N = 70 × 10⁹: phần trọng số khoảng 35 GB, và phần hằng số scale khoảng 4,4 GB.
Với double quantization, hằng số scale FP32 được lượng tử hoá xuống FP8, với một scale thứ cấp cho mỗi 256 block. Tiết kiệm khoảng 0,37 bit mỗi tham số.
Forward pass của một lớp tuyến tính có trọng số NF4 đóng băng và adapter A, B:
Gradient chỉ chảy vào A và B. Base model hoàn toàn đóng băng nhưng vẫn được giải nén mỗi forward, nên QLoRA chậm hơn LoRA thuần.
# pip install "transformers>=4.41" "peft>=0.11" "bitsandbytes>=0.43" accelerate datasets
import torch
from transformers import (
AutoModelForCausalLM, AutoTokenizer,
BitsAndBytesConfig, TrainingArguments,
)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from trl import SFTTrainer
from datasets import load_dataset
MODEL_ID = "meta-llama/Llama-3-70B"
# Bước 1: Cấu hình QLoRA — NF4 + Double Quantization + BF16 compute
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4", # NormalFloat 4-bit (không phải "fp4"!)
bnb_4bit_use_double_quant=True, # tiết kiệm thêm ~0.37 bit/param
bnb_4bit_compute_dtype=torch.bfloat16, # tính toán bằng BF16 sau dequant
)
# Bước 2: Load base model ở 4-bit
model = AutoModelForCausalLM.from_pretrained(
MODEL_ID,
quantization_config=bnb_config,
device_map="auto",
torch_dtype=torch.bfloat16,
trust_remote_code=False,
)
# 70B × 4.125 bit = ~36GB + overhead ≈ 38GB VRAM cho weights
# Bước 3: Chuẩn bị cho k-bit training (cast LN sang FP32, bật gradient checkpointing)
model = prepare_model_for_kbit_training(
model, use_gradient_checkpointing=True
)
# Bước 4: Gắn LoRA adapter ở BF16 — chỉ phần này có gradient
lora_config = LoraConfig(
r=16, # rank; 8-64 là phổ biến
lora_alpha=32, # thường = 2 × r
target_modules=[ # Llama/Mistral: thường đủ 7 proj
"q_proj", "k_proj", "v_proj", "o_proj",
"gate_proj", "up_proj", "down_proj",
],
lora_dropout=0.05,
bias="none",
task_type="CAUSAL_LM",
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# trainable: ~30M (0.04% của 70B) → gradient + optimizer rất nhẹ
# Bước 5: Training args — dùng paged optimizer
training_args = TrainingArguments(
output_dir="./qlora-llama3-70b",
per_device_train_batch_size=1,
gradient_accumulation_steps=16,
learning_rate=2e-4, # LR cao hơn full FT vì adapter nhỏ
max_steps=1000,
optim="paged_adamw_8bit", # PAGED — trick tránh OOM
lr_scheduler_type="cosine",
warmup_ratio=0.03,
bf16=True, # tính toán BF16
logging_steps=10,
save_steps=200,
gradient_checkpointing=True,
)
# Bước 6: Train
tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
dataset = load_dataset("timdettmers/openassistant-guanaco", split="train")
trainer = SFTTrainer(
model=model,
tokenizer=tokenizer,
train_dataset=dataset,
args=training_args,
dataset_text_field="text",
max_seq_length=2048,
peft_config=lora_config,
)
trainer.train()
# Bước 7: Lưu — chỉ adapter ~100MB
model.save_pretrained("./qlora-adapter")
# Inference sau này: load base model (có thể 4-bit) + merge adapterimport torch
import bitsandbytes as bnb
from bitsandbytes.functional import quantize_nf4, dequantize_nf4
# Giả lập 1 layer linear weight 4096x4096 (giống Llama hidden size)
W_fp16 = torch.randn(4096, 4096, dtype=torch.float16, device="cuda") * 0.02
# Quantize sang NF4 — block size 64
W_nf4, quant_state = quantize_nf4(W_fp16, blocksize=64)
print(f"FP16 size: {W_fp16.nelement() * 2 / 1e6:.2f} MB")
print(f"NF4 size: {W_nf4.nelement() / 2 / 1e6:.2f} MB (chia 2 vì pack 2 val/byte)")
print(f"→ Tỉ lệ nén: {2 * W_fp16.nelement() / W_nf4.nelement():.2f}x")
# Dequantize lại — chỉ dùng khi cần tính toán
W_recon = dequantize_nf4(W_nf4, quant_state)
err = (W_fp16 - W_recon).abs().mean().item()
print(f"Sai số trung bình |W - W_recon|: {err:.5f}")
print(f"Tương đối: {err / W_fp16.abs().mean().item() * 100:.2f}%")
# Forward giả: x @ W — cần dequant trước
x = torch.randn(1, 4096, dtype=torch.float16, device="cuda")
y_fp16 = x @ W_fp16
y_nf4 = x @ W_recon
print(f"|y_fp16 - y_nf4| mean: {(y_fp16 - y_nf4).abs().mean():.5f}")
# Trong thực tế, bnb.nn.Linear4bit tự làm bước dequant trong CUDA kernel
layer = bnb.nn.Linear4bit(
4096, 4096,
bias=False,
compute_dtype=torch.bfloat16,
quant_type="nf4",
)
layer.weight.data = W_fp16 # trước khi .cuda() được tự quantizeNếu lượng tử hoá cả tensor bằng một scale duy nhất, các giá trị outlier ở đuôi sẽ kéo scale lớn và làm bẹt phần trung tâm, mất chính xác cho đa số trọng số. Block-wise, ví dụ block 64, chia tensor thành nhiều khối nhỏ, mỗi khối có scale riêng. Với tensor 4096 × 4096 và block 64 có 262.144 block, overhead scale FP32 khoảng 1 MB, so với khoảng 8 MB của tensor NF4 đóng gói (4096 × 4096 tham số × 0,5 byte).
Outlier channel trong LLM có độ lớn có thể trên 100 lần trung bình. SmoothQuant và AWQ xử lý outlier bằng cách scale input trước; QLoRA đơn giản hơn: block size nhỏ đã đủ vì mỗi block tự co giãn.
Theo bảng trong bài báo QLoRA, perplexity trên LLaMA-7B sau lượng tử hoá (chưa fine-tune), với đối chiếu cần kiểm chứng với bài gốc:
| Cách lượng tử hoá | Perplexity | Tăng so với FP16 |
|---|---|---|
| FP16 (baseline) | 5,68 | — |
| NF4 + double quant (block 64) | 5,73 | +0,9% |
| FP4 (block 64) | 5,79 | +1,9% |
| INT4 (block 64) | 5,88 | +3,5% |
| INT4 (per-tensor) | 7,21 | +27% |
Kết luận: block-wise là bắt buộc, INT4 per-tensor không dùng được cho LLM; NF4 nhỉnh hơn FP4 nhẹ, cả hai vượt INT4; double quantization không làm giảm chất lượng đo được. Sau khi fine-tune bằng QLoRA (adapter r = 64 trên tất cả lớp tuyến tính), khoảng cách perplexity với full fine-tuning thường dưới 0,3%.
Bộ nhớ hợp nhất của NVIDIA cho phép cấp phát bộ nhớ mà cả GPU và CPU cùng thấy. Driver tự chuyển trang khi cần. Paged optimizer cấp phát trạng thái Adam qua cudaMallocManaged thay vì cudaMalloc. Khi activation tạm tăng đột ngột (ví dụ chuỗi 8192 token), driver đẩy các trang ít dùng xuống RAM CPU và đưa lại khi optimizer step chạy. Theo nguồn bài, chi phí khoảng 10 đến 20% cho bước có page fault, và 0% cho bước không có đỉnh.
So với offload thủ công kiểu DeepSpeed ZeRO stage 3, paged optimizer đơn giản hơn nhiều và thường đủ cho QLoRA trên một GPU. Với nhiều GPU, DeepSpeed hoặc FSDP vẫn cần để chia gradient.
Với phần cứng mới (H100 FP8, MI300), mỗi năm đẩy giới hạn bit thêm một bước. Nhưng QLoRA (NF4, double quant, paged optimizer) vẫn là nền tảng thực tế nhất giai đoạn 2024 đến 2025 vì hệ sinh thái đã chín (PEFT, TRL, Axolotl, Unsloth).