Run - Weights & Biases Documentation

Classe wandb.Run

Une unité de calcul journalisé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 journaliser des données dans un run avec wandb.Run.log(). Tout ce que vous journalisez 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: (Synthèse) Synthèse du run, sous la forme d’un objet de type dictionnaire. Pour plus d’informations, voir Log summary metrics.

Exemples

Créez un run avec wandb.init() :

import wandb

# Démarrer un nouveau run et enregistrer des données
# Utiliser un 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és

wandb_config.Config

Objet de configuration associé à ce run.

wandb_config.ConfigStatic

Objet de configuration statique associé à ce run.

str

Répertoire dans lequel sont enregistrés les fichiers d’un run.Cela concerne les fichiers enregistrés avec run.save(), y compris ceux créés automatiquement pour certains types de données transmis à run.log(). Pour le répertoire contenant toutes les données d’un run, voir run.sync_dir.

bool

True si le run est désactivé, False sinon.

str

Nom de l’entité W&B associée au run.L’entité peut être un nom d’utilisateur ou le nom d’une équipe ou d’une organisation.

str

Renvoie le nom du groupe associé à ce run.Le regroupement de runs permet d’organiser et de visualiser ensemble des expériences associées dans l’interface W&B. Cela est particulièrement utile dans des scénarios tels que l’entraînement distribué ou la validation croisée, où plusieurs runs doivent être consultés et gérés comme une expérience unifiée.En mode partagé, où tous les processus partagent le même objet run, il n’est généralement pas nécessaire de définir un groupe, puisqu’il n’y a qu’un seul run et qu’aucun regroupement n’est requis.

str

Identifiant de ce run.

str

Nom du type de tâche associé au run.Consultez le type de tâche d’un run sur sa page Aperçu dans W&B App.Vous pouvez l’utiliser pour catégoriser les runs selon leur type de tâche, par exemple « training », « evaluation » ou « inference ». Cela est utile pour organiser et filtrer les runs dans l’interface W&B, en particulier lorsque plusieurs runs de types de tâches différents se trouvent dans le même projet. Pour plus d’informations, voir Organiser les runs.

str | None

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.

str | None

Notes associées au run, le cas échéant.Les notes peuvent être une chaîne multiligne et inclure des équations Markdown et LaTeX entre $$, comme $x + 3$ .

bool

True si le run est hors ligne, False sinon.

str

Chemin du run.Les chemins de run comprennent l’entité, le projet et l’ID du run, au format entity/project/run_id.

str

Nom du projet W&B associé au run.

str | None

URL du projet W&B associé au run, le cas échéant.Les runs hors ligne n’ont pas d’URL de projet.

bool

True si le run a été repris, False sinon.

Settings

Copie figée de l’objet Settings du run.

float

Horodatage Unix (en secondes) du début du run.

int

Étape W&B du prochain appel à log().Lève une erreur pour les runs en mode=“shared”.

str | None

Identifiant du sweep associé au run, le cas échéant.

str | None

URL du sweep associé au run, le cas échéant.Les runs hors ligne n’ont pas d’URL de sweep.

str

Répertoire contenant toutes les données d’un run.Il peut être transmis à wandb sync pour téléverser ou retéléverser le run.

tuple | None

Tags associés au run, le cas échéant.

str | None

URL du run W&B, le cas échéant.Les runs hors ligne n’ont pas d’URL.

Méthodes

méthode Run.alert()

self,
title: 'str',
text: 'str',
level: 'str | AlertLevel | None' = None,
wait_duration: 'int | float | timedelta | None' = None

Crée une alerte avec le titre et le texte indiqués.

Arguments

str

Le titre de l’alerte, qui doit comporter moins de 64 caractères.

str

Le corps du message de l’alerte.

str | AlertLevel | None

Le niveau d’alerte à utiliser : INFO, WARN ou ERROR.

int | float | timedelta | None

Le délai d’attente (en secondes) avant d’envoyer une autre alerte avec ce titre.

méthode Run.define_metric()

self,
name: 'str',
step_metric: 'str | wandb_metric.Metric | None' = None,
step_sync: 'bool | None' = None,
hidden: 'bool | None' = None,
summary: 'str | None' = None,
overwrite: 'bool | None' = None

Personnalisez les métriques journalisées avec wandb.Run.log().

Arguments

str

Le nom de la métrique à personnaliser.

str | wandb_metric.Metric | None

Le nom d’une autre métrique à utiliser comme axe X pour cette métrique dans les graphiques générés automatiquement.

bool | None

Insère automatiquement la dernière valeur de step_metric dans wandb.Run.log() si elle n’est pas fournie explicitement. Par défaut, True si step_metric est spécifiée.

bool | None

Masque cette métrique des graphiques générés automatiquement.

str | None

