INT8 / FP8 Quantization — Support Hardware Native#

TL;DR — La quantification n'a d'intérêt pratique que si le matériel sait calculer directement dans le format compressé. Les GPU modernes (NVIDIA Hopper H100, Blackwell B200), les CPU (Intel AMX) et les accélérateurs (Apple ANE) intègrent désormais des unités de calcul dédiées pour INT8 et FP8. Ce support natif se traduit par un throughput jusqu'à 2× à 4× supérieur au FP16, sans perte d'accuracy notable. Comprendre la correspondance format ↔ hardware est le levier pour déployer des LLMs en production à grande échelle.

Pourquoi le support hardware matters#

Niveau néophyte#

Imaginez que vous deviez traduire un texte du chinois vers le français, mais que votre machine à traduire ne comprend que l'anglais. Vous devez faire une étape intermédiaire (chinois → anglais → français), ce qui prend deux fois plus de temps et introduit des erreurs.

Avec le support hardware natif, la machine traduit directement du chinois au français — pas d'étape intermédiaire, pas de surcoût. Pour les LLMs, le GPU peut multiplier des matrices en INT8 ou FP8 sans jamais repasser par le FP16, ce qui double voire quadruple la vitesse.

Le problème de la déquantification à la volée#

La plupart des méthodes de quantification (GPTQ INT4, AWQ, etc.) stockent les poids compressés mais doivent les déquantifier vers FP16 à chaque calcul :

La différence est fondamentale : sans support hardware natif, la quantification ne fait que réduire la mémoire (utile pour l'edge) mais n'accélère pas le calcul. Avec le support natif, elle accélère tout — mémoire ET compute.

Les formats : FP8 E4M3 vs FP8 E5M2 vs INT8#

Diagramme bit-level#

Comparaison détaillée#

Pourquoi le FP8 gère mieux les outliers#

Les poids de LLMs suivent une distribution heavy-tailed (queue épaisse) avec quelques valeurs extrêmes :

Le FP8, grâce à son exponent, alloue dynamiquement la précision là où c'est nécessaire — plus de niveaux près de zéro, moins pour les grandes valeurs. L'INT8, lui, distribue ses niveaux uniformément, ce qui gaspille de la résolution sur les zones peu peuplées et sature sur les outliers.

Support hardware par plateforme#

Vue d'ensemble#

NVIDIA Hopper (H100) — le game-changer FP8#

L'architecture Hopper a introduit le FP8 natif dans les Tensor Cores :

FP8 = 2× la vitesse du BF16 en dense · 4× en sparse
Transformer Engine : gestion automatique du FP8 (E4M3 forward / E5M2 backward)

Le Transformer Engine (bibliothèque logicielle NVIDIA) gère automatiquement :
- La sélection du format FP8 (E4M3 pour forward, E5M2 pour backward)
- Le scaling dynamique par tile/tensor
- L'amax tracking (suivi de la valeur max d'activation)
- Le fallback vers BF16 si nécessaire

Intel AMX — INT8 sur CPU#

L'Advanced Matrix Extensions (AMX) d'Intel apporte des instructions matricielles INT8/BF16 directement sur CPU Xeon (Sapphire Rapids et ultérieurs) :

Apple Neural Engine (ANE)#

L'ANE des puces Apple Silicon (M1, M2, M3, M4) supporte nativement l'INT8 via le Apple Neural Engine :

Framework : CoreML, MLX → inférence locale INT8 sur Mac/iPad
Pas de FP8 natif sur ANE (mais GPU Apple supporte FP16/BF16)

Niveau tech avancé : le pipeline FP8 complet#

Quantification FP8 statique (PTQ)#

Granularités de quantification#

Benchmarks throughput vs FP16#

Throughput théorique (Tensor Cores)#

FP8 dense = 2× le throughput du BF16 dense · INT8 dense = 2× · FP8/INT8 sparse = 4×

Benchmarks réels (vLLM, Llama-2-7B)#

