> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/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 d’origine.

# Forker un run

<Note>
  Le fork de runs est en préversion pour le Cloud mutualisé et le Cloud dédié. Pour le Cloud dédié, contactez l’assistance afin d’obtenir des conseils. Cette fonctionnalité n’est actuellement pas disponible pour les déploiements autogérés.

  Les fonctionnalités en préversion peuvent être évaluées en production, mais leur fonctionnement, leurs API et leur comportement sont en cours de développement et peuvent changer avant la disponibilité générale.
</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 d’origine. Pour ce faire, forkez un run W\&B existant.

Lorsque vous forkez un run, W\&B crée un nouveau run à partir de l’[ID unique](/fr/products/wandb/runs/run-identifiers#unique-run-identifiers) du run source et d’une étape donnée. Les métriques de synthèse du run source sont copiées dans le run forké. Le run forké partage l’intégralité 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 d’origine.

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

<Note>
  * Le fork d’un run nécessite le SDK [`wandb`](https://pypi.org/project/wandb/) en version >= 0.16.5
  * Le fork d’un run nécessite des étapes strictement croissantes. Vous ne pouvez pas forker un run qui utilise des étapes non monotones définies avec [`define_metric()`](/fr/products/wandb/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’identifiant unique (`run ID`) du run source et la `step` à partir de laquelle vous souhaitez démarrer le run forké comme arguments de `fork_from` dans [`wandb.init()`](/fr/products/wandb/ref/python/functions/init).

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

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

Commencez par obtenir l’ID du run à partir duquel vous souhaitez forker. Ensuite, transmettez l’ID du run et l’étape à partir de laquelle vous souhaitez forker comme arguments de `fork_from` dans [`wandb.init()`](/fr/products/wandb/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={"system"}
import wandb

# ID unique du run source à partir duquel effectuer le fork
source_run_id = "<source-run-id>"

# Indiquer le step à partir duquel effectuer le fork
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
```

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

L’extrait de code suivant montre comment créer un run, puis forker à partir de ce run dans le même script. Cela peut être utile si vous souhaitez forker à partir d’un run que vous venez de créer, sans avoir à rechercher l’ID du run dans la W\&B App.

Commencez par initialiser un run et journaliser quelques données. Utilisez ensuite la propriété `id` de l’objet run d’origine pour obtenir l’ID de ce run. Enfin, initialisez un nouveau run et transmettez à `fork_from`, dans [`wandb.init()`](/fr/products/wandb/ref/python/functions/init), l’ID du run d’origine ainsi que l’étape à partir de laquelle vous souhaitez forker.

```python theme={"system"}
import wandb

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

# Indiquer le step à partir duquel forker
fork_step = int("<num>")

# Utiliser l’ID du run d’origine et indiquer le step à partir duquel forker
with wandb.init(
    project="<project>",
    entity="<entity>",
    fork_from=f"{original_run.id}?_step={fork_step}",
) as forked_run:
    # ...votre logique d’entraînement ici...
    pass
```

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

<h3 id="example-script">
  Exemple de script
</h3>

L’exemple de code suivant montre comment forker d’abord 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={"system"}
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 à un step donné et journaliser la
# métrique à partir du step 200
with wandb.init(
    project="<project>", 
    entity="<entity>", 
    fork_from=f"{run1.id}?_step=200"
) as run2:
    # Poursuivre la journalisation dans le nouveau run
    # Pour les premiers steps, journaliser la métrique telle quelle, comme dans run1
    # À partir du step 250, commencer à journaliser le motif en pics
    for i in range(200, 300):
        if i < 250:
            # Poursuivre la journalisation de run1, sans pics
            metric_value = i
        else:
            # Introduire le comportement en pics à partir du step 250
            metric_value = i + (2 * math.sin(i / 3.0))  # Appliquer un léger motif en pics

        # Journaliser les deux métriques en un appel unique pour garantir
        # qu’elles soient journalisées au même step
        run2.log({
            "metric": metric_value,
            "additional_metric": i * 1.1
        })
```

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

  Le fork complète le [`rewind`](/fr/products/wandb/runs/rewind) en vous offrant davantage 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 à partir d’un point précis de ce run pour vous permettre d’essayer d’autres paramètres ou d’autres modèles.

  Lorsque vous rembobinez un run, W\&B vous permet de corriger ou de modifier directement l’historique du run.
</Note>


## Related topics

- [Rembobiner un run](/fr/products/wandb/runs/rewind.md)