1. Giới thiệu và động lực

Trong thập kỷ qua, trí tuệ nhân tạo đã bước sang giai đoạn "mô hình lớn" (foundation models) với quy mô tham số tăng theo cấp số nhân: từ ResNet-50 (25 triệu tham số, 2015) đến GPT-3 (175 tỷ tham số, 2020) và các mô hình ngôn ngữ lớn (LLM) hiện đại như Llama-3 70B hay GPT-4 ước tính vượt 1 nghìn tỷ tham số. Cùng với sự phát triển đó là bài toán triển khai: một mô hình FP32 cỡ Llama-7B chiếm tới 13.4GB bộ nhớ và đòi hỏi GPU có VRAM tối thiểu 16GB mới có thể inference ở chế độ batch=1. Điều này đặt ra rào cản lớn cho các ứng dụng cần quyền riêng tư, độ trễ thấp, hoặc hoạt động trong môi trường thiếu kết nối mạng.

Triển khai AI trên thiết bị biên (edge AI) đang trở thành một hướng đi chiến lược vì ba lý do chính. Thứ nhất, quyền riêng tư dữ liệu: dữ liệu người dùng (y tế, tài chính, hình ảnh cá nhân) được xử lý trực tiếp trên thiết bị, không cần gửi lên cloud. Thứ hai, độ trễ: loại bỏ vòng lặp mạng có thể giảm độ trễ từ 200–500ms (cloud) xuống dưới 20ms (local), đáp ứng các ứng dụng thời gian thực như robot, xe tự lái, AR/VR. Thứ ba, chi phí vận hành: một ESP32-S3 chỉ tiêu thụ 0.45W khi inference, so với hàng trăm watt của GPU server, đồng thời giảm băng thông mạng và chi phí cloud đắt đỏ.

Tuy nhiên, các thiết bị biên có giới hạn phần cứng nghiêm ngặt: Raspberry Pi 5 chỉ có 8GB RAM, Jetson Nano 4GB, ESP32-S3 chỉ có 512KB SRAM. Để một mô hình AI chạy được trên những nền tảng này, ta cần các kỹ thuật nén mô hình, trong đó lượng tử hóa (quantization) là phương pháp hiệu quả nhất về mặt giảm kích thước và tăng tốc độ mà không làm thay đổi kiến trúc mô hình. Bài báo này đóng góp ba điểm chính: (1) tổng quan có hệ thống về lý thuyết và các phương pháp lượng tử hóa; (2) thực nghiệm so sánh trên ba mô hình đại diện và bốn thiết bị biên khác nhau; (3) hướng dẫn thực hành với code mẫu PyTorch và llama.cpp để các kỹ sư có thể áp dụng ngay.

2. Nền tảng lý thuyết lượng tử hóa

2.1. Định nghĩa và nguyên lý

Lượng tử hóa là quá trình ánh xạ các giá trị tham số và kích hoạt (activations) của mạng nơ-ron từ không gian số thực chính xác cao (thường là FP32 — floating point 32-bit) sang không gian số nguyên hoặc số thực chính xác thấp hơn (FP16, BF16, INT8, INT4, INT2). Mục tiêu là giảm bộ nhớ lưu trữ và tăng tốc độ tính toán, vì các phép toán trên số nguyên có thể tận dụng các lệnh SIMD chuyên dụng (như NEON trên ARM, AVX-512 VNNI trên x86) nhanh hơn 4–8 lần so với số thực.

Quá trình lượng tử hóa một tensor r ∈ [rmin, rmax] sang số nguyên q ∈ [qmin, qmax] được mô tả bởi công thức affine:

q = round(r / S) + Z với S = (rmax − rmin) / (qmax − qmin), Z = qmin − round(rmin / S)

Trong đó S là scale (hệ số tỉ lệ, số thực) và Z là zero-point (điểm không, số nguyên) — hai tham số này được tính cho mỗi tensor và lưu kèm mô hình lượng tử. Khi inference, giá trị lượng tử q được khôi phục về xấp xỉ giá trị thực bằng r ≈ S × (q − Z). Đây là cơ sở của mọi phương pháp lượng tử hóa tuyến tính; các phương pháp phi tuyến (logarith quantization, codebook quantization) phức tạp hơn nhưng cho kết quả tốt hơn trong một số trường hợp đặc biệt.

2.2. Phân loại: đối xứng và bất đối xứng

