Dự đoán
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.
Evaluating routing across providers.
AI Builder
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.
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.
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ạng | Ví dụ hiển thị | Ẩn dụ |
|---|---|---|
| FP32 | 25,34691°C | Nhiệt kế phòng thí nghiệm |
| FP16 | 25,35°C | Nhiệt kế thường trong nhà |
| INT8 | 25,3°C | Nhiệt kế y tế |
| INT4 | 25°C | Nhiệ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.
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ạng | Số bin | Nhận xét |
|---|---|---|
| FP32 và FP16 | Gần như liên tục | Mọi giá trị phân biệt được |
| INT8 | 256 | Đủ mịn, theo nguồn bài mất dưới 0,5% chất lượng |
| INT4 | 16 | Vẫn đủ tốt vì trọng số tập trung quanh 0 |
| INT2 | 4 | Mấ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.
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.
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.
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.
Ví dụ INT8 đối xứng: khoảng [−127, 127], 256 bin. INT4: khoảng [−7, 7], chỉ 16 bin.
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 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.
# 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# 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 (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.
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 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.
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.