Aller au contenu

🗜️ La Quantification (4-bit & 8-bit)

La quantification (quantization) réduit la précision numérique des poids (et parfois des activations) d’un réseau de neurones 1.

En passant de la précision native FP16/BF16 (2 octets par paramètre) à des formats compressés en 8-bit (1 octet), 4-bit (~0,5 octet effectif) ou plus bas, on divise l’empreinte VRAM d’un modèle par 2 à 4, ce qui permet d’exécuter localement des modèles autrement hors de portée matérielle 1.


📐 La Physique Mathématique de la Quantification

La méthode la plus courante en post-training est la quantification affine par blocs (souvent appelée quantification linéaire uniforme à échelle et zero-point) 13. Elle projette un intervalle de valeurs réelles (x∈[βmin,βmax]x \in [\beta_{min}, \beta_{max}]) vers un ensemble discret de basse précision (qq) :

q=round(xS)+Zq = \text{round}\left(\frac{x}{S}\right) + Z

Où :

  • SS (Scale) : facteur d’échelle réel qui étire ou contracte l’intervalle 3.
  • ZZ (Zero-point) : entier qui aligne le zéro réel sur une valeur discrète 3.
  • round\text{round} : arrondi à l’entier le plus proche.
graph LR
    subgraph "Haute Précision (BF16)"
        A[-3.14] --> B[0.0] --> C[1.59] --> D[5.82]
    end
    subgraph "Basse Précision (INT4)"
        E[-8] --> F[0] --> G[4] --> H[15]
    end
    A -.->|Formule de Quantification| E
    B -.->|S & Z| F
    C -.->|S & Z| G
    D -.->|S & Z| H

⚠️ Le problème des valeurs aberrantes (Outliers)

Dans un LLM, certaines activations ou certains poids ont des amplitudes anormalement élevées 34. Si l’on quantifie un tenseur entier avec une seule échelle, SS doit couvrir ces extrêmes : la majorité des valeurs normales se retrouvent alors compressées dans quelques bins discrets, ce qui dégrade fortement la qualité (perplexité, benchmarks downstream) 34.

Toute la recherche récente en quantification LLM vise à contourner ce problème : protection de sous-ensembles de poids (AWQ), compensation par Hessienne (GPTQ), rotations Hadamard (MR-GPTQ), ou formats FP4 à granularité fine (NVFP4/MXFP4) 546.


🗺️ Le Paysage des Formats de Quantification

Le choix du format dépend de votre infrastructure cible (CPU, GPU dédié, mémoire unifiée) et du moteur d’inférence (llama.cpp, vLLM, TensorRT-LLM).

1. GGUF (llama.cpp) : le standard CPU / mémoire unifiée

Le format GGUF (écosystème llama.cpp) cible l’inférence locale, l’offloading partiel vers la RAM et Apple Silicon 78.

  • Les K-Quants (superblocks) : les poids sont découpés en super-blocs de 256 valeurs, avec des sous-blocs et des échelles multiples 8. Les variantes Q4_K_M, Q5_K_M, etc. utilisent une précision mixte : les tenseurs sensibles (souvent les matrices d’attention) restent à plus haute précision que le reste du réseau 8.
  • Idéal pour : Mac Studio, Ryzen x86, inférence CPU-first, déploiements souverains sans stack GPU lourde 7.

2. AWQ vs GPTQ (standard GPU)

Ces formats dominent l’inférence GPU de production (vLLM, TGI, etc.) 54.

  • GPTQ (Generative Pre-trained Transformer Quantization) : quantification PTQ one-shot qui minimise l’erreur de reconstruction en utilisant la matrice Hessienne pour compenser l’arrondi couche par couche 5.
  • AWQ (Activation-aware Weight Quantization) : identifie ~1 % des poids les plus « saillants » via la magnitude des activations et les protège en plus haute précision ; le reste est compressé en 4-bit 4. En pratique, AWQ rivalise ou dépasse souvent GPTQ sur les benchmarks de qualité à taille égale 4.
  • Idéal pour : débit GPU maximal sur Nvidia/AMD avec kernels dédiés.