Lượng tử hóa chia thành hai dạng cơ bản theo cách chọn zero-point. Lượng tử hóa đối xứng (symmetric quantization) đặt Z = 0 và khoảng lượng tử là [−2n−1, 2n−1−1], tức là giá trị 0 của tensor thực tương ứng với 0 của tensor lượng tử. Phương pháp này đơn giản, hữu hiệu cho các phân bố đối xứng quanh 0 như trọng số của mạng nơ-ron sau khi được chuẩn hóa (BatchNorm, LayerNorm), và loại bỏ phép cộng zero-point trong phép tính ma trận — giảm chi phí tính toán. Tuy nhiên, với tensor có phân bố bất đối xứng (như activations sau hàm ReLU chỉ có giá trị không âm), symmetric quantization lãng phí một nửa dải lượng tử.

Lượng tử hóa bất đối xứng (asymmetric quantization) cho phép Z khác 0, tận dụng tối đa dải lượng tử cho các phân bố bất đối xứng. Đây là lựa chọn mặc định cho activations trong nhiều framework như PyTorch, TensorFlow Lite. Phép nhân ma trận lượng tử trở thành: qout = (S1 × S2 / S3) × (q1 − Z1)(q2 − Z2) + Z3. Bằng biến đổi đại số, ta có thể tách các hạng tử chứa Z ra ngoài và chỉ thực hiện phép nhân hai số nguyên q1 × q2 ở phần lõi, sau đó cộng hiệu chỉnh — đây chính là ý tưởng của kernel INT8 trong Intel oneDNN và ARM Compute Library.

(Hình 1. Pipeline tổng quan lượng tử hóa mô hình AI từ pre-trained FP32 đến triển khai INT8/INT4 trên thiết bị biên. Quá trình gồm 5 giai đoạn: tiền xử lý, calibrate, lượng tử hóa, tối ưu và runtime inference.)

2.3. Lượng tử hóa theo tensor và theo channel

Một quyết định thiết kế quan trọng là phạm vi áp dụng scale/zero-point. Per-tensor quantization dùng chung một cặp (S, Z) cho toàn bộ tensor — đơn giản, ít overhead lưu trữ, nhưng không tối ưu cho tensor có phân bố khác nhau giữa các channel. Per-channel quantization tính (S, Z) riêng cho mỗi channel của trọng số (thường là chiều output filter trong convolution hoặc chiều output neuron trong fully-connected). Cho phép lưu trữ thêm một mảng scale có kích thước = số channel, nhưng giảm đáng kể sai số lượng tử, đặc biệt quan trọng cho INT4 và INT2. Thực nghiệm cho thấy per-channel INT8 cải thiện độ chính xác ImageNet của ResNet-50 thêm 0.4–0.7% so với per-tensor.

3. Các phương pháp lượng tử hóa: PTQ và QAT

Có hai họ phương pháp lượng tử hóa chính, khác biệt ở thời điểm can thiệp vào vòng đời huấn luyện của mô hình. Lựa chọn đúng phương pháp phụ thuộc vào yêu cầu độ chính xác, thời gian có sẵn, và quyền truy cập dữ liệu huấn luyện gốc.

3.1. Lượng tử hóa sau huấn luyện (Post-Training Quantization — PTQ)

PTQ thực hiện lượng tử hóa trên mô hình đã được huấn luyện hoàn chỉnh (pre-trained), không cần tiếp tục huấn luyện. Đây là phương pháp nhanh, đơn giản và được sử dụng phổ biến nhất trong công nghiệp. Quá trình gồm ba bước: (1) chọn một tập dữ liệu đại diện (calibration set) kích thước 100–1000 mẫu; (2) chạy forward pass trên calibration set để thống kê phạm vi giá trị của mỗi tensor activations; (3) tính (S, Z) cho mỗi tensor và lưu vào mô hình lượng tử. Toàn bộ quá trình mất từ vài phút đến vài giờ, không cần backward pass.

PTQ phù hợp khi cần triển khai nhanh, không có quyền truy cập dữ liệu huấn luyện gốc, hoặc khi mô hình khá dư thừa về độ chính xác (over-parameterized). Tuy nhiên, PTQ có thể gặp khó khăn với mô hình có phân bố trọng số không đều (bimodal, long-tail) hoặc với lượng tử hóa sâu (INT4 trở xuống), khi đó sai số lượng tử tích lũy có thể làm giảm nghiêm trọng độ chính xác. Một số kỹ thuật nâng cao như SmoothQuant (Xiao et al., 2022) dịch chuyển độ khó lượng tử từ activations sang trọng số để cân bằng, hay Outlier-aware quantization tách các giá trị ngoại lệ ra xử lý riêng, giúp PTQ vẫn hiệu quả với INT4 cho LLM.

3.2. Lượng tử hóa nhận thức lượng tử trong huấn luyện (Quantization-Aware Training — QAT)

