> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-locadex-parallel-t9n-main-cs60c8p4o6ik99tylxgp3.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> Reprenez des runs W&B en pause, arrêtés ou interrompus à l'aide des options du paramètre `resume` dans `wandb.init()`.

# Reprendre un run

Indiquez comment W\&B doit réagir si un run s'arrête ou plante en définissant le paramètre `resume` dans `wandb.init()`. Lorsque vous initialisez un run, W\&B vérifie si l'ID du run existe déjà et applique le comportement défini par la valeur de `resume`.

Le tableau suivant présente le comportement de W\&B en fonction de l'argument transmis au paramètre `resume` et de l'existence ou non de l'ID du run.

| Argument  | Description                                                                                                                                                  | L'ID du run existe                                                                 | L'ID du run n'existe pas                                  | Cas d'utilisation                                     |
| --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------- | --------------------------------------------------------- | ----------------------------------------------------- |
| `"must"`  | W\&B doit reprendre le run spécifié par l'ID du run.                                                                                                         | W\&B reprend le run avec le même ID du run. Reprend à partir de la dernière étape. | W\&B génère une erreur.                                   | Reprendre un run qui doit utiliser le même ID du run. |
| `"allow"` | Autorise W\&B à reprendre le run si l'ID du run existe.                                                                                                      | W\&B reprend le run avec le même ID du run. Reprend à partir de la dernière étape. | W\&B initialise un nouveau run avec l'ID du run spécifié. | Reprendre un run sans écraser un run existant.        |
| `"never"` | N'autorise jamais W\&B à reprendre un run spécifié par l'ID du run.                                                                                          | Génère une erreur si un run avec l'ID spécifié existe déjà.                        | W\&B initialise un nouveau run avec l'ID du run spécifié. |                                                       |
| `"auto"`  | Autorise W\&B à tenter automatiquement de reprendre le run si l'ID du run existe. Redémarrez le run depuis le même répertoire que le processus ayant échoué. | W\&B reprend le run avec le même ID du run.                                        | W\&B initialise un nouveau run avec l'ID du run spécifié. | Permettre la reprise automatique des runs.            |

<Note>
  **Quand utiliser `auto` plutôt que `allow`**

  W\&B recommande d'utiliser `resume="allow"` et de spécifier l'ID exact du run que vous souhaitez reprendre.

  L'option `resume="auto"` ne vous oblige pas à spécifier d'ID du run, mais elle peut entraîner un comportement inattendu si plusieurs runs échouent dans le même répertoire ou si la structure des répertoires change. Vous devez également vous assurer de redémarrer le run depuis le même répertoire que le processus ayant échoué lorsque vous utilisez `resume="auto"`.
</Note>

