SmoothQuant

Définition

SmoothQuant est un algorithme de quantisation post-entrainement (PTQ) pour les LLMs, propose par Xiao et al. (MIT/NVIDIA, 2022), qui permet une quantisation INT8 de haute qualite en adressant le probleme des 'outlier features' dans les activations. L'innovation est de migrer la difficulte de quantisation des activations (difficiles a quantifier) vers les poids (faciles a quantifier) via une transformation mathematique equivalente. Le probleme que SmoothQuant resout : lors de la quantisation INT8 des LLMs, les activations contiennent des 'outliers' (quelques canaux avec des valeurs extremes 10-100x plus grandes que la moyenne). Ces outliers forcent l'utilisation d'une plage dynamique large, reduisant la precision pour les valeurs normales. La quantisation naive des activations INT8 degrade fortement les performances. La solution SmoothQuant : une transformation mathematique per-canal est appliquee (y = (Wx / s) * s = W_smoothed * x_scaled) ou s est un vecteur de facteurs d'echelle calcules depuis les statistiques des activations. Cette transformation 'lisse' les activations (en divisant par s) tout en 'denormisant' les poids (en multipliant par s), migrant la difficulte vers les poids qui supportent mieux la quantisation INT8. L'implementation de SmoothQuant dans les frameworks de production : NVIDIA TensorRT-LLM integre SmoothQuant, permettant d'obtenir un throughput 1.56x superieur a FP16 pour LLaMA 13B en INT8 avec une degradation < 0.5% sur les benchmarks. vLLM supporte aussi SmoothQuant pour les deployments INT8. Comparaison avec LLM.int8() (bitsandbytes) : les deux visent la quantisation INT8 des LLMs. LLM.int8() garde les outlier features en FP16 (approche hybride, plus simple mais moins efficace), SmoothQuant quantifie tout en INT8 apres normalisation (meilleur throughput hardware, moins de sur-face d'exception).

Principe SmoothQuant

import torch

def compute_smooth_scale(model_layer, calib_dataset, alpha=0.5):
    activations = []
    for batch in calib_dataset:
        with torch.no_grad():
            act = model_layer.get_input_activation(batch)
            activations.append(act.abs().max(dim=0).values)

    # Max activation par canal
    max_act = torch.stack(activations).max(dim=0).values  # [d_model]
    max_weight = model_layer.weight.abs().max(dim=0).values

    # Facteurs d'echelle par canal (alpha controle le partage difficultés)
    s = (max_act.pow(alpha) / max_weight.pow(1 - alpha)).clamp(min=1e-5)
    return s  # Diviser activations par s, multiplier poids par s

Gains de performance SmoothQuant vs FP16

Latence : 1.4x reduction (INT8 tensor cores plus rapides)
Memoire : 1.8x reduction (poids + activations en INT8)
Throughput : 1.56x pour LLaMA 13B (NVIDIA A100)
Degradation qualite : < 0.5% sur MMLU, GSM8K, HellaSwag

Articles liés

Expert en cybersécurité offensive et intelligence artificielle. Pentest, audit et développement IA sur-mesure.

Services

Ressources

Projets & Outils

Contact

Nous contacter

Mentions légales Confidentialité Politique éditoriale Plan du site ⭐ Source préférée

Un projet cybersécurité ?

Expert dispo · Réponse 24h

Devis