Phần 3: Thực Chiến Fine-Tuning QLoRA: Axolotl & Unsloth

← Chương trước: Phần 2: Kỹ Nghệ Dữ Liệu Cho SFT: NEFTune & SemDeDup | Mục lục Series | Chương tiếp theo: Phần 4: Knowledge Distillation: Chắt Lọc Tri Thức DeepSeek-R1 →

Answer-first: QLoRA lượng tử hóa trọng số gốc xuống 4-bit NF4 kết hợp Double Quantization và Paged Optimizers, tiết kiệm 65% VRAM mà vẫn giữ 99.3% độ chính xác so với 16-bit. Sử dụng Axolotl cho phép tinh chỉnh hoàn chỉnh mô hình 14B trên một GPU 24GB duy nhất với chi phí dưới $1.50 mỗi lượt chạy.

📖 Bản tiếng Anh (English Edition): Part 3: QLoRA & Axolotl Fine-Tuning on Commodity GPUs

1. LoRA: Cơ Chế Toán Học Phân Rã Ma Trận Hạng Thấp (Low-Rank Adaptation)

BLUF (Bottom Line Up Front): Giả thuyết Hạng Nội Tại (Intrinsic Rank) chứng minh rằng các cập nhật trọng số trong quá trình thích ứng tác vụ đặc thù có số chiều tự do rất nhỏ; phân rã ma trận cập nhật $\Delta W = B \cdot A$ với rank $r=16$ giảm 99.5% số lượng tham số cần tính toán gradient mà không làm giảm năng lực biểu diễn.

Huấn luyện tinh chỉnh toàn phần (Full Parameter Fine-Tuning) một mô hình ngôn ngữ như Llama 3 8B đòi hỏi cập nhật toàn bộ 8 tỷ tham số ở định dạng FP16. Mỗi tham số đòi hỏi lưu trữ trọng số gốc (2 bytes), gradients (2 bytes) và trạng thái bộ tối ưu hóa AdamW (16 bytes), đẩy tổng lượng VRAM yêu cầu lên trên 160GB—bắt buộc phải có cụm 4 đến 8 GPU A100/H100 chạy song song qua FSDP.

Để giải phóng kỹ sư khỏi gánh nặng hạ tầng triệu đô, Hu et al. (Microsoft, 2021) giới thiệu LoRA (Low-Rank Adaptation).

flowchart LR
    subgraph LoRALayer ["Cơ Chế Tính Toán Lớp LoRA (Forward Pass)"]
        direction TB
        Input["Đầu vào x in R^d"] --> Frozen["Trọng số gốc W_0 in R^(d x k)<br/>[ĐÓNG BĂNG - Không Gradient]"]
        Input --> MatA["Ma trận A in R^(r x d)<br/>[Khởi tạo Gaussian N(0, sigma^2)]"]
        MatA --> MatB["Ma trận B in R^(k x r)<br/>[Khởi tạo Bằng 0]"]
        MatB --> Scale["Nhân tỉ lệ: (alpha / r) * B * A * x"]
        Frozen --> Add["Cộng tổng đầu ra: y = W_0*x + (alpha/r)*B*A*x"]
        Scale --> Add
    end

Công thức toán học cốt lõi

Giả sử lớp tuyến tính ban đầu thực hiện phép biến đổi $h = W_0 x$ với $W_0 \in \mathbb{R}^{d \times k}$. LoRA đóng băng hoàn toàn ma trận $W_0$ và mô hình hóa phần cập nhật trọng số $\Delta W$ thành tích của hai ma trận hạng thấp:

$$W = W_0 + \Delta W = W_0 + \frac{\alpha}{r} (B \cdot A)$$

Trong đó:

• $A \in \mathbb{R}^{r \times d}$ được khởi tạo ngẫu nhiên theo phân phối chuẩn Gaussian $\mathcal{N}(0, \sigma^2)$.
• $B \in \mathbb{R}^{k \times r}$ được khởi tạo hoàn toàn bằng các số 0.
• Do $B = 0$ tại thời điểm bắt đầu huấn luyện, $\Delta W = B \cdot A = 0$, đảm bảo đầu ra ban đầu của mô hình hoàn toàn trùng khớp 100% với mô hình gốc.
• $\frac{\alpha}{r}$ là hệ số tỉ lệ (scaling factor). Giữ tỉ lệ cố định $\alpha = 2 \times r$ giúp gradient luôn ổn định khi bạn thử nghiệm thay đổi giữa các mức rank $r=8, 16, 32$.

2. QLoRA & 4-bit NormalFloat (NF4): Lượng Tử Hóa Tối Ưu