Pour tous les exemples ci-dessous, remplacez les valeurs entre `<>` par les vôtres.
<Tip>[Voir une démo en direct d'un run repris](https://wandb.ai/wandb/resume-run/workspace?nw=nwuserjuliarose).</Tip>

<div id="resume-a-run-that-must-use-the-same-run-id">
  ## Reprendre un run en utilisant obligatoirement le même ID du run
</div>

Si un run s’arrête, plante ou échoue, vous pouvez le reprendre avec le même ID du run. Pour ce faire, initialisez un run et indiquez les éléments suivants :

* Définissez le paramètre `resume` sur `"must"` (`resume="must"`)
* Fournissez l’ID du run arrêté ou planté

L’extrait de code suivant montre comment procéder avec le SDK Python W\&B :

```python theme={null}
with wandb.init(entity="<entity>", project="<project>", id="<run ID>", resume="must") as run:
        # Votre code d'entraînement ici
```

<Warning>
  Des résultats inattendus peuvent se produire si plusieurs processus utilisent simultanément le même `id`.

  Pour en savoir plus sur la gestion de plusieurs processus, voir [Journaliser les expériences d’entraînement distribué](/fr/models/track/log/distributed-training/)
</Warning>

<div id="resume-a-run-without-overriding-the-existing-run">
  ## Reprendre un run sans écraser le run existant
</div>

Reprenez un run arrêté ou planté sans écraser le run existant. Cela est particulièrement utile si votre processus ne se termine pas correctement. La prochaine fois que vous démarrerez W\&B, W\&B reprendra la journalisation à partir de la dernière étape.

Définissez le paramètre `resume` sur `"allow"` (`resume="allow"`) lorsque vous initialisez un run avec W\&B. Fournissez l’ID du run arrêté ou planté. L’extrait de code suivant montre comment procéder avec le SDK Python W\&B :

```python theme={null}
import wandb

with wandb.init(entity="<entity>", project="<project>", id="<run ID>", resume="allow") as run:
        # Votre code d'entraînement ici
```

<div id="enable-runs-to-automatically-resume">
  ## Activer la reprise automatique des runs
</div>

L'extrait de code suivant montre comment activer la reprise automatique des runs avec le SDK Python ou des variables d'environnement.

<Tabs>
  <Tab title="W&B Python SDK">
    Passez `auto` comme argument du paramètre `resume` lorsque vous initialisez un run. Veillez à redémarrer le run depuis le même répertoire que le processus ayant échoué.

    Copiez-collez l'extrait de code suivant. Remplacez les valeurs entre `<>` par les vôtres :

    ```python theme={null}
    with wandb.init(entity="<entity>", project="<project>", id="<run ID>", resume="auto") as run:
            # Votre code d'entraînement ici
    ```
  </Tab>

  <Tab title="Script shell">
    L'exemple suivant montre comment définir la variable W\&B `WANDB_RUN_ID` dans un script bash :

    ```bash title="run_experiment.sh" theme={null}
    RUN_ID="$1"

    WANDB_RESUME=auto WANDB_RUN_ID="$RUN_ID" python eval.py
    ```

    Dans votre terminal, vous pouvez exécuter le script shell en lui passant l’ID du run W\&B. L'extrait de code suivant transmet l’ID du run `akj172` :

    ```bash theme={null}
    sh run_experiment.sh akj172 
    ```
  </Tab>
</Tabs>

<Warning>
  La reprise automatique ne fonctionne que si le processus est redémarré sur le même système de fichiers que celui du processus ayant échoué.
</Warning>

Par exemple, supposons que vous exécutiez un script Python appelé `train.py` dans un répertoire nommé `Users/AwesomeEmployee/Desktop/ImageClassify/training/`. Dans `train.py`, le script crée un run avec reprise automatique activée. Supposons ensuite que le script d'entraînement s'arrête. Pour reprendre ce run, vous devez redémarrer votre script `train.py` dans `Users/AwesomeEmployee/Desktop/ImageClassify/training/`.

<Note>
  Si vous ne pouvez pas utiliser un système de fichiers partagé, spécifiez la variable d'environnement `WANDB_RUN_ID` ou transmettez l’ID du run avec le W\&B Python SDK. Voir la section [Custom run IDs](./#custom-run-ids) de la page « What are runs? » pour plus d'informations sur les IDs du run.
</Note>

<div id="resume-preemptible-sweeps-runs">
  ## Reprendre les runs Sweeps préemptibles
</div>

Gérez les signaux de préemption afin que W\&B puisse automatiquement remettre en file d’attente les [runs de sweep](/fr/models/sweeps/) interrompues pour qu’un autre agent les exécute. Ce modèle est utile lorsque l’agent de sweep s’exécute sur des ressources de calcul préemptibles, telles qu’une file d’attente SLURM préemptible, une instance Spot Amazon EC2 ou une VM préemptible Google Cloud.

Les instructions ci-dessous s’appliquent lorsque vous démarrez des agents de sweep avec la CLI [`wandb agent`](/fr/models/ref/cli/wandb-agent). La CLI démarre votre programme d’entraînement en tant que **sous-processus**. Ces instructions ne s’appliquent pas entièrement si vous utilisez uniquement l’API Python [`wandb.agent()`](/fr/models/ref/python/functions/agent). L’API Python exécute la fonction d’entraînement dans un thread. La transmission et le relais des signaux du système d’exploitation diffèrent donc du comportement de l’agent CLI.

<div id="handle-a-preemption-signal">
  ### Gérer un signal de préemption
</div>

Enregistrez un gestionnaire pour le signal que votre ordonnanceur ou votre plateforme utilise pour indiquer une préemption, tel que `SIGUSR1` ou `SIGTERM`. Dans le gestionnaire :

1. Dans le gestionnaire, appelez [`mark_preempting()`](/fr/models/ref/python/experiments/run#mark_preempting) lorsqu’un run est actif
2. Effectuez tout nettoyage nécessaire, par exemple en enregistrant un checkpoint.
3. Quittez avec un code d’état non nul. Une convention courante pour une terminaison par signal est `128 + signum`.

N’appelez **pas** `mark_preempting()` systématiquement juste après `wandb.init()`. Sinon, chaque échec, y compris les bugs dans le code, peut être marqué comme une préemption et le run peut être remis en file d’attente de façon répétée.

Pour des exemples exécutables, l’option `--forward-signals` de l’agent CLI, ainsi qu’un tableau de référence complet pour les différents usages de `mark_preempting()`, voir [Gestion des signaux et runs de sweep](/fr/models/sweeps/signal-handling-sweep-runs).

Lorsque vous suivez ce modèle, W\&B enregistre l’état du run à peu près comme suit :

| Scénario                                                                                                                                                                      | État du run                                                                    |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ |
| Le run se termine normalement avec le code de sortie 0                                                                                                                        | FINISHED                                                                       |
| Le run échoue avec un code de sortie non nul                                                                                                                                  | FAILED                                                                         |
| Le run reçoit un signal non géré (par exemple `SIGKILL`)                                                                                                                      | CRASHED après environ cinq minutes                                             |
| Le run reçoit un signal de préemption géré (par exemple `SIGTERM` ou `SIGUSR1`), le gestionnaire appelle `mark_preempting()`, et le processus se termine avec un code non nul | PREEMPTED ; le run est mis en file d’attente pour la prochaine requête d’agent |

<Info>
  Lorsqu’un agent de sweep récupère un run préempté, le processus d’entraînement doit appeler `wandb.init()` dans les 60 minutes. Si l’initialisation n’a pas lieu, par exemple lorsque le processus échoue après avoir récupéré le run mais avant d’appeler `wandb.init()`, W\&B ne rend pas le run disponible pour un autre agent avant l’expiration du bail de 60 minutes.
</Info>

Les agents de sweep traitent les runs remis en file d’attente avant de demander de nouvelles combinaisons d’hyperparamètres à l’algorithme de recherche du sweep. Une fois la file d’attente vide, le sweep reprend sa planification normale.