Passer au contenu principal

​
class Run

Une unité de calcul enregistrée par W&B. Il s’agit généralement d’une expérience de machine learning. Appelez wandb.init() pour créer un nouveau run. wandb.init() démarre un nouveau run et renvoie un objet wandb.Run. Chaque run est associé à un ID unique (ID du run). W&B recommande d’utiliser un gestionnaire de contexte (instruction with) pour terminer automatiquement le run. Pour les expériences d’entraînement distribué, vous pouvez soit suivre chaque processus séparément avec un run par processus, soit suivre tous les processus dans un run unique. Voir Log distributed training experiments pour plus d’informations. Vous pouvez enregistrer des données dans un run avec wandb.Run.log(). Tout ce que vous enregistrez avec wandb.Run.log() est envoyé à ce run. Voir Create an experiment ou la page de référence de l’API wandb.init pour plus d’informations. Il existe un autre objet Run dans l’espace de noms wandb.apis.public. Utilisez cet objet pour interagir avec des runs déjà créés. Attributs :
  • summary: (Summary) Résumé du run, sous la forme d’un objet de type dictionnaire. Pour plus d’informations, voir
  • [Log summary metrics](https: //docs.wandb.ai/guides/track/log/log-summary/).
Exemples : Créez un run avec wandb.init() : 
import wandb

# Démarrer un nouveau run et journaliser des données
# Utiliser le gestionnaire de contexte (instruction `with`) pour terminer automatiquement le run
with wandb.init(entity="entity", project="project") as run:
    run.log({"accuracy": acc, "loss": loss})

​
propriété Run.config

Objet de configuration associé à ce run. Retourne :
  • wandb_config.Config : La valeur de propriété config.

​
propriété Run.config_static

Objet de configuration statique associé à ce run. Retourne :
  • wandb_config.ConfigStatic : La valeur de propriété config_static.

​
propriété Run.dir

Répertoire dans lequel sont enregistrés les fichiers associés au run. Retourne :
  • str : La valeur de propriété dir.

​
propriété Run.disabled

Vrai si le run est désactivé, faux sinon. Retourne :
  • bool : La valeur de propriété disabled.

​
propriété Run.entity

Le nom de l’entité W&B associée au run. L’entité peut correspondre à un nom d’utilisateur ou au nom d’une équipe ou d’une organisation. Retourne :
  • str : La valeur de propriété entité.

​
propriété Run.group

Renvoie le nom du groupe associé à ce run. Le regroupement de runs permet d’organiser et de visualiser ensemble des expériences liées dans l’UI W&B. Cela est particulièrement utile dans des cas comme l’entraînement distribué ou la validation croisée, où plusieurs runs doivent être affichés et gérés comme une expérience unique. En mode partagé, où tous les processus partagent le même objet run, définir un groupe est généralement inutile, puisqu’il n’y a qu’un seul run et qu’aucun regroupement n’est nécessaire. Retourne :
  • str : La valeur de propriété group.

​
propriété Run.id

L’identifiant de ce run. Retourne :
  • str : La valeur de propriété id.

​
propriété Run.job_type

Nom du type de job associé au run. Vous pouvez voir le type de job d’un run sur la page Aperçu du run dans la W&B App. Vous pouvez l’utiliser pour classer les runs par type de job, par exemple « entraînement », « évaluation » ou « inférence ». C’est utile pour organiser et filtrer les runs dans l’interface W&B, en particulier lorsque vous avez plusieurs runs avec différents types de job dans le même projet. Pour plus d’informations, voir Organiser les runs. Retourne :
  • str : La valeur de propriété job_type.

​
propriété Run.name

Nom d’affichage du run. Les noms d’affichage ne sont pas nécessairement uniques et peuvent être descriptifs. Par défaut, ils sont générés aléatoirement. Retourne :
  • str | None: La valeur de propriété name.

​
propriété Run.notes

Notes associées au run, s’il y en a. Les notes peuvent être une chaîne multilignes et utiliser également du Markdown ainsi que des équations LaTeX entre $$, par exemple $x + 3$. Retourne :
  • str | None: La valeur de propriété notes.

​
propriété Run.offline

True si le run est hors ligne, False sinon. Retourne :
  • bool : La valeur de propriété offline.

​
propriété Run.path

Chemin du run. Les chemins de run incluent l’entité, le projet et l’ID du run, au format entity/project/run_id. Retourne :
  • str : La valeur de la propriété path.

​
propriété Run.project

Nom du projet W&B associé au run. Retourne :
  • str : La valeur de propriété du projet.

​
propriété Run.project_url

URL du projet W&B associé au run, le cas échéant. Les runs hors ligne n’ont pas d’URL de projet. Retourne :
  • str | None : La valeur de propriété project_url.

​
propriété Run.resumed

Vrai si le run a été repris, Faux sinon. Retourne :
  • bool : La valeur de propriété resumed.

​
propriété Run.settings

Une copie immuable de l’objet Settings du run. Retourne :
  • Settings : La valeur de propriété settings.

​
propriété Run.start_time

Horodatage Unix (en secondes) indiquant quand le run a démarré. Retourne :
  • float : La valeur de propriété start_time.

​
propriété Run.sweep_id

Identifiant du balayage associé au run, le cas échéant. Retourne :
  • str | None: La valeur de propriété sweep_id.

​
propriété Run.sweep_url

URL du balayage associé au run, le cas échéant. Les runs hors ligne n’ont pas d’URL de balayage. Retourne :
  • str | None : La valeur de propriété sweep_url.

​
propriété Run.tags

Les tags associés au run, le cas échéant. Retourne :
  • tuple | None : La valeur de propriété tags.

​
propriété Run.url

L’URL du run W&B, s’il en existe une. Les runs hors ligne n’ont pas d’URL. Retourne :
  • str | None: La valeur de la propriété url.

​
méthode Run.alert

alert(
    title: 'str',
    text: 'str',
    level: 'str | AlertLevel | None' = None,
    wait_duration: 'int | float | timedelta | None' = None
) → None
Crée une alerte avec le titre et le texte indiqués. Arguments :
  • title : Le titre de l’alerte ; il doit comporter moins de 64 caractères.
  • text : Le corps de l’alerte.
  • level : Le niveau d’alerte à utiliser, parmi : INFO, WARN ou ERROR.
  • wait_duration : Le délai d’attente (en secondes) avant d’envoyer une autre alerte avec ce titre.

​
méthode Run.define_metric

define_metric(
    name: 'str',
    step_metric: 'str | wandb_metric.Metric | None' = None,
    step_sync: 'bool | None' = None,
    hidden: 'bool | None' = None,
    summary: 'str | None' = None,
    goal: 'str | None' = None,
    overwrite: 'bool | None' = None
) → wandb_metric.Metric
Personnalisez les métriques enregistrées avec wandb.Run.log(). Arguments :
  • name: Le nom de la métrique à personnaliser.
  • step_metric: Le nom d’une autre métrique qui servira d’axe X pour cette métrique dans les graphiques générés automatiquement.
  • step_sync: Insère automatiquement la dernière valeur de step_metric dans wandb.Run.log() si elle n’est pas fournie explicitement. La valeur par défaut est True si step_metric est spécifiée.
  • hidden: Masque cette métrique dans les graphiques générés automatiquement.
  • summary: Spécifie les métriques agrégées ajoutées à summary. Les agrégations prises en charge incluent “min”, “max”, “mean”, “last”, “first”, “best”, “copy” et “none”. “none” empêche la génération d’un summary. “best” est utilisé avec le paramètre goal, mais “best” est obsolète et ne doit pas être utilisé ; utilisez “min” ou “max” à la place. “copy” est obsolète et ne doit pas être utilisé.
  • goal: Spécifie comment interpréter le type de summary “best”. Les options prises en charge sont “minimize” et “maximize”. “goal” est obsolète et ne doit pas être utilisé ; utilisez “min” ou “max” à la place.
  • overwrite: Si false, cet appel est fusionné avec les appels précédents à define_metric pour la même métrique en utilisant leurs valeurs pour tous les paramètres non spécifiés. Si true, les paramètres non spécifiés remplacent les valeurs définies par les appels précédents.
Retourne : Un objet qui représente cet appel, mais qui peut autrement être ignoré.

​
méthode Run.display

display(height: 'int' = 420, hidden: 'bool' = False) → bool
Affiche ce run dans Jupyter.

​
méthode Run.finish

finish(exit_code: 'int | None' = None, quiet: 'bool | None' = None) → None
Terminez un run et envoyez toutes les données restantes. Marque la fin d’un run W&B et garantit que toutes les données sont synchronisées avec le serveur. L’état final du run est déterminé par ses conditions de sortie et son statut de synchronisation. Run States:
  • Running : run actif qui journalise des données et/ou envoie des signaux de pulsation.
  • Crashed : run qui a cessé d’envoyer des signaux de pulsation de façon inattendue.
  • Finished : run terminé avec succès (exit_code=0) et dont toutes les données sont synchronisées.
  • Failed : run terminé avec des erreurs (exit_code!=0).
  • Killed : run arrêté de force avant d’avoir pu se terminer.
Arguments :
  • exit_code : Entier indiquant le statut de sortie du run. Utilisez 0 pour signaler une réussite ; toute autre valeur marque le run comme échoué.
  • quiet : Obsolète. Configurez la verbosité du logging avec wandb.Settings(quiet=...).

​
méthode Run.finish_artifact

finish_artifact(
    artifact_or_path: 'Artifact | str',
    name: 'str | None' = None,
    type: 'str | None' = None,
    aliases: 'list[str] | None' = None,
    distributed_id: 'str | None' = None
) → Artifact
Finalise un artifact non finalisé comme sortie d’un run. Les “upserts” ultérieurs avec le même ID distribué créeront une nouvelle version. Arguments :
  • artifact_or_path: Chemin vers le contenu de cet artifact, pouvant prendre les formes suivantes :
    • /local/directory
    • /local/directory/file.txt
    • s3://bucket/path Vous pouvez également passer un objet Artifact créé en appelant wandb.Artifact.
  • name: Nom d’un artifact. Peut être préfixé par entité/projet. Les noms valides peuvent prendre les formes suivantes :
    • name:version
    • name:alias
    • digest S’il n’est pas spécifié, la valeur par défaut sera le nom de base du chemin, précédé de l’ID du run actuel.
  • type: Le type d’artifact à journaliser, par exemple dataset, model
  • aliases: Alias à appliquer à cet artifact, valeurs par défaut : ["latest"]
  • distributed_id: Chaîne unique partagée par tous les jobs distribués. Si None, la valeur par défaut est le nom du groupe du run.
Retourne : Un objet Artifact. 
link_artifact(
    artifact: 'Artifact',
    target_path: 'str',
    aliases: 'list[str] | None' = None
) → Artifact
Liez l’artifact à une collection. Le terme « link » désigne des pointeurs qui relient l’emplacement où W&B stocke l’artifact à celui où l’artifact est accessible dans le registre. W&B ne duplique pas les artifacts lorsque vous liez un artifact à une collection. Affichez les artifacts liés dans l’interface utilisateur du registre pour la collection spécifiée. Arguments :
  • artifact: L’objet artifact à lier à la collection.
  • target_path: Le chemin de la collection. Il se compose du préfixe “wandb-registry-”, ainsi que du nom du registre et du nom de la collection : wandb-registry-{REGISTRY_NAME}/{COLLECTION_NAME}.
  • aliases: Ajoutez un ou plusieurs alias à l’artifact lié. L’alias “latest” est automatiquement appliqué à l’artifact le plus récent que vous liez.
Retourne : L’artifact lié. 
link_model(
    path: 'StrPath',
    registered_model_name: 'str',
    name: 'str | None' = None,
    aliases: 'list[str] | None' = None
) → Artifact | None
Enregistrer une version d’un artifact de modèle et la lier à un modèle enregistré dans le registre de modèles. Les versions de modèle liées sont visibles dans l’UI pour le modèle enregistré spécifié. Cette méthode :
  • Vérifie si l’artifact de modèle ‘name’ a été enregistré. Si c’est le cas, utilise la version de l’artifact correspondant aux fichiers situés à ‘path’ ou enregistre une nouvelle version. Sinon, elle enregistre les fichiers sous ‘path’ en tant que nouvel artifact de modèle, ‘name’, de type ‘model’.
  • Vérifie si un modèle enregistré nommé ‘registered_model_name’ existe dans le projet ‘model-registry’. Sinon, crée un nouveau modèle enregistré nommé ‘registered_model_name’.
  • Lie la version de l’artifact de modèle ‘name’ au modèle enregistré ‘registered_model_name’.
  • Attache les alias de la liste ‘aliases’ à la version de l’artifact de modèle nouvellement liée.
Arguments :
  • path: (str) Chemin vers le contenu de ce modèle, pouvant prendre les formes suivantes :
    • /local/directory
    • /local/directory/file.txt
    • s3://bucket/path
  • registered_model_name: Nom du modèle enregistré auquel lier le modèle. Un modèle enregistré est une collection de versions de modèle liées au registre de modèles, représentant généralement une tâche de ML propre à une équipe. L’entité à laquelle ce modèle enregistré appartient est dérivée du run.
  • name: Nom de l’artifact de modèle dans lequel les fichiers de ‘path’ seront enregistrés. Par défaut, il s’agit du nom de base du chemin, précédé de l’ID du run actuel, s’il n’est pas spécifié.
  • aliases: Alias appliqués uniquement à cet artifact lié dans le modèle enregistré. L’alias “latest” est toujours appliqué à la version la plus récente d’un artifact lié.
Exceptions levées :
  • AssertionError: Si registered_model_name est un chemin ou si l’artifact de modèle ‘name’ est d’un type ne contenant pas la sous-chaîne ‘model’.
  • ValueError: Si name contient des caractères spéciaux non valides.
Retourne : L’artifact lié si la liaison a réussi, sinon None.

​
méthode Run.log

log(
    data: 'dict[str, Any]',
    step: 'int | None' = None,
    commit: 'bool | None' = None
) → None
Importez les données d’un run. Utilisez log pour journaliser les données des runs, comme des scalaires, des images, des vidéos, des histogrammes, des graphiques et des tableaux. Voir Journaliser des objets et des médias pour des extraits de code, des bonnes pratiques et plus encore. Utilisation de base : 
import wandb

with wandb.init() as run:
     run.log({"train-loss": 0.5, "accuracy": 0.9})
L’extrait de code précédent enregistre la perte et la précision dans l’historique du run, et met à jour les valeurs du summary pour ces métriques. Visualisez les données enregistrées dans un Workspace sur wandb.ai, ou localement sur une instance auto-hébergée de l’application W&B, ou exportez les données pour les visualiser et les explorer en local, par exemple dans un notebook Jupyter, avec l’API publique. Les valeurs enregistrées n’ont pas besoin d’être des scalaires. Vous pouvez enregistrer n’importe quel type de données pris en charge par W&B, comme des images, de l’audio, de la vidéo, etc. Par exemple, vous pouvez utiliser wandb.Table pour enregistrer des données structurées. Voir le tutoriel Enregistrer des tableaux, visualiser et interroger des données pour plus de détails. W&B organise les métriques dont le nom contient une barre oblique (/) en sections nommées d’après le texte qui précède la dernière barre oblique. Par exemple, ce qui suit produit deux sections nommées “train” et “validate” : 
with wandb.init() as run:
     # Consigner des métriques dans la section "train".
     run.log(
         {
             "train/accuracy": 0.9,
             "train/loss": 30,
             "validate/accuracy": 0.8,
             "validate/loss": 20,
         }
     )
Un seul niveau d’imbrication est pris en charge ; run.log({"a/b/c": 1}) crée une section nommée “a”. run.log() n’est pas conçu pour être appelé plus de quelques fois par seconde. Pour des performances optimales, limitez la journalisation à une fois toutes les N itérations, ou accumulez les données sur plusieurs itérations et consignez-les en une seule étape. Par défaut, chaque appel à log crée une nouvelle “étape”. L’étape doit toujours être croissante, et il n’est pas possible de journaliser dans une étape précédente. Vous pouvez utiliser n’importe quelle métrique comme axe X dans les graphiques. Voir Axes de journalisation personnalisés pour plus de détails. Dans de nombreux cas, il est préférable de considérer l’étape W&B comme un horodatage plutôt que comme une étape d’entraînement. 
with wandb.init() as run:
     # Exemple : journaliser une métrique "epoch" à utiliser comme axe X.
     run.log({"epoch": 40, "train-loss": 0.5})
Il est possible d’utiliser plusieurs appels à wandb.Run.log() pour journaliser sur la même étape grâce aux paramètres step et commit. Les opérations suivantes sont toutes équivalentes : 
with wandb.init() as run:
     # Utilisation normale :
     run.log({"train-loss": 0.5, "accuracy": 0.8})
     run.log({"train-loss": 0.4, "accuracy": 0.9})

     # Étape implicite sans auto-incrémentation :
     run.log({"train-loss": 0.5}, commit=False)
     run.log({"accuracy": 0.8})
     run.log({"train-loss": 0.4}, commit=False)
     run.log({"accuracy": 0.9})

     # Étape explicite :
     run.log({"train-loss": 0.5}, step=current_step)
     run.log({"accuracy": 0.8}, step=current_step)
     current_step += 1
     run.log({"train-loss": 0.4}, step=current_step)
     run.log({"accuracy": 0.9}, step=current_step, commit=True)
Arguments :
  • data : Un dict avec des clés str et des valeurs sérialisables
  • Objets Python, notamment : int, float et string ; n’importe lequel des wandb.data_types ; des listes, tuples et tableaux NumPy d’objets Python sérialisables ; d’autres dict de même structure.
  • step : Le numéro d’étape à consigner. Si None, une étape implicite auto-incrémentée est utilisée. Voir les notes dans la description.
  • commit : Si true, finalise et téléverse l’étape. Si false, les données de l’étape sont alors accumulées. Voir les notes dans la description. Si step est None, la valeur par défaut est commit=True ; sinon, la valeur par défaut est commit=False.
Exemples : Pour des exemples supplémentaires et plus détaillés, voir nos guides sur le logging. Utilisation de base 
import wandb

with wandb.init() as run:
    run.log({"train-loss": 0.5, "accuracy": 0.9
Journalisation incrémentale 
import wandb

with wandb.init() as run:
    run.log({"loss": 0.2}, commit=False)
    # Ailleurs, quand je suis prêt à journaliser cette étape :
    run.log({"accuracy": 0.8})
Histogramme 
import numpy as np
import wandb

# échantillonner des gradients aléatoirement à partir d'une distribution normale
gradients = np.random.randn(100, 100)
with wandb.init() as run:
    run.log({"gradients": wandb.Histogram(gradients)})
Image provenant de NumPy 
import numpy as np
import wandb

with wandb.init() as run:
    examples = []
    for i in range(3):
         pixels = np.random.randint(low=0, high=256, size=(100, 100, 3))
         image = wandb.Image(pixels, caption=f"random field {i}")
         examples.append(image)
    run.log({"examples": examples})
Image PIL 
import numpy as np
from PIL import Image as PILImage
import wandb

with wandb.init() as run:
    examples = []
    for i in range(3):
         pixels = np.random.randint(
             low=0,
             high=256,
             size=(100, 100, 3),
             dtype=np.uint8,
         )
         pil_image = PILImage.fromarray(pixels, mode="RGB")
         image = wandb.Image(pil_image, caption=f"random field {i}")
         examples.append(image)
    run.log({"examples": examples})
Vidéo à partir de NumPy 
import numpy as np
import wandb

with wandb.init() as run:
    # les axes sont (temps, canal, hauteur, largeur)
    frames = np.random.randint(
         low=0,
         high=256,
         size=(10, 3, 100, 100),
         dtype=np.uint8,
    )
    run.log({"video": wandb.Video(frames, fps=4)})
Graphique Matplotlib 
from matplotlib import pyplot as plt
import numpy as np
import wandb

with wandb.init() as run:
    fig, ax = plt.subplots()
    x = np.linspace(0, 10)
    y = x * x
    ax.plot(x, y)  # tracé y = x^2
    run.log({"chart": fig})
Courbe PR 
import wandb

with wandb.init() as run:
    run.log({"pr": wandb.plot.pr_curve(y_test, y_probas, labels)})
Objet 3D 
import wandb

with wandb.init() as run:
    run.log(
         {
             "generated_samples": [
                 wandb.Object3D(open("sample.obj")),
                 wandb.Object3D(open("sample.gltf")),
                 wandb.Object3D(open("sample.glb")),
             ]
         }
    )
Exceptions levées :
  • wandb.Error : Si cette méthode est appelée avant wandb.init().
  • ValueError : Si des données invalides sont transmises.

​
méthode Run.log_artifact

log_artifact(
    artifact_or_path: 'Artifact | StrPath',
    name: 'str | None' = None,
    type: 'str | None' = None,
    aliases: 'list[str] | None' = None,
    tags: 'list[str] | None' = None
) → Artifact
Déclare un artifact comme sortie d’un run. Arguments :
  • artifact_or_path: (str ou Artifact) Chemin vers le contenu de cet artifact, sous l’une des formes suivantes :
    • /local/directory
    • /local/directory/file.txt
    • s3://bucket/path Vous pouvez également transmettre un objet Artifact créé en appelant wandb.Artifact.
  • name: (str, facultatif) Nom d’artifact. Les noms valides peuvent prendre les formes suivantes :
    • name:version
    • name:alias
    • digest Si ce paramètre n’est pas spécifié, la valeur par défaut est le nom de base du chemin, préfixé par l’ID du run actuel.
  • type: (str) Type d’artifact à enregistrer, par exemple dataset, model
  • aliases: (list, facultatif) Alias à appliquer à cet artifact. La valeur par défaut est ["latest"]
  • tags: (list, facultatif) Tags à appliquer à cet artifact, le cas échéant.
Retourne : Un objet Artifact.

​
méthode Run.log_code

log_code(
    root: 'str | None' = '.',
    name: 'str | None' = None,
    include_fn: 'Callable[[str, str], bool] | Callable[[str], bool]' = <function _is_py_requirements_or_dockerfile at 0x10998dda0>,
    exclude_fn: 'Callable[[str, str], bool] | Callable[[str], bool]' = <function exclude_wandb_fn at 0x10b11bb00>
) → Artifact | None
Enregistre l’état actuel de votre code dans un Artifact W&B. Par défaut, la méthode parcourt le répertoire courant et consigne tous les fichiers dont le nom se termine par .py. Arguments :
  • root: Le chemin relatif (par rapport à os.getcwd()) ou absolu à partir duquel rechercher le code de manière récursive.
  • name: (str, facultatif) Le nom de notre artifact de code. Par défaut, l’artifact sera nommé source-$PROJECT_ID-$ENTRYPOINT_RELPATH. Dans certains cas, vous pouvez vouloir que plusieurs runs partagent le même artifact. Spécifier un nom vous permet de le faire.
  • include_fn: Une fonction qui accepte un chemin de fichier et, éventuellement, un chemin racine, puis renvoie True s’il doit être inclus et False sinon. Par défaut, c’est
  • defaults to lambda path, root: path.endswith(".py").
  • exclude_fn: Une fonction qui accepte un chemin de fichier et, éventuellement, un chemin racine, puis renvoie True s’il doit être exclu et False sinon. Par défaut, une fonction exclut tous les fichiers des répertoires <root>/.wandb/ et <root>/wandb/.
Exemples : Utilisation de base 
import wandb

with wandb.init() as run:
    run.log_code()
Utilisation avancée 
import wandb

with wandb.init() as run:
    run.log_code(
         root="../",
         include_fn=lambda path: path.endswith(".py") or path.endswith(".ipynb"),
         exclude_fn=lambda path, root: os.path.relpath(path, root).startswith(
             "cache/"
         ),
    )
Retourne : Un objet Artifact si du code a été enregistré

​
méthode Run.log_model

log_model(
    path: 'StrPath',
    name: 'str | None' = None,
    aliases: 'list[str] | None' = None
) → None
Journalise un artifact de modèle contenant le contenu du ‘path’ dans un run et le marque comme sortie de ce run. Le nom de l’artifact de modèle ne peut contenir que des caractères alphanumériques, des traits de soulignement et des traits d’union. Arguments :
  • path: (str) Chemin vers le contenu de ce modèle, pouvant prendre les formes suivantes :
    • /local/directory
    • /local/directory/file.txt
    • s3://bucket/path
  • name: Nom à attribuer à l’artifact de modèle auquel le contenu du fichier sera ajouté. Par défaut, il s’agit du nom de base du chemin, précédé de l’ID du run actuel, s’il n’est pas spécifié.
  • aliases: Alias à appliquer à l’artifact de modèle créé, avec ["latest"] comme valeur par défaut
Exceptions levées :
  • ValueError: Si name contient des caractères spéciaux non valides.
Retourne : None

​
méthode Run.mark_preempting

mark_preempting() → None
Marquez cette run comme préemptée. Indique également au processus interne de le signaler immédiatement au serveur.

​
méthode Run.restore

restore(
    name: 'str',
    run_path: 'str | None' = None,
    replace: 'bool' = False,
    root: 'str | None' = None
) → None | TextIO
Télécharge le fichier spécifié depuis le stockage cloud. Le fichier est placé dans le répertoire courant ou dans le répertoire du run. Par défaut, il n’est téléchargé que s’il n’existe pas déjà. Arguments :
  • name: Le nom du fichier.
  • run_path: Chemin facultatif vers un run à partir duquel récupérer des fichiers, c.-à-d. username/project_name/run_id si wandb.init n’a pas été appelé, ce paramètre est requis.
  • replace: Indique s’il faut télécharger le fichier même s’il existe déjà localement
  • root: Le répertoire dans lequel télécharger le fichier. Valeur par défaut : le répertoire courant, ou le répertoire du run si wandb.init a été appelé.
Retourne : None s’il est impossible de trouver le fichier, sinon un objet fichier ouvert en lecture. Exceptions levées :
  • CommError: Si W&B ne peut pas se connecter au backend W&B.
  • ValueError: Si le fichier est introuvable ou si run_path est introuvable.

​
méthode Run.save

save(
    glob_str: 'str | os.PathLike',
    base_path: 'str | os.PathLike | None' = None,
    policy: 'PolicyName' = 'live'
) → bool | list[str]
Synchronisez un ou plusieurs fichiers dans W&B. Les chemins relatifs sont interprétés par rapport au répertoire de travail actuel. Un glob Unix, tel que “myfiles/*”, est développé au moment de l’appel à save, quelle que soit la valeur de policy. En particulier, les nouveaux fichiers ne sont pas ajoutés automatiquement. Vous pouvez fournir un base_path pour contrôler la structure de répertoires des fichiers téléversés. Il doit être un préfixe de glob_str, et la structure de répertoires située en dessous est conservée. Lorsqu’un chemin absolu ou un glob est fourni sans base_path, un niveau de répertoire est conservé, comme dans l’exemple ci-dessus. Les fichiers sont automatiquement dédupliqués : appeler save() plusieurs fois sur le même fichier sans le modifier ne le téléverse pas à nouveau. Arguments :
  • glob_str : Un chemin relatif ou absolu, ou un glob Unix.
  • base_path : Un chemin utilisé pour déduire une structure de répertoires ; voir les exemples.
  • policy : L’une des valeurs live, now ou end.
    • live: téléverser le fichier à mesure qu’il change, en remplaçant la version précédente
    • now: téléverser le fichier une seule fois, immédiatement
    • end: téléverser le fichier à la fin du run
Retourne : Les chemins des liens symboliques créés pour les fichiers correspondants. Pour des raisons historiques, cette méthode peut renvoyer un booléen dans du code hérité. 
import wandb

run = wandb.init()

run.save("these/are/myfiles/*")
# => Enregistre les fichiers dans un dossier "these/are/myfiles/" dans le run.

run.save("these/are/myfiles/*", base_path="these")
# => Enregistre les fichiers dans un dossier "are/myfiles/" dans le run.

run.save("/Users/username/Documents/run123/*.txt")
# => Enregistre les fichiers dans un dossier "run123/" dans le run. Voir la note ci-dessous.

run.save("/Users/username/Documents/run123/*.txt", base_path="/Users")
# => Enregistre les fichiers dans un dossier "username/Documents/run123/" dans le run.

run.save("files/*/saveme.txt")
# => Enregistre chaque fichier "saveme.txt" dans un sous-répertoire approprié
#    de "files/".

# Terminer explicitement le run car aucun gestionnaire de contexte n'est utilisé.
run.finish()

​
méthode Run.status

status() → RunStatus
Obtenir les informations de synchronisation du run actuel depuis le backend interne.

​
méthode Run.unwatch

unwatch(
    models: 'torch.nn.Module | Sequence[torch.nn.Module] | None' = None
) → None
Supprime la topologie du modèle PyTorch ainsi que les hooks de gradient et de paramètres. Arguments :
  • models : liste facultative de modèles PyTorch sur lesquels watch a été appelé.

​
méthode Run.upsert_artifact

upsert_artifact(
    artifact_or_path: 'Artifact | str',
    name: 'str | None' = None,
    type: 'str | None' = None,
    aliases: 'list[str] | None' = None,
    distributed_id: 'str | None' = None
) → Artifact
Déclarez (ou ajoutez à) un artifact non finalisé comme sortie d’un run. Notez que vous devez appeler run.finish_artifact() pour finaliser l’artifact. Cela est utile lorsque plusieurs jobs distribués doivent tous contribuer au même artifact. Arguments :
  • artifact_or_path: Chemin vers le contenu de cet artifact. Il peut prendre les formes suivantes :
    • /local/directory
    • /local/directory/file.txt
    • s3://bucket/path
  • name: Nom d’artifact. Peut être préfixé par “entité/projet”. Par défaut, s’il n’est pas spécifié, il correspond au nom de base du chemin, précédé du current run ID. Les noms valides peuvent prendre les formes suivantes :
    • name:version
    • name:alias
    • digest
  • type: Type d’artifact à journaliser. Exemples courants : dataset, model.
  • aliases: Alias à appliquer à cet artifact. La valeur par défaut est ["latest"].
  • distributed_id: Chaîne unique partagée par tous les jobs distribués. Si None, la valeur par défaut est le nom du groupe du run.
Retourne : Un objet Artifact.

​
méthode Run.use_artifact

use_artifact(
    artifact_or_name: 'str | Artifact',
    type: 'str | None' = None,
    aliases: 'list[str] | None' = None,
    use_as: 'str | None' = None
) → Artifact
Déclare un artifact comme entrée d’un run. Appelez download ou file sur l’objet renvoyé pour récupérer son contenu en local. Arguments :
  • artifact_or_name: Le nom de l’artifact à utiliser. Il peut être préfixé par le nom du projet dans lequel l’artifact a été enregistré (“entité” ou “entité/projet”). Si aucune entité n’est spécifiée dans le nom, l’entité du Run ou de la configuration de l’API est utilisée. Les noms valides peuvent prendre les formes suivantes
    • nom:version
    • nom:alias
  • type: Le type d’artifact à utiliser.
  • aliases: Alias à appliquer à cet artifact
  • use_as: Cet argument est obsolète et n’a aucun effet.
Retourne : Un objet Artifact. Exemples : 
import wandb

run = wandb.init(project="<example>")

# Utiliser un artifact par nom et alias
artifact_a = run.use_artifact(artifact_or_name="<name>:<alias>")

# Utiliser un artifact par nom et version
artifact_b = run.use_artifact(artifact_or_name="<name>:v<version>")

# Utiliser un artifact par entité/projet/nom:alias
artifact_c = run.use_artifact(
    artifact_or_name="<entity>/<project>/<name>:<alias>"
)

# Utiliser un artifact par entité/projet/nom:version
artifact_d = run.use_artifact(
    artifact_or_name="<entity>/<project>/<name>:v<version>"
)

# Terminer explicitement le run car aucun gestionnaire de contexte n'est utilisé.
run.finish()

​
méthode Run.use_model

use_model(name: 'str') → FilePathStr
Télécharge les fichiers enregistrés dans un artifact de modèle name. Arguments :
  • name : nom d’un artifact de modèle. name doit correspondre au nom d’un artifact de modèle existant déjà enregistré. Peut être préfixé par entity/project/. Les noms valides peuvent prendre les formes suivantes
    • model_artifact_name:version
    • model_artifact_name:alias
Retourne :
  • path (str) : chemin d’accès au(x) fichier(s) de l’artifact de modèle téléchargé(s).
Exceptions levées :
  • AssertionError : si l’artifact de modèle name est d’un type qui ne contient pas la sous-chaîne model.

​
méthode Run.watch

watch(
    models: 'torch.nn.Module | Sequence[torch.nn.Module]',
    criterion: 'torch.F | None' = None,
    log: "Literal['gradients', 'parameters', 'all'] | None" = 'gradients',
    log_freq: 'int' = 1000,
    idx: 'int | None' = None,
    log_graph: 'bool' = False
) → None
Ajoutez un hook au modèle PyTorch donné pour surveiller les gradients et le graphe de calcul du modèle. Cette fonction peut suivre les paramètres, les gradients, ou les deux pendant l’entraînement. Arguments :
  • models: Un seul modèle ou une séquence de modèles à surveiller.
  • criterion: La fonction de perte en cours d’optimisation (facultatif).
  • log: Indique s’il faut journaliser “gradients”, “parameters” ou “all”. Définissez cette valeur sur None pour désactiver la journalisation. (par défaut=“gradients”).
  • log_freq: Fréquence (en lots) à laquelle journaliser les gradients et les paramètres. (par défaut=1000)
  • idx: Indice utilisé lors du suivi de plusieurs modèles avec wandb.watch. (par défaut=None)
  • log_graph: Indique s’il faut journaliser le graphe de calcul du modèle. (par défaut=False)
Exceptions levées : ValueError: Si wandb.init() n’a pas été appelé ou si l’un des modèles n’est pas une instance de torch.nn.Module.