> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/llms.txt
> Use this file to discover all available pages before exploring further.

> Explorez différents paramètres ou modèles à partir d’un point précis d’une expérience, sans affecter le run original.

# Forker un run

<Note>
  La possibilité de forker un run est en cours de développement actif. Elle est en aperçu pour le Cloud mutualisé et le Cloud dédié, et n’est pas encore disponible en Autogéré.
</Note>

Vous pouvez explorer différents hyperparamètres ou modèles à partir d’un point précis d’une expérience sans affecter le run original. Pour cela, forkez à partir d’un run W\&B existant.

Lorsque vous forkez un run, W\&B crée un nouveau run en utilisant l’[ID unique](/fr/models/runs/run-identifiers#unique-run-identifiers) du run source et une étape spécifiée. Les métriques récapitulatives du run source sont copiées dans le run forké. Le run forké partage l’ensemble de l’historique et des fichiers du run source jusqu’à l’étape spécifiée.

Après l’étape de fork, vous pouvez journaliser de nouvelles données dans le run forké indépendamment du run original.

Consultez une [démo en direct](https://wandb.ai/wandb/test-fork-run/workspace?nw=nwuserjuliarose) d’un run forké généré par le code ci-dessous.

<Note>
  * Forker un run nécessite la version du SDK [`wandb`](https://pypi.org/project/wandb/) >= 0.16.5
  * Forker un run nécessite des étapes monotones croissantes. Vous ne pouvez pas forker à partir d’un run qui utilise des étapes non monotones définies avec [`define_metric()`](/fr/models/ref/python/experiments/run#define_metric). Les étapes non monotones rompent l’ordre chronologique de l’historique du run et des métriques système.
</Note>

Indiquez l’ID unique du run source ainsi que la `step` à partir de laquelle vous souhaitez démarrer le run forké comme arguments de `fork_from` dans [`wandb.init()`](/fr/models/ref/python/functions/init).

<div id="fork-from-a-previously-logged-run">
  ## Forker à partir d’un run précédemment enregistré
</div>

L’extrait de code suivant montre comment forker à partir d’un run précédemment enregistré dans W\&B.

Commencez par obtenir l’ID du run du run à partir duquel vous souhaitez forker. Indiquez ensuite l’ID du run et l’étape à partir de laquelle vous souhaitez forker en arguments de `fork_from` dans [`wandb.init()`](/fr/models/ref/python/functions/init).

Copiez-collez le code suivant dans un script Python ou une cellule de notebook. Remplacez `<source-run-id>`, `<project>` et `<entity>` par vos propres valeurs :

```python theme={null}
import wandb

# L'ID unique du run source à partir duquel forker
source_run_id = "<source-run-id>"

# Indiquer l'étape à partir de laquelle forker
fork_step = 200

# Forker le run
with wandb.init(
    project="<project>",
    entity="<entity>",
    fork_from=f"{source_run_id}?_step={fork_step}",
) as forked_run:
    pass
```

<div id="fork-from-a-run-in-the-same-script">
  ## Forker à partir d’un run dans le même script
</div>

L’extrait de code suivant montre comment créer un run et forker à partir de celui-ci dans le même script. Cela peut être utile si vous voulez forker à partir d’un run que vous venez de créer, sans avoir à rechercher l’ID du run dans l’application W\&B.

Commencez par initialiser un run et journaliser quelques données. Ensuite, utilisez la propriété `id` de l’objet run original pour obtenir l’ID du run correspondant. Enfin, initialisez un nouveau run et transmettez l’ID du run original ainsi que l’étape à partir de laquelle vous voulez forker comme arguments à `fork_from` dans [`wandb.init()`](/fr/models/ref/python/functions/init).

```python theme={null}
import wandb

# Initialiser un run
with wandb.init(
    project="<project>",
    entity="<entity>"
) as original_run:
    # ...logique d'entraînement ici ...
    pass

# Spécifier l'étape à partir de laquelle forker
fork_step = int("<num>")

# Utiliser l'ID du run original et spécifier l'étape à partir de laquelle forker
with wandb.init(
    project="<project>",
    entity="<entity>",
    fork_from=f"{original_run.id}?_step={fork_step}",
) as forked_run:
    # ...logique d'entraînement ici ...
    pass
```

<Tip>Utilisez la propriété `original_run.id` pour obtenir l’ID unique du run d’origine.</Tip>

<div id="example-script">
  ### Exemple de script
</div>

Par exemple, le code ci-dessous montre comment d’abord forker un run, puis journaliser des métriques dans le run forké à partir de l’étape d’entraînement 200.

Copiez-collez le code suivant dans un script Python ou une cellule de notebook. Remplacez `<project>` et `<entity>` par vos propres valeurs.

```python theme={null}
import wandb
import math

# Initialiser le premier run et journaliser quelques métriques
with wandb.init(
    project="<project>",
    entity="<entity>"
) as run1:
    for i in range(300):
        run1.log({"metric": i})

# Forker à partir du premier run à une étape spécifique et journaliser
# la métrique à partir de l'étape 200
with wandb.init(
    project="<project>", 
    entity="<entity>", 
    fork_from=f"{run1.id}?_step=200"
) as run2:
    # Continuer la journalisation dans le nouveau run
    # Pour les premières étapes, journaliser la métrique telle quelle depuis run1
    # Après l'étape 250, commencer à journaliser le motif en pics
    for i in range(200, 300):
        if i < 250:
            # Continuer la journalisation depuis run1 sans pics
            metric_value = i
        else:
            # Introduire le comportement en pics à partir de l'étape 250
            metric_value = i + (2 * math.sin(i / 3.0))  # Appliquer un motif en pics subtil

        # Journaliser les deux métriques en un appel unique pour s'assurer qu'elles sont
        # enregistrées à la même étape
        run2.log({
            "metric": metric_value,
            "additional_metric": i * 1.1
        })
```

<Note>
  **Compatibilité entre rembobinage et fork**

  Le fork complète un [`rewind`](/fr/models/runs/rewind/) en offrant plus de flexibilité pour gérer vos Runs et expérimenter avec eux.

  Lorsque vous forkez à partir d'un run, W\&B crée une nouvelle branche depuis ce run à un point précis afin d'essayer différents paramètres ou modèles.

  Lorsque vous rembobinez un run, W\&B vous permet de corriger ou de modifier l'historique du run lui-même.
</Note>