OmniQuant (Omnidirectionally Calibrated Quantization)#

OmniQuant améliore les méthodes PTQ existantes en rendant apprenables (learnable) les paramètres qui étaient auparavant fixés manuellement : le clipping threshold des poids (LWC) et les paramètres de transformation équivalente (LET). Cette approche différenciable couvre toutes les configurations — de W2A16 (2-bit weight-only) à W6A6 — avec une qualité supérieure aux heuristiques fixes.

Le problème : les paramètres fixes des PTQ classiques#

Pour un néophyte#

Les méthodes de quantification PTQ classiques (GPTQ, AWQ, SmoothQuant) utilisent des règles empiriques pour fixer leurs paramètres :

→ Que se passe-t-il si on LAISSE le modèle CHERCHER les meilleurs paramètres ? C'est l'idée d'OmniQuant ! ✅

Analogie : régler une radio. SmoothQuant (manuel) → Tu tournes le bouton à mi-chemin (α=0.5) parce que « ça marche en général ». OmniQuant (apprenable) → Le bouton s'ajoute TOUT SEUL pour chaque station (chaque couche du modèle). Trouve le réglage OPTIMAL, pas juste « correct ».

Le problème technique en détail#

Quantification PTQ standard : Y = X · W (multiplication matricielle). Quantifier W : Q(W) = Clip(W, -τ, τ) / s puis Round, où τ = clipping threshold (seuil) et s = scale = τ / (2^(b-1) - 1).

Le seuil τ contrôle TOUT :
- τ petit → haute résolution mais écrête les valeurs extrêmes (clipping error)
- τ grand → pas d'écrêtage mais faible résolution (rounding error)

Les PTQ classiques fixent τ par heuristique → sous-optimal !

Les deux piliers d'OmniQuant#

1. Learnable Weight Clipping (LWC)#

Au lieu d'un seuil de clipping fixe, LWC optimise le seuil de clipping des poids de manière différentiable :

Implémentation différentiable : Au lieu de Clip(W, τ), on utilise Q(W; γ) = tanh(γ · τ) · Round(W / tanh(γ · τ)) où γ est un paramètre APPRENABLE (gradient descent). γ = 1 : pas de clipping (= max|W|). γ < 1 : clipping agressif (réduit la range). Optimisé par block-wise error minimization.

2. Learnable Equivalent Transformation (LET)#

LET étend l'idée de SmoothQuant en rendant apprenables les paramètres de transformation équivalente :

    SmoothQuant (transformation fixe) :
    Y = (X · diag(1/s)) · (diag(s) · W)
    où s_j = max(|X_j|)^α / max(|W_j|)^(1-α)
    α fixé (typiquement 0.5)

    OmniQuant LET (transformation apprenable) :
    Y = (X · diag(1/s*)) · (diag(s*) · W + b*)
    où s* = paramètre de scaling APPRENABLE
          b* = paramètre de shifting APPRENABLE

    → Le modèle APPREND les meilleures transformations
      pour chaque couche, au lieu d'utiliser une heuristique

Diagramme du process OmniQuant#

Caractéristiques#

Comparaison avec GPTQ / AWQ#

OmniQuant vs SmoothQuant : la même idée, mais apprenable#

SmoothQuant : Y = (X · diag(1/s)) · (diag(s) · W) — s fixé par heuristique.

OmniQuant : Y = (X · diag(1/s*) + b*) · (diag(s*) · W - b*) — s, b APPRIS par couche.

La différence : SmoothQuant a 1 paramètre α global. OmniQuant a s + b par couche (optimisés). → OmniQuant trouve TOUJOURS un meilleur ou égal réglage que SmoothQuant. Mais ça coûte une optimisation (gradient).

Niveau néophyte : l'analogie#