Spécifiez les agrégations de métriques ajoutées à la synthèse. Les agrégations prises en charge incluent « min », « max », « mean », « last », « first », « copy » et « none ». « none » empêche la génération d’une synthèse. « copy » est obsolète et ne doit pas être utilisé.

bool | None

Si false, cet appel est fusionné avec les appels define_metric précédents 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.

méthode Run.display()

self,
height: 'int' = 420,
hidden: 'bool' = False

Affiche ce run dans Jupyter.

Arguments

int

Aucune description fournie.

bool

Aucune description fournie.

méthode Run.finish()

self,
exit_code: 'int | None' = None

Terminez un run et téléversez 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

int | None

Entier indiquant le statut de sortie du run. Utilisez 0 pour signaler une réussite ; toute autre valeur marque le run comme échoué.

méthode Run.finish_artifact()

self,
artifact_or_path: 'Artifact | str',
name: 'str | None' = None,
type: 'str | None' = None,
aliases: 'list[str] | None' = None,
distributed_id: 'str | None' = None

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 | str

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.

str | None

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.

str | None

Le type d’artifact à journaliser, par exemple dataset, model

list[str] | None

Alias à appliquer à cet artifact, valeurs par défaut : ["latest"]

str | None

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.

méthode Run.link_artifact()

self,
artifact: 'Artifact',
target_path: 'str',
aliases: 'list[str] | None' = None

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.

str

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

list[str] | None

Ajoutez un ou plusieurs alias à l’artifact lié. L’alias « latest » est automatiquement appliqué à l’artifact le plus récent que vous liez.

Exemples

import wandb

entity = "team_entity"
project = "project_name"

artifact_name = "artifact_name"
artifact_type = "artifact_type"
local_path = "path/to/local/file"

registry_name = "registry_name"
collection_name = "collection_name"
target_path = f"wandb-registry-{registry_name}/{collection_name}"

with wandb.init(entity=entity, project=project) as run:
    # Créer un objet artifact
    artifact = wandb.Artifact(name=artifact_name, type=artifact_type)

    # Ajouter le fichier à l'objet artifact.
    artifact.add_file(local_path=local_path)

    # Lier l'artifact à la collection
    run.link_artifact(artifact=artifact, target_path=target_path)

méthode Run.link_model()

self,
path: 'StrPath',
registered_model_name: 'str',
name: 'str | None' = None,
aliases: 'list[str] | None' = None

Journaliser 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é journalisé. Si c’est le cas, utilise la version de l’artifact correspondant aux fichiers situés à ‘path’ ou journalise une nouvelle version. Sinon, elle journalise 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

StrPath

(str) Chemin vers le contenu de ce modèle, pouvant prendre les formes suivantes :

/local/directory
/local/directory/file.txt
s3://bucket/path

str

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.

str | None

Nom de l’artifact de modèle dans lequel les fichiers de ‘path’ seront journalisé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é.

list[str] | None

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.

méthode Run.log()

self,
data: 'dict[str, Any]',
step: 'int | None' = None,
commit: 'bool | None' = None

Téléversez 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, etc. 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 de synthèse de ces métriques. Visualisez les données journalisées dans un espace de travail 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 journalisées ne doivent pas nécessairement être des scalaires. Vous pouvez journaliser 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 journaliser des données structurées. Voir le tutoriel Journaliser 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 situé avant la dernière barre oblique. Par exemple, le résultat suivant comporte deux sections nommées “train” et “validate” :

with wandb.init() as run:
    # Journaliser les 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 votre journalisation à une fois toutes les N itérations, ou collectez les données sur plusieurs itérations et journalisez-les en une seule étape. Par défaut, chaque appel à log crée une nouvelle “étape”. L’étape doit toujours augmenter, et il n’est pas possible de journaliser des données sur une étape précédente. Vous pouvez utiliser n’importe quelle métrique comme axe des 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 traiter 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 des données à la même étape à l’aide des paramètres step et commit. Les exemples suivants sont tous équivalents :

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

dict[str, Any]

Un dict avec des clés str et des valeurs qui sont des objets Python sérialisables, y compris : 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 cette structure.

int | None

Le numéro d’étape à journaliser. Si None, une étape implicite avec auto-incrémentation est utilisée. Voir les notes dans la description.

bool | None

Si vrai, finalisez et téléversez l’étape. Si faux, accumulez les données pour l’étape. 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.

Exceptions levées

wandb.Error : si la méthode est appelée avant wandb.init().
ValueError : si des données non valides sont transmises.

Exemples

Pour davantage d’exemples, plus détaillés, voir nos guides sur la journalisation. Utilisation de base

import wandb

