Déployer la parcimonie 2:4 avec FP8 sur Hopper: un guide de production

Sur les GPU de la classe Hopper, la combinaison de la parcimonie structurée 2:4 et de la précision FP8 offre régulièrement des gains de débit de bout en bout de 1,5 à 2,0× pour le décodage LLM, tout en réduisant l’énergie par jeton de 20 à 40 % lorsqu’elle est mise en œuvre dans des moteurs de production comme TensorRT‑LLM. Le constat au niveau des noyaux est simple: les noyaux tensoriels épars de NVIDIA doublent le débit mathématique effectif pour les GEMM éligibles selon le modèle 2:4 N:M, et le pipeline FP8 du moteur Transformer réduit la bande passante et évolue solidement les activations. Mais réaliser ces gains en production - sans sacrifier la qualité - nécessite un pipeline soigneux: les bonnes couches, une calibration bien préparée, une élagage sûre, une récupération rapide basée sur des adaptateurs et une construction de moteur bien ajustée.

Cet article est un guide pratique pour transformer un modèle dense en une construction élaguée, récupérée par adaptateur et calibrée FP8 dans TensorRT‑LLM. Nous vous montrerons comment établir une base de référence et profiler, sélectionner les couches et formats compatibles avec 2:4 pipelines, appliquer une élagage structuré sur les chemins linéaires/FFN, récupérer avec LoRA/AdaLoRA, intégrer dans un moteur de production avec des formes statiques et une attention fusionnée, et valider avec une matrice robuste de métriques, de distributions de latence, de mémoire et de journalisation de puissance. À la fin, vous aurez un processus répétable et sans risque de retour en arrière que vous pourrez opérer dans une flotte réelle.

Détails de l’architecture/de l’implémentation

Aperçu du pipeline de bout en bout

1. Référence en conditions de production

• Construisez une référence dense FP16 ou FP8 dans TensorRT‑LLM avec vos paramètres de décodage de production (lot, longueurs maximales de l’invite/réponse, tokenizer, planificateur).
• Activez l’attention fusionnée (par exemple, noyaux de type FlashAttention) pour que les matmuls MLP deviennent le chemin de calcul dominant que vous allez ensuite épurer.
• Mesurez les jetons/s, les latences p50/p99, la mémoire d’activation/maximum et la puissance GPU (nvidia‑smi dmon ou NVML). C’est votre contrôle.

2. Choisissez les couches et l’orientation éligibles pour 2:4

• Ciblez les matrices linéaires/FFN avec de grandes dimensions K: les projections attention QKV/proj et MLP up/down sont généralement éligibles.
• Évitez les tables d’embeddings, les normalisations de couches et la tête LM finale pour l’élagage.
• Respectez le regroupement 2:4 le long de la dimension de calcul la plus interne attendue par cuSPARSELt (groupes de 4 valeurs contiguës le long de K) afin que les noyaux tensoriels épars puissent s’engager.

3. Calibrez pour FP8 et la parcimonie

• Préparez un ensemble de calibration de 2–5k invites qui reflète la production: instruction, raisonnement et code. Incluez une tranche de contexte long.
• Exécutez la mise à l’échelle des activations/poids FP8 avec le moteur Transformer (mise à l’échelle dynamique par tenseur) pour éviter le débordement pendant que vous collectez les statistiques d’activation.

4. Appliquez l’élagage structuré 2:4 en toute sécurité

• Utilisez des scores de magnitude ou conscients de l’activation au sein de chaque groupe de 4 valeurs pour supprimer les deux éléments les moins importants.
• Commencez à 30–40% de parcimonie globale (2:4 est 50% au sein des matrices éligibles mais appliqué uniquement aux couches sélectionnées). Évitez l’élagage agressif dans les dernières couches d’attention qui peuvent être critiques pour le comportement à long terme.

5. Récupération basée sur des adaptateurs (LoRA/AdaLoRA)

• Attachez des adaptateurs de bas rang aux modules élagués et ajustez-les pendant quelques milliers de pas sur un mélange de tâches similaire à votre ensemble de calibration.
• Utilisez l’arrêt précoce basé sur un petit panier de validation (par exemple, des tranches de MMLU/GSM8K/MT‑Bench/HumanEval) pour récupérer de 0,5 à 2 points sans SFT complet et coûteux.

6. Pipeline de précision et recalibration après l’élagage

• Établissez d’abord une base de référence FP8 stable, puis élaguez, puis recalibrez les échelles FP8 après l’élagage.
• Si vous préférez INT8 (W8A8 ou uniquement poids), créez une référence pré-élagage (LLM.int8(), GPTQ), élaguez, puis recalibrez et validez.

