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

Lượng tử hóa mô hình

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

Kỹ thuật giảm kích thước mô hình bằng cách giảm độ chính xác số học, từ FP32 xuống INT8/INT4.

lesson105 minFine-tuning & Tối ưuAI Engineer

Dự đoán

Llama 3 70B chiếm 140 GB ở FP16, cần hai GPU A100 80 GB. Có cách nào chạy trên một GPU 24 GB?

Lượng tử hoá giống nén ảnh RAW 50 MB thành JPEG 5 MB: mắt thường khó phân biệt. Đây là chìa khoá giúp LLM từ đặc quyền của trung tâm dữ liệu trở thành thứ chạy được trên laptop.

Ẩn dụ — nhiệt kế

Nhiệt kế điện tử hiển thị 25,347°C, nhiệt kế cơ học chỉ 25°C. Bạn cần độ chính xác nào để quyết định bật quạt? Cả hai đều được: bạn chỉ quan tâm nóng hay lạnh.

Định dạngVí dụ hiển thịẨn dụ
FP3225,34691°CNhiệt kế phòng thí nghiệm
FP1625,35°CNhiệt kế thường trong nhà
INT825,3°CNhiệt kế y tế
INT425°CNhiệt kế cơ đơn giản

Trọng số mạng nơ-ron giống nhiệt độ: giá trị chính xác đến năm chữ số thập phân không làm mô hình trả lời tốt hơn so với một chữ số. Lượng tử hoá khai thác điều này: giảm độ chính xác đến mức kết quả cuối gần như không đổi, đổi lấy tiết kiệm bộ nhớ từ 4 đến 8 lần.

Khám phá — bin, bit và kích thước

Với một phân bố trọng số hình chuông, mỗi mức bit cho số bin khác nhau:

Định dạngSố binNhận xét
FP32 và FP16Gần như liên tụcMọi giá trị phân biệt được
INT8256Đủ mịn, theo nguồn bài mất dưới 0,5% chất lượng
INT416Vẫn đủ tốt vì trọng số tập trung quanh 0
INT24Mất nhiều thông tin; cần QAT hoặc kỹ thuật đặc biệt

Llama 70B ở các mức chính xác: FP32 cần 280 GB (cần cluster); FP16 và BF16 cần 140 GB; INT8 cần 70 GB; INT4 cần 35 GB, vừa RTX 6000 Ada hoặc hai RTX 4090, với chất lượng khoảng 97,5% theo nguồn bài; INT2 cần 17,5 GB, chạy được trên laptop nhưng chất lượng giảm mạnh.

Theo nguồn bài (Llama-7B, perplexity c4): chất lượng gần như không đổi từ FP32 xuống INT8, mất nhẹ ở INT4 (khoảng 2,5%), và có vách đá rõ ở INT2 nếu không dùng QAT hoặc phương pháp đặc biệt như AQLM, BitNet.

Khoảnh khắc aha

Trọng số mạng nơ-ron không cần chính xác đến từng chữ số thập phân. Giống như biết nhiệt độ phòng là 25°C là đủ để bật quạt, lượng tử hoá giảm độ chính xác đến mức quyết định cuối của mô hình gần như không đổi, đổi lại tiết kiệm bộ nhớ và tăng tốc. Đó là lý do một mô hình 70B từng cần cluster nay chạy được trên một GPU gaming.

Thử thách

Bạn có mô hình 13B ở FP16 (26 GB). GPU của bạn có 16 GB VRAM. Mức lượng tử hoá nào nhỏ nhất mà vẫn dùng được?
Team muốn deploy chatbot INT4 trên GPU server. Giữa GPTQ và AWQ, chọn cái nào?

Lý thuyết

Lượng tử hoá là ánh xạ giá trị liên tục (float) sang tập rời rạc ít bit hơn. Trong deep learning, áp dụng lên trọng số và hoặc kích hoạt để giảm bộ nhớ và tăng tốc suy luận. Cùng với pruning và distillation, đây là ba trụ cột nén mô hình.