Imagine que tu cuisines un gâteau. Les recettes classiques (GPTQ, AWQ) te disent : "mets 200g de sucre" — un montant fixe pour tous les gâteaux. OmniQuant dit : "apprends la quantité parfaite de sucre pour chaque gâteau". Au début, tu fais plusieurs essais (optimisation par gradient), mais au final, chaque gâteau est parfait car la quantité a été ajustée individuellement. C'est plus long que de suivre une recette fixe, mais le résultat est meilleur.

Résultats de performance#

Perplexité sur LLaMA-2#

Tableau récapitulatif#

Points forts : OmniQuant surpasse systématiquement les PTQ classiques sur toutes les configurations, avec un avantage particulièrement marqué en W4A4 (quantification poids + activation) et en W2A16 (2-bit extrême).

Exemple pratique#

Installation#

git clone https://github.com/OpenGVLab/OmniQuant.git
cd OmniQuant
pip install -e .

Quantification W4A16 (weight-only 4-bit)#

# Quantifier LLaMA-2-7B en W4A16
python omniquant.py \
    --model meta-llama/Llama-2-7B-hf \
    --output_dir ./llama-7b-omniquant-w4a16 \
    --wbits 4 \
    --abits 16 \
    --let --lwc \
    --calib_dataset pile \
    --nsamples 128 \
    --epochs 5 \
    --gpu_id 0

Quantification W4A4 (weight + activation)#

python omniquant.py \
    --model meta-llama/Llama-2-7B-hf \
    --output_dir ./llama-7b-omniquant-w4a4 \
    --wbits 4 \
    --abits 4 \
    --let --lwc \
    --calib_dataset pile \
    --nsamples 128 \
    --epochs 10 \
    --gpu_id 0

Quantification W2A16 (2-bit extrême)#

python omniquant.py \
    --model meta-llama/Llama-2-7B-hf \
    --output_dir ./llama-7b-omniquant-w2a16 \
    --wbits 2 \
    --abits 16 \
    --let --lwc \
    --calib_dataset pile \
    --nsamples 128 \
    --epochs 20 \
    --gpu_id 0

Inférence#

import torch
from transformers import AutoTokenizer
from omniquant import OmniQuantModelForCausalLM

# Charger le modèle quantifié
model = OmniQuantModelForCausalLM.from_quantized(
    "./llama-7b-omniquant-w4a16",
    device="cuda",
)
tokenizer = AutoTokenizer.from_pretrained("./llama-7b-omniquant-w4a16")

# Génération
inputs = tokenizer("Qu'est-ce que la quantification apprenable ?", return_tensors="pt").to("cuda")
output = model.generate(**inputs, max_new_tokens=200)
print(tokenizer.decode(output[0], skip_special_tokens=True))

Avantages et inconvénients#

✅ Avantages#

• Différentiable : optimise les paramètres plutôt que de les fixer manuellement
• Très flexible : couvre W2A16 → W6A6 (weight-only ET weight+activation)
• Best-in-class : surpasse GPTQ, AWQ, SmoothQuant sur toutes les configurations testées
• W4A4 compétitif : une des rares PTQ viables en quantification poids + activation simultanée
• W2A16 viable : meilleure PTQ 2-bit weight-only avant QuIP#/AQLM
• Block-wise : optimisation par bloc, pas de ré-entraînement complet

⚠️ Inconvénients#

• Nécessite un GPU pour l'optimisation (gradient descent sur 128 samples)
• Plus complexe que GPTQ/AWQ (training-based PTQ, pas purement one-shot)
• Plus lent à exécuter que la PTQ pure (1-16h vs minutes pour GPTQ)
• Support limité dans les frameworks mainstream (vs GPTQ/AWQ très intégrés)
• Moins d'écosystème d'inférence (kernels custom nécessaires)

Quand choisir OmniQuant ?#

Références#

• Papier arXiv : OmniQuant: Omnidirectionally Calibrated Quantization for Large Language Models — Shao et al., 2023
• Code officiel : github.com/OpenGVLab/OmniQuant
• Voir aussi : SmoothQuant · GPTQ · AWQ · Index quantification