Accelerate documentation
Synchronisation des gradients
Synchronisation des gradients
Le module distribué de PyTorch fonctionne en communiquant en permanence entre tous les GPU de votre système.
Cette communication prend du temps, et le fait de s’assurer que tous les processus connaissent l’état des autres se produit à des points de déclenchement précis
lors de l’utilisation du module ddp.
Ces points de déclenchement sont ajoutés au modèle PyTorch, plus précisément à ses méthodes forward() et backward().
Cela se produit lorsque le modèle est encapsulé avec DistributedDataParallel :
import torch.nn as nn
from torch.nn.parallel import DistributedDataParallel
model = nn.Linear(10, 10)
ddp_model = DistributedDataParallel(model)Dans Accelerate, cette conversion est effectuée automatiquement lors de l'appel à prepare() en y passant votre modèle.
+ from accelerate import Accelerator
+ accelerator = Accelerator()
import torch.nn as nn
- from torch.nn.parallel import DistributedDataParallel
model = nn.Linear(10,10)
+ model = accelerator.prepare(model)Le ralentissement de l'accumulation des gradients
Vous comprenez désormais que PyTorch ajoute des hooks à la méthode forward et à la méthode backward de votre modèle PyTorch lors de l’entraînement dans un environnement distribué. Mais comment cela peut-il ralentir votre code ?
Dans DDP (parallélisme de données distribué), l'ordre spécifique dans lequel les processus sont exécutés est attendu à des points précis, et ces opérations doivent également se produire approximativement en même temps avant de passer à la suite.
L’exemple le plus direct est lorsque vous mettez à jour les paramètres du modèle via optimizer.step().
Sans accumulation de gradients, toutes les instances du modèle doivent avoir calculé, agrégé et mis à jour leurs gradients avant de passer au lot de données suivant.
Lors de l’accumulation de gradients, vous accumulez n gradients de perte et
ignorez optimizer.step() jusqu’à ce que n lots aient été atteints. Comme tous les processus
d’entraînement n’ont besoin de se synchroniser qu’au moment où optimizer.step() est appelé,
sans aucune modification de votre étape d’entraînement, cette communication inter-processus
inutile peut provoquer un ralentissement important.
Comment éviter cette surcharge ?
Résoudre le problème de ralentissement
Puisque vous sautez la mise à jour des paramètres du modèle lors de l’entraînement sur ces lots, leurs gradients n’ont pas besoin d’être synchronisés jusqu’au moment où optimizer.step() est réellement appelé.
PyTorch ne peut pas déterminer automatiquement quand vous devez effectuer cette opération, mais il fournit un outil pour vous aider via le gestionnaire de contexte no_sync
qui est ajouté à votre modèle après sa conversion en DDP.
Dans ce gestionnaire de contexte, PyTorch ignore la synchronisation des gradients lorsque .backward() est appelé, et le premier appel à .backward() en dehors de ce gestionnaire de contexte déclenchera la synchronisation. Voir un exemple ci-dessous :
ddp_model, dataloader, optimizer = accelerator.prepare(model, dataloader, optimizer)
for index, batch in enumerate(dataloader):
inputs, targets = batch
# Trigger gradient synchronization on the last batch
if index != (len(dataloader) - 1):
with ddp_model.no_sync():
# Gradients only accumulate
outputs = ddp_model(inputs)
loss = loss_func(outputs)
accelerator.backward(loss)
else:
# Gradients finally sync
outputs = ddp_model(inputs)
loss = loss_func(outputs)
accelerator.backward(loss)
optimizer.step()Dans Accelerate, pour en faire une API qui peut être appelée quel que soit l'appareil d'entraînement (bien qu'elle ne fasse peut-être rien si vous n'êtes pas dans un système distribué !), ddp_model.no_sync est remplacé par no_sync() et fonctionne de la même manière :
ddp_model, dataloader, optimizer = accelerator.prepare(model, dataloader, optimizer)
for index, batch in enumerate(dataloader):
inputs, targets = batch
# Trigger gradient synchronization on the last batch
if index != (len(dataloader)-1):
- with ddp_model.no_sync():
+ with accelerator.no_sync(model):
# Gradients only accumulate
outputs = ddp_model(inputs)
loss = loss_func(outputs, targets)
accelerator.backward(loss)
else:
# Gradients finally sync
outputs = ddp_model(inputs)
loss = loss_func(outputs)
accelerator.backward(loss)
optimizer.step()
optimizer.zero_grad()Comme vous pouvez vous y attendre, la fonction accumulate() encapsule cette vérification conditionnelle en suivant le numéro du lot actuel, vous laissant avec l’API finale d’accumulation des gradients :
ddp_model, dataloader, optimizer = accelerator.prepare(model, dataloader, optimizer)
for batch in dataloader:
with accelerator.accumulate(model):
optimizer.zero_grad()
inputs, targets = batch
outputs = model(inputs)
loss = loss_function(outputs, targets)
accelerator.backward(loss)
optimizer.step()
optimizer.zero_grad()En conséquence, vous devez utiliser accelerator.accumulate ou accelerator.no_sync en ce qui concerne le choix de l’API.
À quel point le ralentissement est-il important, et les erreurs faciles à commettre
Pour mettre en place un exemple réaliste, considérez la configuration suivante :
- Deux nœuds mono-GPU T4 et un nœud doté de deux GPU
- Chaque GPU est un T4 et est hébergé sur GCP
- Le script utilisé est une modification du script NLP Example
- La taille du lot par GPU est de 16, et les gradients sont accumulés toutes les 4 étapes
Tous les scripts sont disponibles dans ce dépôt.
Si l'on ne fait pas attention à la synchronisation des gradients et à la communication entre GPU, une grande quantité de temps peut être perdue lorsque ces GPU communiquent entre eux pendant des périodes inutiles.
De combien ?
Référence :
- Référence : n'utilise aucune des pratiques de synchronisation abordées ici
no_syncde manière incorrecte :no_syncuniquement autour de l'appelbackward, et non autour deforwardno_sync: utiliser correctement le motifno_syncaccumulate: utiliser correctement accumulate()
Voici le nombre moyen de secondes par lot, en parcourant 29 lots de données pour chaque configuration, sur un nœud unique et sur la configuration à double nœud :
| Ligne de base | no_sync de manière incorrecte | no_sync | accumulate | |
|---|---|---|---|---|
| Multi-nœud | 2±0.01s | 2.13±0.08s | 0.91±0.11s | 0.91±0.11s |
| Nœud unique | 0.50±0.01s | 0.50±0.01s | 0.41±0.015s | 0.41±0.015s |
Comme vous pouvez le constater, si vous ne faites pas attention à la manière dont vous configurez la synchronisation des gradients, vous pouvez subir un ralentissement de plus de 2x pendant l’entraînement !
Si vous souhaitez vous assurer que tout est correctement exécuté, nous vous recommandons vivement d’utiliser la fonction accumulate() et de passer gradient_accumulation_steps ou gradient_accumulation_plugin à l’objet Accelerator afin qu’Accelerate s’en charge pour vous.
no_sync nécessite une mémoire GPU supplémentaire lors de l'utilisation de FSDP
Sachez que le fait de ne pas synchroniser les gradients peut avoir des effets néfastes lors de l’entraînement avec FSDP. Comme averti dans torch, le gestionnaire de contexte no_sync pour FSDP nécessitera une mémoire supplémentaire.
Par conséquent, dans les situations où la consommation mémoire est élevée lors de l’utilisation de FSDP, nous recommandons de définir sync_each_batch sur True dans le GradientAccumulationPlugin afin de désactiver no_sync.
Voir l’exemple ci-dessous où nous affinons Mixtral (47B paramètres) sur 8 GPU A100-80GB. Nous constatons que même pour un gradient_accumulation_steps=2 modeste, nous atteignons rapidement une erreur de mémoire insuffisante (OOM) si no_sync est activé. Là encore, cela est dû aux surcoûts mémoire supplémentaires liés à no_sync de FSDP. Toutefois, si no_sync est désactivé via sync_each_batch=True, la consommation mémoire pour gradient_accumulation_steps=16 revient à celle de gradient_accumulation_steps=1.
| Modèle | no_sync (accum=1) | no_sync (accum=2) | no_sync désactivé (accum=16) |
|---|---|---|---|
| mixtral 8x7B | 69G | OOM | 69G |
Update on GitHubDésactiver
no_syncentraîne un ralentissement en raison des synchronisations de données supplémentaires, comme l’expliquent les sections précédentes de ce guide.