xq=round(xs)+z,xdequant=s⋅(xq−z)x_q = \text{round}\left(\frac{x}{s}\right) + z, \qquad x_{\text{dequant}} = s \cdot (x_q - z)

s là scale factor (độ phân giải mỗi bin), z là zero-point (giá trị 0 được ánh xạ vào bin nào). Với lượng tử hoá đối xứng, z = 0.

s=max⁡(∣x∣)2b−1−1,xq∈[−(2b−1−1), 2b−1−1]s = \frac{\max(|x|)}{2^{b-1} - 1}, \qquad x_q \in [-(2^{b-1}-1), \, 2^{b-1}-1]

Ví dụ INT8 đối xứng: khoảng [−127, 127], 256 bin. INT4: khoảng [−7, 7], chỉ 16 bin.

Granularity: mức độ chia nhỏ scale

  • Per-tensor: một scale cho cả tensor. Đơn giản nhưng kém, vì outlier làm bẹt đa số giá trị.
  • Per-channel: một scale cho mỗi output channel. Mặc định cho INT8 trong LLM.
  • Per-group hoặc block-wise: một scale cho mỗi block (ví dụ 32 đến 128 giá trị). Cần cho INT4; GPTQ, AWQ và NF4 đều dùng.

PTQ và QAT

  • PTQ (post-training): áp dụng sau khi huấn luyện xong, chỉ cần vài trăm mẫu để đo khoảng giá trị. Nhanh, nhưng có thể giảm chất lượng ở 4 bit trở xuống.
  • QAT (quantization-aware training): mô phỏng lượng tử hoá trong lượt forward, gradient chạy ngược qua straight-through estimator. Mô hình học cách bù lỗi. Tốt hơn PTQ, đặc biệt ở 2 bit trở xuống.

GPTQ: lượng tử hoá từng lớp với Hessian

min⁡Wq∥WX−WqX∥22tương đươngmin⁡Wq(W−Wq)TH(W−Wq),  H=XXT\min_{W_q} \|WX - W_q X\|_2^2 \quad \text{tương đương} \quad \min_{W_q} (W - W_q)^T H (W - W_q), \; H = XX^T

GPTQ xử lý từng cột của ma trận trọng số; sau mỗi cột, cập nhật các cột còn lại để bù lỗi bằng nghịch đảo Hessian. Theo nguồn bài, 4 bit chỉ mất khoảng 1,5% PPL trên Llama-7B.

AWQ: lượng tử hoá nhận biết kích hoạt

AWQ quan sát rằng chỉ khoảng 1% kênh quan trọng nhất, xác định qua độ lớn kích hoạt chứ không phải độ lớn trọng số. Scale các kênh này lên trước khi lượng tử hoá để giảm lỗi đúng chỗ cần thiết. Theo nguồn bài, chất lượng nhỉnh GPTQ khoảng 0,2 đến 0,5 PPL, với kernel tối ưu cho suy luận.

Ví dụ 1: bitsandbytes lượng tử hoá khi nạp

bnb_quantize.py

# pip install "transformers>=4.41" "bitsandbytes>=0.43" accelerate
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

MODEL_ID = "meta-llama/Llama-3-70B"

# Config: INT4 quantization khi load
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",          # "nf4" hoặc "fp4"
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,     # tiết kiệm thêm ~0.4 bit/param
)

model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    quantization_config=bnb_config,
    device_map="auto",
)
# 70B × 16-bit = 140GB → quantized ≈ 36GB VRAM

tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
inputs = tokenizer("Quantization in simple terms:", return_tensors="pt").to("cuda")

with torch.no_grad():
    outputs = model.generate(**inputs, max_new_tokens=100, do_sample=False)

print(tokenizer.decode(outputs[0]))
# Tốc độ inference ≈ 1.5-2x nhanh hơn FP16 vì giảm memory bandwidth
# Chất lượng: PPL chỉ tăng ~1-2% so với FP16

