AmeliorIA

tekio.org

Quantification

Modèle bf16référenceTextes de calibrationGPTQ, AWQ : 256 textesQuantificationNF4, int4, GPTQ, AWQMesuremémoire, débit, qualitéDéploiementvLLM, llama.cpp, Ollama1234
  1. Les poids des couches linéaires sont arrondis sur 8, 4 ou 3 bits, avec une échelle par groupe de 128 poids.
  2. GPTQ et AWQ mesurent les activations sur quelques centaines de textes représentatifs pour limiter l'erreur d'arrondi.
  3. On compare au modèle bf16 dans les mêmes conditions : mémoire, tokens par seconde, perplexité, exactitude sur la tâche.
  4. 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.py mesure 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.py utilise le format torchao tile_packed_to_4d, dont les noyaux int4 (tinygemm) sont inclus dans PyTorch CUDA.

Références

Dans le dépôt

Exemple, résultats mesurés et commandes : Quantification : exemple de code.