W4A8 / W8A8 — Quantification en précision mixte#

TL;DR — La notation WxAy décrit une quantification en précision mixte où les poids (Weights) sont codés sur x bits et les activations sur y bits. Les poids étant statiques et réguliers, on peut les compresser agressivement (4-bit). Les activations, sujettes à des outliers dynamiques, nécessitent plus de précision (8 ou 16-bit). W8A8 est la configuration la plus robuste (support natif Tensor Cores INT8/FP8). W4A8 est plus agressive et optimale pour le cloud serving à grand batch.

Le concept : pourquoi quantifier différemment poids et activations ?#

Dans un Transformer, une couche linéaire calcule Y = X × W où :
- W (poids) — fixe après entraînement, distributions lisses et régulières
- X (activations) — changent à chaque token, contiennent des outliers (valeurs extrêmes)

L'analogie pour néophyte#

Imagine un restaurant. Les poids sont le livre de recettes : il ne change jamais, tu peux le photocopier en version condensée (4 mots-clés par recette). Les activations, ce sont les ingrédients qui arrivent en temps réel — chaque plat est différent, parfois un ingrédient sort du lot (une dose 20× trop forte). Tu ne peux pas condenser les ingrédients autant que les recettes, sinon tu ruines le plat. Donc : recettes en 4-bit, ingrédients en 8-bit.

Les trois configurations principales#

W8A8 : la configuration de référence#

Principe#

Poids et activations tous deux en 8-bit. C'est le standard de l'industrie pour la quantification production-ready.

Pourquoi W8A8 est le plus stable#

1. Pas de déquantification coûteuse : tout le pipeline reste en INT8
2. Support hardware natif : Tensor Cores INT8 depuis NVIDIA Volta (V100)
3. Outliers gérables : SmoothQuant + INT8 suffit à contenir les valeurs extrêmes
4. Perte d'accuracy < 1% sur la plupart des benchmarks

Outils principaux pour W8A8#

W4A8 : le meilleur des deux mondes pour le cloud serving#

Principe#

Poids en INT4 (compression agressive), activations en INT8 (stabilité + accélération compute). C'est la configuration qui a émergé comme optimale pour le large-batch cloud serving.

W4A8 vs W4A16 : quand utiliser quoi ?#

La nuance critique : la déquantification progressive#

Le défi du W4A8 est le GEMM : comment multiplier du INT4 par du INT8 ? Il faut déquantifier les poids. Deux approches :

C'est exactement l'innovation du progressive quantization dans QoQ/QServe.

Diagramme unifié : W8A8 vs W4A8 vs W4A16#

Le rôle de SmoothQuant dans W8A8 et W4A8#

SmoothQuant est le prérequis pour toute quantification W8A8 ou W4A8 réussie. Sans lui, les outliers d'activation rendent l'INT8 catastrophique.

La transformation est mathématiquement équivalente (même sortie) :

  Y = X · W                           (original)
  Y = (X · diag(1/s)) · (diag(s) · W) (équivalent, mais X lissé)
  Y = X' · W'                          (W' = poids modifiés)

Méthodes et outils de quantification W4A8 / W8A8#

Vue d'ensemble#

Le combo SmoothQuant + GPTQ (W4A8 pratique)#

Une approche pratique de W4A8 combine SmoothQuant (pour les activations INT8) avec GPTQ (pour les poids INT4) :

Exemple pratique#

W8A8 avec TensorRT-LLM#

# 1. Installer TensorRT-LLM
pip install tensorrt-llm

# 2. Quantification W8A8 (SmoothQuant + INT8)
python tensorrt_llm/examples/llama/quantize.py \
    --model_dir ./llama-3-8b \
    --dtype float16 \
    --qformat int8_smoothquant \  # W8A8 avec SmoothQuant
    --calib_size 512 \            # 512 échantillons de calibration
    --output_dir ./llama-3-8b-w8a8

# 3. Build du moteur TensorRT
trtllm-build \
    --checkpoint_dir ./llama-3-8b-w8a8 \
    --output_dir ./trt-engine-w8a8 \
    --gemm_plugin int8  # Utiliser les Tensor Cores INT8

# 4. Inférence
python -m tensorrt_llm.run \
    --engine_dir ./trt-engine-w8a8 \
    --tokenizer_dir ./llama-3-8b

W4A8 avec QServe/QoQ#

# Cloner QServe
git clone https://github.com/mit-han-lab/omniserve.git
cd omniserve
pip install -e .

# Serving W4A8KV4
python -m qserve.entrypoints.openai.api_server \
    --model meta-llama/Meta-Llama-3-8B \
    --quantization qoq \
    --w-bits 4 \
    --a-bits 8 \
    --kv-bits 4 \
    --port 8000

W8A8 avec SmoothQuant (standalone)#

from smoothquant import SmoothQuant, Calibration

# 1. Calibration
calib = Calibration(model, dataset="redpajama", n_samples=512)
activation_stats = calib.collect_stats()

# 2. Migration des outliers
sq = SmoothQuant(alpha=0.5)  # α contrôle la migration
model_smoothed = sq.migrate(model, activation_stats)

# 3. Quantification INT8 (W8A8)
model_int8 = quantize_int8(model_smoothed)
# → GEMM INT8 × INT8 sur Tensor Cores

Tableau de décision#

Avantages et inconvénients#

Références#

• SmoothQuant — Xiao et al., "SmoothQuant: Accurate and Efficient Post-Training Quantization for Large Language Models", ICML 2023 — arXiv:2211.10438
• LLM.int8() — Dettmers et al., "LLM.int8(): 8-bit Matrix Multiplication for Transformers at Scale", NeurIPS 2022 — arXiv:2208.07339
• QoQ / QServe — Lin et al., "QServe: W4A8KV4 Quantization and System Co-design for Efficient LLM Serving", 2024 — arXiv:2405.04532
• QQQ — "QQQ: Quality Quattuor-Bit Quantization for Large Language Models", 2024 — arXiv:2406.09904
• OmniQuant — Shao et al., "OmniQuant: Omnidirectionally Calibrated Quantization for Large Language Models", 2023 — arXiv:2308.13137
• FP8 Formats — Micikevicius et al., "FP8 Formats for Deep Learning", 2022 — arXiv:2209.05433
• Voir aussi : SmoothQuant · QoQ / QServe · GPTQ · LLM.int8() · Marlin · Index quantification