LLC (Locally-Low-Correlation Compression)#

TL;DR — LLC (Locally-Low-Correlation) est un paradigme de quantification qui exploite la structure de corrélation locale des matrices de poids. L'idée centrale : si l'on regroupe les poids de sorte que chaque groupe ait une faible corrélation interne, la vector quantization devient plus efficace car le codebook n'a pas besoin de modéliser des dépendances inter-poids. Ce concept sous-tend plusieurs méthodes SOTA en régime sub-2-bit (CRVQ, GLVQ, VPTQ).

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

Quand on compresse les poids d'un LLM, on les regroupe en petits paquets et on cherche la meilleure façon de les représenter avec moins d'information. Le problème, c'est que tous les paquets ne se valent pas : certains contiennent des poids qui « bougent ensemble » (forte corrélation), d'autres contiennent des poids parfaitement indépendants (faible corrélation).

Imagine deux groupes de nombres :
- Groupe A (forte corrélation) : [0.10, 0.11, 0.10, 0.09, 0.10] — ils varient tous ensemble
- Groupe B (faible corrélation) : [0.50, -0.03, 0.12, -0.40, 0.08] — ils sont indépendants

L'insight de LLC : au lieu de regrouper les poids par position arbitraire (groupes contigus), on les réarrange de sorte que chaque groupe ait une faible corrélation interne. Cela permet à la vector quantization de mieux exploiter chaque bit du codebook.

Contexte scientifique#

LLC n'est pas une méthode unique avec un seul papier fondateur — c'est un paradigme qui sous-tend plusieurs travaux récents sur la vector quantization pour LLMs en régime extrême (≤ 2 bits/poids). Les concepts de corrélation locale apparaissent dans :

Papier de référence principal#

CRVQ est l'implémentation la plus aboutie du concept LLC pour les LLMs : elle atteint une quantification 1-bit quasi-lossless en sélectionnant et réordonnant les canaux de poids critiques pour minimiser la corrélation intra-groupe.

Mécanisme#

Niveau néophyte#

Pense à un jeu de cartes. Si tu distribues les cartes au hasard, chaque main aura un mélange varié (faible corrélation). Mais si tu tries les cartes par couleur avant de distribuer, chaque main sera dominée par une couleur (forte corrélation). Pour la quantification, on veut le contraire du tri : on veut que chaque « main » (groupe de poids) soit la plus diverse possible, pour que le codebook puisse exprimer plus de combinaisons.

LLC procède en trois étapes :
1. Analyser la matrice de corrélation des poids
2. Réordonner les canaux (colonnes) pour regrouper ceux qui sont peu corrélés
3. Quantifier chaque groupe avec un codebook adapté à son profil

Niveau intermédiaire#

La matrice de poids W ∈ R^{m×n} d'une couche linéaire possède une structure de corrélation entre ses colonnes (canaux de sortie). La corrélation entre canaux i et j est :

ρ(i,j) = Cov(W[:,i], W[:,j]) / (σ_i × σ_j)

LLC cherche une permutation π des colonnes telle que, pour chaque groupe contigu de g colonnes après permutation, la corrélation moyenne intra-groupe soit minimisée :

min_π  Σ_groups  (1/g²) Σ_{i,j ∈ group} |ρ(π(i), π(j))|

Niveau tech avancé#

La motivation théorique de LLC repose sur la théorie du rate-distortion pour la vector quantization. Le théorème de Gish-Robin-Grey établit que, pour des sources vectorielles avec une densité de probabilité f(w), l'erreur de quantification optimale diminue avec la dimension du vecteur d :

D(R, d) ≈ C(d) × 2^(-2R/d) × σ²

  où :
  R = bitrate par poids
  d = dimension du vecteur (= group_size)
  C(d) = facteur dépendant de la structure de corrélation

Le facteur C(d) est minimisé quand les composantes du vecteur sont indépendantes ( décorrélation totale). Si les composantes sont corrélées, C(d) augmente car le codebook doit « gaspiller » des entrées pour modéliser la structure de corrélation plutôt que la diversité des valeurs.

Dans la pratique LLC :

1. Analyse de corrélation : calculer la matrice de corrélation R ∈ R^{n×n} sur les colonnes de W.

