Quantization là kỹ thuật chuyển đổi trọng số (weight) của model AI từ dạng số thực có độ chính xác cao (FP16, FP32) sang dạng số có bit thấp hơn (INT8, INT4, INT2), từ đó giảm đáng kể lượng bộ nhớ RAM hoặc VRAM cần thiết để chạy model. Với quantization đúng mức, bạn có thể chạy model 70B tham số trên GPU 24GB VRAM thay vì cần ~140GB như nguyên bản FP16.
Quantization hoạt động như thế nào?
Model AI lưu trữ hàng tỷ tham số dưới dạng số thực (floating point). Mỗi tham số ở FP16 chiếm 2 byte, ở FP32 chiếm 4 byte. Kỹ thuật quantization thu gọn các giá trị này thành các mức rời rạc của một kiểu dữ liệu ít bit hơn.
Ví dụ, quantization Q4_K_M nén mỗi trọng số về 4-bit nhưng vẫn giữ một phần trọng số quan trọng ở dạng FP16 gốc. Kỹ thuật block quantization chia trọng số thành từng khối (thường 128 tham số), mỗi khối có scale factor riêng để tái tạo giá trị chính xác hơn khi giải nén.
Vì sao giảm bit lại giảm được RAM và VRAM?
Mỗi trọng số model tại FP16 cần 16 bit = 2 byte. Khi chuyển sang Q8, mỗi trọng số chỉ còn 8 bit = 1 byte. Khi chuyển sang Q4, mỗi trọng số chỉ còn trung bình ~4.5 bit (với định dạng Q4_K_M). Đây là phép toán đơn giản:
- Model 7B tham số × 2 byte (FP16) = 14 GB
- Model 7B tham số × 1 byte (Q8) = ~7 GB
- Model 7B tham số × 0.5 byte (Q4) = ~3.7 GB
Công thức tổng quát: RAM/VRAM cần thiết ≈ (Số tham số × Bit-per-parameter) ÷ 8 + 1~2 GB overhead. Mức overhead 1-2 GB phục vụ activation, KV cache và bộ nhớ tạm khi inference.
So sánh FP16, FP8, Q8, Q6, Q5, Q4, Q3, Q2 chi tiết
Bảng bit trên mỗi tham số và định dạng
Các mức quantization phổ biến nhất hiện nay, sắp xếp từ cao xuống thấp:
- FP16 — 16 bit/tham số, không nén, chất lượng nguyên bản, tốc độ nhanh nhất trên GPU.
- FP8 (Float8) — 8 bit/tham số, định dạng mới của NVIDIA (H100/H200), giữ gần như nguyên chất lượng FP16.
- Q8 (INT8) — 8 bit/tham số, chất lượng rất gần FP16 (chênh lệch dưới 1%), tiết kiệm 50% bộ nhớ.
- Q6_K — ~6 bit/tham số, cân bằng tốt giữa chất lượng và bộ nhớ, hiệu năng tốt trên CPU lẫn GPU.
- Q5_K_M — ~5.5 bit/tham số, giữ phần lớn chất lượng, phù hợp khi cần độ chính xác cao hơn Q4.
- Q4_K_M — ~4.5 bit/tham số, định dạng phổ biến nhất hiện nay, cân bằng tốt chất lượng–bộ nhớ.
- Q4_K_S — ~4.3 bit/tham số, biến thể tiết kiệm hơn Q4_K_M, chất lượng giảm nhẹ.
- Q4_0 / Q4_1 — ~4 bit/tham số, định dạng legacy của llama.cpp, ít dùng nay.
- Q3_K_M — ~3.5 bit/tham số, bắt đầu thấy giảm chất lượng rõ ở các task phức tạp.
- Q2_K — ~2.5 bit/tham số, tiết kiệm bộ nhớ tối đa nhưng chất lượng suy giảm đáng kể, chỉ dùng khi bắt buộc.
Đặc điểm các hậu tố trong tên định dạng GGUF
Định dạng GGUF dùng hậu tố để phân biệt phương pháp nén:
- Q4_K_M: K-quant, medium — nén 4-bit với block size 128, giữ một phần trọng số ở FP16, cân bằng chất lượng–kích thước.
- Q5_K_M: K-quant, medium — nén 5-bit, giữ nhiều chi tiết hơn Q4, phù hợp khi cần độ chính xác cao.
- Q8_0: Nén 8-bit nguyên bản, không dùng K-quant, gần như FP16, kích thước gấp đôi Q4.
- Q4_K_S: K-quant, small — tiết kiệm hơn M, giảm nhẹ chất lượng so với M.
- Q6_K: K-quant 6-bit, không nén thấp hơn Q5 nhưng vẫn nhỏ hơn Q8.
Hậu tố K nghĩa là dùng block quantization (khối 128 tham số), giúp tái tạo trọng số chính xác hơn so với nén toàn bộ đơn lẻ. Hậu tố M (medium) giữ nhiều metadata hơn S (small), cho kết quả tốt hơn ở cùng bit-level.
GGUF, GPTQ, AWQ, EXL2 khác nhau thế nào?
Mỗi định dạng quantization phù hợp với nền tảng và phần cứng khác nhau:
- GGUF: Định dạng của llama.cpp, được tạo ra để chạy local trên CPU và GPU rời (Apple Metal, CUDA). File có đuôi .gguf, tải trọng số tách riêng (trước đây là .bin). Hỗ trợ rất nhiều mức Q2–Q8, chạy được trên phần cứng đa dạng. Phù hợp: người dùng phổ thông, chạy trên CPU hoặc GPU consumer.
- GPTQ: Quantization gốc dành cho GPU NVIDIA, tối ưu hóa theo hàng (row-wise). Thường dùng với các tool inference như text-generation-webui, oobabooga. Hiệu năng GPU tốt. Phù hợp: chạy trên GPU NVIDIA với VRAM đủ.
- AWQ (Activation-aware Weight Quantization): Cải tiến hơn GPTQ, giảm quantization error dựa trên activation magnitudes, cho chất lượng cao hơn ở cùng bit-level. Hỗ trợ GPU rời tốt, đang dần thay thế GPTQ. Phù hợp: ai muốn chất lượng tốt nhất trên GPU với VRAM hạn chế.
- EXL2: Định dạng của EXLlama, hỗ trợ mixed-bit quantization không đồng đều (ví dụ 4-bit cho một phần, 6-bit cho phần khác), tối ưu hóa cực sâu cho VRAM. Phù hợp: người dùng GPU VRAM thấp muốn tối đa hóa chất lượng.
Tóm lại: GGUF cho CPU và sự linh hoạt, AWQ/GPTQ cho GPU NVIDIA tối ưu, EXL2 cho extreme low VRAM trên GPU.
Quantization ảnh hưởng chất lượng model và tốc độ ra sao?
Ảnh hưởng chất lượng
Chất lượng model giảm dần theo mức quantization thấp hơn. Theo kinh nghiệm thực tế từ cộng đồng:
- FP16 → Q8: Chênh lệch gần như không nhận ra được trong hầu hết use case (dưới 1% loss trên benchmark).
- Q8 → Q6: Giảm nhẹ, hầu hết người dùng không phát hiện, phù hợp cho hầu hết tác vụ.
- Q6 → Q5_K_M: Vẫn giữ chất lượng tốt, phù hợp cho hầu hết công việc.
- Q5_K_M → Q4_K_M: Mức cân bằng phổ biến nhất. Giảm bộ nhớ đáng kể, chất lượng suy giảm không đáng kể với model tham số từ 7B trở lên.
- Q4_K_M → Q3: Bắt đầu thấy suy giảm rõ ở các task đòi hỏi tính toán chính xác (code generation, toán học, reasoning dài).
- Q3 → Q2: Chất lượng giảm rõ rệt, hallucinations tăng, chỉ nên dùng khi phần cứng bắt buộc.
Ảnh hưởng tốc độ
Quantization giúp tăng tốc độ inference đáng kể trên GPU vì giảm lượng dữ liệu cần xử lý mỗi lần. Tuy nhiên, trên CPU, tốc độ còn phụ thuộc nhiều vào kiểu quantization:
- GPU NVIDIA: AWQ/GPTQ cho tốc độ nhanh nhất. GGUF chạy qua llama.cpp CUDA backend cũng tốt.
- CPU: GGUF là lựa chọn tối ưu. llama.cpp liên tục tối ưu SIMD (AVX2, AVX512, NEON) giúp Q4 chạy nhanh hơn đáng kể so với Q8 trên cùng CPU.
- Apple Silicon: GGUF với Metal backend cho hiệu năng GPU tích hợp rất tốt ở Q4.
Weight Quantization khác KV Cache Quantization thế nào?
Đây là hai kỹ thuật nén hoạt động ở các giai đoạn khác nhau của quá trình inference:
Weight Quantization nén trọng số model — các con số học được trong quá trình training. Đây là thứ chiếm phần lớn bộ nhớ khi chạy model. Mỗi lần inference, toàn bộ trọng số này đều được sử dụng. Nén trọng số giúp giảm đồng thời cả VRAM lẫn RAM.
KV Cache Quantization nén bộ nhớ đệm Key-Value — dữ liệu trung gian được sinh ra trong quá trình xử lý chuỗi token. Khi model xử lý một chuỗi dài, bộ nhớ KV tăng tuyến tính theo độ dài chuỗi và số lượng layers. Nén KV cache không làm model nhẹ hơn nhưng giúp inference chuỗi dài tiết kiệm bộ nhớ hơn. Nhiều GGUF model mới đã tích hợp sẵn KV cache quantization.
Tóm gọn: Weight Quantization nén model (giảm kích thước file, giảm RAM/VRAM cần thiết). KV Cache Quantization nén dữ liệu chạy runtime (giảm bộ nhớ cho chuỗi dài, không thay đổi kích thước file).
Bảng ước tính RAM/VRAM theo mức quantization
Bảng dưới đây ước tính bộ nhớ cần thiết bao gồm trọng số model và overhead inference (thường 1–2 GB). Giá trị tính theo GB, đã cộng overhead thực tế khi chạy.
| Mức quantization | 7B tham số | 14B tham số | 32B tham số | 70B tham số |
|---|---|---|---|---|
| FP16 | ~16 GB | ~30 GB | ~66 GB | ~144 GB |
| FP8 | ~9 GB | ~17 GB | ~38 GB | ~80 GB |
| Q8_0 | ~9 GB | ~17 GB | ~38 GB | ~80 GB |
| Q6_K | ~6.5 GB | ~12 GB | ~26 GB | ~55 GB |
| Q5_K_M | ~5.5 GB | ~10 GB | ~22 GB | ~46 GB |
| Q4_K_M | ~4.5 GB | ~8.5 GB | ~18 GB | ~38 GB |
| Q4_K_S | ~4 GB | ~8 GB | ~17 GB | ~35 GB |
| Q3_K_M | ~3.5 GB | ~6.5 GB | ~14 GB | ~28 GB |
| Q2_K | ~2.8 GB | ~5 GB | ~10 GB | ~20 GB |
Lưu ý: Đây là ước tính dựa trên định dạng GGUF. Con số thực tế có thể chênh lệch 0.5–1 GB tùy model và framework. Nếu chạy multi-GPU (tensor parallel), mỗi GPU chỉ cần chịu 1 phần tương ứng.
Gợi ý chọn mức quantization theo phần cứng
Việc chọn quantization phụ thuộc vào ba yếu tố chính: dung lượng bộ nhớ khả dụng, task sử dụng, và GPU hay CPU.
Theo dung lượng VRAM/RAM
- Dưới 6 GB VRAM (GTX 1060, RTX 3050, Intel Arc): Q4_K_M hoặc Q3_K_M cho 7B. 14B cần Q2_K. Ưu tiên GGUF chạy qua llama.cpp.
- 6–8 GB VRAM (RTX 3060, RTX 4060, RTX 2060 12GB): Q4_K_M cho 7B hoặc Q5_K_M nếu cần chính xác hơn. 14B cần Q3_K_M hoặc Q4_K_S.
- 8–12 GB VRAM (RTX 3080 10GB, RTX 4070, RTX 4070 Ti): Q4_K_M cho 14B, Q5_K_M hoặc Q6_K cho 7B. Có thể chạy AWQ/GPTQ thoải mái.
- 12–24 GB VRAM (RTX 3090, RTX 4090, RTX 4070 Ti Super): Q4_K_M hoặc Q5_K_M cho 32B, Q6_K hoặc Q8 cho 14B.
- 24+ GB VRAM (RTX 4090 24GB, A100, H100): Q4_K_M hoặc Q5_K_M cho 70B, Q8/FP8 cho 32B, thoải mái dùng model lớn.
Theo loại task
- Chat thông thường, viết lách, tóm tắt: Q4_K_M là đủ, không cần cao hơn.
- Code generation, lập trình: Q5_K_M hoặc Q6_K — model cần giữ chính xác cú pháp và logic.
- Reasoning dài, toán học, phân tích phức tạp: Q6_K trở lên, lý tưởng là Q8 nếu VRAM cho phép.
- Thử nghiệm nhanh, prototype: Q2_K để test nhanh model mới, sau đó lên Q4.
Theo nền tảng
- CPU thuần: Dùng GGUF Q4_K_M là sweet spot giữa tốc độ và chất lượng. Q5 trở lên sẽ chậm đáng kể trên CPU.
- GPU NVIDIA (CUDA): AWQ hoặc GPTQ Q4_K_M cho VRAM tối ưu, tốc độ nhanh nhất.
- Apple Silicon (Mac): GGUF với Metal backend, Q4_K_M chạy rất mượt trên M-series với unified memory.
Kết luận
Quantization là kỹ thuật nền tảng giúp AI local trở nên khả thi với phần cứng phổ thông. Q4_K_M là lựa chọn an toàn nhất cho đa số trường hợp — đủ nhẹ để chạy trên GPU 6–8GB VRAM, đủ chất lượng cho hầu hết tác vụ thường ngày. Nếu VRAM cho phép, Q5_K_M hoặc Q6_K mang lại trải nghiệm gần như nguyên bản. Chỉ xuống Q3 hoặc Q2 khi bộ nhớ thực sự giới hạn — và chấp nhận đánh đổi về chất lượng output.
Câu hỏi thường gặp
Quantization có làm model kém thông minh hơn không?
Giảm quantization từ Q8 xuống Q4_K_M hầu như không ảnh hưởng đến khả năng của model với model từ 7B trở lên. Từ Q3 trở xuống, bạn sẽ bắt đầu thấy hallucinations tăng và phản hồi kém chính xác hơn trong các task đòi hỏi suy luận phức tạp.
Chạy GGUF trên CPU có nhanh không?
Tốc độ phụ thuộc CPU và mức quantization. Q4_K_M trên CPU 8-core hiện đại đạt khoảng 5–15 token/giây với model 7B, đủ dùng cho chat. Q5 trở lên sẽ chậm hơn đáng kể. Nếu cần tốc độ, ưu tiên chạy trên GPU.
Tôi nên dùng định dạng nào — GGUF, GPTQ hay AWQ?
Chọn GGUF nếu chạy trên CPU hoặc Mac, hoặc muốn tính linh hoạt cao. Chọn AWQ hoặc GPTQ nếu chạy trên GPU NVIDIA — AWQ cho chất lượng cao hơn ở cùng bit-level, GPTQ cho sự tương thích rộng hơn với các framework.
GPU 6GB VRAM có chạy được model 14B không?
Có, nhưng cần quantization Q2_K hoặc Q3_K_M. Model 14B tại Q3_K_M cần khoảng 6.5 GB VRAM. Chất lượng sẽ giảm rõ so với nguyên bản, phù hợp để thử nghiệm hoặc dùng khi không có lựa chọn khác.
KV Cache Quantization có giảm được VRAM không?
KV Cache Quantization không làm file model nhỏ hơn mà chỉ giảm bộ nhớ cần thiết khi inference chuỗi dài. Nếu bạn cần giảm lượng VRAM tổng thể, weight quantization (Q4, Q5…) mới là giải pháp chính cần quan tâm.