3. Microscaling FP4 : MXFP4 et NVFP4

Standardisés par l’OCP (Open Compute Project) et accélérés matériellement sur GPU récents (Blackwell ; AMD Instinct MI350 en CDNA 4 — le MI300X s’arrête au FP8) 9610 :

  • Format E2M1 : nombres flottants 4-bit (1 signe, 2 exposant, 1 mantisse) 9.
  • MXFP4 : échelle de bloc E8M0 partagée sur 32 valeurs 9.
  • NVFP4 (NVIDIA) : échelle E4M3 FP8 sur 16 valeurs, plus un facteur d’échelle par tenseur 911.
  • MR-GPTQ (ICLR 2026) : variante GPTQ avec rotations Hadamard par blocs, adaptée aux contraintes FP4. Elle améliore nettement MXFP4 et atteint une précision proche de NVFP4, avec des accélérations jusqu’à ~4× end-to-end sur RTX 5090 et ~2,2× sur B200 vs FP16 — mais le FP4 n’est pas un upgrade automatique sur INT4 sans méthode dédiée 6.

📊 Arbitrage : Taille, Perplexité et qualité downstream

La perplexité (PPL) sur WikiText-2 mesure la capacité prédictive du modèle (plus bas = mieux). Elle est utile pour comparer des quantifications sur le même modèle et tokenizer, mais ne suffit pas : des écarts faibles en PPL peuvent masquer des régressions sur le raisonnement ou l’instruction-following 811.

Benchmarks GGUF — Llama 3.1-8B-Instruct (données unifiées)

Source : étude llama.cpp sur un même checkpoint, 13 formats GGUF + baseline F16 8. PPL = WikiText-2 ; Avg = moyenne non pondérée de GSM8K, HellaSwag, IFEval, MMLU, TruthfulQA.

Formatbpw effectif (≈)Réduction taille (%) 8PPL WikiText-2Avg downstreamCommentaire
F16 (référence)16,0—7,3269,47Baseline
Q8_08,046,97,3369,41Quasi-identique à F16
Q6_K~6,159,07,3569,23Conservateur
Q5_0~5,265,27,4369,92Meilleur compromis Pareto qualité/taille 8
Q5_K_M~5,564,47,4069,365-bit K-quant robuste
Q4_K_S~4,270,87,6269,17Default équilibré 4-bit 8
Q4_K_M~4,569,47,5669,15Standard communautaire
Q3_K_M~3,575,07,9668,073-bit utilisable si contraint
Q3_K_S~3,477,28,9665,49Compression max, perte visible
Q2_K~2,5———Voir scoreboard llama.cpp : PPL ~9,75 sur Llama 3 8B base 12

💡 Le paradoxe de la quantification (règle d’or)

Une erreur classique : préférer un petit modèle non quantifié à un grand modèle quantifié. Sous contrainte mémoire fixe, le nombre de paramètres domine souvent le niveau de bits 1213.


📋 Le Conseil de l’Architecte

