INT4 / INT3 / INT2 — Quantification Extrême#

TL;DR — La quantification sub-4-bit est la frontière ultime de la compression des LLMs. INT4 est le sweet spot quasi-lossless avec les méthodes modernes (GPTQ, AWQ, GGUF Q4_K_M). INT3 reste acceptable pour les grands modèles (≥ 30B) mais dégrade notablement les petits. INT2 est le régime extrême qui exige des méthodes avancées (vector quantization, codebooks appris) comme AQLM ou QuIP#. Comprendre la courbe de dégradation perplexity-vs-bits est le facteur de décision.

Le spectre de la quantification extrême#

↓ Plus on descend en bits, plus le « gap » se creuse entre les méthodes naïves et les méthodes avancées.

Le défi de la quantification sub-4-bit#

Niveau néophyte#

Imaginez que vous devez peindre un portrait avec de moins en moins de couleurs. Avec 256 nuances (INT8), le portrait est fidèle. Avec 16 nuances (INT4), c'est encore bon — les ombres et les couleurs principales sont là. Avec 4 nuances (INT2), ça devient un collage : les détails disparaissent, le visage est à peine reconnaissable.

Pour les LLMs, c'est pareil. En dessous de 4 bits, la « palette » est si limitée que chaque niveau doit être placé stratégiquement, pas uniformément. C'est là que les méthodes avancées (vector quantization, codebooks appris, incoherence processing) entrent en jeu.

Pourquoi INT4 est le sweet spot#

Le mur du sub-4-bit#

En dessous de 4 bits, trois problèmes majeurs apparaissent :

Dégradation de la perplexité vs bits#

La courbe fondamentale#

Lecture : FP16 → INT4 : dégradation MINIME (+0.1 PPL) · INT4 → INT3 : MODÉRÉE (+0.5-1.0 PPL) · INT3 → INT2 : MASSIVE selon méthode (GPTQ: +3 PPL, AWQ: +1.5 PPL, QuIP#/AQLM: +0.5 PPL)

Tableau détaillé par méthode et modèle#

Llama-2-7B (WikiText2 PPL)#

Llama-2-70B (WikiText2 PPL)#

Observation clé : les grands modèles (≥ 30B) sont beaucoup plus robustes à la quantification extrême. Un INT2 sur un 70B peut être meilleur qu'un INT4 sur un 7B. C'est le principe de overquantization : mieux vaut un grand modèle ultra-quantifié qu'un petit modèle en haute précision.

INT4 — Le sweet spot en détail#

Méthodes recommandées#

Pourquoi INT4 fonctionne si bien#

INT3 — La zone limite#

Quand INT3 est acceptable#

Méthodes INT3 viables#

INT2 — Le régime extrême#

Pourquoi la quantification scalaire échoue en INT2#

Les méthodes qui réussissent en INT2#

Seules les méthodes de vector quantization et d'incoherence processing fonctionnent en INT2 :

QuIP# — le SOTA en INT2#

La RHT « étale » l'information uniformément, donc chaque poids contient un peu de TOUTE la matrice → la quantification est beaucoup plus robuste.

Diagramme de décision : quel format choisir ?#

Comparaison des méthodes par régime#

Légende : ✅✅ = recommandé, ✅ = bon, ⚠️ = acceptable avec réserves, ❌ = éviter, — = non supporté

Le principe d'overquantization#

State of the art en ultra-low bit (2024-2025)#

Timeline des avancées#

Méthodes à surveiller#

Quand utiliser vs éviter#

Exemple pratique#

INT4 avec GPTQ (le standard)#

# Installation
pip install auto-gptq optimum

# Quantification INT4
python -m auto_gptq.examples.quantize \
    --model-path meta-llama/Llama-2-7b-hf \
    --bits 4 \
    --group-size 128 \
    --calibration-dataset c4 \
    --num-samples 128 \
    --output-dir ./llama-7b-gptq-4bit

# Servir avec vLLM (GPTQ + Marlin automatique)
python -m vllm.entrypoints.openai.api_server \
    --model ./llama-7b-gptq-4bit \
    --quantization gptq

INT3 avec GGUF (llama.cpp)#

# Conversion + quantification Q3_K_M
./quantize \
    ./models/llama-7b-fp16.gguf \
    ./models/llama-7b-Q3_K_M.gguf \
    Q3_K_M

# Résultat :
# - Taille : 13.5 GB → 3.3 GB
# - PPL WikiText2 : ~6.6
# - Inférence CPU/GPU avec llama.cpp
./main -m ./models/llama-7b-Q3_K_M.gguf -p "Bonjour"

INT2 avec QuIP#

# Installation
pip install quip-sharp

# Quantification 2-bit avec incoherence processing
python -m quipsharp.quantize \
    --model-path meta-llama/Llama-2-7b-hf \
    --codebook E8P12 \
    --bits 2 \
    --hadamard-transform \
    --output-dir ./llama-7b-quip-2bit

# Résultat attendu :
# - Taille : 13.5 GB → ~2.2 GB
# - PPL WikiText2 : ~7.27 (SOTA 2-bit)
# - Temps : plusieurs heures

INT2 avec AQLM#

# Installation
pip install auto-aqlm

# Quantification 2-bit (2 codebooks × 8-bit indices)
python -m auto_aqlm \
    --model meta-llama/Llama-2-7b-hf \
    --output_dir ./llama-7b-aqlm-2bit \
    --num_codebooks 2 \
    --in_group_size 8 \
    --num_indices 256 \
    --calibration_dataset c4 \
    --num_calibration_samples 128

# Résultat :
# - Taille : 13.5 GB → ~2.5 GB
# - PPL WikiText2 : ~7.50
# - Temps : 2-6h sur A100

Comparaison rapide des formats GGUF (llama.cpp)#

# Lister les quantifications disponibles
# Format : Q{bits}_{variant}

# Recommandations par objectif :
# Q4_K_M   → Sweet spot (4-bit, ~5.59 PPL sur 7B)
# Q3_K_M   → Bon compromis mémoire (3-bit, ~6.6 PPL)
# Q3_K_L   → Meilleur INT3 (plus de poids en 4-bit)
# Q2_K     → Ultra-compact (2-bit, ~8.5 PPL — limite)
# Q2_K_S   → Plus petit possible (qualité dégradée)

Références#

• GPTQ — Frantar et al., "GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers", ICLR 2023 — arXiv:2210.17323
• AWQ — Lin et al., "AWQ: Activation-aware Weight Quantization for LLM Compression and Acceleration", MLSys 2024 — arXiv:2306.00978
• QuIP# — Tseng et al., "QuIP#: Even Better LLM Quantization with Hadamard Incoherence and Lattice Codebooks", 2024 — arXiv:2402.04396
• AQLM — Egiazarian et al., "Extreme Compression of Large Language Models via Additive Quantization", ICML 2024 — arXiv:2401.06118
• OmniQuant — Shao et al., "OmniQuant: Omnidirectionally Calibrated Quantization for Large Language Models", ICLR 2024 — arXiv:2308.13137
• HQQ — Mobius Labs, "Half-Quadratic Quantization (HQQ)", 2023 — github.com/mobiusml/hqq
• BitNet b1.58 — Wang et al., "The Era of 1-bit LLMs", 2024 — arXiv:2402.17764
• llama.cpp — github.com/ggerganov/llama.cpp — Quantifications GGUF Q2_K à Q8_0
• Voir aussi : GPTQ · AWQ · QuIP · AQLM · HQQ · GGUF · Index quantification