BLUF (Bottom Line Up Front): QLoRA (Dettmers et al., 2023) kết hợp định dạng lượng tử hóa tối ưu theo lý thuyết thông tin 4-bit NormalFloat (NF4), Double Quantization (tiết kiệm 0.37 bits/param) và Paged Optimizers để đưa mô hình 8B xuống mức tiêu thụ 4.4GB VRAM.

Mặc dù LoRA đã loại bỏ bộ nhớ gradient cho trọng số gốc, bản thân ma trận trọng số $W_0$ ở định dạng 16-bit vẫn chiếm tới 16GB VRAM cho mô hình 8B. QLoRA giải quyết triệt để rào cản này bằng ba kỹ thuật đột phá:

flowchart TD
    subgraph QLoRATechnology ["Ba Trụ Cột Đột Phá Của QLoRA"]
        NF4["1. 4-bit NormalFloat (NF4)<br/>Phân phối lượng tử hóa tối ưu theo phân phối chuẩn"]
        DQ["2. Double Quantization (DQ)<br/>Lượng tử hóa cấp hai hằng số scale (tiết kiệm 0.37 bits/param)"]
        PO["3. Paged Optimizers<br/>Tự động phân trang bộ nhớ AdamW sang CPU RAM khi có đỉnh VRAM"]
    end

1. Định dạng 4-bit NormalFloat (NF4)

Các trọng số nơ-ron sau khi tiền huấn luyện luôn tuân theo phân phối chuẩn đối xứng qua điểm 0: $\mathcal{N}(0, \sigma^2)$. Nếu dùng định dạng số nguyên INT4 thông thường (phân bổ đều khoảng cách giữa các số), các vùng tập trung nhiều trọng số gần 0 sẽ bị mất mát độ phân giải, trong khi các vùng biên xa lại thừa thãi bit biểu diễn.

NF4 xây dựng 16 điểm lượng tử hóa sao cho mỗi khoảng chứa xác suất tích lũy bằng nhau (equal probability mass). Đây là định dạng lượng tử hóa tối ưu tuyệt đối theo lý thuyết thông tin (information-theoretically optimal), giúp trọng số 4-bit đạt 99.3% độ chính xác của trọng số 16-bit.

2. Lượng tử hóa kép (Double Quantization - DQ)

Để lượng tử hóa một khối trọng số gồm 64 phần tử, chúng ta cần lưu trữ một hằng số tỉ lệ 32-bit float ($c_1$). Hằng số này chiếm tới:

$$\frac{32 \text{ bits}}{64} = 0.5 \text{ bits/parameter}$$

Double Quantization tiếp tục lượng tử hóa hằng số $c_1$ này xuống định dạng 8-bit FP8 với kích thước khối 256. Nhờ đó, chi phí lưu hằng số giảm xuống còn:

$$\frac{8 \text{ bits}}{64} + \frac{32 \text{ bits}}{64 \times 256} \approx 0.127 \text{ bits/parameter}$$

Tiết kiệm được 0.373 bits trên mỗi tham số, tương đương giải phóng gần 400MB VRAM trên mô hình 8B.

3. Paged Optimizers

Sử dụng tính năng CUDA Unified Memory của NVIDIA, Paged Optimizers tự động đẩy các tensor trạng thái của bộ tối ưu hóa AdamW từ VRAM sang RAM máy chủ (CPU) khi phát hiện các đỉnh bùng nổ độ dài chuỗi (sequence spikes), triệt tiêu hoàn toàn lỗi văng chương trình CUDA Out-Of-Memory (OOM).

3. Công Thức Tính Toán Bộ Nhớ VRAM Huấn Luyện (7B & 14B)

BLUF (Bottom Line Up Front): Bộ nhớ VRAM khi fine-tune QLoRA được tính toán bằng tổng của 5 thành phần: Trọng số 4-bit + Trọng số Adapters + Gradients Adapters + Trạng thái AdamW 8-bit + Bộ nhớ kích hoạt (Activations); mô hình 8B với context 4,096 chỉ tiêu tốn 14.8GB VRAM khi bật Gradient Checkpointing.

$$\text{VRAM}{\text{total}} = \text{VRAM}{\text{model_4bit}} + \text{VRAM}{\text{adapters}} + \text{VRAM}{\text{gradients}} + \text{VRAM}{\text{adamw_8bit}} + \text{VRAM}{\text{activations}} + \text{CUDA}_{\text{overhead}}$$

Bảng Phân Bổ Bộ Nhớ VRAM Huấn Luyện Thực Tế (Batch Size = 1, Gradient Checkpointing = True)

4. Cấu Hình Sản Xuất Axolotl (YAML Specification 2026)

BLUF (Bottom Line Up Front): Axolotl là framework chuẩn công nghiệp cho phép cấu hình huấn luyện LLM dưới dạng một file YAML khai báo duy nhất; cấu hình chuẩn yêu cầu bật FlashAttention-2, gradient_checkpointing, target all-linear và paged_adamw_8bit.