7. Intégration du moteur pour la production

• Exportez les poids élagués avec des masques 2:4.
• Construisez un moteur TensorRT‑LLM avec FP8 et la parcimonie activés, des profils de forme statiques couvrant votre enveloppe d’invite/réponse et l’attention fusionnée activée.
• Vérifiez l’engagement des noyaux épars sur toutes les formes configurées; les incompatibilités de forme désactiveront silencieusement la parcimonie.

8. Validez et itérez

• Remesurez les jetons/s, la latence p50/p99, la mémoire et la puissance. Attendez-vous à 1,3–1,8× de la parcimonie 2:4 seule et à 1,5–2,0× avec FP8 sur H100/H200, avec des réductions de 20–40% d’énergie par jeton.
• Évaluez MMLU, GSM8K, HumanEval, MT‑Bench, BBH et une tâche de long contexte avec des paramètres de décodage fixes pour des comparaisons directes.

Diagramme (conceptuel): Les données circulent du tokenizer → embeddings calibrés FP8 → blocs d’attention (noyaux fusionnés FlashAttention‑2) → blocs FFN (matmuls épars 2:4 via cuSPARSELt) → tête LM. Les adaptateurs de récupération se situent sur les chemins linéaires élagués. Les profils de formes statiques garantissent que les noyaux restent sur des chemins optimisés.

Remarques de performance pratique sur Hopper

• L’éligibilité est binaire: seules les matrices 2:4 correctement masquées bénéficient de l’amélioration 2× du noyau. Un seul axe mal groupé ou un agencement non pris en charge vous ramène aux noyaux denses.
• Les plus grands gains de FP8 proviennent des économies de bande passante et du maintien des matrices sur les chemins rapides; maintenez les cas extrêmes d’échelle sous contrôle avec une calibration mise à jour après l’élagage.
• L’attention fusionnée/optimisée (par exemple, FlashAttention‑2) réduit la surcharge d’attention, amplifiant l’accélération réalisée par l’épuration des MLP.

Tableaux de comparaison

Recettes de précision et de parcimonie sur Hopper (TensorRT‑LLM)

Recette	Accélération e2e attendue (décodage)	Impact sur la mémoire/BW	Profil de risque	Remarques
Dense FP16	1,0×	Élevé	Faible	Référence; le plus facile à valider
Dense FP8	1,2–1,4×	BW d’activation ↓	Faible–modéré	Nécessite une mise à l’échelle soigneuse; bon premier pas
2:4 + FP16	1,3–1,8×	BW de poids ↓	Modéré	Assurez-vous de l’éligibilité/orientation de la couche
2:4 + FP8	1,5–2,0×	Poids + BW d’activation ↓	Modéré	Point optimal sur H100/H200
INT8 W8A8	1,2–1,6×	BW poids/activation ↓	Modéré	Largement pris en charge; recalibrez après l’élagage

Que tailler (LLM denses)

Module	Éligible 2:4	Risque pour la qualité	Conseils
Attention Q/K/V	Oui	Moyen	Élaguer avec prudence dans les couches tardives; conserver les têtes critiques KV
Proj d’output d’attention	Oui	Faible–modéré	Généralement sûr; valider long contexte
FFN haut/bas (porte)	Oui	Faible	Cible principale pour les accélérations 2:4
Embeddings	Non	Élevé	Ne pas élaguer
RMSNorm/LayerNorm	Non	Élevé	Ne pas élaguer
Tête LM	Généralement éviter	Élevé	Optionnel seulement avec validation rigoureuse

Avantages et inconvénients (2:4 vs alternatives sur NVIDIA)

Approche	Avantages	Inconvénients
2:4 N:M	Débit mathématique 2× au niveau du noyau; prêt pour la production dans TensorRT‑LLM	Contraintes de modèle; agencement/orientation strict
FP8 seul	Facile à adopter; portable entre couches	Gains plus petits; toujours limité par la bande passante à certains endroits
Parcimonie non structurée	Compressibilité élevée	Peu/pas d’accélération sans noyaux spécialisés
Parcimonie structurée en bloc	Bonne localité; noyaux plus faciles que non structurés	Nécessite des noyaux personnalisés ajustés ou une couverture spécifique

Bonnes pratiques

Curage du set de calibration et hygiène de mise à l’échelle

• Mélangez instruction, raisonnement (maths), code, et invocations de long contexte. 2–5k invites suffisent pour des scores de mise à l’échelle et d’élagage stables.
• Fixez les paramètres de décodage (température/top‑p/max‑new‑tokens) pour la calibration et l’évaluation afin d’éviter les biais.
• Pour FP8, utilisez la mise à l’échelle dynamique par tenseur du moteur Transformer et relancez la calibration après l’élagage pour tenir compte des changements de distribution.

