Accelerate documentation

Comparaison des performances entre différentes configurations distribuées

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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 :

  1. Définir les bons seeds
  2. Tailles de lot observées
  3. 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 uniqueTaille de lot équivalente multi-GPUTaille de lot équivalente sur TPU
25612832
1286416
64328
32164

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