# 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` :
```python
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()](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.Accelerator.prepare) en y passant votre modèle.

```diff
+ 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 ceux-ci 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 vous sautez `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 y aider via le gestionnaire de contexte [`no_sync`](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel.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 :
```python
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()](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.Accelerator.no_sync) et fonctionne de la même manière :

```diff
  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()](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.Accelerator.accumulate) encapsule cette vérification conditionnelle en suivant le numéro du lot actuel, vous laissant avec l’API finale d’accumulation des gradients :

```python
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](https://github.com/muellerzr/timing_experiments/blob/main/baseline.py)
* 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](https://github.com/muellerzr/timing_experiments).

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_sync` de manière incorrecte : `no_sync` uniquement autour de l'appel `backward`, et non autour de `forward`
- `no_sync` : utiliser correctement le motif `no_sync`
- `accumulate` : utiliser correctement [accumulate()](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.Accelerator.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()](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.Accelerator.accumulate) et de passer `gradient_accumulation_steps` ou `gradient_accumulation_plugin` à l’objet [Accelerator](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.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](https://pytorch.org/docs/stable/fsdp.html#torch.distributed.fsdp.FullyShardedDataParallel.no_sync) 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](/docs/accelerate/main/fr/package_reference/utilities#accelerate.utils.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

> [!WARNING] 
> Désactiver `no_sync` entraîne _un ralentissement_ en raison des synchronisations de données supplémentaires, comme l’expliquent les sections précédentes de ce guide.