# Muốn INT8 thay vì INT4? Dùng llm_int8:
bnb_int8 = BitsAndBytesConfig(
    load_in_8bit=True,
    llm_int8_threshold=6.0,  # outlier threshold — giữ FP16 cho kênh >6σ
)
model8 = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    quantization_config=bnb_int8,
    device_map="auto",
)
# 70B INT8 ≈ 70GB — vừa 1×A100 80GB

Ví dụ 2: GPTQ với AutoGPTQ

gptq_quantize.py

# pip install auto-gptq>=0.7 transformers optimum
import torch
from transformers import AutoTokenizer
from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig

MODEL_ID = "meta-llama/Llama-3-8B"
OUT_DIR = "./llama3-8b-gptq-4bit"

# Bước 1: Cấu hình GPTQ
quantize_config = BaseQuantizeConfig(
    bits=4,                    # 2, 3, 4, 8 đều hỗ trợ
    group_size=128,            # block-wise; 128 là chuẩn
    desc_act=True,             # activation order — tăng chất lượng
    damp_percent=0.1,          # Hessian dampening
)

# Bước 2: Load model ở FP16 để quantize
tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
model = AutoGPTQForCausalLM.from_pretrained(
    MODEL_ID,
    quantize_config=quantize_config,
    torch_dtype=torch.float16,
)

# Bước 3: Chuẩn bị calibration dataset (128-1024 mẫu đủ)
from datasets import load_dataset
data = load_dataset("c4", "en", split="train", streaming=True)
examples = []
for i, sample in enumerate(data):
    if i >= 512:
        break
    tokens = tokenizer(sample["text"], return_tensors="pt",
                       truncation=True, max_length=2048)
    examples.append({
        "input_ids": tokens.input_ids[0],
        "attention_mask": tokens.attention_mask[0],
    })

# Bước 4: Quantize — chạy layer-by-layer, dùng Hessian
model.quantize(examples)  # ~15 phút cho 8B trên A100

# Bước 5: Lưu
model.save_quantized(OUT_DIR)
tokenizer.save_pretrained(OUT_DIR)

# Bước 6: Load lại và dùng (kernel tối ưu)
from auto_gptq import AutoGPTQForCausalLM
q_model = AutoGPTQForCausalLM.from_quantized(
    OUT_DIR,
    device="cuda:0",
    use_safetensors=True,
    use_triton=False,       # True cho kernel Triton nhanh hơn
)

# Inference: 2-4x nhanh hơn FP16, chất lượng ~98.5% FP16
prompt = "Giải thích quantization:"
tokens = tokenizer(prompt, return_tensors="pt").to("cuda")
output = q_model.generate(**tokens, max_new_tokens=200)
print(tokenizer.decode(output[0]))

Đối xứng hay bất đối xứng?

Đối xứng (z = 0) giả định phân bố cân đối quanh 0, có decoder đơn giản chỉ là phép nhân với s; phù hợp trọng số. Bất đối xứng (z khác 0) có hai tham số scale và zero-point, chứa được phân bố lệch như đầu ra ReLU; decoder tốn thêm một phép cộng. Thực tế LLM thường dùng trọng số đối xứng và kích hoạt bất đối xứng.

Bao nhiêu mẫu calibration là đủ?

Theo nguồn bài, thử trên Llama-7B: 32 mẫu chưa đủ (PPL tăng 5 đến 10%); 128 mẫu là sàn (trong 2% FP16); 512 mẫu là điểm tối ưu; trên 2048 mẫu thì lợi ích giảm dần. Nếu mô hình dùng cho tiếng Việt, nên calibrate bằng văn bản tiếng Việt thay vì C4 tiếng Anh, vì lệch miền có thể làm PPL tăng 3 đến 5%.

FP8

FP8 là định dạng tensor core mới trên H100, có hai biến thể: E4M3 (4 bit mũ, 3 bit mantissa) dùng cho trọng số và kích hoạt; E5M2 (5 bit mũ, 2 bit mantissa) dùng cho gradient. NVIDIA Transformer Engine tự chuyển giữa FP16 và FP8 theo độ ổn định của loss. Theo nguồn bài, huấn luyện LLM với FP8 đạt tốc độ 1,5 đến 2 lần FP16 mà không mất chất lượng đo được.

