Outlier Suppression+ / SpAtten#

Outlier Suppression+ (OS+) est un framework qui élimine les outliers d'activation par shifting et scaling équivalents par canal — des transformations mathématiques qui naltèrent pas la sortie du modèle. SpAtten est un co-design algorithm-architecture qui sparsifie l'attention en éliminant progressivement les tokens et têtes peu importants. Ensemble, ils repoussent les limites de la quantification des transformers.

Le problème des outliers dans les activations#

Pour un néophyte#

Les activations sont les valeurs qui circulent à l'intérieur du modèle pendant l'inférence. Dans les transformers, certaines activations développent des valeurs extrêmes (outliers) — des pics qui sont 20× à 100× plus grands que la moyenne.

Si tu enregistres en « basse qualité » (quantification), le didjéridoo sature TOUT l'enregistrement. On n'entend plus les autres instruments.

Solution OS+ : atténuer le didjéridoo AVANT l'enregistrement, puis le ré-amplifier APRÈS (transformation équivalente).

Le problème technique détaillé#

Distribution des activations : la majorité des valeurs est concentrée entre -1 et +1, mais des outliers systématiques apparaissent à 5, 10, 20, 50, voire 100. Ces 0.1% des valeurs dominent la dynamique.

Quantification INT8 : tout doit tenir entre -128 et +127. Les outliers à 100 forcent un scale = 100/127 ≈ 0.79. Toutes les valeurs « normales » (entre -1 et +1) sont quantifiées à 0 ou ±1 → perte massive d'information !

Sans traitement des outliers : Scale = max|X| / 127 = 100/127 ≈ 0.79

Valeur	Quantifiée	Erreur
0.03	0	0.03 ❌
0.12	0	0.12 ❌
0.50	1	0.50 ❌
100.0	127	0.21 ✓

Les valeurs normales sont DÉTRUITES. L'outlier est bien représenté mais tout le reste est perdu.

Outlier Suppression+ : la solution#

Les deux opérations équivalentes#

OS+ applique deux transformations mathématiquement équivalentes (elles ne changent pas la sortie du modèle) pour éliminer les outliers :

Diagramme de la distribution avant/après suppression#

AVANT (distribution brute avec outliers) : un seul canal outlier atteint l'amplitude 100, tandis que tous les autres canaux sont concentrés autour de 0. La distribution est totalement déséquilibrée.

APRÈS (shifting + scaling par canal) : la distribution devient uniforme — tous les canaux ont une amplitude similaire entre -4 et +4. → Distribution UNIFORME → quantification efficace !

Pourquoi c'est "équivalent" (sans perte)#

Couche linéaire : Y = XW + b

OS+ shifting : X' = X - μ (par canal). Y = (X - μ)W + b = XW + (b - μW) = XW + b' où b' = b - μW.
→ La sortie Y est IDENTIQUE, seul le biais change. C'est une transformation ÉQUIVALENTE (lossless).

OS+ scaling : X'' = X' / s (par canal). Y = (X'/s)W + b' = X'(W/s) + b' où W' = W/s.
→ La sortie Y est IDENTIQUE, seuls les poids changent. Transformation ÉQUIVALENTE.

Le modèle MATHÉMATIQUE ne change pas, mais la DISTRIBUTION des activations devient quantification-friendly.

SpAtten : attention sparsifiée#

SpAtten est un co-design algorithm-architecture qui réduit le coût du mécanisme d'attention en éliminant les tokens et têtes peu importants.

Les trois techniques de SpAtten#

Diagramme : attention dense vs sparsifiée#

Niveau néophyte : l'analogie complète#

Imagine que tu lis un livre de 500 pages. L'attention dense (standard), c'est lire chaque mot avec la même concentration. SpAtten, c'est :
1. Skim les passages peu importants (token pruning)
2. Sauter les chapitres redondants (head pruning)
3. Lire attentivement les passages clés et diagonalement le reste (quantification adaptative)

Le résultat : tu comprends l'histoire aussi bien, mais en 3× moins de temps.

OS+ vs les autres méthodes de gestion des outliers#

Caractéristiques#

Résultats#

Outlier Suppression+#

OS+ INT4 : +15.5% d'accuracy par rapport à la baseline INT4 !

