Runs

"""
Créer une expérience dans W&B. Si le projet n'existe pas, W&B le crée.

Notez que ce fichier initialise uniquement l'expérience ; vous pouvez ajouter du code pour consigner des métriques,
des Artifacts, etc., dans le bloc `with`.
"""
import wandb

# Initialiser un run W&B
with wandb.init(project="<project>") as run:
    # Le code de l'expérience va ici
    pass

"""Forker un run W&B existant à partir d'une étape spécifique."""

import wandb

# Initialiser un run à forker ultérieurement
with wandb.init(project="<project>", entity="<entity>") as original_run:
    # Le code d'entraînement et de journalisation va ici.
    pass

# Forker le run à partir d'une étape spécifique. Dans cet exemple, nous forkerons à partir de l'étape 200. Vous pouvez ajuster le numéro d'étape selon vos besoins.
with wandb.init(project="<project>",entity="<entity>", fork_from=f"{original_run.id}?_step=200") as forked_run:
    # Le code d'entraînement et de journalisation va ici.
    pass

"""
Initialise un run W&B.

W&B crée automatiquement le projet s'il n'existe pas. Notez que ce
fichier initialise uniquement l'expérience ; vous pouvez ajouter du code pour consigner des métriques,
des Artifacts, etc., dans le bloc `with`.
"""
import wandb

# Notez l'utilisation de l'instruction `with` pour garantir une bonne gestion des ressources.
with wandb.init(project="<project>") as run:
    # Le code d'entraînement et de logging va ici
    pass

"""
Définit le comportement de reprise d'un run s'il est mis en pause, s'arrête ou échoue.

Ceci est utile pour les expériences de longue durée susceptibles d'être interrompues. Voir
la documentation de référence de wandb.init(resume=) pour la liste de toutes les options de reprise.
"""
import wandb

# Initialise un run W&B avec le comportement de reprise
with wandb.init(project="<project>", resume="<resume_option>") as run:
    # Le code d'entraînement et de journalisation va ici
    pass

"""
Rembobiner un run pour modifier l'historique d'un run.

Spécifiez l'ID du run et l'étape vers laquelle rembobiner avec le paramètre `resume_from` dans `wandb.init()`.
"""
import wandb
import math

# Initialiser un run et journaliser des métriques
with wandb.init(project="<project>", entity="<entity>") as run:
    # Le code d'entraînement et de journalisation va ici
    pass

run_ID = "<run_id>" # Remplacer par l'ID du run original
step = int("<step>") # Spécifier l'étape vers laquelle rembobiner

# Démarrer un nouveau run qui reprend à partir de l'étape spécifiée du run original
with wandb.init(project="<project>", entity="<entity>", resume_from=f"{run_ID}?_step={step}") as run:
    # Le code d'entraînement et de journalisation va ici
    pass    

"""
Add one or more tags to a run.
"""
import wandb

with wandb.init(entity="<entity>", project="<project>", tags=["<tag1>", "<tag2>"]) as run:
    # Le code d'entraînement et de journalisation va ici
    pass

"""
Add one or more runs to a group.

Pass the name of your group as an argument to the `group` parameter when you
initialize a run with `wandb.init(group="")`.
"""
import wandb

entity = "<entity>"
project = "<project>"

# Le code suivant crée 3 groupes de runs, avec 3 runs dans chaque groupe. 
for group in ["<GroupA>", "<GroupB>", "<GroupC>"]: # Remplacez par les noms de groupes souhaités
    # Simulation de la création de trois runs pour chaque groupe.
    for i in range(3):
        with wandb.init(entity=entity, project=project, group=group, name=f"{group}_run_{i}") as run:
            # Le code d'entraînement et de journalisation va ici
            pass    

"""
Organisez les runs par type de job.

Ajoutez un type de job à un run en passant le paramètre `job_type` à `wandb.init(job_type="")`.
"""
import wandb

entity = "<entity>"
project = "<project>"

# Crée des runs et les organise par type de job.
for job_type in ["<JobType1>", "<JobType2>"]: # Remplacez par les noms de types de job
    # Simule la création de deux runs pour chaque type de job.
    for i in range(2):
        with wandb.init(entity=entity, project=project, job_type=job_type, name=f"{job_type}_run_{i}") as run:
            # Le code d'entraînement et de journalisation va ici
            pass    

"""
Add one or more tags to an active run.

A run object's `tags` property is a tuple. To add a new tag to an existing run,
update the `tags` property with a new tuple that includes the existing tags and the new tag(s).
"""

import wandb

with wandb.init(entity="<entity>", project="<project>", tags=["<tag1>", "<tag2>"]) as run:
    # Le code d'entraînement et de journalisation va ici

    # Ajouter un nouveau tag aux tags existants en créant un nouveau tuple qui inclut les tags existants et le nouveau tag.
    run.tags += ("<tag3>",)

"""
Ajouter un ou plusieurs tags à des runs précédemment sauvegardés.

Utilisez l'API publique pour mettre à jour les tags sur des données stockées après la fin du run ou
lorsque vous travaillez en dehors du processus de run.

Pour ajouter un nouveau tag à un run, mettez à jour la propriété "tags"
avec une nouvelle liste incluant les tags existants et le(s) nouveau(x) tag(s).
Le chemin du run est composé de entity/project/run_id.
Après avoir mis à jour les tags, appelez la méthode `update()` du run pour enregistrer les modifications.
"""
import wandb

entity = "<entity>"
project = "<project>"
run_id = "<run-id>"  # Remplacez par l'ID du run que vous souhaitez mettre à jour

# Le chemin est composé de entity/project/run_id
with wandb.Api().run(f"{entity}/{project}/{run_id}") as run:
  run.tags.append("<tag>")
  run.update()