with wandb.init() as run:
    run.log({"train-loss": 0.5, "accuracy": 0.9

Journalisation incrémentielle

import wandb

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

Histogramme

import numpy as np
import wandb

# échantillonner des gradients aléatoirement depuis une distribution normale
gradients = np.random.randn(100, 100)
with wandb.init() as run:
    run.log({"gradients": wandb.Histogram(gradients)})

Image depuis 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 provenant de 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 depuis 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, format="mp4", 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)  # graphique y = x^2
    run.log({"chart": fig})

Courbe précision-rappel

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")),
            ]
        }
    )

méthode Run.log_artifact()

self,
artifact_or_path: 'Artifact | StrPath',
name: 'str | None' = None,
type: 'str | None' = None,
aliases: 'list[str] | None' = None,
tags: 'list[str] | None' = None

Déclare un artifact comme sortie d’un run.

Arguments

Artifact | StrPath

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

str | None

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

str | None

(str) Type d’artifact à journaliser, par exemple dataset, model

list[str] | None

(list, facultatif) Alias à appliquer à cet artifact. La valeur par défaut est ["latest"]

list[str] | None

(list, facultatif) Tags à appliquer à cet artifact, le cas échéant.

méthode Run.log_code()

self,
root: 'str | None' = '.',
name: 'str | None' = None,
include_fn: 'Callable[[str, str], bool] | Callable[[str], bool]' = _is_py_requirements_or_dockerfile,
exclude_fn: 'Callable[[str, str], bool] | Callable[[str], bool]' = exclude_wandb_fn

Enregistre l’état actuel de votre code dans un Artifact W&B. Par défaut, la méthode parcourt le répertoire courant et journalise tous les fichiers dont le nom se termine par .py.

Arguments

str | None

Le chemin relatif (par rapport à os.getcwd()) ou absolu à partir duquel rechercher le code de manière récursive.

str | None

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

Callable[[str, str], bool] | Callable[[str], bool]

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 lambda path, root: path.endswith(".py").

Callable[[str, str], bool] | Callable[[str], bool]

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/"
        ),
    )

méthode Run.log_model()

self,
path: 'StrPath',
name: 'str | None' = None,
aliases: 'list[str] | 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

StrPath

(str) Chemin vers le contenu de ce modèle, pouvant prendre les formes suivantes :

/local/directory
/local/directory/file.txt
s3://bucket/path

str | None

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

list[str] | None

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.

méthode Run.mark_preempting()

self

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

méthode Run.pin_config_keys()

self,
keys: 'Sequence[str]' = ()

Épinglez les clés de configuration à afficher dans la section References de Run Aperçu. Les clés épinglées apparaissent bien en évidence au-dessus de Notes sur la page Run Aperçu. Les valeurs de type chaîne sont affichées en markdown ; les valeurs non textuelles sont affichées en texte brut. Un nouvel appel remplace la liste précédemment épinglée.

Arguments

Sequence[str]

Noms des clés de configuration à épingler, correspondant aux clés définies via run.config. Il s’agit de chaînes de clés exactes (les points et les barres obliques sont interprétés littéralement, et non comme des séparateurs de chemin). L’ordre est conservé et détermine l’ordre d’affichage.

méthode Run.restore()

self,
name: 'str',
run_path: 'str | None' = None,
replace: 'bool' = False,
root: 'str | None' = None

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

str

Le nom du fichier.

str | None

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.

bool

Indique s’il faut télécharger le fichier même s’il existe déjà localement

str | None

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

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()

self,
glob_str: 'str | os.PathLike',
base_path: 'str | os.PathLike | None' = None,
policy: 'PolicyName' = 'live',
glob: 'bool' = True

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. glob_str est développé à l’aide du module glob de Python : voir https://docs.python.org/3/library/glob.html pour la syntaxe exacte et le comportement. En particulier, les caractères *, ? et [] sont traités comme des métacaractères glob, et non comme des caractères littéraux, même s’ils apparaissent dans un nom de fichier réel (par ex. “myfile[1].txt”). Si le nom de votre fichier contient l’un de ces caractères et que vous souhaitez le faire correspondre littéralement plutôt que comme un motif, échappez-le vous-même avec glob.escape() avant d’appeler save, ou passez glob=False pour désactiver complètement l’expansion des motifs et traiter glob_str comme un chemin littéral. 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

str | os.PathLike

Un chemin relatif ou absolu, ou un glob Unix.

str | os.PathLike | None

Un chemin utilisé pour déduire une structure de répertoires ; voir les exemples.

PolicyName

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

bool

Indique s’il faut traiter glob_str comme un motif glob. La valeur par défaut est True pour assurer la compatibilité descendante. Définissez False pour traiter glob_str comme un chemin littéral, par exemple lorsque son nom contient des métacaractères de glob comme [, ], * ou ? que vous ne souhaitez pas voir interprétés comme un motif.

