Quantization : GPTQ, GGUF, AWQ - Quel Format Choisir

3 GPTQ : Quantization Post-Training sur GPU

L'algorithme OBQ revisité

GPTQ (Generative Pre-trained Transformer Quantization), publié par Frantar et al. en 2023, est une méthode de quantization post-entraînement qui s'appuie sur l'algorithme OBQ (Optimal Brain Quantization). Le principe est de quantifier les poids colonne par colonne en compensant l'erreur introduite sur les colonnes restantes.

Concrètement, pour chaque couche linéaire du modèle, GPTQ procède ainsi : il calcule la matrice de Hessienne à partir des activations du dataset de calibration, puis quantifie les poids un par un en ordre décroissant d'impact. Après chaque quantification, l'erreur résiduelle est redistribuée sur les poids non encore quantifiés grâce aux informations de la Hessienne inverse. Cette compensation intelligente est ce qui rend GPTQ nettement supérieur à une quantization naïve round-to-nearest.

Calibration et dataset

GPTQ nécessite un dataset de calibration pour calculer la Hessienne. En pratique, 128 à 256 échantillons de texte suffisent (typiquement issus de C4 ou WikiText-2). Le choix du dataset impacte la qualité finale : un dataset proche du domaine cible donne de meilleurs résultats. Le processus de quantification d'un modèle 70B prend environ 2 à 4 heures sur un seul GPU A100.

GPTQ utilise par défaut une quantization per-group en 4 bits avec des groupes de 128, et stocke les paramètres scale/zero-point en FP16. Le format résultant est optimisé pour l'inférence GPU avec des kernels CUDA spécialisés (Marlin, ExLlama, ExLlamaV2) qui dépaquettent et dé-quantifient les poids à la volée.

AutoGPTQ en pratique

AutoGPTQ est la bibliothèque de référence pour quantifier et charger des modèles GPTQ. Voici un exemple complet :

from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig
from transformers import AutoTokenizer

model_id = "meta-llama/Llama-3.1-8B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_id)

# Configuration de quantization
quant_config = BaseQuantizeConfig(
    bits=4,               # Quantization 4 bits
    group_size=128,       # Taille des groupes
    desc_act=True,        # Ordre décroissant (meilleure qualité)
    sym=True,             # Quantization symétrique
)

# Chargement et quantization
model = AutoGPTQForCausalLM.from_pretrained(model_id, quant_config)
model.quantize(examples)  # examples = dataset de calibration tokenizé

# Sauvegarde du modèle quantifié
model.save_quantized("./llama-3.1-8b-gptq-4bit")

Forces et limites de GPTQ

• ▹Forces — Excellente qualité grâce à la compensation d'erreur, kernels GPU très optimisés (Marlin atteint 80% de la bande passante théorique), large écosystème (vLLM, TGI, transformers)
• ▹Limites — GPU obligatoire pour l'inférence, pas de support CPU natif, temps de quantification long, sensible au choix du dataset de calibration

Votre organisation est-elle prête à faire face aux attaques basées sur l'IA ?

4 GGUF : Le Format Universel de llama.cpp

Architecture et philosophie

GGUF (GPT-Generated Unified Format) est le format de fichier créé par Georgi Gerganov pour le projet llama.cpp. Successeur de GGML, GGUF est un format binaire auto-descriptif conçu pour être portable, extensible et autonome. Chaque fichier GGUF contient à la fois les métadonnées du modèle (architecture, vocabulaire, paramètres de tokenization) et les tenseurs quantifiés, dans un seul fichier facilement distribuable.

La philosophie de GGUF est radicalement différente de GPTQ : là où GPTQ cible l'inférence GPU pure, GGUF est conçu pour fonctionner partout — CPU pur (x86, ARM), GPU offloading partiel, Apple Silicon (Metal), et même les accélérateurs NPU. Cette universalité en fait le format de prédilection pour les déploiements locaux via Ollama, LM Studio ou directement llama.cpp.

Les types de quantization K-quant

GGUF propose un système de quantization poussé appelé K-quant (k-means quantization), introduit en 2023. Contrairement à GPTQ qui applique la même précision à toutes les couches, K-quant utilise une quantization mixte : les couches les plus sensibles conservent une précision plus élevée.

GPU Offloading et inférence hybride

L'une des fonctionnalités les plus puissantes de llama.cpp est le GPU offloading partiel. Vous pouvez décharger un nombre spécifique de couches sur le GPU tout en gardant le reste sur CPU. Cela permet d'exécuter des modèles qui ne tiennent pas entièrement en VRAM :

# Conversion d'un modèle HuggingFace en GGUF
python3 convert_hf_to_gguf.py ./model-dir --outtype f16 --outfile model-f16.gguf

