Accelerate documentation

Context Parallel dans đŸ€— accelerate

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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_size et cp_comm_strategy dans la commande accelerate config, ce qui les enregistre dans votre fichier de configuration accelerate, 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 classe ParallelismConfig pour 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 utilisez FullyShardedDataParallelPlugin ou --use-fsdp avec la version définie sur 2 dans votre programme. Si FSDP2 n'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 SDPA sans 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.

context parallelism memory usage
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 liste buffers. Si vous passez buffers=[input_ids, shift_labels] avec les deux ayant la forme [batch_size, sequence_length], vous passeriez buffer_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 en torch.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’argument buffers, 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 labels qui sont une copie de input_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Ăč PAD est 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 :

all-to-all profiler output
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.

why FSDP2+CP
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.
Update on GitHub