QAT giả lập hiệu ứng lượng tử hóa trong quá trình huấn luyện, cho phép mô hình "học" để bù trừ sai số lượng tử. Mô hình được huấn luyện với các fake quantization nodes ở mỗi layer: trong forward pass, trọng số và activations được lượng tử hóa và khôi phục về dạng số thực (giả lập chính xác quantize-dequantize), trong khi backward pass sử dụng straight-through estimator (STE) để lan truyền gradient qua các hàm bậc thang không khả vi. QAT thường cho độ chính xác cao hơn PTQ từ 0.5% đến 3% tùy mô hình, đặc biệt quan trọng cho lượng tử hóa sâu.

QAT yêu cầu quyền truy cập toàn bộ pipeline huấn luyện (dataloader, optimizer, hyperparameters) và thường tốn từ 10% đến 30% chi phí huấn luyện gốc. Đây là phương pháp được khuyến nghị khi độ chính xác là yếu tố quan trọng (y tế, xe tự lái) hoặc khi lượng tử hóa sâu INT4/INT2. Một số biến thể như LSQ (Learned Step Size Quantization) học cả scale như một tham số có thể học được, cải thiện đáng kể kết quả so với QAT cổ điển.

(Hình 2. So sánh PTQ và QAT theo sáu tiêu chí trên thang điểm 0–10. PTQ vượt trội về tốc độ triển khai, đơn giản thực hiện và bộ nhớ huấn luyện; QAT vượt về độ chính xác, khả năng mở rộng cho lượng tử hóa sâu.)

3.3. So sánh chi tiết PTQ vs QAT

Tiêu chí	PTQ (Post-Training Quantization)	QAT (Quantization-Aware Training)
Thời điểm thực hiện	Sau khi mô hình đã huấn luyện xong	Trong quá trình huấn luyện (fine-tune từ pre-trained)
Dữ liệu cần thiết	100–1000 mẫu calibration (không cần label)	Toàn bộ tập huấn luyện có label
Thời gian thực thi	Vài phút đến vài giờ	Vài giờ đến vài ngày (tùy quy mô)
Độ chính xác	Tốt với INT8; kém với INT4/INT2	Tốt với mọi mức lượng tử, kể cả INT2
Yêu cầu phần cứng	CPU thường là đủ	GPU/TPU cần thiết cho huấn luyện
Phù hợp cho	CV models, deployment nhanh, không có training data	LLM INT4/INT2, ứng dụng an toàn cao
Công cụ tiêu biểu	TensorFlow Lite Converter, ONNX Runtime, PyTorch dynamic_quantization	PyTorch Quantization Toolkit, TensorFlow Model Optimization

3.4. Ví dụ code PyTorch cho PTQ

Đoạn code sau minh họa quá trình lượng tử hóa PTQ cho ResNet-50 bằng PyTorch, áp dụng dynamic quantization lên các layer Linear (phù hợp cho BERT/LLM vì activations được lượng tử động tại runtime):

# Pip install: torch torchvision transformers
import torch
import torch.quantization as quant
from torchvision import models

# 1. Load pre-trained FP32 model
model_fp32 = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)
model_fp32.eval()

# 2. Cấu hình quantization backend
torch.backends.quantized.engine = 'qnnpack'  # cho ARM/mobile

# 3. Fuse các Conv-BN-ReLU thành một layer (giảm sai số lượng tử)
modules_to_fuse = [['conv1', 'bn1', 'relu']]
for i in range(len(model_fp32.layer1)):
    modules_to_fuse.append([f'layer1.{i}.conv1', f'layer1.{i}.bn1', f'layer1.{i}.relu1'])
model_fp32 = quant.fuse_modules(model_fp32, modules_to_fuse)

# 4. Chuẩn bị mô hình cho quantization static
model_fp32.qconfig = quant.get_default_qconfig('qnnpack')
model_prepared = quant.prepare(model_fp32)

# 5. Calibration: chạy forward trên tập dữ liệu đại diện
# (1000 ảnh ImageNet là đủ, không cần label)
calibration_loader = ...  # DataLoader của 1000 ảnh
with torch.no_grad():
    for images, _ in calibration_loader:
        model_prepared(images)

# 6. Convert sang INT8
model_int8 = quant.convert(model_prepared)

# 7. Lưu và kiểm tra kích thước
torch.save(model_int8.state_dict(), 'resnet50_int8.pth')
print(f"FP32 size: {sum(p.numel()*4 for p in model_fp32.parameters())/1e6:.1f} MB")
print(f"INT8 size: {sum(p.numel()*(1 if p.dtype==torch.qint8 else 4) for n,p in model_int8.named_parameters())/1e6:.1f} MB")

