Accelerate documentation
Context Parallel dans đ€ accelerate
Context Parallel dans đ€ accelerate
Ce guide abordera les bases de lâutilisation du parallĂ©lisme de contexte dans đ€accelerate ; pour les lecteurs les plus curieux, nous aborderons Ă©galement certains aspects techniques dans les sections suivantes.
Voir également le trÚs lié Guide to Sequence Parallelism.
Pourquoi le parallélisme de contexte ?
Avec lâavĂšnement des grands modĂšles de langage, et rĂ©cemment des modĂšles de raisonnement, la longueur des sĂ©quences a augmentĂ© rapidement. Cela, combinĂ© Ă la complexitĂ© mĂ©moire quadratique de lâattention, a engendrĂ© le besoin de mĂ©thodes plus efficaces pour entraĂźner des modĂšles avec de longues sĂ©quences.
Avec une longueur de sĂ©quence de 128k, lâexigence mĂ©moire de la matrice dâattention est de 128k * 128k * 2 bytes * num_heads = ~32 GB * num_heads pour une prĂ©cision bf16, en supposant une implĂ©mentation dâattention standard. Certes, avec lâutilisation de flash attention ou de SDPA, qui ne matĂ©rialisent pas ces poids dâattention, cela diminue considĂ©rablement, mais la croissance des exigences mĂ©moire reste importante.
Le parallélisme de contexte nous permet de fractionner les entrées du calcul d'attention le long de la dimension de la séquence et de calculer l'attention en parallÚle sur plusieurs GPU. Grùce à cela, nous pouvons entraßner des modÚles avec de longues séquences, en passant potentiellement à une longueur de séquence supérieure à 1 million.
Comment utiliser le parallélisme de contexte ?
from accelerate.utils import ParallelismConfig, TorchContextParallelConfig
+ cp_config = TorchContextParallelConfig(
+ cp_comm_strategy="alltoall", # no need to use cp_config at all, if you want to use the default "allgather"
+ )
+ parallelism_config = ParallelismConfig(
+ cp_size=8,
+ cp_handler=cp_config, # or just cp_size=8, if you want to use the default "allgather"
+ )
accelerator = Accelerator(
...,
parallelism_config=parallelism_config,
)Comme pour toute autre fonctionnalitĂ© de đ€accelerate, vous pouvez Ă©galement activer le parallĂ©lisme de contexte en passant les drapeaux correspondants Ă accelerate launch.
Dans ce cas, rien ne change :
accelerate launch --parallelism-config-cp-size 8 --parallelism-config-cp-comm-strategy [allgather|alltoall] ...
Vous pouvez également définir
cp_sizeetcp_comm_strategydans la commandeaccelerate config, ce qui les enregistre dans votre fichier de configurationaccelerate, afin de ne plus avoir Ă les passer Ă chaque lancement de votre script.
Le parallélisme de contexte est compatible avec d'autres stratégies de parallélisme, telles que le parallélisme de données, le parallélisme de tenseurs et FSDP2. Vous pouvez simplement les combiner en définissant les tailles de parallélisme sur les valeurs souhaitées, par exemple
--parallelism-config-dp-size 8 --parallelism-config-tp-size 2 --parallelism-config-cp-size 8. Ou vous pouvez utiliser la classeParallelismConfigpour les définir de maniÚre programmatique.
Le parallĂ©lisme de contexte est Ă©troitement couplĂ© Ă
FSDP2, dont vous pouvez en savoir plus dans l'introduction à FSDP2. Cela signifie que le parallélisme de contexte ne fonctionne que si vous utilisezFullyShardedDataParallelPluginou--use-fsdpavec la version définie sur 2 dans votre programme. SiFSDP2n'est pas utilisé, une erreur est levée.
Le parallĂ©lisme de contexte ne fonctionne quâavec SDPA et uniquement sans masque ou masque causal. Nous ne pouvons pas dĂ©tecter correctement cela pour vous, il est donc de votre responsabilitĂ© de vous assurer dâutiliser
SDPAsans masque ni masque causal. Si vous utilisez toute autre implĂ©mentation dâattention, une erreur sera levĂ©e.
AprĂšs avoir activĂ© le parallĂ©lisme de contexte Ă lâaide des mĂ©thodes mentionnĂ©es ci-dessus, vous pouvez ensuite lâappliquer Ă votre boucle dâentraĂźnement. Nous fournissons un wrapper fin autour de torch.distributed.tensor.experimental.context_parallel que vous pouvez utiliser dans votre boucle dâentraĂźnement, et qui abstrait une partie de la complexitĂ© liĂ©e Ă son utilisation (plus de dĂ©tails Ă ce sujet plus tard). Pour minimiser les modifications Ă apporter Ă votre boucle dâentraĂźnement, nous fournissons un gestionnaire de contexte qui est un noop si le parallĂ©lisme de contexte nâest pas activĂ©, et qui applique le parallĂ©lisme de contexte sâil est activĂ©. Ainsi, vous pouvez lâutiliser dans votre boucle dâentraĂźnement sans modifier aucun code en fonction de votre configuration de parallĂ©lisme.
Vous pouvez lâutiliser comme suit :
for batch in dataloader:
with accelerator.maybe_context_parallel(
buffers=[batch["input_ids"], batch["attention_mask"]],
buffer_seq_dims=[1, 1],
no_restore_buffers={batch["input_ids"], batch["labels"]},
):
outputs = model(**batch)
...Ce gestionnaire de contexte doit ĂȘtre recréé Ă chaque Ă©tape dâentraĂźnement, comme le montre lâexemple ci-dessus. Il est crucial de le faire.
Cela permet potentiellement dâaugmenter la taille du contexte jusquâĂ une longueur de sĂ©quence supĂ©rieure Ă 1 M. Ci-dessous, nous prĂ©sentons la vitesse et lâutilisation de la mĂ©moire du parallĂ©lisme de contexte pour une taille de contexte allant jusquâĂ 256 k. On observe que lorsque lâon double la taille du contexte et le nombre de GPU, on obtient une utilisation de la mĂ©moire constante, ce qui permet potentiellement une mise Ă lâĂ©chelle illimitĂ©e de la longueur du contexte.
Figure 1 : Utilisation de la mémoire et vitesse du parallélisme de contexte pour une taille de contexte allant jusqu'à 256k.
Ces exemples ont été créés à l'aide d'un script que vous pouvez trouver dans le dossier examples. Pour exécuter l'exemple sur 8 GPU H100 (longueur de séquence de 128k), vous pouvez utiliser la commande suivante :
accelerate launch --use-fsdp --fsdp-activation-checkpointing=TRUE examples/torch_native_parallelism/nd_parallel.py --cp-size=8 --sequence-length=128000
Lâinterface dâAccelerate
Le gestionnaire de contexte prend plusieurs arguments, utilisés pour configurer le parallélisme de contexte.
buffers: il s'agit d'une liste de tenseurs qui doivent ĂȘtre fractionnĂ©s le long de la dimension de sĂ©quence. Ces tenseurs sont gĂ©nĂ©ralement des identifiants d'entrĂ©e, des Ă©tiquettes et un masque d'attention.buffer_seq_dims: il sâagit dâune liste dâentiers qui spĂ©cifient la dimension de sĂ©quence des tampons, dans lâordre de la listebuffers. Si vous passezbuffers=[input_ids, shift_labels]avec les deux ayant la forme[batch_size, sequence_length], vous passeriezbuffer_seq_dims=[1, 1], car la dimension de sĂ©quence est la deuxiĂšme dimension des tenseurs. Ceci est requis pour un calcul correct des sorties du modĂšle.no_restore_buffers: LâimplĂ©mentation du parallĂ©lisme de contexte modifie les buffers sur place, en les convertissant entorch.distributed.tensor.Dtensor. AprĂšs la sortie du gestionnaire de contexte, un noyau de communication devrait ĂȘtre lancĂ© pour restaurer les buffers Ă leur Ă©tat dâorigine (gĂ©nĂ©ralement un all-gather). Cela prend un certain temps, il est donc recommandĂ© de passer les mĂȘmes tenseurs que dans lâargumentbuffers, afin dâĂ©viter toute communication inutile, Ă moins dâĂȘtre certain de devoir utiliser les buffers aprĂšs la sortie du gestionnaire de contexte.
Le parallélisme de contexte n'est pas compatible avec des
labelsqui sont une copie deinput_ids, ce que les modĂšles de đ€ transformers peuvent dĂ©caler eux-mĂȘmes pour activer le modĂ©lisation de langage causale. Imaginez ce cas : labels = [l1, l2, l3, l4, ⊠li] si nous appliquons le parallĂ©lisme de contexte, chaque rang se retrouverait avec une partie des labels, comme ceci : labels_rank_0 = [l1, l2], labels_rank_1 = [l3, l4], ⊠aprĂšs que le code de modĂ©lisation de transformers a dĂ©calĂ© les labels, on obtiendrait : labels_rank_0 = [l2, PAD], labels_rank_1 = [l3, PAD], ⊠oĂčPADest un jeton de bourrage. Cela entraĂźnerait un calcul de perte incorrect, car les labels ne sont plus alignĂ©s avec les entrĂ©es. En raison de cela, vous devez dĂ©caler manuellement les labels avant de les passer au modĂšle
Options configurables
Accelerate ne propose qu'une seule option pour configurer le parallélisme de contexte (à l'exception de cp_size)
cp_comm_strategy: MĂ©thode de rotation Ă utiliser pour les shards. Nous recommandons vivement de conserver"allgather", car il est trĂšs probable quâil surpasse"alltoall"dans la plupart des cas.
La taille du parallĂ©lisme de contexte est assez explicite par elle-mĂȘme : câest le nombre de rangs sur lesquels les entrĂ©es doivent ĂȘtre fractionnĂ©es. La rotation des fragments du parallĂ©lisme de contexte dĂ©finit la maniĂšre dont les fragments des entrĂ©es sont tournĂ©s entre les rangs. Nous dĂ©taillerons les 2 options dans la section suivante.
Vous pouvez consulter un exemple de bout en bout dans le fichier ND parallel example, oĂč il est possible dâentraĂźner un modĂšle de 8B avec une longueur de contexte allant jusquâĂ 128k sur un seul nĆud 8xH100. En utilisant lâentraĂźnement multi-nĆuds, vous pouvez Ă©tendre cette configuration Ă une longueur de sĂ©quence supĂ©rieure Ă 1M sur plusieurs GPU. Vous pouvez Ă©galement le combiner sans effort avec dâautres stratĂ©gies de parallĂ©lisme pour rĂ©pondre Ă vos besoins.
Détails techniques
Cette section est assez technique, donc si vous nâavez pas besoin de comprendre le fonctionnement interne du parallĂ©lisme de contexte, vous pouvez la passer et commencer Ă construire đ
Nous allons utiliser le terme shard de maniĂšre extensive dans les sections suivantes, dĂ©finissons-le donc d'abord. Si nous disons qu'un tenseur est sharded sur la dimension Dth, sur N rangs, cela signifie que ce tenseur est divisĂ© en N parties, oĂč chaque partie du tenseur a la forme [..., D//N, ...].
Alors, comment cela fonctionne-t-il ?
Le parallĂ©lisme de contexte fonctionne en fractionnant les matrices Q, K and V le long de la dimension de la sĂ©quence. Chaque rang possĂšde sa fraction de Q, que nous appellerons Q_i. Cette matrice reste uniquement sur ce rang, pendant toute la durĂ©e du calcul. De mĂȘme, chaque rang possĂšde sa propre fraction de K et V, que nous appellerons K_i et V_i. Ensuite, chaque rang calcule l'attention avec sa propre fraction de Q_i, K_i et V_i, que nous appellerons attn_i. Pendant ce calcul, un noyau de communication est lancĂ© pour collecter les Ks et les Vs de tous les autres rangs. La primitive de communication utilisĂ©e dĂ©pend de l'option context_parallel_shard_rotation.
De cette maniÚre, chaque rang calcule l'attention locale, d'abord avec Q_i, K_i et V_i, puis avec K_j et V_j provenant de tous les autres rangs. Comme chaque rang détient des matrices Q, K and V fractionnées le long de la dimension de la séquence, les matrices résultantes sont plus petites et peuvent tenir sur une seule GPU.
Nous pouvons formaliser cela dans le pseudocode suivant :
comm_kernel = {"allgather": allgather, "alltoall": alltoall}[context_parallel_shard_rotation]
Qi, Ki, Vi = shard(Q, K, V, seq_dim)
attn[i] = attn(Qi, Ki, Vi)
for j in range(context_parallel_size):
Kj, Vj = comm_kernel()
attn[j] = attn(Qi, Kj, Vj) # [batch, num_heads, seq_len // context_parallel_size, head_dim]
final_attn = combine(attn)all-to-all vs all-gather
all-gather
Quelle est donc la différence entre all-to-all et all-gather ? Avec all-gather, la communication est trÚs simple. AprÚs (ou plutÎt avant, car cela prend généralement plus de temps) avoir calculé l'attention locale attn_i, nous lançons un all-gather pour rassembler tous les autres Ks et Vs provenant de tous les autres rangs. Une fois cette communication effectuée, chaque rang dispose de tous les Ks et Vs des autres rangs et peut calculer l'attention avec eux séquentiellement.
Dans un scĂ©nario idĂ©al, l'all-gather se termine exactement au moment oĂč le calcul de attn_i est achevĂ©. Cependant, cela n'arrive jamais en pratique, de sorte que le chevauchement rĂ©el idĂ©al est atteint lorsque le calcul complet de attn_i est chevauchĂ© avec une partie de la communication, puis, pour commencer le calcul avec K_j et V_j, nous attendons la fin de l'all-gather.
all-to-all
LâopĂ©ration all-to-all, parfois appelĂ©e ring-rotation, utilise un motif de communication en anneau. Une fois le calcul de attn_i terminĂ©, un all-to-all est lancĂ© pour envoyer K_i et V_i aux rangs voisins. Nous rĂ©pĂ©tons ensuite cette opĂ©ration context_parallel_size-1 fois, afin que chaque rang voie une fois toutes les tranches de K et V provenant de tous les autres rangs. Dans un scĂ©nario idĂ©al, nous prĂ©chargeons les tranches K_i+1 et V_i+1 depuis le rang voisin, et cette communication est exactement superposĂ©e au calcul de notre attn_i actuel. LĂ encore, en rĂ©alitĂ©, cette superposition parfaite nâarrive jamais. Compte tenu de la nature de cette approche, si nous nâatteignons pas une superposition parfaite, la pĂ©nalitĂ© est bien plus importante quâavec lâopĂ©ration all-gather.
Comment choisir la bonne méthode de rotation ?
En thĂ©orie, all-to-all devrait ĂȘtre le meilleur choix. En pratique, câest rarement le cas. Nous choisissons donc par dĂ©faut all-gather, car il a plus de chances dâoffrir de meilleures performances. Des benchmarks approfondis de lâĂ©quipe torchtitan montrent Ă©galement quâall-to-all surpasse rarement all-gather. Nous proposons nĂ©anmoins les deux options, car lâune dâelles pourrait sâavĂ©rer plus adaptĂ©e Ă votre cas dâusage.
Vous pouvez voir directement ce problĂšme dans la sortie du profilageur de lâimage ci-dessous :
Figure 1 : En rouge, on voit le temps dâattente pendant que le noyau all-to-all termine. La premiĂšre barre bleue, mise en Ă©vidence, montre quâil faut environ 250 us pour quâil se termine, ce qui se rĂ©pĂšte N-1 fois pour chaque appel dâattention, oĂč N est la taille du parallĂ©lisme de contexte.
Pourquoi uniquement FSDP2 ?
Nous ne prenons en charge le parallĂ©lisme de contexte quâavec FSDP2, car nous crĂ©ons un maillage conjoint de context_parallel_size et dp_shard_size afin dâen exploiter tout le potentiel.
Le fonctionnement est le suivant : nous fragmentons le modÚle sur le maillage conjoint de taille cp_size*dp_shard_size, ce qui maximise les économies de mémoire.
Câest une sorte de « repas gratuit », car la communication de FSDP est entiĂšrement superposĂ©e au calcul de lâattention, comme le montrent les images ci-dessous.
Figure 2 : Dans les rectangles bleus (Stream 23), on observe que le pré-chargement du shard FSDP est entiÚrement superposé au calcul de l'attention (Stream 7), tandis que dans les rectangles rouges (Stream 24), on constate que le noyau all-gather entraßne une bulle de temps inactif, au cours de laquelle notre stream de calcul (7) est inactif.
Dans la figure ci-dessus, on peut également noter la différence entre all-to-all et all-gather. Alors qu'en all-to-all (Figure 1), nous lançons un noyau de communication N-1 fois pour chaque appel d'attention, en all-gather (Figure 2), nous ne lançons un noyau de communication qu'une seule fois. Cela entraßne une bulle plus grande, mais elle ne se produit qu'une fois par appel d'attention, tandis qu'en all-to-all, elle se produit N-1 fois.
Affectation des données dans le maillage conjoint
Nous veillons Ă distribuer le mĂȘme lot de donnĂ©es Ă l'ensemble du sous-groupe cp, afin que les rĂ©sultats soient corrects. (Cela signifie que chaque rang du sous-groupe cp reçoit le mĂȘme lot de donnĂ©es.) Cependant, nous distribuons Ă©galement des lots diffĂ©rents Ă chaque rang du groupe dp_shard.
Imaginez-le ainsi :
# 8 GPUS, --dp_shard_size 4, --cp_size 2
# mesh = [[0, 1], [2, 3], [4, 5], [6, 7]]
# model is sharded across the whole mesh (each GPU holds 1/8 of the model)
# GPUs 0,1 = batch 0
# GPUs 2,3 = batch 1
... and so on.