Élagage structuré en toute sécurité

• Taillez uniquement les couches avec un support 2:4 prouvé dans votre moteur. Suivez le regroupement de cuSPARSELt le long de la dimension K interne et gardez les poids dans des dispositions prises en charge.
• Étape les augmentations de parcimonie (par exemple, 20% → 30% → 40%) avec des évaluations rapides entre chaque étape. Arrêtez lorsque MMLU/GSM8K bouge d’environ 1–2 points.
• Traitez les dernières couches d’attention comme critiques pour KV: taillez moins agressivement là-bas, et préservez les têtes connues pour porter un signal long.

Récupération basée sur des adaptateurs

• Commencez avec LoRA rang 8–16 sur les chemins d’attention et FFN; augmentez le rang seulement si la validation ne récupère pas dans un point sur vos métriques.
• AdaLoRA peut attribuer le rang dynamiquement à travers les modules; utile lorsque les budgets d’élagage diffèrent selon la profondeur des couches.
• Entraînez avec votre mélange de calibration et un léger poids sur le code/math pour stabiliser GSM8K/HumanEval.

Intégration moteur et discipline des formes

• Construisez des moteurs avec des formes statiques couvrant les charges de travail réelles (seaux invite/réponse). Si vous tombez en dehors d’une forme profilée à l’exécution, la parcimonie peut être désactivée.
• Activez l’attention fusionnée (de type FlashAttention‑2) pour faire apparaître le goulot d’étranglement MLP et maximiser les gains de bout en bout.
• Vérifiez l’engagement de la parcimonie en inspectant les traces des noyaux et les journaux TensorRT‑LLM; un pic soudain p99 indique souvent un retour aux chemins denses.

Matrice de validation et garde-fous

• Rapport: jetons/s, latence p50/p90/p99, mémoire d’activation/maximum, énergie par jeton (via journalisation de puissance). Comparez directement.
• Suite de tâches: MMLU, GSM8K, HumanEval, MT‑Bench/BBH, plus au moins un benchmark de long contexte.
• Tests canaris: invites courtes ciblant la sécurité, le suivi d’instructions et l’intégrité du long contexte.
• Plan de retour en arrière: artefacts versionnés par étape (base → élagué → récupéré → recalibré). Rampement progressif du trafic avec retour en arrière automatisé sur les budgets d’erreurs ou régressions p99. ✅

Conseils rapides pour le dépannage

• Débordement/NaNs FP8: serrez les clips-max ou recueillez à nouveau les échelles avec des invites lourdes en cas extrême.
• Accélération <1.2×: vérifiez que les masques 2:4 s’alignent sur l’axe correct et que toutes les formes de production sont profilées avec la parcimonie activée.
• Régressions d’attention: revenez sur l’élagage Q/K dans les couches tardives ou augmentez le rang LoRA sur ces modules.
• Pics p99: assurez-vous que le planificateur ne dépasse pas les longueurs maximales profilées, et que le lotissement n’introduit pas de dérive de forme.

Exemples pratiques

1) Application de masque 2:4 (PyTorch, illustratif)

import torch

@torch.no_grad()
def apply_2_4_mask(weight: torch.Tensor, group_dim: int = -1):
 # Reshape pour que les groupes de 4 se trouvent le long de la dimension la plus interne
 assert weight.shape[group_dim] % 4 == 0
 w = weight.transpose(group_dim, -1)
 g = w.reshape(*w.shape[:-1], w.shape[-1] // 4, 4)
 # Score de magnitude dans chaque groupe de 4
 scores = g.abs()
 # Garder les 2 premiers par groupe
 top2 = scores.topk(k=2, dim=-1).indices
 mask = torch.zeros_like(g, dtype=torch.bool)
 mask.scatter_(-1, top2, True)
 w_pruned = (g * mask).reshape_as(w)
 return w_pruned.transpose(group_dim, -1)

# Exemple: appliquer à une projection haut de MLP
for name, mod in model.named_modules():
 if isinstance(mod, torch.nn.Linear) and is_eligible(name):
 mod.weight.copy_(apply_2_4_mask(mod.weight, group_dim=1)) # groupe le long de K

Note: L’agencement/la disposition exacte doit correspondre aux attentes de cuSPARSELt pour l’engagement du noyau tensoriel épars.

2) Calibration FP8 avec Transformer Engine (simplifié)

import transformer_engine.pytorch as te

class FP8Block(te.fp8_autocast):
 def __init__(self, enabled=True):
 super().__init__(enabled=enabled)