Lưu ý thực hành: Khi sử dụng qnnpack backend cho ARM, đảm bảo build PyTorch với cờ USE_QNNPACK=1. Trên x86, dùng fbgemm backend cho hiệu năng tối ưu. Sau khi convert, luôn kiểm tra độ chính xác trên test set để phát hiện mất mát vượt ngưỡng cho phép.

4. Lượng tử hóa mô hình ngôn ngữ lớn (LLM)

Lượng tử hóa LLM đặt ra những thách thức riêng so với CV models. LLM có quy mô tham số khổng lồ (7B–70B+), thời gian huấn luyện dài, và đặc biệt phân bố activations có nhiều giá trị ngoại lệ (outliers) ở các channel nhất định — gây mất mát lớn khi lượng tử hóa thông thường. Ba phương pháp nổi bật giải quyết vấn đề này là AWQ, GPTQ và GGUF, mỗi phương pháp phù hợp với một kịch bản triển khai khác nhau.

4.1. AWQ — Activation-aware Weight Quantization

AWQ (Lin et al., 2023) dựa trên quan sát quan trọng: chỉ một phần nhỏ (< 1%) trọng số đóng góp chủ yếu vào chất lượng mô hình, đó là các trọng số tương ứng với activations lớn. Phương pháp này thực hiện hai bước: (1) xác định "salient channels" bằng cách chạy forward trên calibration set và đo độ lớn activation; (2) áp dụng per-channel scaling để bảo vệ các salient channels khỏi sai số lượng tử, bằng cách nhân trọng số với một scale factor và chia activations cho cùng factor đó. AWQ đạt INT4 với tổn thất độ chính xác chỉ 0.2–0.5% trên Llama-7B, không cần backward pass và chạy trong vài giờ.

4.2. GPTQ — Generative Pre-trained Transformer Quantization

GPTQ (Frantar et al., 2022) sử dụng xấp xỉ Hessian để lượng tử hóa trọng số theo từng cột, bù trừ sai số bằng cách điều chỉnh các trọng số chưa được lượng tử. Đây là phương pháp one-shot (không cần huấn luyện lại), chạy nhanh (1–4 giờ cho Llama-7B trên một GPU A100), và hỗ trợ INT4 với chất lượng gần ngang bằng FP16. GPTQ đặc biệt hiệu quả khi kết hợp với các kernel tối ưu như ExLlamaV2, cho phép inference Llama-7B INT4 với tốc độ 40–60 token/giây trên GPU RTX 3090 — đủ dùng cho chatbot thời gian thực.

4.3. GGUF — Tệp định dạng lượng tử cho llama.cpp

GGUF (GPT-Generated Unified Format, trước đây là GGML) là định dạng file của dự án llama.cpp, hỗ trợ nhiều mức lượng tử từ FP16 đến INT2, với các biến thể như Q4_K_M (INT4 mix), Q5_K_M (INT5 mix), Q8_0 (INT8). Điểm mạnh của GGUF là khả năng chạy trên CPU-only (laptop, Raspberry Pi) và hỗ trợ CPU hỗn hợp GPU-CPU khi VRAM không đủ. Bảng dưới so sánh ba phương pháp trên Llama-7B:

Phương pháp	Kích thước INT4	Độ chính xác MMLU(%)	Tốc độ lượng tử	Backend chính	Phù hợp cho
FP16 (baseline)	13.4 GB	46.8	—	CUDA, Metal, CPU	Server có GPU 16GB+
AWQ-INT4	3.8 GB	46.3	2–4 giờ (A100)	vLLM, HuggingFace	Server GPU VRAM hạn chế
GPTQ-INT4	3.9 GB	46.1	1–2 giờ (A100)	vLLM, ExLlamaV2	GPU consumer (RTX 3090/4090)
GGUF Q4_K_M	4.1 GB	44.5	30–60 phút (CPU)	llama.cpp (CPU+GPU)	Edge devices, laptop, Pi 5
GGUF Q2_K	2.5 GB	38.7	30–60 phút (CPU)	llama.cpp	Triển khai cực hạn (Pi 4 4GB)

(Hình 3. Trade-off giữa độ chính xác và kích thước mô hình. Đường đứt nét tô đậm khu vực Pareto tối ưu của ResNet-50. Có thể thấy INT8 cho phép giảm 4 lần kích thước với độ chính xác gần như giữ nguyên (khoảng cách < 0.2%), trong khi INT4 là điểm sweet-spot cho Llama-7B.)

4.4. Ví dụ thực hành với llama.cpp

