Accelerate documentation
Utiliser Local SGD avec Accelerate
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 :
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 :
+ 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 :
+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.
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.
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.
Update on GitHub