Accelerate documentation
Comparaison des performances entre différentes configurations distribuées
Comparaison des performances entre différentes configurations distribuées
Évaluer et comparer les performances issues de différentes configurations peut s’avérer délicat si vous ne savez pas sur quels points porter votre attention. Par exemple, vous ne pouvez pas exécuter le même script avec la même taille de lot sur TPU, multi-GPU et GPU unique avec Accelerate et vous attendre à ce que vos résultats soient identiques.
Mais pourquoi ?
Il y a trois raisons à cela, que ce tutoriel abordera :
- Définir les bons seeds
- Tailles de lot observées
- Taux d'apprentissage
Définir la graine
Bien que ce problème soit moins fréquent, assurez-vous d'utiliser utils.set_seed() pour définir complètement la graine dans tous les cas distribués afin que l'entraînement soit reproductible :
from accelerate.utils import set_seed
set_seed(42)Pourquoi est-ce important ? En interne, cela définira 5 paramètres de graine différents :
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed) # or torch.xpu.manual_seed_all, etc
# ^^ safe to call this function even if cuda is not available
if is_torch_xla_available():
xm.set_rng_state(seed)L'état aléatoire, l'état de numpy, torch, l'état du dispositif de torch, et, si des TPU sont disponibles, l'état cuda de torch_xla.
Tailles de lot observées
Lors de l’entraînement avec Accelerate, la taille de lot passée au dataloader correspond à la taille de lot par GPU. Cela signifie qu’une taille de lot de 64 sur deux GPU correspond en réalité à une taille de lot de 128. Par conséquent, lors des tests sur un seul GPU, il faut en tenir compte, de même que pour les TPU.
Le tableau ci-dessous peut servir de référence rapide pour tester différentes tailles de lot :
Dans cet exemple, il y a deux GPU pour « Multi-GPU » et un pod TPU avec 8 workers
| Taille de lot sur GPU unique | Taille de lot équivalente multi-GPU | Taille de lot équivalente sur TPU |
|---|---|---|
| 256 | 128 | 32 |
| 128 | 64 | 16 |
| 64 | 32 | 8 |
| 32 | 16 | 4 |
Taux d'apprentissage
Comme indiqué dans plusieurs sources[1][2], le taux d'apprentissage doit être mis à l'échelle linéairement en fonction du nombre d'appareils présents. L'extrait de code ci-dessous montre comment le faire avec Accelerate :
Les utilisateurs pouvant définir leurs propres planificateurs de taux d'apprentissage, nous laissons à leur discrétion la décision de mettre à l'échelle leur taux d'apprentissage ou non.
learning_rate = 1e-3
accelerator = Accelerator()
learning_rate *= accelerator.num_processes
optimizer = AdamW(params=model.parameters(), lr=learning_rate)Vous constaterez également que accelerate ajuste le taux d'apprentissage en fonction du nombre de processus utilisés pour l'entraînement. Cela s'explique par la taille de lot observée mentionnée précédemment. Ainsi, dans le cas de 2 GPU, le taux d'apprentissage sera ajusté deux fois plus souvent qu'avec un seul GPU, afin de compenser le fait que la taille de lot soit deux fois plus grande (si aucune modification de la taille de lot n'est apportée sur l'instance à GPU unique).
Accumulation de gradient et précision mixte
Lors de l'utilisation de l'accumulation de gradients et de la précision mixte, en raison du fonctionnement de la moyenne des gradients (accumulation) et de la perte de précision (précision mixte), une certaine dégradation des performances est à prévoir. Cela se verra explicitement lors de la comparaison de la perte par lot entre différentes configurations de calcul. Cependant, la perte globale, la métrique et les performances générales à la fin de l'entraînement devraient être à peu près les mêmes.
Update on GitHub