AI Model Compression: Quantization Và Pruning Cho Production

Model AI càng lớn càng chậm và tốn kém khi deploy production. Quantization giảm trọng số từ 32-bit xuống 8-bit (hoặc thấp hơn), giảm kích thước model 4-8 lần mà chỉ mất 1-3% accuracy. Pruning loại bỏ các kết nối ít quan trọng, giảm số lượng tham số 30-50%. Kết hợp cả hai mang lại model nhẹ, nhanh, vẫn đủ chính xác cho sản xuất — đặc biệt quan trọng khi chạy trên edge devices hay infra có giới hạn.

Tại Sao Model Production Cần Compression?

Model AI hiện đại (đặc biệt LLM) có kích thước khổng lồ:

• GPT-3.5: ~175 tỷ parameters → ~700GB float32
• Llama 2 7B: ~7 tỷ parameters → ~28GB float32
• Một model BERT base: ~110 triệu parameters → ~440MB float32

Triển khai model gốc gặp vấn đề:

• Chi phí infra cao: GPU VRAM đắt, scale ngang tốn server
• Latency lớn: inference chậm, ảnh hưởng UX
• Không chạy được edge: mobile/IoT không đủ RAM
• Carbon footprint: GPU tiêu thụ điện năng lớn

Compression giải quyết bằng cách đánh đổi có kiểm soát: giảm kích thước, tăng tốc, chấp nhận mất vài phần trăm accuracy.

Quantization: Giảm Bits, Giữ Cấu Trúc

Quantization là gì?

Quantization chuyển đổi trọng số và activation từ độ chính xác cao (float32 - 32 bits) xuống độ chính xác thấp (int8 - 8 bits, int4 - 4 bits, hoặc thậm chí binary 1-bit).

Ví dụ cụ thể:

• Float32: 3.14159265 → 32 bits
• Int8: 3 (làm tròn) → 8 bits (giảm 4 lần)
• Int4: 3 (4 bits range -8 đến 7) → 4 bits (giảm 8 lần)

Một model 7B parameters:

• Float32: 7B × 4 bytes = 28GB
• Int8: 7B × 1 byte = 7GB (giảm 4×)
• Int4: 7B × 0.5 byte = 3.5GB (giảm 8×)

Các Loại Quantization

1. Post-Training Quantization (PTQ)

• Nén model ĐÃ huấn luyện xong
• Không cần re-train
• Mất accuracy 1-5% tùy độ nén
• Công cụ: GPTQ, AWQ, llama.cpp

2. Quantization-Aware Training (QAT)

• Train model với quantization từ đầu
• Model “học” cách hoạt động tốt ở độ chính xác thấp
• Accuracy gần bằng model gốc
• Tốn thời gian training
• Công cụ: TensorFlow Lite, PyTorch Quantization

3. Dynamic vs Static Quantization

• Dynamic: quantize weights trước, activation khi runtime (linh hoạt)
• Static: quantize cả weights + activation trước (nhanh hơn nhưng cần calibration dataset)

Benchmark Thực Tế

Llama 2 7B (so sánh perplexity — thấp hơn = tốt hơn):

Format	Kích thước	Perplexity	Tốc độ inference (tokens/s)
Float32	28GB	5.68 (baseline)	12
Int8 (GGUF Q8)	7GB	5.71 (+0.5%)	28
Int4 (GGUF Q4)	3.5GB	5.89 (+3.7%)	45
Int3 (GGUF Q3)	2.6GB	6.12 (+7.7%)	52

Int8 là điểm cân bằng tốt nhất trong thực tế: giảm 4× kích thước, tăng 2.3× tốc độ, chỉ đánh mất 0.5% accuracy. Int4 phù hợp khi bạn deploy lên mobile hay IoT, nhưng nhớ test accuracy trước — 3.7% degradation không phải con số nhỏ với mọi use case.

Pruning: Giảm Số Lượng Parameters

Pruning là gì?

Pruning loại bỏ các trọng số hoặc neuron ít đóng góp vào output của model. Giống như “tỉa cành” một cây — cắt bỏ phần không cần thiết để cây nhẹ hơn mà vẫn sống khỏe.

Ví dụ: Một lớp Dense có 1000 neurons. Sau khi phân tích, phát hiện 300 neurons có trọng số gần 0 và activation thấp → prune bỏ 300 neurons → giảm 30% tham số.

Các Loại Pruning

1. Unstructured Pruning

• Loại bỏ từng trọng số riêng lẻ (fine-grained)
• Sparse matrix (nhiều giá trị 0)
• Giảm parameters nhiều (50-90%)
• Hạn chế: cần phần cứng hỗ trợ sparse operations (GPU thường không tăng tốc thật)

2. Structured Pruning

• Loại bỏ cả channels, filters, hoặc attention heads
• Giữ cấu trúc dense (không sparse)
• Giảm ít hơn (30-50%) nhưng tăng tốc thật trên phần cứng thông thường
• Phù hợp production

3. Magnitude-Based vs Gradient-Based

• Magnitude: prune trọng số có giá trị tuyệt đối nhỏ
• Gradient: prune trọng số có gradient thấp (ít ảnh hưởng loss)

Pruning Workflow Thực Tế

# Ví dụ với PyTorch (structured pruning)
import torch
import torch.nn.utils.prune as prune

model = YourModel()
# Prune 30% channels trong conv layer
prune.ln_structured(
    model.conv1, 
    name="weight", 
    amount=0.3, 
    n=2,  # L2 norm
    dim=0  # prune theo channel dimension
)

# Fine-tune lại model sau khi prune
train(model, fine_tune_epochs=5)

Quy trình production:

