Model Quantization

Lượng tử hóa model chuyển đổi trọng số của mạng nơ-ron, và thường cả activation, từ số dấu phẩy động 32 bit (FP32) sang các định dạng có độ chính xác thấp hơn như số dấu phẩy động 16 bit (FP16), số nguyên 8 bit (INT8) hoặc số nguyên 4 bit. Khi đó, mỗi giá trị cần ít bit hơn để lưu trữ và di chuyển; phép tính số nguyên cũng chạy nhanh hơn và tiêu thụ ít năng lượng hơn trên hầu hết bộ xử lý. Model INT8 có kích thước bằng một phần tư model FP32 gốc, nhờ vậy các model phát hiện đối tượng có thể chạy thời gian thực trên điện thoại, camera và các thiết bị AI biên khác, đồng thời giúp mô hình ngôn ngữ lớn (LLMs) vừa với một GPU.

Cách lượng tử hóa hoạt động#

Lượng tử hóa ánh xạ một dải số thực thành một tập nhỏ các mức số nguyên. Trong phương pháp affine phổ biến, mỗi giá trị float x được lưu dưới dạng số nguyên q = round(x / scale) + zero_point và được khôi phục thành x ≈ (q - zero_point) × scale. Scale xác định khoảng cách giữa các mức, còn điểm zero bảo đảm giá trị float 0 được ánh xạ chính xác thành một số nguyên. INT8 có 256 mức, vì vậy cần chọn dải giá trị cẩn thận: dải quá rộng làm lãng phí các mức cho những giá trị không bao giờ xuất hiện, còn dải quá hẹp sẽ cắt bỏ các giá trị ngoại lai. Giá trị trọng số đã biết trước, nên dải của chúng được lấy trực tiếp từ model đã training, thường được tính riêng cho từng kênh đầu ra. Activation phụ thuộc vào đầu vào, vì vậy dải giá trị của chúng được đo trong quá trình hiệu chuẩn bằng cách đưa một tập nhỏ ảnh hoặc mẫu văn bản đại diện qua model.

import numpy as np

rng = np.random.default_rng(0)
weights = rng.normal(0, 0.05, size=1000).astype(np.float32)

# Affine INT8 quantization maps the observed float range onto 256 integer levels
scale = (weights.max() - weights.min()) / 255
zero_point = np.round(-128 - weights.min() / scale)
q = np.clip(np.round(weights / scale + zero_point), -128, 127).astype(np.int8)

# Dequantize to measure the rounding error the model has to tolerate
restored = (q.astype(np.float32) - zero_point) * scale
print(f"Size: {weights.nbytes} -> {q.nbytes} bytes")
print(f"Max error: {np.abs(weights - restored).max():.5f} (half a step: {scale / 2:.5f})")

Kết quả in ra là Size: 4000 -> 1000 bytes cùng sai số tối đa 0.00068, bằng một nửa bước lượng tử hóa. Trọng số giảm kích thước còn một phần tư và không giá trị nào lệch quá nửa bước so với giá trị ban đầu.

Lượng tử hóa sau training và training có nhận biết lượng tử hóa#

• Lượng tử hóa sau training (PTQ): Chuyển đổi một model đã training, sử dụng tập hiệu chuẩn nhỏ để thiết lập dải activation. Quá trình này chỉ mất vài phút và không cần dữ liệu training ngoài các mẫu đó. Lượng tử hóa động là một biến thể PTQ tính dải activation ngay khi inference; lượng tử hóa chỉ trọng số giữ activation ở dạng dấu phẩy động.
• Training có nhận biết lượng tử hóa (QAT): Mô phỏng lượng tử hóa trong quá trình training hoặc fine-tune bằng cách làm tròn giá trị ở lượt forward, giúp trọng số học cách chịu được việc làm tròn. Phương pháp này khôi phục phần lớn độ chính xác mà PTQ làm mất, đổi lại cần thêm thời gian training.

Các nhóm thường bắt đầu bằng PTQ và chỉ chuyển sang phương pháp khác khi mức giảm độ chính xác quá lớn:

LLM có thêm các phương pháp riêng. Các phương pháp 4 bit chỉ lượng tử hóa trọng số như GPTQ và AWQ nén hàng tỷ parameter trong khi giữ activation ở 16 bit; định dạng GGUF lưu trữ model đã lượng tử hóa để inference cục bộ; các GPU mới hơn tính toán trực tiếp bằng những định dạng dấu phẩy động có độ chính xác thấp như FP8.

Lượng tử hóa và các kỹ thuật liên quan#

• Độ chính xác hỗn hợp: Kỹ thuật training chạy hầu hết phép toán ở FP16 hoặc BF16 trong khi giữ bản sao chính của trọng số ở FP32 để tăng tốc training. Lượng tử hóa nhắm đến inference và đi xa hơn, thường chuyển sang số nguyên.
• Cắt tỉa model: Loại bỏ trọng số hoặc toàn bộ kênh để giảm số phép toán; kỹ thuật này thường được kết hợp với lượng tử hóa, vốn giúp mỗi phép toán còn lại tốn ít chi phí hơn.
• Chưng cất tri thức: Training một model student nhỏ để bắt chước model teacher lớn. Model student thường được lượng tử hóa sau đó để triển khai.

Lượng tử hóa trong thực tế#

Mức tăng tốc phụ thuộc vào hỗ trợ phần cứng: model INT8 chỉ chạy nhanh hơn trên bộ xử lý có kernel INT8, chẳng hạn GPU NVIDIA với TensorRT, CPU Intel với OpenVINO và bộ xử lý thần kinh (NPUs) trong điện thoại. Ultralytics YOLO26 áp dụng PTQ trong quá trình export với quantize=8, hiệu chuẩn bằng ảnh từ dataset data; còn model.train(quantize=8) fine-tune checkpoint bằng QAT. Ví dụ này export model INT8 cho LiteRT, runtime của Google dành cho Android và thiết bị nhúng:

from ultralytics import YOLO

# Tải model YOLO26 nano đã pretrained
model = YOLO("yolo26n.pt")

# Lượng tử hóa INT8 sau training; ảnh từ coco8.yaml dùng để hiệu chuẩn dải activation
model.export(format="litert", quantize=8, data="coco8.yaml")

Đo trên COCO bằng TensorRT, PTQ INT8 chỉ làm giảm mAP_50-95 của YOLO26n từ 0.403 xuống 0.393, nhưng ảnh hưởng đến YOLO26s nhiều hơn, từ 0.479 xuống 0.441; QAT giúp YOLO26s phục hồi lên 0.471.