Comparatif exhaustif des méthodes de quantification LLM#

Page centrale du guide quantification — Compare en un coup d'œil toutes les méthodes de quantification pour Large Language Models, avec tableaux détaillés, diagrammes décisionnels ASCII, graphiques comparatifs et matrice de compatibilité des outils.

Sommaire#

1. Introduction
2. Tableau comparatif principal
3. Guides de choix
4. Graphiques ASCII comparatifs
5. Matrice de compatibilité outils
6. Cross-références
7. Références

Introduction#

Pourquoi comparer les méthodes ?#

La quantification des LLMs n'est pas un problème à solution unique. Le choix de la méthode dépend de quatre facteurs principaux :

Les grandes familles#

Comment choisir — résumé express#

Tableau comparatif principal#

Légende : PPL Δ = variation de perplexité vs baseline FP16 (approximatif, varie selon le modèle). Vitesse = speedup d'inférence relatif vs FP16. Mémoire = réduction vs FP16. Facilité = 🟢 facile · 🟡 moyen · 🔴 complexe.

Les valeurs sont approximatives et dépendent du modèle, du hardware et de la configuration exacte.

QAT et fine-tuning#

PTQ — Méthodes INT8 / W8A8#

PTQ — Méthodes INT4 / weight-only#

PTQ — Compression extrême (≤ 3 bit)#

Formats et kernels d'inférence#

Hardware natif et configurations#

Techniques émergentes#

Guides de choix#

Diagramme décisionnel principal#

Arbre de décision détaillé#

Matrice de décision rapide#

★ = 1 (faible) · ★★★ = moyen · ★★★★★ = excellent

Graphiques ASCII comparatifs#

Perplexité vs méthode (à 4-bit, approximation)#

Plus la barre est courte, meilleure est la qualité. Baseline FP16 = 0.

Perplexité à 2-bit (compression extrême)#

Réduction mémoire vs méthode#

Plus la barre est longue, plus la compression est importante. Baseline FP16 = 1x.

Vitesse d'inférence relative vs méthode#

Speedup approximatif vs FP16 baseline. Dépend du batch size et du hardware.

Temps de quantification (coût de la mise en œuvre)#

Temps approximatif pour quantifier un modèle 7B sur A100.

BitNet b1.58 : entraînement from scratch (non représentable sur cette échelle)

Matrice de compatibilité outils#

Quel outil supporte quelle méthode ?#

Tableau de compatibilité détaillé#

Compatibilité hardware#

Synthèse comparative par dimension#

Qualité (perplexité) par nombre de bits#

Trade-off qualité vs compression#

Cross-références#

Pages individuelles détaillées de chaque méthode dans le Brain KB.

QAT et fine-tuning#

• QAT — Quantization-Aware Training
• bitsandbytes / NF4 (QLoRA)
• BitNet b1.58 — Ternary / Binary

PTQ — INT8 / W8A8#

• PTQ — Post-Training Quantization générique
• LLM.int8()
• SmoothQuant
• Outlier Suppression+

PTQ — INT4 / weight-only#

• GPTQ
• AWQ
• HQQ — Half-Quadratic Quantization
• OmniQuant
• SqueezeLLM
• SpQR

Compression extrême#

• QuIP / QuIP#
• AQLM

Formats et kernels#

• GGUF / GGML (llama.cpp)
• Marlin
• QoQ / QServe
• KV Cache Quantization (KIVI)

Hardware et configurations#

• INT8 / FP8 Hardware
• FP4 / FP8 Floating-Point
• INT4 / INT3 / INT2 — Quantification extrême
• W4A8 / W8A8 Mixed Precision

Techniques émergentes#

• Sub-byte Quantization
• LLC — Locally-Low-Correlation
• HFQ — Hash-based Quantization

Références#

Papiers arXiv cités#