Pour un déploiement souverain d’agents locaux on-premise :

  1. Standard PME (CPU / Mac / hybride) : Q4_K_S ou Q4_K_M en GGUF via llama.cpp — meilleur compromis taille/qualité/vitesse documenté pour Llama 3.1-8B ; monter en Q5_0 si la marge qualité prime 8.
  2. Inférence GPU partagée (vLLM / TensorRT-LLM) : FP8 sur les poids (Hopper/Blackwell/RTX récentes) ou AWQ INT4 selon le moteur ; le FP8 réduit la VRAM ~×2 avec une dégradation faible si bien calibré, sans être strictement identique au BF16 14. Les noms d’options bougent vite (vLLM 0.31 : fp8 → fp8_per_tensor ; SGLang ≥ 0.5.16 : NVFP4 via FlashInfer uniquement) et le FP4 sur GPU de station (SM120 : RTX 50, RTX PRO 6000) reste partiellement supporté dans TensorRT-LLM au T4 2026 : testez votre couple moteur/GPU avant d’acheter 214.
  3. Éviter Q2 et Q3 agressif en production : Q3_K_S et Q2_K dégradent nettement le raisonnement (GSM8K) et la perplexité ; réserver aux contraintes extrêmes de RAM 812. Cette règle vaut pour un modèle requantifié après coup. Un 2 bits livré par l’éditeur et entraîné pour ce format est un autre cas : c’est Nemotron 3.5 Bolt 74B-A9B (octobre 2026), dont les experts sont en IQ2_XXS par distillation QAD, et que NVIDIA juge meilleur que des modèles plus petits en 4 bits à mémoire égale. À juger sur vos propres benchmarks 15.
  4. FP4 (NVFP4/MXFP4) : accéléré nativement sur Blackwell (B200, RTX 50, RTX PRO 6000, DGX Spark) ; depuis 2026 c’est aussi un format de livraison : Kimi K3 est entraîné en MXFP4 natif (QAT), gpt-oss et Nemotron 3.5 Lightning sont publiés en MXFP4 / NVFP4 officiels (≈ 22 Go pour Lightning), Mistral Small 4 a son dépôt NVFP4 16. Quand l’éditeur fournit ce checkpoint, préférez-le à une requantification communautaire ; sur GPU pré-Blackwell, le moteur retombe sur un chemin W4A16 plus lent. Validez toujours sur vos benchmarks métier 611.

📚 Sources et Références