Pipeline triển khai

  1. Huấn luyện hoặc tinh chỉnh mô hình ở FP16 hoặc BF16.
  2. Chuẩn bị calibration dataset: 128 đến 512 mẫu từ phân bố production.
  3. Chạy GPTQ hoặc AWQ để tạo checkpoint 4-bit.
  4. Đo PPL hoặc accuracy trên eval set; nếu giảm trên 3%, thử AWQ, group size nhỏ hơn, hoặc giữ một số lớp ở FP16.
  5. Xuất sang engine suy luận: vLLM, TGI, TensorRT-LLM hoặc SGLang.
  6. Benchmark throughput và độ trễ trên phần cứng đích.
  7. A/B test với baseline FP16 trên một phần lưu lượng trước khi triển khai đầy đủ.

Không được bỏ bước đo chất lượng và A/B test. Nhiều nhóm triển khai thẳng mà không đo, rồi người dùng phàn nàn bot trở nên kém đi. Lượng tử hoá không miễn phí; phải đo.

Ứng dụng thực tế

  • LLM trên GPU phổ thông: Llama 70B INT4 chạy được trên RTX 4090 và MacBook M2 Max 64 GB (qua GGUF).
  • Mobile và edge: Phi-3 và Gemma 2B INT4 chạy được trên điện thoại (theo nguồn bài).
  • Phục vụ production: vLLM kết hợp AWQ INT4 đạt throughput gấp 3 đến 4 lần FP16 trên cùng phần cứng (theo nguồn bài).
  • Nhiều mô hình trên một GPU: INT4 cho phép đặt ba mô hình 13B trên một A100 80 GB.
  • Fine-tune khi thiếu bộ nhớ: QLoRA (NF4) cho phép fine-tune 70B trên một GPU.
  • Thiết bị nhúng: BERT INT8 chạy được trên Raspberry Pi và Coral TPU.

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

  • Không đo chất lượng sau lượng tử hoá: luôn đo PPL và tác vụ downstream trước khi triển khai.
  • Per-tensor cho INT4: không dùng được cho LLM; luôn dùng group-wise.
  • Calibration sai miền: calibrate bằng C4 tiếng Anh rồi triển khai tiếng Việt làm PPL tăng bất thường.
  • Lượng tử hoá LayerNorm và embedding: hai lớp này nhạy cảm, thường giữ ở FP16 hoặc BF16.
  • So sánh tốc độ không công bằng: INT4 có thể nhanh ở batch 1 nhưng chậm hơn FP16 ở batch 128 do overhead khởi chạy kernel.
  • Không kiểm tra độ ổn định số học: INT2 và INT3 có thể sinh NaN với đầu vào cực đoan; hãy thử các trường hợp biên.
  • Bỏ qua băng thông bộ nhớ: nếu kernel vẫn giải nén sang FP16 rồi nhân ma trận, lợi ích băng thông có thể nhỏ hơn kỳ vọng. Đo trước khi kết luận.

Tóm tắt

  • Lượng tử hoá giảm số bit mỗi tham số: FP32, FP16, INT8, INT4, INT2. Chất lượng giảm không đều; INT4 là điểm cân bằng thường dùng.
  • PTQ nhanh cần dữ liệu calibration; QAT chậm hơn nhưng chất lượng tốt hơn ở 4 bit trở xuống. Hầu hết LLM mã nguồn mở dùng PTQ.
  • INT4 giảm khoảng 8 lần so với FP32 và mất khoảng 2,5% chất lượng theo nguồn bài. INT2 cần kỹ thuật đặc biệt.
  • Thuật toán: GPTQ (Hessian từng lớp), AWQ (bảo vệ 1% kênh quan trọng), NF4 (QLoRA), GGUF (llama.cpp), SmoothQuant (INT8).
  • Granularity: per-tensor kém cho LLM vì outlier; per-channel tốt cho INT8; group-wise bắt buộc cho INT4.
  • Chọn định dạng theo phần cứng và luôn đo chất lượng sau khi lượng tử hoá.

Continue the module

Lesson 5 of 8