# Utiliser Local SGD avec Accelerate

Le SGD local est une technique d’entraînement distribué dans laquelle les gradients ne sont pas synchronisés à chaque étape. Ainsi, chaque processus met à jour sa propre version des poids du modèle, et après un nombre donné d’étapes, ces poids sont synchronisés par une moyenne sur l’ensemble des processus. Cela améliore l’efficacité de la communication et peut entraîner une accélération significative de l’entraînement, en particulier lorsqu’un ordinateur ne dispose pas d’un interconnect plus rapide tel que NVLink. Contrairement à l’accumulation de gradients (où l’amélioration de l’efficacité de la communication nécessite d’augmenter la taille de lot effective), le SGD local ne requiert pas de modification de la taille de lot ou du taux d’apprentissage / de son calendrier. Toutefois, si nécessaire, le SGD local peut également être combiné avec l’accumulation de gradients.

Dans ce tutoriel, vous verrez comment configurer rapidement Local SGD Accelerate. Par rapport à une configuration standard d'Accelerate, cela ne nécessite que deux lignes de code supplémentaires.

Cet exemple utilise une boucle d’entraînement PyTorch très simpliste qui effectue l’accumulation des gradients toutes les deux itérations :

```python
device = "cuda"
model.to(device)

gradient_accumulation_steps = 2

for index, batch in enumerate(training_dataloader):
    inputs, targets = batch
    inputs = inputs.to(device)
    targets = targets.to(device)
    outputs = model(inputs)
    loss = loss_function(outputs, targets)
    loss = loss / gradient_accumulation_steps
    loss.backward()
    if (index + 1) % gradient_accumulation_steps == 0:
        optimizer.step()
        scheduler.step()
        optimizer.zero_grad()
```

## Conversion vers Accelerate

Tout d'abord, le code présenté précédemment sera converti pour utiliser Accelerate sans aucun LocalSGD ni assistant d'accumulation de gradients :

```diff
+ from accelerate import Accelerator
+ accelerator = Accelerator()

+ model, optimizer, training_dataloader, scheduler = accelerator.prepare(
+     model, optimizer, training_dataloader, scheduler
+ )

  for index, batch in enumerate(training_dataloader):
      inputs, targets = batch
-     inputs = inputs.to(device)
-     targets = targets.to(device)
      outputs = model(inputs)
      loss = loss_function(outputs, targets)
      loss = loss / gradient_accumulation_steps
+     accelerator.backward(loss)
      if (index+1) % gradient_accumulation_steps == 0:
          optimizer.step()
          scheduler.step()
```

## Laisser Accelerate gérer la synchronisation du modèle 

Il ne reste plus qu'à laisser Accelerate gérer la synchronisation des paramètres du modèle **et** l'accumulation des gradients pour nous. Pour simplifier, supposons que nous devons synchroniser toutes les 8 étapes. Cela se fait en ajoutant une déclaration `with LocalSGD` et un appel `local_sgd.step()` après chaque étape de l'optimiseur :

```diff
+local_sgd_steps=8

+with LocalSGD(accelerator=accelerator, model=model, local_sgd_steps=8, enabled=True) as local_sgd:
    for batch in training_dataloader:
        with accelerator.accumulate(model):
            inputs, targets = batch
            outputs = model(inputs)
            loss = loss_function(outputs, targets)
            accelerator.backward(loss)
            optimizer.step()
            scheduler.step()
            optimizer.zero_grad()
+           local_sgd.step()
```

Sous le capot, le code Local SGD **désactive** la synchronisation automatique des gradients (mais l’accumulation fonctionne toujours comme prévu !). Il moyenne plutôt les paramètres du modèle toutes les `local_sgd_steps` étapes (ainsi qu’à la fin de la boucle d’entraînement).

## Limites

L'implémentation actuelle ne fonctionne qu'avec l'entraînement multi-GPU (ou multi-CPU) de base, sans, par exemple, [DeepSpeed.](https://github.com/deepspeedai/DeepSpeed)

## Références

    Bien que nous ne connaissions pas les origines exactes de cette approche simple, l’idée du SGD local est assez ancienne et remonte au moins à :

    Zhang, J., De Sa, C., Mitliagkas, I., & Ré, C. (2016). [Parallel SGD: When does averaging help?. arXiv preprint arXiv:1606.07365.](https://huggingface.co/papers/1606.07365)

    Nous attribuons le terme Local SGD à l'article suivant (mais il pourrait exister des références antérieures dont nous n'avons pas connaissance).

    Stich, Sebastian Urban. [« Local SGD Converges Fast and Communicates Little. » ICLR 2019-International Conference on Learning Representations. No. CONF. 2019.](https://huggingface.co/papers/1805.09767)