Tableau récapitulatif#

Résultat marquant : OS+ permet une quantification INT4 de BERT avec +15.5% d'accuracy par rapport à la baseline — rendant le 4-bit enfin viable pour BERT.

Exemple pratique#

Outlier Suppression+#

git clone https://github.com/ModelTC/Outlier_Suppression_Plus.git
cd Outlier_Suppression_Plus
pip install -e .

Quantification BERT INT8 avec OS+#

python run_quant.py \
    --model bert-base-uncased \
    --task squad \
    --bits 8 \
    --suppression plus \
    --calibration_data squad \
    --nsamples 128 \
    --output_dir ./bert-int8-osplus

Quantification BERT INT4 avec OS+#

python run_quant.py \
    --model bert-base-uncased \
    --task squad \
    --bits 4 \
    --suppression plus \
    --calibration_data squad \
    --nsamples 256 \
    --output_dir ./bert-int4-osplus

Inférence#

from outlier_suppression import OSPlusModel
from transformers import AutoTokenizer

model = OSPlusModel.from_quantized("./bert-int8-osplus")
tokenizer = AutoTokenizer.from_pretrained("./bert-int8-osplus")

# Q&A
question = "Qu'est-ce que l'outlier suppression ?"
context = "L'outlier suppression est une technique qui élimine les valeurs extrêmes..."

inputs = tokenizer(question, context, return_tensors="pt")
outputs = model(**inputs)
answer = tokenizer.decode(outputs.start_logits.argmax())
print(f"Réponse : {answer}")

SpAtten#

git clone https://github.com/mit-han-lab/spatten.git
cd spatten
pip install -e .

from spatten import SpAttenConfig, SpAttenModel
from transformers import AutoTokenizer

# Configuration avec pruning
config = SpAttenConfig(
    token_pruning=True,           # cascade token pruning
    head_pruning=True,            # head pruning
    adaptive_quant=True,          # quantification adaptative
    token_prune_ratio=0.3,        # 30% de tokens prunés par couche
    head_prune_ratio=0.2,         # 20% de têtes prunées
)

model = SpAttenModel.from_pretrained("bert-base-uncased", config=config)
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")

# Inférence avec attention sparsifiée
inputs = tokenizer("Sparsifier l'attention réduit le coût computationnel.", return_tensors="pt")
outputs = model(**inputs)

OS+ en combinaison avec d'autres méthodes#

OS+ prépare les activations, les autres méthodes gèrent les poids. Effet MULTIPLICATIF.

Avantages et inconvénients#

✅ Avantages#

• Near-floating-point en INT8 et INT6 (perte négligeable)
• INT4 enfin viable pour BERT (+15.5% vs baseline)
• Transformation équivalente : pas de changement mathématique
• Plug-and-play : se combine avec d'autres méthodes
• Validé sur de nombreux modèles : BERT, OPT, BLOOM, BLOOMZ, LLaMA
• SpAtten : réduction drastique du coût d'attention

⚠️ Inconvénients#

• OS+ : principalement validé sur des modèles plus petits (BERT, OPT)
• OS+ : moins éprouvé sur les très grands LLMs modernes (70B+)
• SpAtten : co-design hardware/software complexe
• SpAtten : le pruning introduit une perte contrôlée (pas lossless)
• Support limité dans les frameworks mainstream de serving
• Écosystème moins mature que GPTQ/AWQ/bitsandbytes

Références#

• Papier Outlier Suppression — Wei et al., "Outlier Suppression: Pushing the Limit of Low-bit Transformer Language Models", 2022 — arXiv:2209.13325
• Papier Outlier Suppression+ — Wei et al., "Outlier Suppression+: Accurate quantization of large language models by equivalent and optimal shifting and scaling", EMNLP 2023 — arXiv:2304.09145
• Papier SpAtten — Wang et al., "SpAtten: Efficient Sparse Attention Architecture with Cascade Token and Head Pruning", HPCA 2021 — arXiv:2012.09852
• Code OS+ — github.com/ModelTC/Outlier_Suppression_Plus
• Code SpAtten — github.com/mit-han-lab/spatten
• Voir aussi : LLM.int8() · SmoothQuant · OmniQuant · Index quantification