# Quantization avec llama-quantize
./llama-quantize model-f16.gguf model-Q4_K_M.gguf Q4_K_M

# Inférence avec GPU offloading partiel (33 couches sur GPU)
./llama-cli -m model-Q4_K_M.gguf -ngl 33 -c 4096 \
    --temp 0.7 -p "Explique la quantization en IA :"

# Via Ollama (simplifié)
ollama run llama3.1:8b-instruct-q4_K_M

5 AWQ : Activation-Aware Quantization

Le principe des poids saillants

AWQ (Activation-Aware Weight Quantization), publié par Lin et al. en 2024 (MIT), repose sur une observation fondamentale : seule une petite fraction des poids (environ 1%) est réellement critique pour la qualité du modèle. Ces poids « saillants » (salient weights) sont identifiés non pas par leur magnitude, mais par l'amplitude des activations qu'ils traitent.

L'intuition est la suivante : un poids qui reçoit de grandes activations en entrée a un impact disproportionné sur la sortie. Le quantifier grossièrement introduit une erreur importante. AWQ identifie ces canaux « chauds » en analysant la distribution des activations sur le dataset de calibration, puis applique un facteur de scaling optimal avant la quantization pour protéger ces poids sensibles.

Scaling optimal par canal

Contrairement à GPTQ qui compense l'erreur après quantification, AWQ agit avant : il multiplie chaque canal de poids par un facteur s optimal, puis divise les activations par le même facteur pour maintenir l'équivalence mathématique. Le facteur optimal est calculé par une recherche sur grille qui minimise l'erreur de quantization pondérée par l'amplitude des activations.

L'avantage est double : les poids saillants occupent une plus grande plage dans l'espace quantifié (meilleure résolution), et le processus est beaucoup plus rapide que GPTQ car il ne nécessite pas le calcul coûteux de la Hessienne inverse. Un modèle 70B se quantifie en 30 à 45 minutes sur un seul GPU, contre 2 à 4 heures pour GPTQ. Pour approfondir, consultez Milvus, Qdrant, Weaviate :.

AutoAWQ en pratique

from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

model_id = "meta-llama/Llama-3.1-8B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_id)

# Configuration AWQ
quant_config = {
    "zero_point": True,      # Asymétrique
    "q_group_size": 128,    # Taille des groupes
    "w_bit": 4,              # Quantization 4 bits
    "version": "GEMM",      # Kernel optimisé
}

# Chargement et quantization (~10 min pour un 8B)
model = AutoAWQForCausalLM.from_pretrained(model_id)
model.quantize(tokenizer, quant_config=quant_config)

# Sauvegarde
model.save_quantized("./llama-3.1-8b-awq-4bit")
tokenizer.save_pretrained("./llama-3.1-8b-awq-4bit")

Intégration avec vLLM et TGI

AWQ brille particulièrement dans les serveurs d'inférence de production. vLLM supporte nativement les modèles AWQ avec des kernels GEMM et GEMV optimisés, offrant un throughput de tokens/seconde parmi les meilleurs de l'industrie. L'intégration est transparente :

# Servir un modèle AWQ avec vLLM
python -m vllm.entrypoints.openai.api_server \
    --model ./llama-3.1-8b-awq-4bit \
    --quantization awq \
    --max-model-len 8192 \
    --gpu-memory-utilization 0.9

• ▹Forces — Quantization très rapide, qualité légèrement supérieure à GPTQ sur la plupart des benchmarks, excellent support dans vLLM, moins sensible au dataset de calibration
• ▹Limites — GPU obligatoire (comme GPTQ), écosystème plus récent et moins mature, pas de support CPU, moins de variantes de quantization disponibles

6 Benchmarks Comparatifs : GPTQ vs GGUF vs AWQ

Tableau comparatif complet

Le tableau suivant compare les trois formats sur un modèle Llama 3.1 70B quantifié en 4 bits, testé sur un serveur équipé d'un GPU NVIDIA RTX 4090 24GB et 64 Go de RAM DDR5 :

Analyse de la perplexité

La perplexité est la métrique standard pour évaluer la perte de qualité liée à la quantization. Plus elle est basse, meilleur est le modèle. Le modèle FP16 de référence affiche une perplexité de 5.53 sur WikiText-2. Les trois formats en 4 bits ajoutent entre 0.25 et 0.38 points de perplexité, ce qui reste remarquablement faible.

AWQ obtient la meilleure perplexité (5.78) grâce à sa protection des poids saillants. GPTQ suit de près (5.82) avec sa compensation d'erreur. GGUF Q4_K_M est légèrement derrière (5.91) mais compense par sa flexibilité CPU/GPU et sa quantization mixte qui attribue plus de bits aux couches critiques.

Figure 2 — Comparatif visuel des performances GPTQ, GGUF et AWQ sur Llama 3.1 70B en 4 bits