# Pass de calibration
with te.fp8_autocast(enabled=True):
 for batch in calib_loader:
 _ = model(**batch)
# Enregistrez les échelles collectées (le cadre gère les statistiques par tenseur)

Référence: Le moteur Transformer de NVIDIA fournit des recettes de casting FP8, de mise à l’échelle et des orientations d’intégration.

3) Récupération LoRA (pseudo-code style PEFT)

from peft import LoraConfig, get_peft_model

lora = LoraConfig(r=16, lora_alpha=32, target_modules=["q_proj","k_proj","v_proj","o_proj","up_proj","down_proj"], lora_dropout=0.05)
model = get_peft_model(model, lora)
# Entraînez pendant 3–10k pas sur l'instruction/math mélangé avec du code; arrêt précoce sur tranche MMLU/GSM8K

Contexte: LoRA/AdaLoRA récupèrent la qualité avec peu de calcul après l’élagage.

4) Build TensorRT‑LLM (extrait de configuration exemple)

{
 "precision": "fp8",
 "enable_sparse_weights": true,
 "fused_attention": "flash_v2",
 "profiles": [
 {"prompt": [1, 2048], "response": [1, 512]},
 {"prompt": [1, 4096], "response": [1, 1024]}
 ],
 "plugins": {"kv_cache": {"static": true}}
}

Construire et exécuter (CLI varie selon la version; consultez la documentation de TensorRT‑LLM):

trtllm-build --model./pruned_lora_recovered --config./trt_config.json --output./engine
trtllm-run --engine./engine --dataset./eval.jsonl --metrics tokens_per_s,latency_p50,latency_p99

Documentation: Répertoire et documentation TensorRT‑LLM pour activer FP8, la parcimonie et les noyaux fusionnés.

5) Journalisation de puissance et de latence

# Puissance
nvidia-smi dmon -s pucmt -i 0 -o DT >> power.log &
# Distribution de latence via votre runner
trtllm-run... --metrics latency_histogram

6) Alternative INT8 (seulement poids)

Si votre pile préfère INT8, établissez une référence GPTQ/LLM.int8(), élaguez, puis re-quantifiez/recalibrez avant la construction du moteur.

Conclusion

La parcimonie 2:4 plus FP8 sur Hopper n’est plus un simple exercice de laboratoire - c’est une recette déployable qui offre régulièrement un débit de 1,5 à 2,0× et des économies d’énergie matérielles lorsqu’elle est exécutée avec discipline dans TensorRT‑LLM. Le chemin critique est opérationnel: clouez votre référence, n’élaguez que les couches éligibles avec l’orientation correcte, recalibrez la précision après les changements structurels, récupérez avec des adaptateurs légers, et maintenez les moteurs sur des noyaux optimisés avec des profils de formes statiques. Une matrice de validation rigoureuse, les tests canaris, et les garde-fous de retour en arrière transforment ces gains en quelque chose dont vous pouvez avoir confiance à grande échelle.

Principaux points à retenir

• Établissez une référence dense FP16/FP8 dans TensorRT‑LLM avec l’attention fusionnée avant tout élagage.
• Appliquez 2:4 uniquement aux matrices linéaires/FFN éligibles, respectez le regroupement de cuSPARSELt; taillez modérément dans les dernières couches d’attention.
• Recalibrez FP8 (ou INT8) après l’élagage et effectuez une récupération brève LoRA/AdaLoRA pour maintenir les deltas de métriques à environ ~1–2 points.
• Validez les jetons/s, la latence p50/p99, la mémoire et la puissance; utilisez MMLU, GSM8K, HumanEval, MT‑Bench/BBH, et le long contexte pour attraper les régressions.
• Protégez avec des tests canaris et des retours en arrière versionnés; la discipline des formes est essentielle pour maintenir l’engagement des noyaux épars.

Prochaines étapes

• Prototyper le pipeline sur un modèle de taille moyenne (par exemple, 7–13B) avec un petit ensemble de calibration pour valider les outils.
• Passez à votre échelle cible, étalez la parcimonie par incréments, et codifiez des seuils de passage/échec pour la qualité et la latence.
• Automatisez les constructions de moteurs pour chaque seau de profil et intégrez la télémétrie de puissance/latence dans votre pipeline de déploiement.

Regard vers l’avenir: à mesure que la couverture TensorRT‑LLM s’élargit et que les outils FP8 mûrissent, attendez-vous à des chemins plus faciles, plus automatisés pour mélanger la parcimonie 2:4 avec l’évolutivité de la précision - et plus de votre flotte roulant confortablement sur la voie rapide.

Sources & Références