SqueezeLLM (Dense-and-Sparse Quantization)#

TL;DR — SqueezeLLM combine deux innovations : la quantification non-uniforme sensible à l'importance des poids (les poids critiques reçoivent plus de précision) et la décomposition dense+sparse (les outliers sont extraits et stockés séparément en haute précision). Résultat : une compression 3-bit quasi lossless avec accélération de 2.3× sur GPU.

Le problème fondamental (expliqué pour un néophyte)#

Deux problèmes se posent quand on quantifie un LLM à très basse précision (3-bit) :

1. Tous les poids ne sont pas égaux : certains poids sont critiques pour la qualité du modèle, d'autres peuvent être approximés sans dommage. Une quantification uniforme traite tout le monde pareil — c'est suboptimal.

2. Les outliers ruinent la quantification : quelques poids avec des valeurs extrêmes (outliers) forcent l'échelle de quantification à s'étaler, réduisant la précision pour la majorité des poids « normaux ».

SqueezeLLM résout les deux :
- Non-uniform quantization : alloue plus de bins aux poids sensibles (fonction de leur second ordre / Hessienne)
- Dense+Sparse decomposition : extrait les outliers dans une représentation sparse séparée, libérant l'espace de quantification pour les poids normaux

Papier source#

Mécanisme#

Niveau néophyte#

Imagine que tu dois peindre un tableau avec un nombre limité de couleurs (tes « bins » de quantification). Tu pourrais répartir ces couleurs uniformément (quantification uniforme) — mais ce serait gaspiller des couleurs dans des zones que personne ne regarde.

SqueezeLLM fait deux choses intelligentes :
1. Concentre les couleurs là où ça compte : les zones du tableau les plus détaillées (poids sensibles) reçoivent plus de nuances de couleur.
2. Sépare les couleurs extrêmes : les quelques taches de couleur très différentes (outliers) sont peintes séparément avec des tubes de précision, pour ne pas perturber la palette principale.

Niveau intermédiaire#

SqueezeLLM repose sur deux piliers techniques :

1. Sensitivity-based non-uniform quantization

Au lieu d'utiliser des bins également espacés (quantification uniforme), SqueezeLLM calcule la sensibilité de chaque poids via la diagonale de la Hessienne et alloue les bins de quantification proportionnellement :

Uniforme (GPTQ, AWQ) : bins |-|-|-|-|-|-|-|-| → espacement régulier.

Non-uniforme (SqueezeLLM) : bins |--|-|-|---|--|-|-|--| → plus de bins où les poids sont sensibles (concentrés près de certaines valeurs).

Les poids sensibles (où une petite erreur cause une grande perte de qualité) reçoivent une résolution plus fine. C'est l'analogue de l'allocation optimale de bits en théorie de l'information (comme le companding en audio).

2. Dense-and-Sparse decomposition

Avant la quantification, SqueezeLLM sépare les poids en deux composantes :

W = W_dense + W_sparse

  W_dense  : ~99% des poids, distribution « normale »
             → quantifiés en 3-4 bit

  W_sparse : ~1% des poids = outliers
             → stockés en FP16 dans un format sparse
             (seuls les indices et valeurs non-zéros sont stockés)

Cette décomposition élimine les outliers de la distribution dense, permettant une quantification beaucoup plus précise de la majorité des poids.

Niveau tech avancé#

Non-uniform quantization via Lloyd-Max optimisé

SqueezeLLM détermine les bins de quantification en minimisant l'erreur attendue pondérée par la sensibilité :

Minimiser : Σᵢ sᵢ · (wᵢ − q(wᵢ))²

  où sᵢ = [H⁻¹]ᵢᵢ (sensibilité du poids i, dérivée de la Hessienne)
       q(wᵢ) = valeur quantifiée

L'optimisation des bins utilise un algorithme de type Lloyd-Max modifié pour incorporer les poids de sensibilité :

1. Initialiser les bins (estimation statistique)
2. Assigner chaque poids au bin le plus proche (pondéré par sᵢ)
3. Mettre à jour les centres de bins (moyenne pondérée)
4. Répéter jusqu'à convergence

Sélection des outliers

Les outliers sont identifiés par leur sensibilité (et non simplement par leur magnitude) : un poids avec une valeur modérée mais une très haute sensibilité (la Hessienne indique que ce poids est critique) peut aussi être extrait vers la composante sparse. Le critère :

Poids i est outlier si : sᵢ · (wᵢ − q(wᵢ))² > seuil

  → on extrait les poids dont l'erreur de quantification pondérée
    par la sensibilité dépasse un seuil