1. Train model baseline
2. Prune iteratively (10-20% mỗi lần)
3. Fine-tune sau mỗi lần prune
4. Evaluate accuracy → nếu giảm >3% → giảm tỷ lệ prune
5. Lặp lại đến khi đạt target size hoặc accuracy threshold

So Sánh Quantization vs Pruning

Tiêu chí	Quantization	Pruning
Giảm gì	Bits per parameter	Số lượng parameters
Giảm được	4-8× kích thước	30-50× (unstructured có thể hơn)
Accuracy loss	1-3% (int8), 3-7% (int4)	2-5% (structured), có thể hơn (unstructured)
Tốc độ inference	Tăng 2-4× (phần cứng hỗ trợ)	Tăng 1.5-3× (structured), ít hơn (unstructured)
Dễ deploy	Rất dễ (nhiều tool sẵn)	Trung bình (cần retrain)
Khi nào dùng	Model quá lớn cho RAM, cần tăng throughput	Model có redundancy cao, cần giảm latency

Kết hợp cả hai là chiến lược tối ưu:

1. Prune model 30-40%
2. Fine-tune
3. Quantize xuống int8
4. → Giảm 6-10× kích thước tổng hợp

Công Cụ Thực Tế Cho Production

1. Llama.cpp + GGUF (Cho LLM)

Phù hợp: Chạy LLM local (Llama, Mistral, GPT-J…)

Ưu điểm:

• Hỗ trợ nhiều quantization formats (Q4, Q5, Q8…)
• Chạy trên CPU consumer (Apple Silicon, x86)
• Cộng đồng lớn, nhiều model pre-quantized

Cách dùng:

# Convert model sang GGUF + quantize
python convert.py --outtype q8_0 ./llama-2-7b

# Inference
./llama.cpp -m llama-2-7b-q8_0.gguf -p "Your prompt"

2. Hugging Face Optimum

Phù hợp: Model Transformers cần export sang ONNX/TensorRT

Ưu điểm:

• API đơn giản, tích hợp với transformers
• Hỗ trợ ONNX Runtime (deploy đa nền tảng)

Cách dùng:

from optimum.onnxruntime import ORTModelForSequenceClassification
from optimum.onnxruntime.configuration import AutoQuantizationConfig

# Load model + quantize
model = ORTModelForSequenceClassification.from_pretrained("bert-base")
qconfig = AutoQuantizationConfig.avx512_vnni(is_static=False)
model.quantize(save_directory="./bert-quantized", quantization_config=qconfig)

3. TensorFlow Lite (Cho Mobile/Edge)

Phù hợp: Deploy trên Android/iOS/embedded devices

Ưu điểm:

• Tích hợp sâu với mobile frameworks
• Hỗ trợ GPU delegate, NPU acceleration

Cách dùng:

import tensorflow as tf

converter = tf.lite.TFLiteConverter.from_saved_model("./model")
converter.optimizations = [tf.lite.Optimize.DEFAULT]  # quantization
tflite_model = converter.convert()

with open("model_quantized.tflite", "wb") as f:
    f.write(tflite_model)

4. GPTQ / AWQ (Cho LLM Production)

Phù hợp: Quantize LLM lớn (7B-70B) cho GPU inference

Ưu điểm:

• Accuracy cao hơn PTQ naive
• Hỗ trợ int4 với minimal loss

Cách dùng (với AutoGPTQ):

from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig

model = AutoGPTQForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")
quantize_config = BaseQuantizeConfig(bits=4, group_size=128)

model.quantize(calibration_dataset, quantize_config=quantize_config)
model.save_quantized("./llama-2-7b-gptq")

Checklist Trước Khi Deploy Model Nén

• Evaluate accuracy: So sánh model nén vs baseline trên test set
• Benchmark latency: Đo tốc độ inference trên target hardware
• Test edge cases: Kiểm tra inputs cực đoan (rất dài, ký tự đặc biệt…)
• Monitor memory: Xác nhận model chạy trong RAM available
• A/B test production: Deploy song song với model cũ, so sánh business metrics

Khi Nào KHÔNG Nên Nén Quá Mạnh

• Model đã nhỏ (<100M parameters) → lợi ích compression không đáng kể
• Task yêu cầu accuracy tuyệt đối (y tế, tài chính) → mất 3% accuracy có thể không chấp nhận được
• Có đủ infra (GPU dư thừa) và latency không phải vấn đề → giữ model gốc đơn giản hơn

Nguyên tắc: tối ưu theo giới hạn thật của bạn. RAM hạn chế? Quantize. Latency cao? Prune. Cả hai? Kết hợp.

Kết Luận

Compression không phải “trick” để model chạy nhanh. Nó là kỹ thuật engineering bắt buộc khi đưa AI vào production thực tế — infra có giới hạn, người dùng không chờ lâu, chi phí phải kiểm soát.

Bắt đầu từ int8 quantization (ít rủi ro, lợi nhiều). Cần tối ưu thêm? Thử structured pruning. Nhưng đừng tin con số trên giấy — đo thật trước và sau deployment, vì mỗi model và task có đặc điểm riêng.

Đọc thêm:

• Local LLM: Chạy AI Riêng Tư Trên Máy Cá Nhân — Hướng dẫn setup llama.cpp và các công cụ chạy LLM đã quantize trên laptop/desktop thông thường.
• Edge AI: Chạy AI Trên Thiết Bị IoT Và Mobile — Deploy model nén xuống thiết bị edge với TensorFlow Lite và PyTorch Mobile.
• Multimodal AI: Xu Hướng Và Ứng Dụng Thực Tế — Xu hướng model AI đa phương thức, compression quan trọng hơn khi model xử lý cả text, image, audio.