Dưới đây là cấu hình hoàn chỉnh cho tác vụ fine-tune Qwen 2.5 Coder 7B trên 1 card GPU RTX 4090 (24GB VRAM):

# axolotl_qwen_coder_7b_qlora.yaml - Production Axolotl Config
base_model: Qwen/Qwen2.5-Coder-7B-Instruct
model_type: AutoModelForCausalLM
tokenizer_type: AutoTokenizer

load_in_8bit: false
load_in_4bit: true
strict: false

# Cấu hình LoRA Adapters
adapter: qlora
lora_r: 16
lora_alpha: 32
lora_dropout: 0.05
lora_target_modules:
  - q_proj
  - k_proj
  - v_proj
  - o_proj
  - gate_proj
  - up_proj
  - down_proj

# Bộ dữ liệu huấn luyện
datasets:
  - path: /opt/data/sft_clean_data.jsonl
    type: chat_template
    chat_template: chatml

dataset_prepared_path: /opt/cache/last_run_prepared
val_set_size: 0.05
output_dir: /opt/checkpoints/qwen7b-qlora-prod

# Tối ưu hóa chuỗi và tính toán
sequence_len: 4096
sample_packing: true
pad_to_sequence_len: true

# Tối ưu hóa bộ nhớ GPU
gradient_accumulation_steps: 16
micro_batch_size: 1
num_epochs: 2
optimizer: paged_adamw_8bit
lr_scheduler: cosine
learning_rate: 0.0002

# Kỹ thuật ổn định và gia tốc phần cứng
train_on_inputs: false
group_by_length: false
bf16: true
fp16: false
tf32: true
gradient_checkpointing: true
flash_attention: true
warmup_ratio: 0.05
weight_decay: 0.01

# Tiêm nhiễu nhúng NEFTune
neftune_noise_alpha: 5

logging_steps: 10
eval_steps: 50
save_steps: 100
save_total_limit: 3

5. Tăng Tốc Huấn Luyện Gấp 3 Lần Với Unsloth (Triton Kernels)

BLUF (Bottom Line Up Front): Unsloth viết lại các bước tính đạo hàm backward pass của PyTorch bằng OpenAI Triton kernels tùy biến, giảm 68% bộ nhớ tiêu thụ và tăng tốc độ huấn luyện lên 2.4x–3.0x mà không làm sai lệch dù chỉ một giá trị gradient so với toán học chuẩn.

Khi huấn luyện trên card đồ họa đơn lẻ, thư viện Unsloth là cơ chế then chốt giúp rút ngắn chu kỳ thử nghiệm:

• Fusing Cross-Entropy Loss: Trong PyTorch thông thường, lớp tính CrossEntropy phải cấp phát một tensor khổng lồ có kích thước [Batch, Seq_Len, Vocab_Size]. Với từ điển 152,000 tokens của Qwen, tensor này chiếm tới hơn 5GB VRAM. Unsloth tính toán loss trực tiếp trong kernel Triton mà không cần lưu trữ toàn bộ tensor xác suất này ra bộ nhớ toàn cục (Global VRAM).
• Tối ưu RoPE (Rotary Position Embeddings): Gom toàn bộ các phép quay vector vị trí vào một kernel duy nhất, giảm 80% thời gian giao tiếp giữa GPU Core và VRAM.

Đoạn mã Python huấn luyện với Unsloth

# unsloth_train.py - Fast 2.4x QLoRA Training with Unsloth
import torch
from unsloth import FastLanguageModel
from trl import SFTTrainer
from transformers import TrainingArguments
from datasets import load_dataset

# 1. Tải mô hình 4-bit với kernel tăng tốc
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="Qwen/Qwen2.5-Coder-7B-Instruct",
    max_seq_length=4096,
    dtype=None,  # Tự động chọn Float16 hoặc Bfloat16
    load_in_4bit=True,
)

# 2. Gắn LoRA adapters vào tất cả các lớp tuyến tính
model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    lora_alpha=32,
    lora_dropout=0,  # Unsloth tối ưu tốt nhất khi dropout=0
    bias="none",
    use_gradient_checkpointing="unsloth",
    random_state=42,
)

# 3. Chuẩn bị dữ liệu và huấn luyện
dataset = load_dataset("json", data_files={"train": "/opt/data/train.jsonl"})

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset["train"],
    dataset_text_field="text",
    max_seq_length=4096,
    dataset_num_proc=2,
    packing=True,  # Gộp nhiều câu ngắn để tăng tốc độ huấn luyện
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=8,
        warmup_steps=20,
        max_steps=200,
        learning_rate=2e-4,
        fp16=not torch.cuda.is_bf16_supported(),
        bf16=torch.cuda.is_bf16_supported(),
        logging_steps=10,
        output_dir="/opt/checkpoints/unsloth_out",
    ),
)
trainer.train()