Note : le speedup réel est inférieur au speedup théorique car le GEMM n'est qu'une partie du pipeline complet (attention, sampling, KV cache management).

Accuracy : INT8 / FP8 vs FP16#

À 8 bits, INT8 et FP8 sont essentiellement lossless pour la plupart des modèles ≥ 7B. C'est le régime « safe » de la quantification.

Outils principaux#

NVIDIA TensorRT-LLM — le standard production#

# Installation
pip install tensorrt-llm

# Quantification FP8 d'un modèle Hugging Face
python tensorrt_llm/quantization/quantize.py \
    --model_dir meta-llama/Llama-2-7b-hf \
    --dtype float16 \
    --qformat fp8 \
    --output_dir ./llama-7b-fp8 \
    --calib_size 512

# Build du moteur TensorRT optimisé
trtllm-build \
    --checkpoint_dir ./llama-7b-fp8 \
    --output_dir ./llama-7b-fp8-engine \
    --gemm_plugin fp8

# Inférence via l'API Python ou le serveur Triton

vLLM — le plus simple pour FP8#

# Servir un modèle en FP8 sur H100
python -m vllm.entrypoints.openai.api_server \
    --model neuralmagic/Meta-Llama-3.1-8B-Instruct-FP8 \
    --quantization fp8 \
    --dtype auto \
    --port 8000

# vLLM détecte le FP8 et utilise les Tensor Cores nativement

Intel OpenVINO — INT8 sur CPU#

from optimum.intel import OVQuantizer, OVModelForCausalLM

# Quantification INT8 avec calibration
model = OVModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")
quantizer = OVQuantizer.from_pretrained(model)

# Calibration + quantification INT8
quantizer.quantize(
    calibration_dataset=dataset,
    save_directory="./llama-7b-int8-ov",
)

# Inférence sur CPU Xeon avec AMX
model_int8 = OVModelForCausalLM.from_pretrained("./llama-7b-int8-ov")

torch.compile — PyTorch natif#

import torch

# Quantification INT8 dynamique avec PyTorch 2+
model_fp16 = ...  # votre modèle

# Quantization dynamique INT8 (activations)
model_int8 = torch.ao.quantization.quantize_dynamic(
    model_fp16,
    {torch.nn.Linear},
    dtype=torch.qint8
)

# torch.compile avec backend optimisé
model_int8 = torch.compile(model_int8, mode="max-autotune")

# Pour FP8 (nécessite PyTorch 2.2+ + H100)
# Utiliser le Transformer Engine de NVIDIA :
import transformer_engine.pytorch as te

# Remplacer les Linear par des te.Linear (FP8 natif)

NVIDIA Transformer Engine — FP8 natif#

import transformer_engine.pytorch as te
import torch

# Modèle avec FP8 natif
model = te.TransformerLayer(
    hidden_size=4096,
    ffn_hidden_size=11008,
    num_attention_heads=32,
)

# Le FP8 est géré automatiquement par le Transformer Engine
# Sélection E4M3 (forward) / E5M2 (backward) transparente
with te.fp8_autocast():
    output = model(input_ids)
    loss = loss_fn(output, labels)
    loss.backward()  # gradients en E5M2

Quand utiliser INT8 vs FP8#

Références#

• Papier FP8 Formats — Micikevicius et al., "FP8 Formats for Deep Learning", 2022 — arXiv:2209.05433
• Papier FP8 PTQ — "Efficient Post-training Quantization with FP8 Formats", MLSys 2024 — arXiv:2310.18313
• NVIDIA H100 Whitepaper — NVIDIA Hopper Architecture In-Depth
• NVIDIA Transformer Engine — docs.nvidia.com/deeplearning/transformer-engine
• Intel AMX — Intel Advanced Matrix Extensions
• NVIDIA TensorRT-LLM — github.com/NVIDIA/TensorRT-LLM
• OpenVINO — docs.openvino.ai
• Voir aussi : LLM.int8() · SmoothQuant · Index quantification