# 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.

```py
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`.

> [!TIP]
> Pour les déclarations `print` autonomes qui ne sont pas enveloppées dans `accelerator.is_local_main_process`, remplacez `print` par la méthode [print()](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.Accelerator.print) d'Accelerate pour n'imprimer qu'une fois par processus.

```py
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()](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.Accelerator.on_local_main_process).

```py
@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.

```py
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()](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.Accelerator.on_main_process).

```py
@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()](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.Accelerator.on_process) et spécifiez l’index du processus sur lequel exécuter la fonction.

```py
@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()](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.Accelerator.on_local_process) et spécifiez l’index du processus local sur lequel exécuter la fonction.

```py
@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()](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.Accelerator.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).

```py
accelerator.wait_for_everyone()
```