# 4. Lưu adapter hoặc gộp thẳng vào mô hình 16-bit
model.save_pretrained_merged("/opt/models/qwen7b_merged_16bit", tokenizer, save_method="merged_16bit")
print("Huấn luyện thành công và đã merge trọng số sang SafeTensors 16-bit!")

6. Câu Chuyện Thất Bại Thực Chiến (Production Failure Case Study)

BLUF (Bottom Line Up Front): Một đội ngũ kỹ sư đã làm hỏng hoàn toàn năng lực của mô hình Llama 3 8B do huấn luyện ở định dạng FP16 trên card A10G, gây ra hiện tượng tràn số dưới (underflow) và khiến hàm Loss nổ thành giá trị NaN tại bước thứ 340.

Bối cảnh sự cố

Một công ty phần mềm SaaS thực hiện fine-tune Llama 3 8B trên một GPU NVIDIA A10G sử dụng mã nguồn PyTorch PEFT tự viết. Họ cấu hình tham số fp16: true thay vì bf16: true.

┌────────────────────────────────────────────────────────────────────────┐
│                   SỰ CỐ NỔ LOSS NaN VÀ PHÁ HỎNG ADAPTER                │
├────────────────────────────────────────────────────────────────────────┤
│ Bước 1 - 200: Loss giảm đều từ 2.45 xuống 1.15 (Trông rất hứa hẹn!)   │
│ Bước 320: Gặp một batch dữ liệu chứa chuỗi code phức tạp dài 3,800 tok │
│ Bước 340: Phép tính Softmax trong Attention Layer bị tràn số dưới      │
│ Bước 341: Giá trị Gradient bằng 0 dẫn đến phép chia cho 0 -> NaN       │
│ Bước 342: Toàn bộ ma trận Adapter B bị nhiễm giá trị NaN vĩnh viễn     │
│ Hậu quả: Mô hình sinh ra toàn ký tự rác '!!!!!!!!!!', mất 12 giờ GPU   │
└────────────────────────────────────────────────────────────────────────┘

Phân tích nguyên nhân gốc rễ (Root-Cause Autopsy)

1. Dải động hạn chế của FP16: Định dạng FP16 chỉ có 5 bits cho phần mũ (exponent), dải giá trị cực đại chỉ đạt xấp xỉ $65,504$ và giá trị dương nhỏ nhất là $5.96 \times 10^{-8}$. Khi độ dài chuỗi tăng lên 4,096 tokens, các giá trị attention logit chưa chuẩn hóa bị tràn biên dưới (underflow), biến thành giá trị 0 thuần túy.
2. Thiếu Gradient Clipping: Mã nguồn không bật cơ chế giới hạn biên độ gradient (max_grad_norm: 1.0). Khi hiện tượng bất ổn định số học xảy ra, gradient bùng nổ vượt ngưỡng và xóa sạch các trọng số hữu ích đã học được trước đó.
3. Không lưu checkpoint trung gian: Cấu hình huấn luyện chỉ lưu checkpoint ở cuối epoch, khiến nhóm không có bản sao lưu nào để phục hồi lại trạng thái trước khi sự cố NaN xảy ra.

Quy tắc an toàn bắt buộc (SOTA Guardrails)

• Luôn dùng BF16 trên kiến trúc Ampere trở lên: Bfloat16 có cùng 8 bits phần mũ như FP32, mang lại dải động khổng lồ lên tới $10^{38}$, triệt tiêu 100% rủi ro tràn số dưới khi tính Attention.
• Bắt buộc bật Gradient Clipping: Luôn cấu hình max_grad_norm: 1.0 hoặc 0.5 trong mọi file tham số.
• Cơ chế Checkpoint tự động: Lưu checkpoint định kỳ mỗi 100 bước với save_total_limit: 3. Khi loss xuất hiện dấu hiệu tăng vọt bất thường hoặc chạm NaN, script huấn luyện phải lập tức dừng và khôi phục từ checkpoint liền trước.

7. Ma Trận Đánh Đổi Kỹ Thuật (Trade-Off Framing 2027)

So sánh toàn diện các phương pháp tinh chỉnh tham số mô hình ngôn ngữ:

❓ Câu Hỏi Thường Gặp (FAQ)

🔗 Các Bước Tiếp Theo Trong Sổ Tay

Sau khi làm chủ kỹ thuật huấn luyện QLoRA trên phần cứng phổ thông, hãy khám phá phương pháp chắt lọc năng lực tư duy logic từ các siêu mô hình suy luận:
👉 Phần 4: Knowledge Distillation: Chắt Lọc Tri Thức DeepSeek-R1.