Résultat : seuls ~0.45% des poids sont extraits en sparse, mais ces poids captent l'essentiel de l'erreur de quantification potentielle.

Illustration : la décomposition Dense+Sparse#

Process complet SqueezeLLM#

Bits / Formats supportés#

Le bitrate effectif est : ~3 bits pour la partie dense + ~0.1 bit/poids pour la partie sparse = ~3.1 bits par poids au total.

Résultats#

Llama (perplexité sur WikiText2 — plus bas = mieux)#

SqueezeLLM réduit le gap de perplexité (vs FP16) de 2.1× par rapport au SOTA à mémoire équivalente.

Métriques clés#

Le gain de la décomposition dense+sparse#

Avantages et inconvénients#

Outils et implémentations#

SqueezeLLM (SqueezeAILab)#

# Cloner le repository
git clone https://github.com/SqueezeAILab/SqueezeLLM.git
cd SqueezeLLM

# Installer
pip install -e .

Quantification#

# 1. Générer les données de sensibilité (Hessienne)
python squeeze_llm/generate_sensitivity_data.py \
    --model meta-llama/Llama-2-7b-hf \
    --output_dir ./sensitivity_data

# 2. Détection des outliers
python squeeze_llm/get_outliers.py \
    --model meta-llama/Llama-2-7b-hf \
    --sensitivity_data ./sensitivity_data \
    --output_dir ./outlier_data

# 3. Quantification dense+sparse 3-bit
python squeeze_llm/quantization.py \
    --model meta-llama/Llama-2-7b-hf \
    --sensitivity_data ./sensitivity_data \
    --outlier_data ./outlier_data \
    --nbits 3 \
    --output_dir ./llama-7b-squeezellm-3bit

Exemple pratique#

Quantifier Llama-2-7B avec SqueezeLLM#

# 1. Installer
git clone https://github.com/SqueezeAILab/SqueezeLLM.git
cd SqueezeLLM
pip install -e .

# 2. Pipeline complet de quantification
# Étape A : sensibilité (Hessienne)
python squeeze_llm/generate_sensitivity_data.py \
    --model meta-llama/Llama-2-7b-hf \
    --output_dir ./sens

# Étape B : outliers
python squeeze_llm/get_outliers.py \
    --model meta-llama/Llama-2-7b-hf \
    --sensitivity_data ./sens \
    --output_dir ./outliers

# Étape C : quantification 3-bit
python squeeze_llm/quantization.py \
    --model meta-llama/Llama-2-7b-hf \
    --sensitivity_data ./sens \
    --outlier_data ./outliers \
    --nbits 3 \
    --output_dir ./llama-2-7b-squeezellm

# 3. Résultat attendu
# ┌──────────────────────────────────────────────────┐
# │  Llama-2-7b FP16         :  13.5 GB              │
# │  Llama-2-7b SqueezeLLM   :  ~3.2 GB  (−76%)      │
# │  Outliers extraits       :  ~0.45% des poids     │
# │  Speedup inférence        :  2.3× sur A6000       │
# │  PPL WikiText2            :  ~5.8–6.0             │
# └──────────────────────────────────────────────────┘

Inférence avec le modèle quantifié#

# Inférence avec les kernels SqueezeLLM
python eval.py \
    --model ./llama-2-7b-squeezellm \
    --task wikitext \
    --benchmark

# Résultat :
# Throughput : 2.3× plus rapide que FP16 baseline
# PPL : ~5.8 (vs 5.47 FP16 → perte < 6%)

Comparaison avec les alternatives#

SqueezeLLM et SpQR partagent l'idée de décomposition dense+sparse. SqueezeLLM y ajoute la quantification non-uniforme sensible à l'importance des poids, tandis que SpQR utilise GPTQ pour la partie dense.

Références#

• Papier SqueezeLLM — Kim et al., "SqueezeLLM: Dense-and-Sparse Quantization", ICML 2024 — arXiv:2306.07629
• Code officiel — github.com/SqueezeAILab/SqueezeLLM
• SqueezeAILab — github.com/SqueezeAILab — Laboratoire de recherche UC Berkeley spécialisé dans la compression de modèles
• Méthode comparable — Voir SpQR pour une approche dense+sparse similaire avec GPTQ
• Quantification non-uniforme — Lloyd-Max quantization, base théorique de l'allocation optimale de bins
• Page de référence — Voir aussi Quantification LLM pour le panorama complet