méthode Run.status()

self

Obtenir les informations de synchronisation du run actuel depuis le backend interne.

méthode Run.unwatch()

self,
models: 'torch.nn.Module | Sequence[torch.nn.Module] | None' = None

Supprime la topologie du modèle PyTorch ainsi que les hooks de gradient et de paramètres.

Arguments

torch.nn.Module | Sequence[torch.nn.Module] | None

Liste facultative de modèles PyTorch sur lesquels watch a été appelé.

méthode Run.upsert_artifact()

self,
artifact_or_path: 'Artifact | str',
name: 'str | None' = None,
type: 'str | None' = None,
aliases: 'list[str] | None' = None,
distributed_id: 'str | None' = None

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 | str

Chemin vers le contenu de cet artifact. Il peut prendre les formes suivantes :

/local/directory
/local/directory/file.txt
s3://bucket/path

str | None

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 run actuel ID. Les noms valides peuvent prendre les formes suivantes :

name:version
name:alias
digest

str | None

Type d’artifact à journaliser. Exemples courants : dataset, model.

list[str] | None

Alias à appliquer à cet artifact. La valeur par défaut est ["latest"].

str | None

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.

méthode Run.use_artifact()

self,
artifact_or_name: 'str | Artifact',
type: 'str | None' = None,
aliases: 'list[str] | None' = None,
use_as: 'str | None' = None

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

str | Artifact

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

str | None

Le type d’artifact à utiliser.

list[str] | None

Alias à appliquer à cet artifact

str | None

Cet argument est obsolète et n’a aucun effet.

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()

self,
name: 'str'

Télécharge les fichiers enregistrés dans un artifact de modèle name.

Arguments

str

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

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()

self,
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

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

torch.nn.Module | Sequence[torch.nn.Module]

Un modèle unique ou une séquence de modèles à surveiller.

torch.F | None

La fonction de perte à optimiser (facultatif).

Literal['gradients', 'parameters', 'all'] | None

Indique s’il faut journaliser les « gradients », les « parameters » ou « all ». Définissez cette valeur sur None pour désactiver la journalisation. (par défaut=“gradients”).

int

Fréquence (en lots) de journalisation des gradients et des paramètres. (par défaut=1000)

int | None

Index utilisé pour suivre plusieurs modèles avec wandb.watch. (par défaut=None)

bool

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.

méthode Run.write_logs()

self,
text: 'str'

Écrivez du texte dans l’onglet Logs du run. Utilisez write_logs pour écrire directement du texte dans l’onglet Logs, au lieu de vous fier à la capture automatique de stdout/stderr. Les appels effectués après la fin du run sont simplement ignorés. Vous pouvez utiliser le paramètre capture_loggers, qui s’intègre au module logging de Python.

Arguments

str

Le texte à écrire. Un saut de ligne final est ajouté s’il n’est pas déjà présent.

​Classe wandb.Run

​Attributs

​Exemples

​Propriétés

​Méthodes

​méthode Run.alert()

Arguments

​méthode Run.define_metric()

Arguments

​méthode Run.display()

Arguments

​méthode Run.finish()

Arguments

​méthode Run.finish_artifact()

Arguments

​méthode Run.link_artifact()

Arguments

Exemples

​méthode Run.link_model()

Arguments

Exceptions levées

​méthode Run.log()

Arguments

Exceptions levées

Exemples

​méthode Run.log_artifact()

Arguments

​méthode Run.log_code()

Arguments

Exemples

​méthode Run.log_model()

Arguments

Exceptions levées

​méthode Run.mark_preempting()

​méthode Run.pin_config_keys()

Arguments

​méthode Run.restore()

Arguments

Exceptions levées

​méthode Run.save()

Arguments

​méthode Run.status()

​méthode Run.unwatch()

Arguments

​méthode Run.upsert_artifact()

Arguments

​méthode Run.use_artifact()

Arguments

Exemples

​méthode Run.use_model()

Arguments

Exceptions levées

​méthode Run.watch()

Arguments

Exceptions levées

​méthode Run.write_logs()

Arguments

Classe wandb.Run

Attributs

Exemples

Propriétés

Méthodes

méthode Run.alert()

méthode Run.define_metric()

méthode Run.display()

méthode Run.finish()

méthode Run.finish_artifact()

méthode Run.link_artifact()

méthode Run.link_model()

méthode Run.log()

méthode Run.log_artifact()

méthode Run.log_code()

méthode Run.log_model()

méthode Run.mark_preempting()

méthode Run.pin_config_keys()

méthode Run.restore()

méthode Run.save()

méthode Run.status()

méthode Run.unwatch()

méthode Run.upsert_artifact()

méthode Run.use_artifact()

méthode Run.use_model()

méthode Run.watch()

méthode Run.write_logs()