Accelerate documentation
Processus d'exécution
Processus d'exécution
Lors de l’utilisation de systèmes d’entraînement distribué, il est essentiel de gérer la manière et le moment auxquels les processus sont exécutés sur les GPU. Certains processus sont terminés plus rapidement que d’autres, et certains ne doivent pas commencer si d’autres ne sont pas encore terminés. Accelerate fournit des outils pour orchestrer le moment d’exécution des processus afin de garantir que tout reste synchronisé sur tous les appareils.
Ce tutoriel vous apprendra comment exécuter un processus sur une seule machine et comment différer l'exécution jusqu'à ce que tous les processus aient atteint un certain point.
Exécuter sur un seul processus
Certain code ne doit être exécuté qu'une seule fois sur une machine donnée, par exemple pour afficher un message de journalisation ou n'afficher qu'une seule barre de progression sur le processus principal local.
Vous devez utiliser accelerator.is_local_main_process pour indiquer le code qui ne doit être exécuté qu'une seule fois.
from tqdm.auto import tqdm
progress_bar = tqdm(range(args.max_train_steps), disable=not accelerator.is_local_main_process)Vous pouvez également envelopper une instruction avec accelerator.is_local_main_process.
Pour les déclarations
accelerator.is_local_main_process, remplacez
if accelerator.is_local_main_process:
print("Accelerate is the best")Pour une fonction qui ne doit être exécutée qu'une seule fois, utilisez on_local_main_process().
@accelerator.on_local_main_process
def do_my_thing():
"Something done once per server"
do_thing_once_per_server()Vous pouvez également indiquer à Accelerate d’exécuter le code une seule fois sur tous les processus, quel que soit le nombre de machines. Cela est utile si vous téléversez un modèle final sur le Hub.
Vous devez utiliser accelerator.is_main_process pour indiquer le code qui ne doit être exécuté qu'une seule fois sur l'ensemble des processus.
if accelerator.is_main_process:
repo.push_to_hub()Pour une fonction qui ne doit être exécutée qu'une seule fois sur tous les processus, utilisez on_main_process().
@accelerator.on_main_process
def do_my_thing():
"Something done once per server"
do_thing_once()Exécuter sur un processus spécifique
Accelerate peut également vous aider à exécuter des fonctions qui ne doivent être exécutées que sur un processus spécifique ou un index de processus local.
Utilisez la méthode on_process() et spécifiez l’index du processus sur lequel exécuter la fonction.
@accelerator.on_process(process_index=0)
def do_my_thing():
"Something done on process index 0"
do_thing_on_index_zero()Utilisez la méthode on_local_process() et spécifiez l’index du processus local sur lequel exécuter la fonction.
@accelerator.on_local_process(local_process_idx=0)
def do_my_thing():
"Something done on process index 0 on each server"
do_thing_on_index_zero_on_each_server()Différer l'exécution
Lorsque vous exécutez votre script sur plusieurs GPU simultanément, certaines parties du code peuvent s’exécuter plus rapidement que d’autres. Il peut être nécessaire d’attendre que tous les processus atteignent un certain point avant d’exécuter la série d’instructions suivante. Par exemple, vous ne devez pas enregistrer un modèle avant de vous assurer que chaque processus a terminé l’entraînement.
Pour ce faire, ajoutez wait_for_everyone() dans votre code. Cela bloque tous les processus qui ont terminé en premier, les empêchant de continuer jusqu’à ce que tous les processus restants aient atteint le même point (cela n’a aucun effet si vous exécutez sur un seul GPU ou CPU).
accelerator.wait_for_everyone()