Context Parallelism
Le parallélisme de contexte répartit une longue séquence d’entrée entre des GPU qui échangent des clés et des valeurs pendant le mécanisme d’attention, réduisant ainsi la mémoire nécessaire à chaque GPU.
Le parallélisme de contexte (CP) est une technique d’entraînement distribué qui répartit une longue séquence d’entrée entre plusieurs GPU. Chaque GPU contient une partie contiguë ou entrelacée des jetons ainsi que toutes les activations calculées à partir de ceux-ci ; la mémoire nécessaire sur chaque appareil diminue donc à mesure qu’on en ajoute. Les couches qui traitent les jetons indépendamment, comme la normalisation et les blocs feed-forward, s’exécutent sur les jetons locaux sans communication. L’auto-attention fait exception, car chaque requête peut consulter chaque clé. Les GPU échangent donc clés et valeurs pour produire exactement le même résultat qu’une attention appliquée à la séquence complète. Il s’agit d’une technique système permettant d’exécuter une fenêtre de contexte donnée, dont la longueur est fixée par l’architecture et l’entraînement du modèle.
Comment les GPU partagent les clés et les valeurs#
Les implémentations diffèrent principalement par la manière dont les clés et les valeurs sont transmises aux GPU qui en ont besoin :
- Attention en anneau : Les GPU forment un anneau et transmettent les blocs clé-valeur à leurs voisins tout en effectuant des calculs sur le bloc qu’ils détiennent, ce qui masque les transferts derrière les calculs.
- All-gather : Chaque GPU récupère toutes les clés et les valeurs, puis calcule l’attention pour ses propres requêtes. Meta a choisi cette méthode pour Llama 3, car elle prend facilement en charge les masques de document, et l’attention à requêtes groupées maintient les clés et les valeurs bien plus petites que les requêtes.
- All-to-all : DeepSpeed Ulysses réorganise les données afin que chaque GPU détienne tous les jetons pour un sous-ensemble de têtes d’attention, ce qui limite le degré de parallélisme au nombre de têtes.
L’API expérimentale de parallélisme de contexte de PyTorch remplace l’attention à produit scalaire mis à l’échelle par l’attention en anneau dans un bloc context_parallel(). Le Megatron-Core de NVIDIA rassemble les clés et les valeurs au moyen de transferts point à point en anneau lors de la passe avant, puis réduit et répartit leurs gradients lors de la passe arrière. Le CP diffère de l’ancien parallélisme de séquence de Megatron, qui ne répartit que les activations de normalisation de couche et de dropout en complément du parallélisme tensoriel, car il répartit les entrées et toutes les activations le long de la séquence.
Équilibrer l’attention causale#
Avec un masque causal, le jeton i ne prête attention qu’aux i jetons qui le précèdent et à lui-même ; les jetons ultérieurs demandent donc davantage de calcul. Attribuer à chaque GPU un quart contigu de la séquence laisse peu de travail au premier GPU et la majeure partie au dernier, et le GPU le plus occupé impose le rythme. Llama 3 et Megatron-Core découpent la séquence en deux fois plus de blocs que de GPU et attribuent à chaque GPU un bloc du début et son symétrique depuis la fin :
import torch
seq_len, ranks = 8192, 4
positions = torch.arange(seq_len)
causal_work = positions + 1 # sous un masque causal, le jeton i prête attention à i + 1 clés
# Découpage contigu : le rang r reçoit le r-ième quart de la séquence
contiguous = [causal_work[shard].sum().item() for shard in positions.chunk(ranks)]
# Découpage équilibré en charge : découper en 2 * ranks blocs, le rang r reçoit le bloc r et son symétrique depuis la fin
chunks = positions.chunk(2 * ranks)
balanced = [causal_work[torch.cat([chunks[r], chunks[-1 - r]])].sum().item() for r in range(ranks)]
print("Contiguous, millions of scores per rank:", [round(w / 1e6, 1) for w in contiguous])
print("Balanced, millions of scores per rank: ", [round(w / 1e6, 1) for w in balanced])Le découpage contigu attribue aux quatre GPU [2.1, 6.3, 10.5, 14.7] millions de scores d’attention, soit un écart de 7×, tandis que le découpage symétrique en attribue 8.4 millions à chacun.
Utilisation du parallélisme de contexte#
L’utilisation principale consiste à entraîner des grands modèles de langage (LLM) sur de longs documents et de grandes bases de code. Meta a étendu Llama 3 405B à des séquences de 131 072 jetons avec un parallélisme de contexte à 16 voies, en complément du parallélisme tensoriel, de pipeline et de données, sur 16 384 GPU H100. Le débit a atteint 38 % du débit BF16 maximal, contre 41 % pour le même cluster avec 8 192 jetons. La vidéo constitue l’autre cas d’usage : le modèle de génération vidéo Movie Gen de Meta, doté de 30 milliards de paramètres, a été entraîné sur des séquences encodées en environ 73 000 jetons, avec un parallélisme de contexte combiné au parallélisme tensoriel, de séquence et de données entièrement réparties. Les modèles vision-langage et les systèmes de compréhension vidéo traitant de longues vidéos rencontrent la même limite, car chaque image ajoute des centaines de jetons.
Le parallélisme de contexte se combine aux autres stratégies :
- Parallélisme de pipeline : Répartit les couches du modèle entre les GPU.
- Parallélisme de données : Répartit le lot entre des copies complètes du modèle.
- Flash attention : Évite de stocker la matrice d’attention sur un seul GPU. Les implémentations du parallélisme de contexte exécutent un noyau similaire sur le bloc local de chaque GPU.
Les modèles d’image n’atteignent ces longueurs qu’à très haute résolution, car la longueur de séquence croît avec le nombre de patches ou de positions de la carte de caractéristiques. Ultralytics YOLO26 place l’auto-attention uniquement sur sa carte de caractéristiques la plus grossière, à un pas de 32, dans les couches 10 et 22 de sa configuration de modèle. L’attention porte donc sur 400 positions avec le imgsz=640 par défaut et sur 1 600 avec imgsz=1280.










