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

> Rembobinez un run pour corriger ou modifier son historique sans perdre les données d’origine.

# Rembobiner un run

Rembobinez un run pour modifier son historique. Lorsque vous rembobinez un run, W\&B réinitialise l’état du run à l’étape indiquée tout en conservant le même ID du run.

<Note>
  La fonctionnalité de rembobinage des runs est en cours de développement actif. Elle est disponible en préversion sur le Cloud mutualisé et le Cloud dédié, mais pas encore en environnement autogéré.

  En raison de limitations de performances connues du rembobinage, W\&B recommande généralement de recourir plutôt au [fork](/fr/products/wandb/runs/forking).
</Note>

<h3 id="prerequisites">
  Prérequis
</h3>

Avant de rembobiner un run, vérifiez que vous remplissez les prérequis suivants :

* Pour rembobiner un run, vous devez disposer du [SDK Python W\&B](https://pypi.org/project/wandb/) en version >= `0.17.1`.
* Vous devez utiliser des valeurs d’étape monotones croissantes. Le rembobinage ne fonctionne pas avec des valeurs d’étape non monotones définies avec [`define_metric()`](/fr/products/wandb/ref/python/experiments/run#define_metric), car elles perturbent l’ordre chronologique requis de l’historique du run.

<h3 id="limitations">
  Limitations
</h3>

Le rembobinage ne prend pas en charge les éléments suivants :

* **Rembobinage des journaux** : les journaux sont réinitialisés dans le nouveau segment du run.
* **Rembobinage des métriques système** : W\&B journalise uniquement les nouvelles métriques système postérieures au point de rembobinage.
* **Association des artifacts** : W\&B associe les artifacts au run source qui les produit.

W\&B recalcule les métriques de synthèse du run rembobiné à partir de l’historique nouvellement journalisé, avec les conséquences suivantes :

* **Troncature de l’historique** : W\&B tronque l’historique au point de rembobinage, ce qui permet de journaliser de nouvelles données.
* **Métriques de synthèse** : elles sont recalculées à partir de l’historique nouvellement journalisé.
* **Conservation de la configuration** : W\&B conserve les configurations d’origine, et vous pouvez y fusionner de nouvelles configurations.

<h3 id="rewind-and-forking-compatibility">
  Compatibilité entre le rembobinage et le fork
</h3>

Le fork complète le rembobinage.

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

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

<h2 id="rewind-a-run">
  Rembobiner un run
</h2>

Rembobinez un run à partir d’une étape donnée et journalisez de nouvelles données à partir de ce point. Transmettez l’ID du run et l’étape à partir de laquelle vous souhaitez rembobiner comme arguments du paramètre `resume_from` de [`wandb.init()`](/fr/products/wandb/ref/python/functions/init). Le paramètre `resume_from` accepte une chaîne de caractères au format `<run ID>?_step=<step>`, où `<run ID>` est l’ID du run que vous souhaitez rembobiner et `<step>` l’étape à partir de laquelle vous souhaitez rembobiner.

Supposons que vous journalisiez une droite pendant 300 étapes :

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

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

Dans le workspace de votre projet, vous voyez un graphique en courbes de l’étape 0 à l’étape 300 :

<img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/_media/rewind_run_original.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=f08b7f13e5c42bdea0c2e491f4e102f7" alt="Graphique en courbes du run d’origine" width="2014" height="1024" data-path="products/wandb/_media/rewind_run_original.png" />

Par la suite, vous souhaitez rembobiner le run à partir de l’étape 200 et journaliser une nouvelle métrique, `additional_metric`, qui journalise `i*1.1` de l’étape 200 à l’étape 300. À partir de l’étape 250, vous souhaitez journaliser un nouveau motif légèrement ondulé (`i**2 + 2*sin(i/3)`) au lieu d’une ligne droite :

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

run_ID = "<run_ID>" # Remplacez par l’ID du run que vous souhaitez rembobiner

# Rembobiner le premier run jusqu’à une étape donnée et journaliser la métrique à partir de l’étape 200
with wandb.init(project="<project>", entity="wandb", resume_from=f"{run_ID}?_step=200") as run:

    # Pour les premières étapes, journaliser la métrique telle qu’elle était dans le run
    # Après l’étape 250, commencer à journaliser le motif ondulé
    for i in range(200, 300):
        if i < 250:
            run.log({"metric": i, "step": i})  # Poursuivre la journalisation du run sans ondulations
        else:
            # Introduire le comportement ondulé à partir de l’étape 250
            subtle_wave = i + (2 * math.sin(i / 3.0))  # Appliquer un léger motif ondulé
            run.log({"metric": subtle_wave, "step": i})
        # Journaliser également la nouvelle métrique à chaque étape
        run.log({"additional_metric": i * 1.1, "step": i})
```

L’image suivante montre le workspace du projet mis à jour. Notez les modifications suivantes dans le graphique après le rembobinage :

* Le graphique en courbes affiche la ligne droite d’origine de l’étape 0 à l’étape 200, puis le nouveau motif légèrement ondulé à partir de l’étape 250 (image de gauche).
* W\&B a créé un nouveau graphique (graphique de droite), intitulé `additional_metric`, qui commence à l’étape 200.

<img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/_media/rewind_run_step200_wmetric.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=1739ebdb6401da0ae79ff8732606e2b4" alt="De gauche à droite : ligne droite d’origine et métrique supplémentaire" width="3266" height="1057" data-path="products/wandb/_media/rewind_run_step200_wmetric.png" />

<h2 id="view-an-archived-run">
  Afficher un run archivé
</h2>

Après avoir rembobiné un run, vous pouvez explorer le run d’origine archivé dans la W\&B App. Pour afficher un run archivé, suivez ces étapes :

1. **Ouvrez l’onglet Overview :** accédez à l’[onglet **Overview**](/fr/products/wandb/runs#overview-tab) sur la page du run. Cet onglet offre une vue complète des détails et de l’historique du run.
2. **Repérez le champ Forked From :** dans l’onglet **Overview**, trouvez le champ `Forked From`. Ce champ conserve l’historique des reprises. Le champ **Forked From** contient un lien vers le run source, ce qui vous permet de remonter jusqu’au run d’origine et de retracer l’historique complet des rembobinages.

Grâce au champ `Forked From`, vous pouvez parcourir facilement l’arborescence des reprises archivées et mieux comprendre l’enchaînement et l’origine de chaque rembobinage.

<h2 id="fork-from-a-run-that-you-rewind">
  Forker à partir d’un run rembobiné
</h2>

Pour forker à partir d’un run rembobiné, utilisez l’argument [`fork_from`](/fr/products/wandb/runs/forking) dans `wandb.init()` en indiquant l’ID du run source ainsi que l’étape de ce run à partir de laquelle forker :

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

# Créer un fork du run à partir d’un step donné
forked_run = wandb.init(
    project="<project>",
    entity="<entity>",
    fork_from=f"{rewind_run.id}?_step=500",
)

# Poursuivre la journalisation dans le nouveau run
for i in range(500, 1000):
    forked_run.log({"metric": i*3})
forked_run.finish()
```