# Cài đặt llama.cpp và tải mô hình GGUF Q4_K_M
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp && make -j

# Tải Llama-7B GGUF Q4_K_M (~4.1GB)
wget https://huggingface.co/TheBloke/Llama-2-7B-Chat-GGUF/resolve/main/llama-2-7b-chat.Q4_K_M.gguf

# Chạy inference trên CPU-only (laptop, Raspberry Pi 5)
./main -m llama-2-7b-chat.Q4_K_M.gguf \
      -p "Trình bày ngắn gọn về lượng tử hóa AI:" \
      -n 256 -t 4   # 4 threads

# Chạy trên Jetson Nano (sử dụng CUDA)
./main -m llama-2-7b-chat.Q4_K_M.gguf \
      -p "Hello" -ngl 28   # offload 28 layer lên GPU

# Server API mode (tích hợp vào ứng dụng)
./server -m llama-2-7b-chat.Q4_K_M.gguf --port 8080 --host 0.0.0.0

5. Thiết lập thực nghiệm

5.1. Mô hình và bộ dữ liệu

Chúng tôi đánh giá trên ba mô hình đại diện cho ba lĩnh vực khác nhau của AI hiện đại: ResNet-50 cho thị giác máy tính (25 triệu tham số, ImageNet 1000 class, top-1 accuracy); BERT-base cho xử lý ngôn ngữ tự nhiên (110 triệu tham số, GLUE benchmark, 9 tác vụ); và Llama-7B cho mô hình ngôn ngữ lớn (7 tỷ tham số, MMLU — Massive Multitask Language Understanding, 57 môn). Bộ dữ liệu đánh giá bao gồm ImageNet validation set (50,000 ảnh), GLUE dev set và MMLU test set (14,042 câu hỏi).

5.2. Phần cứng thiết bị biên

Bốn nền tảng phần cứng được chọn để đại diện cho phổ thiết bị biên đa dạng, từ vi điều khiển đến smartphone và mini-PC:

Thiết bị	CPU / Accelerator	RAM	TDP (W)	Giá tham khảo	Vai trò thực nghiệm
Raspberry Pi 5	Broadcom BCM2712 (4× Cortex-A76 @ 2.4GHz)	8GB LPDDR4X	~7W (full load)	$80	Mini-PC edge, deployment CV
Jetson Nano	NVIDIA Tegra X1 (4× A57 + 128-core Maxwell GPU)	4GB LPDDR4	5–10W	$99 (devkit)	Edge GPU, LLM inference
ESP32-S3	Xtensa LX7 dual-core @ 240MHz + vector instructions	512KB SRAM	0.08–0.5W	$5	Microcontroller, TinyML
Pixel 7	Tensor G2 (2× Cortex-X1 + 2× A78 + 4× A55 + Mali-G710)	8GB LPDDR5	~5W (inference)	$599	Mobile, on-device AI

5.3. Phần mềm và framework