Footnotes

  1. NVIDIA Technical Blog, Mastering LLM Techniques: Inference Optimization (quantification, compromis précision/mémoire), novembre 2023. https://developer.nvidia.com/blog/mastering-llm-techniques-inference-optimization/ ↩ ↩2 ↩3 ↩4

  2. DeepSeek AI, DeepSeek-V4.1-Flash (« FP4 main KV caching », E2M1 + une échelle E4M3 par 16 canaux, 890 octets par token, MIT), 2026. https://huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash ; vLLM Project, Release v0.31.0 (FlashMLA + KV cache NVFP4 compressé par défaut sur SM100 pour DeepSeek-V4.1-Flash), 5 octobre 2026. https://github.com/vllm-project/vllm/releases/tag/v0.31.0 ↩ ↩2

  3. NVIDIA Technical Blog, Mastering LLM Techniques: Inference Optimization (outliers, activation quantization), novembre 2023. https://developer.nvidia.com/blog/mastering-llm-techniques-inference-optimization/ ↩ ↩2 ↩3 ↩4 ↩5

  4. J. Lin et al., AWQ: Activation-aware Weight Quantization for LLM Compression and Acceleration (arXiv:2306.00978), 2023. https://arxiv.org/abs/2306.00978 ↩ ↩2 ↩3 ↩4 ↩5 ↩6 ↩7

  5. E. Frantar et al., GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers (arXiv:2210.17323), 2022. https://arxiv.org/abs/2210.17323 ↩ ↩2 ↩3

  6. S. Egiazarian et al., Bridging the Gap Between Promise and Performance for Microscaling FP4 Quantization (MR-GPTQ, ICLR 2026), arXiv:2509.23202. https://arxiv.org/abs/2509.23202 ↩ ↩2 ↩3 ↩4

  7. ggml-org, llama.cpp (moteur GGUF, formats K-quant), 2026. https://github.com/ggml-org/llama.cpp ↩ ↩2

  8. J. Wang et al., Which Quantization Should I Use? A Unified Evaluation of llama.cpp Quantization on Llama-3.1-8B-Instruct (arXiv:2601.14277), janvier 2026. https://arxiv.org/abs/2601.14277 ↩ ↩2 ↩3 ↩4 ↩5 ↩6 ↩7 ↩8 ↩9 ↩10

  9. J. Chhugani et al., Unveiling the Potential of Quantization with MXFP4: Strategies for Quantization Error Reduction (arXiv:2603.08713), 2026. https://arxiv.org/abs/2603.08713 ↩ ↩2 ↩3 ↩4

  10. AMD, AMD Instinct MI350X GPU — brochure produit (CDNA 4 : prise en charge matérielle des formats FP6 et FP4 OCP MX, en plus de FP16 / FP8 ; le MI300X, CDNA 3, s’arrête au FP8), consultée le 2026-10-10. https://www.amd.com/content/dam/amd/en/documents/instinct-tech-docs/product-briefs/amd-instinct-mi350x-gpu-brochure.pdf ↩

  11. NVIDIA Technical Blog, Optimizing Inference for Long Context and Large Batch Sizes with NVFP4 KV Cache (format NVFP4), décembre 2025. https://developer.nvidia.com/blog/optimizing-inference-for-long-context-and-large-batch-sizes-with-nvfp4-kv-cache/ ↩ ↩2 ↩3

  12. ggml-org, llama.cpp perplexity scoreboard (WikiText-2, Llama 3 8B, formats K-quant), 2026. https://github.com/ggml-org/llama.cpp/blob/master/tools/perplexity/README.md ↩ ↩2 ↩3

  13. T. Dettmers, L. Zettlemoyer, The case for 4-bit precision: k-bit Inference Scaling Laws (arXiv:2212.09720 ; « 4-bit precision is almost universally optimal for total model bits and zero-shot accuracy », plus de 35 000 expériences), 2023. https://arxiv.org/abs/2212.09720 ; Meta, Muse Glimmer 30B (paliers BF16 64 Go / K-Quant-Dynamic 32 Go, −0,2 % / K-Quant 24 Go, −1,0 % en moyenne sur 15 benchmarks), août 2026. https://huggingface.co/meta-models/Muse-Glimmer-30B ↩ ↩2

  14. SGLang Project, Release v0.5.16 (GEMM NVFP4 via FlashInfer uniquement), 2026. https://github.com/sgl-project/sglang/releases/tag/v0.5.16 · NVIDIA, TensorRT-LLM — Releases (1.3.0 rc26/rc27 : NVFP4 W4A16 MoE non supporté sur SM120), relevé le 2026-10-09. https://github.com/NVIDIA/TensorRT-LLM/releases ↩

  15. NVIDIA Research, NVIDIA Nemotron 3.5 Bolt 74B-A9B 24GB (experts FC1/FC2 en IQ2_XXS à 2,0625 bits par élément via quantization-aware distillation, couches Mamba en NVFP4, embeddings et attention en Q8_0 ; « better than similarly sized models that are trained from scratch and quantized to 4 bit »), 2026-10-15. https://research.nvidia.com/labs/nemotron/Nemotron-3.5-Bolt-24GB/ ↩

  16. Moonshot AI, Kimi K3 (« MXFP4 weights / MXFP8 activations (quantization-aware training) »), juillet 2026. https://huggingface.co/moonshotai/Kimi-K3 ; NVIDIA, NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4 (≈ 21,6 Go de safetensors, « the NVFP4 release is the recommended path » pour le déploiement), août 2026. https://huggingface.co/nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4 ; OpenAI, gpt-oss-120b (« post-trained with MXFP4 quantization of the MoE weights », Apache 2.0), août 2025. https://huggingface.co/openai/gpt-oss-120b ; Mistral AI, dépôts Hugging Face (Mistral-Small-4-119B-2603 et sa variante NVFP4), relevé le 2026-10-09. https://huggingface.co/mistralai ↩

Donner mon avis

Tout est facultatif : une seule réponse suffit. Ce site n'envoie rien : c'est vous qui envoyez, par le moyen de votre choix.

Votre notePas de note
Votre avis porte sur
Sur quoi ? (plusieurs choix possibles)
Ce qui sera envoyé
Envoyer par e-mail

Privé, sans compte : ouvre votre messagerie avec le message prêt, pour ia-on-prem@damien.becherini.fr.

Ouvrir un ticket GitHub ↗

Public, avec un compte GitHub. Vous relisez le ticket avant de le publier.

Pour le coller où vous voulez.

Donnez au moins une note, un sujet ou un message pour pouvoir envoyer.