2. Réordonnancement / sélection (approche CRVQ) :
   - Identifier les canaux critiques (ceux dont l'erreur de quantification domine)
   - Réordonner pour que les canaux dans un même groupe soient décorrelés
   - Pour CRVQ : appliquer un codebook étendu (extended codebook fitting) aux canaux critiques, laissant le reste à une VQ standard

3. Vector quantization adaptée : chaque groupe de g poids décorrelés est quantifié via VQ avec un codebook optimisé. Comme les composantes sont quasi-indépendantes, le codebook peut se concentrer sur la précision plutôt que sur la modélisation de structure.

4. Lien avec l'incoherence processing (QuIP#) : QuIP# atteint un objectif similaire via la Transformée de Hadamard aléatoire (RHT), qui décorrelent globalement la matrice. LLC fait une décorrélation locale (par groupe), qui est moins coûteuse mais ciblée.

Illustration : le process LLC#

Lien avec l'incoherence processing (QuIP#)#

LLC et QuIP# poursuivent le même objectif — réduire la corrélation avant de quantifier — mais avec des stratégies différentes :

Complémentaire : on peut combiner les deux — appliquer Hadamard global puis LLC local.

Bits / Formats supportés#

LLC est pertinent en régime sub-2-bit. À 4 bits et plus, la quantification scalaire (GPTQ, AWQ) est plus simple et suffisante.

Résultats#

CRVQ — Quantification 1-bit quasi-lossless#

CRVQ, l'implémentation la plus aboutie du concept LLC, atteint des résultats remarquables :

CRVQ : 38.9% d'amélioration vs le baseline sub-2-bit SOTA · Compression 16× vs FP16

Comparaison des approches LLC#

Avantages et inconvénients#

Exemple pratique#

Quantifier avec CRVQ (implémentation LLC la plus aboutie)#

# 1. Installer CRVQ
pip install crvq transformers accelerate

# 2. Quantification ~1-bit
python -c "
import torch
from crvq import CRVQQuantizer
from transformers import AutoModelForCausalLM

# Charger le modèle
model = AutoModelForCausalLM.from_pretrained(
    'meta-llama/Llama-2-7b-hf',
    torch_dtype=torch.float16,
    device_map='auto'
)

# Configuration CRVQ
quantizer = CRVQQuantizer(
    bits_per_weight=1.0,        # Régime extrême ~1-bit
    group_size=8,               # Vecteurs de 8 poids
    num_critical_channels=64,   # Canaux critiques étendus
    num_calibration_samples=128,
)

# Quantifier
quantized_model = quantizer.quantize(model)

# Résultat attendu :
# ┌──────────────────────────────────────────────┐
# │  Llama-2-7b FP16      :  13.5 GB             │
# │  Llama-2-7b CRVQ 1bit :  ~1.0 GB  (−93%)     │
# │  Temps de quantif.     :  1–3h sur A100      │
# │  PPL WikiText2         :  ~7.0–8.0            │
# │  Amélioration vs SOTA  :  +38.9%              │
# └──────────────────────────────────────────────┘
"

Comparaison rapide : LLC vs quantification scalaire#

# Script de comparaison : quantification 2-bit
python -c "
# ┌────────────────────────────────────────────────────────────┐
# │  À 2 bits/poids, Llama-2-7B :                              │
# │                                                            │
# │  Méthode          Type          PPL     Taille   Utilisable│
# │  ──────────────── ──────────── ─────── ──────── ──────────│
# │  GPTQ 2-bit       Scalaire      11.36   ~3.5GB   ❌ Non    │
# │  AWQ 2-bit        Scalaire       8.48   ~3.5GB   ⚠️ Marg.  │
# │  AQLM 2-bit       Vector (LLC)   7.5   ~2.5GB   ✅ Oui    │
# │  QuIP# 2-bit      Vector (LLC)   7.27  ~2.5GB   ✅ Oui    │
# │  CRVQ ~1-bit      Vector (LLC)  ~7.0   ~1.5GB   ✅ Oui    │
# │                                                            │
# │  → Les méthodes LLC rendent le régime 1-2 bit UTILISABLE  │
# │    alors que la quantification scalaire échoue             │
# └────────────────────────────────────────────────────────────┘
"

Comparaison avec les alternatives#

Les méthodes basées sur LLC (CRVQ, VPTQ, GLVQ) et l'incoherence processing (QuIP#) dominent le régime sub-2-bit. La quantification scalaire (GPTQ, AWQ, HQQ) reste pertinente à 3-4 bits.

Références#

• CRVQ — Xu et al., « CRVQ: Channel-Relaxed Vector Quantization for Extreme Compression of LLMs », TACL 2025 — arXiv:2412.09282
• GLVQ — « Learning Grouped Lattice Vector Quantizers for Low-Bit LLM Compression », NeurIPS 2025 — OpenReview
• VPTQ — Liu et al., « VPTQ: Extreme Low-bit Vector Post-Training Quantization for Large Language Models » — Semantic Scholar
• QuIP# — Tseng et al., « QuIP#: Even Better LLM Quantization with Hadamard Incoherence and Lattice Codebooks », ICML 2024 — arXiv:2402.04396
• AQLM — Egiazarian et al., « Extreme Compression of Large Language Models via Additive Quantization », ICML 2024 — arXiv:2401.06118
• Code CRVQ — github.com/xuyuzhuang11/CRVQ
• Théorie rate-distortion VQ — Gish & Gray, « Quantization », 1998 — fondement théorique du gain de la vector quantization sur la quantification scalaire
• Page de référence — Voir Quantification LLM pour le panorama complet
• Méthodes comparables — Voir QuIP#, AQLM