Rembobiner un run

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

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

L’option permettant de rembobiner un run est en préversion privée et en cours de développement actif. En raison de limitations de performances connues avec Rewind, W&B recommande généralement Forking comme solution alternative.

W&B ne prend actuellement pas en charge :

• Rembobinage des journaux : les journaux sont réinitialisés dans le nouveau segment du run.
• Rembobinage des métriques système : W&B n’enregistre que les nouvelles métriques système après le point de rembobinage.
• Association d’Artifacts : W&B associe les artifacts au run source qui les produit.

Contactez l’assistance W&B à l’adresse [e-mail] pour demander l’accès à cette fonctionnalité.

W&B recalcule les métriques de summary du run que vous rembobinez à partir de l’historique nouvellement enregistré. Cela implique le comportement suivant :

• Troncature de l’historique : W&B tronque l’historique jusqu’au point de rembobinage, ce qui permet d’enregistrer de nouvelles données.
• Métriques de summary : recalculées à partir de l’historique nouvellement enregistré.
• Préservation de la configuration : W&B conserve les configurations d’origine et vous pouvez fusionner de nouvelles configurations.

Compatibilité entre le rembobinage et le fork

Le fork vient compléter le rembobinage.

Lorsque vous créez un fork à partir d’un run, W&B crée une nouvelle branche du 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.

​

Prérequis

Avant de rembobiner un run, assurez-vous de respecter les prérequis suivants :

• Pour rembobiner un run, vous devez disposer du W&B Python SDK en version >= 0.17.1.
• Vous devez utiliser des étapes à progression monotone croissante. Cela ne fonctionne pas avec des étapes non monotones définies avec define_metric(), car cela perturbe l’ordre chronologique requis de l’historique du run et des métriques système.

​

Rembobiner un run

Rembobinez un run à partir d’une étape donnée et journalisez de nouvelles données à partir de ce point. Transmettez à la fois l’ID du run et l’étape à partir de laquelle vous souhaitez rembobiner en arguments du paramètre resume_from dans wandb.init(). Le paramètre resume_from accepte une chaîne au format <run ID>?_step=<step>, où <run ID> est l’ID du run du run que vous souhaitez rembobiner et <step> est l’étape à partir de laquelle vous souhaitez rembobiner.

Supposons que vous journalisiez une droite linéaire pendant 300 étapes :

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 ligne linéaire
        run.log({"metric": i, "step": i})

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

Plus tard, vous souhaitez rembobiner le run à partir de l’étape 200 et journaliser une nouvelle métrique appelée additional_metric, avec les valeurs i*1.1 de l’étape 200 à l’étape 300. À partir de l’étape 250, vous souhaitez journaliser à la place un nouveau motif ondulé subtil (i**2 + 2*sin(i/3)) plutôt qu’une ligne droite :

import math

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

# Rembobiner depuis le premier run à une étape spécifique et enregistrer 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, enregistrer la métrique telle quelle depuis le run
    # Après l'étape 250, commencer à enregistrer le motif ondulé
    for i in range(200, 300):
        if i < 250:
            run.log({"metric": i, "step": i})  # Continuer à enregistrer depuis le run sans ondulations
        else:
            # Introduire le comportement ondulé à partir de l'étape 250
            subtle_wave = i + (2 * math.sin(i / 3.0))  # Appliquer un motif légèrement ondulé
            run.log({"metric": subtle_wave, "step": i})
        # Enregistrer également la nouvelle métrique à toutes les étapes
        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 rembobinage :

• Le graphique en courbes affiche la ligne linéaire d’origine de l’étape 0 à l’étape 200, et un léger motif ondulé apparaît à 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.

​

Afficher un run archivé

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

1. Accédez à l’onglet Vue d’ensemble : Accédez à l’onglet Vue d’ensemble de 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 Vue d’ensemble, repérez le champ Forked From. Ce champ enregistre 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 comprendre tout l’historique du rembobinage.

En utilisant le champ Forked From, vous pouvez naviguer facilement dans l’arborescence des reprises archivées et mieux comprendre la séquence et l’origine de chaque rembobinage.

​

Créer un fork à partir d’un run que vous rembobinez

Pour créer un fork à partir d’un run rembobiné, utilisez l’argument fork_from dans wandb.init() et indiquez l’ID du run source ainsi que l’étape du run source à partir de laquelle créer le fork :

import wandb

# Forker le run à partir d'une étape spécifique
forked_run = wandb.init(
    project="<project>",
    entity="<entity>",
    fork_from=f"{rewind_run.id}?_step=500",
)

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