Quantification
- Les poids des couches linéaires sont arrondis sur 8, 4 ou 3 bits, avec une échelle par groupe de 128 poids.
- GPTQ et AWQ mesurent les activations sur quelques centaines de textes représentatifs pour limiter l'erreur d'arrondi.
- On compare au modèle bf16 dans les mêmes conditions : mémoire, tokens par seconde, perplexité, exactitude sur la tâche.
- Le modèle quantifié est servi tel quel, ou exporté en GGUF pour llama.cpp et Ollama.
Stocker les poids (et parfois les activations) sur 8, 4 ou 3 bits au lieu de 16 : un modèle 2 à 5 fois plus petit, souvent plus rapide, pour une perte de qualité mesurée.
- Identifiant : FORM15
- Catégorie : FORM · Remodeler : étendre ou compresser
- Regroupe : bitsandbytes, torchao, GPTQ, AWQ, QAT ; variante GGUF llama.cpp
- Modèles concernés : Tous : LLM, MoE, encodeurs, VLM, diffusion, Whisper
- Calcul : 1 GPU (inférence)
- Temps : minutes
- Modèle :
poids nécessaires - Données : — aucune donnée
- GPU local 12 Go (exemple de code) : ✅
- Code :
15-quantification/
Principe
« Améliorer » veut dire ici rendre le modèle déployable : moins de mémoire, plus de débit, et parfois la possibilité de faire tourner un modèle plus grand sur le même matériel. Un 14B en 4 bits bat souvent un 7B en 16 bits.
| Famille | Méthodes | Idée | Coût |
|---|---|---|---|
| PTQ à la volée | bnb_nf4, bnb_int8, torchao_int8wo, torchao_int4wo, torchao_fp8 |
Arrondi par groupes de poids, avec une échelle par groupe. NF4 utilise des niveaux adaptés à une distribution normale | Secondes, pas de données |
| PTQ calibrée | gptq, awq |
Quelques centaines d'exemples servent à mesurer les activations. GPTQ corrige les erreurs d'arrondi colonne par colonne (inverse de la hessienne) ; AWQ protège les canaux importants par une mise à l'échelle | Minutes à heures, 256 à 512 exemples |
| QAT | qat |
Pendant un court fine-tuning, les poids passent par une fausse quantification : le modèle apprend à tolérer l'arrondi, puis conversion réelle | Un fine-tuning. Récupère une bonne partie de la perte de la PTQ en 4 bits et moins |
| GGUF | variantes/gguf-llamacpp |
k-quants à blocs et super-blocs, matrice d'importance (imatrix) calculée sur un texte | Minutes sur CPU |
Mesures (référence bf16 puis modèle quantifié) : mémoire du modèle, tokens/s en génération, perplexité wikitext, exactitude sur la tâche.
Poids seuls ou poids + activations : W4A16 réduit la mémoire et accélère le décodage, limité par la bande passante mémoire. W8A8 et FP8 accélèrent les gros lots (prefill, serveur) sur les GPU qui ont les noyaux adaptés.
Modèles concernés
| Type de modèle | Exemples de modèles | Applicable | Remarques |
|---|---|---|---|
| LLM décodeur (toutes familles) | Llama 3, Qwen2.5, Mistral 7B, Gemma 2 | ✅ cas principal | run.py |
| MoE | Mixtral, Qwen-MoE, DeepSeek | ✅ | Experts quantifiés, routeur souvent laissé en haute précision |
| Encodeurs | BERT | ✅ | int8 dynamique (torch.ao, ONNX Runtime, Optimum) très courant en CPU |
| Vision / VLM | Qwen2.5-VL, LLaVA, Idefics | ✅ | Tour vision souvent gardée en 16 bits, LLM quantifié |
| Diffusion | SDXL, Flux | ✅ | NF4/FP8 du transformer de diffusion (diffusers + bitsandbytes/torchao), GGUF pour Flux |
| Whisper | Whisper | ✅ | int8 (CTranslate2 / faster-whisper), GGUF (whisper.cpp) |
| Modèle fermé via API | GPT-4o, Claude, Gemini | ❌ | Le fournisseur le fait, ou pas |
Quand l'utiliser
- ✅ Toujours envisager en déploiement. 8 bits : perte quasi nulle ; 4 bits : perte faible sur les modèles ≥ 7B.
- ✅ Faire tenir un modèle plus gros sur le matériel disponible.
- ✅ QLoRA (DATA03) : entraîner au-dessus d'un modèle NF4.
- ⚠️ Moins de 4 bits, petits modèles (< 3B), maths et code : les pertes deviennent visibles. Toujours mesurer sur sa tâche, pas seulement la perplexité.
Pièges
- Débit : tous les formats ne sont pas plus rapides. bitsandbytes NF4 est souvent plus lent que bf16 en génération. GPTQ/AWQ (noyaux Marlin dans vLLM) et FP8 sont rapides.
- Calibration non représentative : du texte wikitext pour un modèle de code donne un résultat dégradé.
- Perplexité trompeuse : une petite hausse de perplexité peut masquer une chute nette sur des raisonnements longs.
- Couches sensibles : garder
lm_head(et parfois les embeddings, le routeur MoE) en haute précision. - Format et moteur d'inférence doivent correspondre : compressed-tensors pour vLLM, GGUF pour llama.cpp / Ollama, bnb pour transformers.
- GPTQ/AWQ dans transformers : le modèle se charge compressé, mais transformers le décompresse en bf16 dès la première génération (pas de noyaux 4 bits compressed-tensors). Le gain de mémoire et de débit se voit dans vLLM.
run.pymesure donc la mémoire avant de générer, et ajoute la taille sur disque. - Format int4 et noyaux : un format quantifié n'est utile que si des noyaux l'exécutent sur le matériel visé.
run.pyutilise le format torchaotile_packed_to_4d, dont les noyaux int4 (tinygemm) sont inclus dans PyTorch CUDA.
Références
- LLM.int8() : Dettmers et al., LLM.int8(): 8-bit Matrix Multiplication for Transformers at Scale (2022). Quantification int8 avec traitement des valeurs aberrantes.
- NF4 (QLoRA) : Dettmers et al., QLoRA: Efficient Finetuning of Quantized LLMs (2023). Format 4 bits adapté aux poids de distribution normale.
- GPTQ : Frantar et al., GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers (2022). Quantification calibrée corrigeant les erreurs colonne par colonne.
- AWQ : Lin et al., AWQ: Activation-aware Weight Quantization for LLM Compression and Acceleration (2023). Protéger les canaux importants par mise à l'échelle.
- SmoothQuant : Xiao et al., SmoothQuant: Accurate and Efficient Post-Training Quantization for Large Language Models (2022). Déplacer la difficulté des activations vers les poids (W8A8).
- FP8 : Micikevicius et al., FP8 Formats for Deep Learning (2022). Formats flottants 8 bits pour l'entraînement et l'inférence.
- LLM-QAT : Liu et al., LLM-QAT: Data-Free Quantization Aware Training for Large Language Models (2023). Quantification pendant l'entraînement pour les LLM.
- torchao QAT : PyTorch, Quantization-Aware Training for Large Language Models with PyTorch (2024). Recette QAT de torchao utilisée par l'exemple.
- k-quants : Kawrakow, k-quants (llama.cpp, 2023). Quantification par blocs et super-blocs du format GGUF.
Dans le dépôt
Exemple, résultats mesurés et commandes : Quantification : exemple de code.