Initialiser des runs

​

Un seul run par processus

import wandb

with wandb.init(entity="nico", project="awesome-project") as run:
    # Placez ici votre logique d’entraînement

🚀 View run exalted-darkness-6 at: 
https://wandb.ai/nico/awesome-project/runs/pgbn9y21
Find logs at: wandb/run-20241106_090747-pgbn9y21/logs

​

Plusieurs runs dans un même processus

• Créer des runs secondaires pour des évaluations ou des sous-tâches pendant qu’un run principal reste actif.
• Exécuter plusieurs sous-expériences à partir d’un seul script.
• Journaliser différentes tâches ou périodes dans des runs distincts depuis un même processus.

​

Options de reinit

​

Configurer reinit

• Utilisez wandb.init() en passant directement l’argument reinit :
  import wandb
  with wandb.init(reinit="<create_new|finish_previous|return_previous>") as run:
      # Votre code ici
  
• Utilisez wandb.init() et passez un objet wandb.Settings au paramètre settings. Spécifiez reinit dans l’objet Settings :
  import wandb
  with wandb.init(settings=wandb.Settings(reinit="<create_new|finish_previous|return_previous>")) as run:
      # Votre code ici
  
• Utilisez wandb.setup() pour définir l’option reinit de manière globale pour tous les runs du processus en cours. Cette approche est utile si vous souhaitez configurer le comportement une seule fois et l’appliquer à tous les appels wandb.init() suivants dans ce processus.
  import wandb
  with wandb.setup(wandb.Settings(reinit="<create_new|finish_previous|return_previous>")) as run:
       # Votre code ici
  
• Spécifiez la valeur souhaitée pour reinit dans la variable d’environnement WANDB_REINIT. Une fois la variable d’environnement définie, l’option reinit s’applique aux appels wandb.init().
  export WANDB_REINIT="<create_new|finish_previous|return_previous>"
  

import wandb

wandb.setup(wandb.Settings(reinit="create_new"))

with wandb.init() as experiment_results_run:
    # Ce run sert à journaliser les résultats de chaque expérience.
    # Considérez-le comme un run parent qui regroupe les résultats
      with wandb.init() as run:
         # La fonction do_experiment() journalise des métriques détaillées
         # dans le run fourni et renvoie les métriques de résultat que
         # vous souhaitez suivre séparément.
         experiment_results = do_experiment(run)

         # Après chaque expérience, journalisez ses résultats dans un run
         # parent. Chaque point des graphiques du run parent correspond
         # aux résultats d’une expérience.
         experiment_results_run.log(experiment_results)

​

Exemple : processus simultanés

1. Initialisez le processus principal Run A avec wandb.init() et journalisez les métriques d’entraînement.
2. Initialisez Run B1 (avec wandb.init()), journalisez des données, puis terminez-le.
3. Journalisez d’autres données dans Run A.
4. Initialisez Run B2, journalisez des données, puis terminez-le.
5. Continuez à journaliser dans Run A.
6. Pour finir, terminez Run A.

import wandb

def train(name: str) -> None:
    """Perform one training iteration in its own W&B run.

    Using a 'with wandb.init()' block with `reinit="create_new"` ensures that
    this training sub-run can be created even if another run (like our primary
    tracking run) is already active.
    """
    with wandb.init(
        project="my_project",
        name=name,
        reinit="create_new"
    ) as run:
        # Dans un vrai script, exécutez vos étapes d’entraînement dans ce bloc.
        run.log({"train_loss": 0.42})  # Remplacez par vos propres métriques

def evaluate_loss_accuracy() -> (float, float):
    """Returns the current model's loss and accuracy.
    
    Replace this placeholder with your real evaluation logic.
    """
    return 0.27, 0.91  # Valeurs de métriques d’exemple

# Créer un run « principal » qui reste actif sur plusieurs étapes d’entraînement et d’évaluation.
with wandb.init(
    project="my_project",
    name="tracking_run",
    reinit="create_new"
) as tracking_run:
    # 1) Premier entraînement dans un sous-run nommé 'training_1'
    train("training_1")
    loss, accuracy = evaluate_loss_accuracy()
    tracking_run.log({"eval_loss": loss, "eval_accuracy": accuracy})

    # 2) Nouvel entraînement dans un sous-run nommé 'training_2'
    train("training_2")
    loss, accuracy = evaluate_loss_accuracy()
    tracking_run.log({"eval_loss": loss, "eval_accuracy": accuracy})
    
    # Le run 'tracking_run' se termine automatiquement à la sortie de ce bloc 'with'.

1. reinit="create_new" crée un nouveau run chaque fois que vous appelez wandb.init().
2. Vous conservez une référence à chaque run. wandb.run ne pointe pas automatiquement vers le nouveau run créé avec reinit="create_new". Stockez les nouveaux runs dans des variables telles que run_a, run_b1, etc., puis appelez .log() ou .finish() sur ces objets si nécessaire.
3. Vous pouvez terminer les sous-runs à tout moment tout en gardant le run principal ouvert jusqu’à.
4. Terminez vos runs avec run.finish() lorsque vous avez fini d’y journaliser des données. Vous avez ainsi la garantie que toutes les données sont téléversées et que le run est correctement fermé.