1. LLM-QAT — Liu et al., LLM-QAT: Data-Free Quantization Aware Training for Large Language Models, arXiv:2305.17888, 2023
2. PTQ générique — Jacob et al., Quantization and Training of Neural Networks for Efficient Integer-Arithmetic-Only Inference, arXiv:1712.05877, 2017
3. LLM.int8() — Dettmers et al., LLM.int8(): 8-bit Matrix Multiplication for Transformers at Scale, arXiv:2208.07339, 2022
4. SmoothQuant — Xiao et al., SmoothQuant: Accurate and Efficient Post-Training Quantization for Large Language Models, arXiv:2211.10438, 2022
5. GPTQ — Frantar et al., GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers, arXiv:2210.17323, 2022
6. AWQ — Lin et al., AWQ: Activation-aware Weight Quantization for LLM Compression and Acceleration, arXiv:2306.00978, 2023
7. QLoRA — Dettmers et al., QLoRA: Efficient Finetuning of Quantized LLMs, arXiv:2305.14314, 2023
8. QuIP — Chee et al., QuIP: 2-Bit Quantization of Large Language Models With Guarantees, arXiv:2307.13304, 2023
9. QuIP# — Tseng et al., QuIP#: Even Better LLM Quantization with Hadamard Incoherence and Lattice Codebooks, arXiv:2402.04396, 2024
10. AQLM — Egiazarian et al., Extreme Compression of Large Language Models via Additive Quantization, arXiv:2401.06118, 2024
11. HQQ — Badri & Shaji, Half-Quadratic Quantization of Large Machine Learning Models, 2023 — blog technique
12. SqueezeLLM — Kim et al., SqueezeLLM: Dense-and-Sparse Quantization, arXiv:2306.07629, 2023
13. SpQR — Dettmers et al., SpQR: A Sparse-Quantized Representation for Near-Lossless LLM Weight Compression, arXiv:2306.03078, 2023
14. OmniQuant — Shao et al., OmniQuant: Omnidirectionally Calibrated Quantization for Large Language Models, arXiv:2308.13137, 2023
15. Outlier Suppression+ — Wei et al., Outlier Suppression+: Accurate quantization of large language models by equivalent and optimal shifting and scaling, arXiv:2304.09145, 2023
16. MARLIN — Frantar et al., MARLIN: Mixed-Precision Auto-Regressive Parallel Inference on Large Language Models, arXiv:2408.11743, 2024
17. QServe / QoQ — Lin et al., QServe: W4A8KV4 Quantization and System Co-design for Efficient LLM Serving, arXiv:2405.04532, 2024
18. KIVI — Liu et al., KIVI: A Tuning-Free Asymmetric 2bit Quantization for KV Cache, arXiv:2402.02750, 2024
19. FP8 Formats — Micikevicius et al., FP8 Formats for Deep Learning, arXiv:2209.05433, 2022
20. FP8 PTQ — Efficient Post-training Quantization with FP8 Formats, MLSys 2024
21. BitNet — Wang et al., BitNet: Scaling 1-bit Transformers for Large Language Models, arXiv:2310.11453, 2023
22. BitNet b1.58 — Ma et al., The Era of 1-bit LLMs: All Large Language Models are in 1.58 Bits, arXiv:2402.17764, 2024
23. BitNet b1.58 2B4T — modèle open-source, arXiv:2504.12285, 2025
24. GGUF evaluation — Which Quantization Should I Use? A Unified Evaluation of llama.cpp Quantization Types, arXiv:2601.14277, 2026
25. QQQ — QQQ: Quality Quattuor-Bit Quantization for Large Language Models, arXiv:2406.09904, 2024
26. SpAtten — Wang et al., SpAtten: Efficient Sparse Attention Architecture with Cascade Token and Head Pruning, arXiv:2012.09852, 2020
27. TernaryLM — implémentation alternative BitNet, arXiv:2602.07374, 2026

Sources complémentaires#

• Document de recherche source : recherche-quantification-llm.md (Brain KB)
• llama.cpp GitHub — documentation des formats GGUF
• Hugging Face Quantization Docs
• vLLM Quantization Docs

Glossaire rapide#

Page de navigation principale du guide quantification du Brain KB.
Dernière mise à jour : août 2026.