ONE is preparing: 01 / INITIALIZING MODEL ROUTER. Evaluating routing across providers.
Current state
01 / INITIALIZING MODEL ROUTER.

Evaluating routing across providers.

Start learning
← Fine-tuning & Tối ưu

AI Builder

QLoRA - LoRA lượng tử hóa

Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.

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.

lesson105 minFine-tuning & Tối ưuAI Engineer

Dự đoán

Mô hình 70 tỷ tham số ở FP16 chiếm 140 GB VRAM để suy luận. Full fine-tuning cần khoảng 840 GB. Bạn chỉ có một GPU 48 GB. Có thể fine-tune được không?

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.

Ẩn dụ — bảo tàng tranh và lớp kính

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ượcCách làmNhận xét
Full fine-tuningMang từng bức tranh gốc về phòng và sơn lạiCầ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ínhKhô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
QLoRAChụ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ínhPhò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.

Khám phá — bộ nhớ và layout NF4

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ápTrọng số baseGhi chú
Full fine-tuningKhoảng 140 GB ở FP16, cộng gradient và AdamKhoảng 840 GB tổng cộng
LoRAKhoảng 140 GB ở FP16Chỉ adapter được huấn luyện
QLoRAKhoảng 35 GB ở 4-bit NF4Adapter 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.

Khoảnh khắc aha

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.

Thử thách

Tại sao QLoRA dùng NF4 (NormalFloat 4-bit) thay vì INT4 thông thường?
Bạn muốn fine-tune Llama 33B bằng QLoRA. VRAM tối thiểu cần là bao nhiêu?

Lý thuyết

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:

  1. NF4: kiểu 4-bit tối ưu về thông tin cho tensor có phân bố chuẩn.
  2. Double quantization: lượng tử hoá tiếp các hằng số quantization, tiết kiệm thêm khoảng 0,37 bit mỗi tham số.
  3. Paged optimizer: dùng bộ nhớ hợp nhất của NVIDIA để tránh tràn bộ nhớ khi có đỉnh gradient.

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):

MNF4=N×48+Nbblock×32(bytes)M_{\text{NF4}} = \frac{N \times 4}{8} + \frac{N}{b_{\text{block}}} \times 32 \quad \text{(bytes)}

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:

y=dequant(WNF4) x+BAxy = \text{dequant}(W_{\text{NF4}}) \, x + B A x

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.

Ví dụ 1: PEFT và bitsandbytes (QLoRA chuẩn)

qlora_training.py

# 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 adapter

Ví dụ 2: bitsandbytes mức thấp (hiểu NF4)

bnb_nf4_internals.py

import 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ự quantize

Vì sao block-wise quan trọng?

Nế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.

So sánh NF4, FP4 và INT4

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áPerplexityTă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%.

Khi nào QLoRA không phải lựa chọn tốt?

  • Mô hình dưới 7B và VRAM dư: full fine-tuning hoặc LoRA FP16 nhanh hơn nhiều, chất lượng nhỉnh hơn một chút. QLoRA chỉ đáng khi VRAM là rào cản.
  • Continued pre-training trên miền rất khác: adapter rank nhỏ có thể không đủ biểu diễn kiến thức hoàn toàn mới. Cân nhắc full fine-tuning hoặc tăng rank lên 128 đến 256.
  • Suy luận với throughput rất cao: adapter chạy lúc suy luận thêm phép nhân ma trận. Với vLLM hoặc TensorRT, nên merge rồi lượng tử hoá lại bằng AWQ.
  • H100 với FP8: FP8 mixed precision (Transformer Engine) có thể đạt VRAM tương đương QLoRA mà không chậm hơn; nên kiểm tra nếu có sẵn H100.

Paged optimizer: cơ chế bên trong

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.

Các bản cải tiến sau QLoRA

  • LoftQ (2023): khởi tạo adapter bằng SVD của lỗi lượng tử hoá, theo nguồn bài tốt hơn NF4 thuần khoảng 0,5 PPL.
  • QA-LoRA (2024): lượng tử hoá theo nhóm cho adapter, tiết kiệm thêm khoảng 10 đến 15% VRAM.
  • BitNet b1.58 (2024): huấn luyện từ đầu với trọng số {−1, 0, 1}, không cần giải nén khi chạy.
  • AQLM (2024): additive quantization đạt khoảng 2 bit mỗi trọng số với chất lượng gần NF4.

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).

Ứng dụng thực tế

  • Cá nhân và startup: fine-tune Llama 70B cho miền tiếng Việt, y tế hoặc luật trên một GPU 48 GB.
  • Doanh nghiệp: thay cluster 8 GPU bằng một đến hai A100 cho fine-tune hàng loạt.
  • Nghiên cứu: thử ý tưởng nhanh trên mô hình lớn mà không chờ hàng đợi cluster.
  • Kho adapter theo miền: mỗi adapter khoảng 100 MB, có thể lưu hàng nghìn adapter trên một base model.

Cạm bẫy thường gặp

  • Quên prepare_model_for_kbit_training: LayerNorm và LM head cần cast về FP32 hoặc FP16 để gradient ổn định. Thiếu bước này dễ gây loss NaN sau vài step.
  • Target modules sai: chỉ gắn LoRA vào q_proj và v_proj, bỏ qua MLP, chất lượng kém 2 đến 3% (theo nguồn bài). Gắn đủ 7 projection thì tốt hơn.
  • Batch size quá lớn: bắt đầu với batch 1 và gradient accumulation 16 đến 32.
  • Merge sai cách: merge vào base NF4 làm mất chất lượng vì lượng tử hoá hai lần. Luôn merge vào base FP16 hoặc BF16.
  • Learning rate sai: QLoRA thường dùng 2e-4 đến 3e-4, cao hơn full fine-tuning (khoảng 1e-5) vì adapter nhỏ. Dùng LR của full fine-tuning sẽ bị underfit nặng.

Tóm tắt

  • QLoRA = base model lượng tử hoá xuống NF4 (4-bit) + LoRA adapter BF16. Tiết kiệm đáng kể VRAM so với LoRA FP16 và full fine-tuning.
  • Ba đổi mới: NF4, double quantization (khoảng 0,37 bit mỗi tham số), paged optimizer (tránh tràn bộ nhớ khi có đỉnh).
  • Cho phép fine-tune 70B trên một GPU 48 GB, và 33B trên RTX 4090 24 GB.
  • Đánh đổi: chậm hơn LoRA thuần do giải nén khi chạy; chất lượng gần full fine-tuning.
  • Pipeline chuẩn: BitsAndBytesConfig (4-bit, nf4, double quant, bf16) + prepare_model_for_kbit_training + LoRA (r = 16) + paged_adamw_8bit.
  • Lỗi hay gặp: quên prepare k-bit, target modules thiếu MLP, LR quá thấp, merge adapter vào base NF4.

Continue the module

Lesson 3 of 8