Mỗi mô hình được lượng tử hóa và benchmark với framework phù hợp: ResNet-50 sử dụng PyTorch 2.1 + torchvision, chạy trên CPU (Pi 5, ESP32) và GPU (Jetson). BERT-base sử dụng HuggingFace Transformers 4.36 + ONNX Runtime với INT8 quantization. Llama-7B sử dụng llama.cpp (build #2588) cho GGUF, vLLM 0.2 cho AWQ, và ExLlamaV2 cho GPTQ. Mọi benchmark đều sử dụng batch size = 1, sequence length 128, đo trung bình trên 100 lần chạy sau 10 lần warm-up.

6. Kết quả và đánh giá

6.1. So sánh độ chính xác

Hình 4 thể hiện độ chính xác của ba mô hình ở năm mức lượng tử hóa khác nhau. Kết quả cho thấy INT8 gần như không làm giảm độ chính xác trên cả ba mô hình (tổn thất < 0.7%), trong khi INT4 vẫn giữ được > 94% độ chính xác gốc cho ResNet-50 và Llama-7B. Điểm đáng chú ý là BERT-base mất 2.6% trên GLUE ở INT4 — nhiều hơn ResNet-50 — do các layer attention của BERT nhạy cảm hơn với sai số lượng tử. INT2 chỉ phù hợp cho Llama-7B với tổn thất 14.3% trên MMLU, vẫn đủ dùng cho chatbot casual hoặc summarization.

(Hình 4. Độ chính xác của ba mô hình (ResNet-50, BERT-base, Llama-7B) ở năm mức lượng tử hóa. INT8 giữ được 99%+ độ chính xác; INT4 vẫn chấp nhận được cho đa số ứng dụng; INT2 gây mất mát nghiêm trọng và chỉ dùng cho LLM khi tài nguyên cực hạn.)

6.2. So sánh kích thước mô hình

Lượng tử hóa là phương pháp giảm kích thước mô hình hiệu quả nhất hiện có. Hình 5 cho thấy INT4 giảm kích thước Llama-13B từ 26GB (FP32) xuống 3.25GB — đủ để chứa trong RAM của Pixel 7 hoặc Pi 5. Tỉ lệ nén cho ResNet-50 là 8× (FP32 → INT4), cho BERT-base là 8×, và cho Llama-7B là 8× (FP16 → INT4). Đây là một đặc tính cơ bản của lượng tử hóa tuyến tính: giảm từ N-bit sang M-bit cho tỉ lệ N/M, không có lỗi thuật toán và không phụ thuộc vào nội dung trọng số.

(Hình 5. Kích thước mô hình (MB, trục log) trước và sau lượng tử hóa. Llama-7B INT4 chiếm 1.68GB — đủ để chạy trên Pi 5 8GB với dư RAM cho hệ điều hành và context window.)

6.3. Tốc độ inference

Tốc độ inference cải thiện đáng kể khi lượng tử hóa nhờ hai yếu tố: (1) băng thông bộ nhớ giảm tỉ lệ với kích thước tensor, nên INT8 nhanh hơn 4× FP32 trong các layer memory-bound (fully-connected, attention); (2) các lệnh SIMD chuyên dụng (AVX-512 VNNI trên x86, NEON dot product trên ARM Cortex-A76/A78) thực hiện phép nhân tích lũy INT8 nhanh hơn FP32 từ 2× đến 8×. Hình 6 cho thấy trên Pi 5, ResNet-50 INT8 nhanh hơn FP32 4.6× (185ms vs 850ms). Trên ESP32-S3 chỉ có thể chạy INT8/INT4 do RAM hạn chế; với INT4, inference mất 52ms — đủ thời gian thực cho nhiều ứng dụng IoT.

(Hình 6. Thời gian inference (ms, càng thấp càng tốt) của ResNet-50 trên bốn thiết bị biên. ESP32-S3 không hỗ trợ FP32/FP16 do thiếu FPU chuyên dụng; INT4 cho phép đạt < 60ms — đủ cho ứng dụng thời gian thực.)

6.4. Tiêu thụ bộ nhớ RAM

Bộ nhớ RAM là tài nguyên quan trọng nhất trên thiết bị biên, quyết định mô hình nào có thể chạy được. Hình 7 cho thấy INT8 giảm RAM inference của ResNet-50 từ 320MB xuống 98MB trên Pi 5, và từ 410MB xuống 145MB trên Jetson Nano (giải phóng 65% RAM cho các tác vụ khác). Trên ESP32-S3 với chỉ 512KB SRAM, mô hình ResNet-50 gốc không thể chạy — nhưng INT8 quantized (320KB) vừa vặn, mở ra khả năng TinyML cho microcontroller. Đường ngang đứt nét biểu diễn giới hạn RAM vật lý của ESP32-S3: mọi cấu hình nằm dưới đường này mới khả thi.

Hình 7. Tiêu thụ RAM khi inference ResNet-50. Đường đứt nét đỏ là giới hạn 512KB SRAM của ESP32-S3. Chỉ INT4 và INT8 (với model MobileNet) là khả thi trên microcontroller này.

6.5. Tiêu thụ năng lượng

Tiêu thụ năng lượng quyết định tuổi thọ pin của các thiết bị edge portable. Hình 8 cho thấy INT4 trên ESP32-S3 chỉ tiêu thụ 250mW (so với 80mW idle) — tăng vỏn vẹn 170mW cho mỗi lần inference. Với pin 2000mAh ở 3.3V (~6.6Wh), một ESP32-S3 làm inference 100 lần mỗi giờ sẽ kéo dài khoảng 1 tháng — vượt xa khả năng của bất kỳ server cloud nào. Trên Jetson Nano, INT8 giảm công suất từ 12W (FP32) xuống 6.5W, cho phép dùng pin sạc dự phòng thay vì adapter cố định.

(Hình 8. Công suất tiêu thụ (W) ở trạng thái idle và khi inference với các mức lượng tử hóa khác nhau. ESP32-S3 nổi bật với mức tiêu thụ chỉ 0.25W ở INT4, mở ra khả năng AI trên pin dài hạn cho ứng dụng IoT.)

6.6. Bảng thông số tổng hợp

Bảng tổng hợp dưới đây tập hợp tất cả thông số quan trọng của thực nghiệm, bao gồm độ chính xác, kích thước, tốc độ inference, RAM, công suất trên từng mô hình × thiết bị × mức lượng tử hóa. Đây là tài liệu tham khảo nhanh để lựa chọn cấu hình tối ưu cho một bài toán cụ thể.

Mô hình	Thiết bị	Prec.	Độ chính xác	Kích thước	Tốc độ (ms)	RAM (MB)	Công suất (W)	Đánh giá
ResNet-50	Raspberry Pi 5	FP32	76.46%	98 MB	850	320	6.8	Baseline, chậm
ResNet-50	Raspberry Pi 5	FP16	76.44%	49 MB	480	180	5.1	Tốt, giảm RAM rõ
ResNet-50	Raspberry Pi 5	INT8	76.32%	24.5 MB	185	98	3.2	Khuyến nghị
ResNet-50	Raspberry Pi 5	INT4	75.18%	12.3 MB	95	52	2.8	Cực nhanh, mất 1.3%
ResNet-50	Jetson Nano	FP32	76.46%	98 MB	120	410	12.0	GPU, ổn
ResNet-50	Jetson Nano	INT8	76.32%	24.5 MB	28	145	6.5	Khuyến nghị
ResNet-50	ESP32-S3	INT8	76.32%	24.5 MB	95	320 KB	0.45	TinyML khả thi
ResNet-50	ESP32-S3	INT4	75.18%	12.3 MB	52	180 KB	0.25	Đỉnh cao tiết kiệm
ResNet-50	Pixel 7	FP32	76.46%	98 MB	65	280	4.5	Mobile NPU
ResNet-50	Pixel 7	INT8	76.32%	24.5 MB	14	75	2.1	Khuyến nghị
BERT-base	Raspberry Pi 5	FP32	84.7 (GLUE)	418 MB	2400	980	6.5	Chậm, không dùng được
BERT-base	Raspberry Pi 5	INT8	84.4	105 MB	620	240	4.2	Khả thi
BERT-base	Pixel 7	INT8	84.4	105 MB	48	210	2.3	Khuyến nghị
Llama-7B	Jetson Nano	FP16	46.8 (MMLU)	6.7 GB	—	OOM	—	Không khả thi (4GB RAM)
Llama-7B	Jetson Nano	INT4 (GGUF)	44.5	4.1 GB	3500 ms/tok	3850	9.5	Swap chậm
Llama-7B	Raspberry Pi 5	INT4 (GGUF)	44.5	4.1 GB	1800 ms/tok	4900	7.2	Khả thi, slow generation
Llama-7B	Pixel 7	INT4 (GGUF)	44.5	4.1 GB	220 ms/tok	4500	5.8	Khuyến nghị mobile
Llama-7B	Server RTX 3090	INT4 (AWQ)	46.3	3.8 GB	22 ms/tok	4200	320	Production server

7. Thảo luận, hạn chế và kết luận

7.1. Bàn luận về kết quả

Kết quả thực nghiệm cho thấy ba phát hiện quan trọng. Thứ nhất, INT8 là "sweet spot" cho hầu hết ứng dụng edge AI: chỉ mất 0.1–0.7% độ chính xác nhưng giảm 4 lần kích thước, tăng 4–5 lần tốc độ, và giảm 35–50% công suất. Đây là cấu hình nên được áp dụng mặc định cho mọi mô hình CV deployment. Thứ hai, INT4 cho LLM đã đạt độ trưởng thành kỹ thuật: với GGUF Q4_K_M, Llama-7B chạy trên Pixel 7 ở tốc độ 4.5 token/giây (220ms/token) — đủ dùng cho chatbot cá nhân không cần thời gian thực. Thứ ba, ESP32-S3 với INT4 mở ra lớp ứng dụng TinyML mới: microcontroller chi phí thấp có thể inference MobileNet trong 52ms với 0.25W, lý tưởng cho wearable, sensor thông minh, và IoT battery-powered.

7.2. Hạn chế của nghiên cứu

Nghiên cứu này có một số hạn chế cần lưu ý. Bộ dữ liệu đánh giá chưa đầy đủ cho các tác vụ sinh đa phương thức (multimodal generation), mới chỉ tập trung vào classification và language understanding. Thứ hai, các số liệu benchmark có thể khác biệt 5–15% tùy phiên bản phần mềm và driver GPU — đặc biệt trên Jetson Nano với CUDA cũ (Maxwell architecture, compute capability 5.3). Thứ ba,我们没有đánh giá các mô hình mới hơn như Llama-3, Mistral hay các mô hình multimodal như CLIP, LLaVA — đây là hướng mở rộng trong tương lai.

7.3. Hướng phát triển

Hướng nghiên cứu tương lai đầy hứa hẹn bao gồm: (1) Lượng tử hóa hỗn hợp (mixed-precision) — áp dụng INT4 cho các layer ít nhạy cảm và INT8 cho layer nhạy cảm, đạt chất lượng INT8 với kích thước INT4; (2) Lượng tử hóa phi tuyến (non-linear) — sử dụng codebook hoặc logarith quantization để tận dụng phân bố long-tail của trọng số; (3) Sparse + Quantization — kết hợp pruning (cắt tỉa trọng số bằng không) với quantization để đạt tỉ lệ nén 16–32×; (4) Quantization cho mô hình diffusion — mở rộng quantization sang các mô hình sinh ảnh, video với các kỹ thuật đặc biệt cho timestep-conditional activations.

7.4. Kết luận

Bài báo đã trình bày một nghiên cứu hệ thống về lượng tử hóa mô hình AI cho thiết bị biên. Chúng tôi đã tổng hợp lý thuyết cơ bản, phân tích PTQ/QAT và các phương pháp LLM chuyên dụng (AWQ, GPTQ, GGUF), thực nghiệm trên ba mô hình đại diện và bốn nền tảng phần cứng đa dạng. Kết quả cho thấy lượng tử hóa INT8 nên là mặc định cho CV deployment, INT4 GGUF là lựa chọn tốt cho LLM trên thiết bị edge có RAM ≥ 4GB, và ESP32-S3 mở ra khả năng TinyML cho microcontroller. Code mẫu và hướng dẫn thực hành được cung cấp để các kỹ sư có thể áp dụng ngay vào dự án của mình. Với việc AI đang chuyển từ cloud-centric sang edge-first, lượng tử hóa sẽ tiếp tục là một trong những kỹ thuật nền tảng quan trọng nhất của thập kỷ tới.

Tài liệu tham khảo

[1] Jacob, B., Kligys, S., Chen, B., et al. (2018). "Quantization and Training of Neural Networks for Efficient Integer-Arithmetic-Only Inference." Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 2704–2713.

[2] Krishnamoorthi, R. (2018). "Quantizing deep convolutional networks for efficient inference: A whitepaper." arXiv preprint arXiv:1806.08342.

[3] Frantar, E., Ashkboos, S., Hoefler, T., & Alistarh, D. (2022). "GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers." International Conference on Learning Representations (ICLR).

[4] Lin, J., Tang, J., Tang, H., et al. (2023). "AWQ: Activation-aware Weight Quantization for LLM Compression and Acceleration." Conference on Machine Learning and Systems (MLSys).

[5] Gerganov, G. & contributors (2023). "llama.cpp: Port of Facebook's LLaMA model in C/C++." GitHub repository, github.com/ggerganov/llama.cpp.

[6] Xiao, G., Lin, J., Seznec, M., et al. (2022). "SmoothQuant: Accurate and Efficient Post-Training Quantization for Large Language Models." arXiv preprint arXiv:2211.10438.

[7] Esser, S. K., McKinstry, J. L., Bablani, D., et al. (2020). "Learned Step Size Quantization." International Conference on Learning Representations (ICLR).

[8] Banbury, C., Zhou, C., Fedorov, I., et al. (2021). "MLPerf Tiny Benchmark." Proceedings of the Neural Information Processing Systems Track on Datasets and Benchmarks (NeurIPS Datasets).

[9] Sanchez-Lengeling, B., Wei, J., et al. (2022). "Edge AI: Challenges and Opportunities." Nature Machine Intelligence, vol. 4, pp. 651–660.

[10] Dettmers, T., Pagnoni, A., Holtzman, A., & Zettlemoyer, L. (2023). "QLoRA: Efficient Finetuning of Quantized LLMs." Conference on Neural Information Processing Systems (NeurIPS).

[11] Tailor, R. A., Fernandez-Marques, J., & Lane, N. D. (2021). "Quant-LLM: Accelerated LLM Inference on Edge." arXiv preprint arXiv:2310.08065.

[12] He, K., Zhang, X., Ren, S., & Sun, J. (2016). "Deep Residual Learning for Image Recognition." CVPR, pp. 770–778.

[13] Devlin, J., Chang, M.-W., Lee, K., & Toutanova, K. (2019). "BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding." NAACL-HLT.

[14] Touvron, H., Lavril, T., Izacard, G., et al. (2023). "LLaMA: Open and Efficient Foundation Language Models." arXiv preprint arXiv:2302.13971.

[15] Hendrycks, D., Burns, C., Basart, S., et al. (2021). "Measuring Massive Multitask Language Understanding." International Conference on Learning Representations (ICLR).