Run - CoreWeave Docs

Classe wandb.Run

Une unité de calcul journalisée par W&B. Il s’agit généralement d’une expérience de ML. 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 seul run. Pour plus d’informations, voir Journaliser des expériences d’entraînement distribué. 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. Pour plus d’informations, voir Créer une expérience ou la page de référence de l’API wandb.init. Il existe un autre objet Run dans le namespace wandb.apis.public. Cet objet permet d’interagir avec des runs déjà créés.

Attributs

summary : (Summary) Une synthèse du run, sous la forme d’un objet de type dictionnaire. Pour plus d’informations, voir Journaliser les métriques de synthèse.

Exemples

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

import wandb

# Démarrer un nouveau run et journaliser des données
# Utiliser un gestionnaire de contexte (instruction `with`) pour que le run se termine automatiquement
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 les fichiers d’un run sont enregistrés.Il s’agit des fichiers enregistrés avec run.save(), y compris les fichiers créés automatiquement pour certains types de données transmis à run.log(). Pour le répertoire contenant l’ensemble des données d’un run, voir run.sync_dir.

bool

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

str

Nom de l’entity W&B associée au run.L’entity 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.Regrouper des runs permet d’organiser et de visualiser ensemble des expériences liées dans l’interface W&B. C’est particulièrement utile dans des scénarios tels que l’entraînement distribué ou la validation croisée, où plusieurs runs doivent être affichés et gérés comme une seule et même expérience.En mode partagé, où tous les processus partagent le même objet run, il est généralement inutile de définir un groupe, puisqu’il n’existe qu’un seul run et qu’aucun regroupement n’est nécessaire.

str

Identifiant de ce run.

str

Nom du type de job associé au run.Le type de job d’un run est visible sur la page Overview du run dans la W&B App.Vous pouvez l’utiliser pour classer les runs selon leur type de job, par exemple « training », « evaluation » ou « inference ». Cela permet d’organiser et de filtrer les runs dans l’interface W&B, en particulier lorsqu’un même projet contient plusieurs runs de types de job différents. 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 de caractères multiligne et peuvent également contenir du markdown et des équations LaTeX entre $$, par exemple $x + 3$ .

bool

True si le run est hors ligne, False sinon.

str

Chemin du run.Les chemins de run comprennent l’entity, 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émarrage du run.

int

Step 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 l’ensemble des données d’un run.Il peut être transmis à wandb sync pour téléverser le run ou le téléverser à nouveau.

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

str

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

str

Le corps du texte de l’alerte.

str | AlertLevel | None

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

int | float | timedelta | None

Le délai d’attente (en secondes) avant d’envoyer une autre alerte portant 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

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

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. Vaut True par défaut si step_metric est spécifié.

bool | None

Masque cette métrique dans les graphiques automatiques.

str | None

Spécifie les métriques agrégées à ajouter à la synthèse. Les agrégations prises en charge sont « 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 : leurs valeurs sont reprises pour tous les paramètres non spécifiés. Si true, les paramètres non spécifiés écrasent 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.

int

Aucune description fournie.

bool

Aucune description fournie.

méthode Run.finish()

self,
exit_code: 'int | None' = None

Termine un run et téléverse 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. États du run :

Running : run actif qui journalise des données et/ou envoie des signaux de pulsation (heartbeats).
Crashed : run qui a cessé d’envoyer des signaux de pulsation de manière 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.

int | None

Entier indiquant le code de sortie du run. Utilisez 0 en cas de succès ; 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é en tant que sortie d’un run. Les « upserts » ultérieurs portant le même ID distribué créeront une nouvelle version.

Artifact | str

Chemin vers le contenu de cet artifact, qui peut prendre les 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

Nom de l’artifact. Peut être préfixé par entity/project. Les noms valides peuvent prendre les formes suivantes :

name:version
name:alias
digest S’il n’est pas spécifié, le nom par défaut est le nom de base du chemin, précédé de l’ID du run actuel.

str | None

Type d’artifact à journaliser, par exemple dataset ou model

list[str] | None

Alias à appliquer à cet artifact. 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

Lie l’artifact à une collection. Le terme « lien » désigne les pointeurs qui relient l’emplacement où W&B stocke l’artifact et celui où l’artifact est accessible dans le registre. W&B ne duplique pas les artifacts lorsque vous liez un artifact à une collection. Consultez les artifacts liés à la collection spécifiée dans l’interface utilisateur du registre.

Artifact

L’objet artifact à lier à la collection.

str

Le chemin de la collection. Il se compose du préfixe « wandb-registry- », suivi du nom du registre et du nom de la collection, sous la forme wandb-registry-{REGISTRY_NAME}/{COLLECTION_NAME}.

list[str] | None

Ajoutez un ou plusieurs alias à l’artifact lié. L’alias « latest » est automatiquement attribué au dernier artifact que vous liez.

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

Journalise une version d’artifact de modèle et la lie à un modèle enregistré dans le registre de modèles. Les versions de modèle liées sont visibles dans l’interface utilisateur, sur la page du modèle enregistré spécifié. Cette méthode effectue les opérations suivantes :

Vérifier si l’artifact de modèle ‘name’ a déjà été journalisé. Si c’est le cas, utiliser la version d’artifact qui correspond aux fichiers situés dans ‘path’, ou journaliser une nouvelle version. Sinon, journaliser les fichiers de ‘path’ en tant que nouvel artifact de modèle ‘name’ de type ‘model’.
Vérifier s’il existe un modèle enregistré nommé ‘registered_model_name’ dans le projet ‘model-registry’. Si ce n’est pas le cas, créer un nouveau modèle enregistré nommé ‘registered_model_name’.
Lier la version de l’artifact de modèle ‘name’ au modèle enregistré ‘registered_model_name’.
Joindre les alias de la liste ‘aliases’ à la version d’artifact de modèle nouvellement liée.

StrPath

(str) Chemin vers le contenu de ce modèle, qui peut 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, qui représente généralement une tâche de ML spécifique d’une équipe. L’entity auquel appartient ce modèle enregistré est déduit du run.

str | None

Nom de l’artifact de modèle dans lequel les fichiers de ‘path’ seront journalisés. S’il n’est pas spécifié, la valeur par défaut est le nom de base du chemin, précédé de l’ID du run actuel.

list[str] | None

Alias appliqués uniquement à cet artifact lié au sein du modèle enregistré. L’alias « latest » est toujours appliqué à la dernière version d’un artifact lié.

AssertionError : si registered_model_name est un chemin ou si le type de l’artifact de modèle ‘name’ ne contient 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éverse les données du run. Utilisez log pour journaliser les données des runs, telles que des scalaires, des images, des vidéos, des histogrammes, des graphiques et des tableaux. Consultez Journaliser des objets et des médias pour obtenir 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 de synthèse de ces métriques. Visualisez les données journalisées dans un workspace sur wandb.ai ou localement sur une instance autohébergée de l’application W&B App, ou exportez les données pour les visualiser et les explorer localement, par exemple dans un Jupyter Notebook, à l’aide de l’API publique. Les valeurs journalisées ne sont pas forcément 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. Pour plus de détails, consultez le tutoriel Journaliser des tableaux, visualiser et interroger des données. W&B regroupe 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, le code suivant produit deux sections nommées « train » et « validate » :

with wandb.init() as run:
    # Journaliser 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}) produit 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 collectez les données sur plusieurs itérations et journalisez-les en un seul step. Par défaut, chaque appel à log crée un nouveau « step ». Le step doit toujours être croissant, et il est impossible de journaliser dans un step précédent. 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 le step 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 » pour l’utiliser comme axe X.
    run.log({"epoch": 40, "train-loss": 0.5})

Vous pouvez effectuer plusieurs appels à wandb.Run.log() pour journaliser dans le même step à l’aide des paramètres step et commit. Les exemples suivants sont tous équivalents :

with wandb.init() as run:
    # Utilisation standard :
    run.log({"train-loss": 0.5, "accuracy": 0.8})
    run.log({"train-loss": 0.4, "accuracy": 0.9})

    # step implicite, sans incrémentation automatique :
    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})

    # step 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)

dict[str, Any]

Un dict dont les clés sont de type str et les valeurs sont des objets Python sérialisables, notamment : int, float et string ; tout type de wandb.data_types ; des listes, tuples et tableaux NumPy d’objets Python sérialisables ; d’autres dict ayant cette même structure.

int | None

Le numéro de step à journaliser. Si la valeur est None, un step implicite à incrémentation automatique est utilisé. Voir les remarques dans la description.

bool | None

Si la valeur est true, le step est finalisé et téléversé. Si elle est false, les données sont accumulées pour le step. Voir les remarques dans la description. Si step vaut None, la valeur par défaut est commit=True ; sinon, la valeur par défaut est commit=False.

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

Pour des exemples plus nombreux et plus détaillés, consultez 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, une fois prêt à journaliser ce step :
    run.log({"accuracy": 0.8})

Histogramme

import numpy as np
import wandb

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

Image à partir 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 à partir 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 à partir de NumPy

import numpy as np
import wandb

with wandb.init() as run:
    # axes : (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)  # tracer 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")),
            ]
        }
    )

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.

Artifact | StrPath

(str ou Artifact) Chemin vers le contenu de cet artifact, qui peut 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

(str, facultatif) Nom de l’artifact. 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 est le nom de base du chemin, précédé de l’ID du run en cours.

str | None

(str) Type de l’artifact à journaliser, par exemple dataset ou model

list[str] | None

(list, facultatif) Alias à appliquer à cet artifact. Valeur par défaut : ["latest"]

list[str] | None

(list, facultatif) Tags éventuels à appliquer à cet artifact.

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 l’extension est .py.

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 l’artifact de code. Par défaut, l’artifact est nommé source-$PROJECT_ID-$ENTRYPOINT_RELPATH. Dans certains cas, vous pouvez souhaiter que plusieurs runs partagent le même artifact. Pour cela, spécifiez name.

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

Un callable qui accepte un chemin de fichier et, éventuellement, un chemin racine, et qui renvoie True si le fichier doit être inclus, et False dans le cas contraire. La valeur par défaut est lambda path, root: path.endswith(".py").

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

Un callable qui accepte un chemin de fichier et, éventuellement, un chemin racine, et qui renvoie True si le fichier doit être exclu, et False dans le cas contraire. La valeur par défaut est une fonction qui exclut tous les fichiers situés dans les répertoires <root>/.wandb/ et <root>/wandb/.

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 dans un run un artifact de modèle contenant les éléments situés dans ‘path’, 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 caractères de soulignement et des traits d’union.

StrPath

(str) Chemin vers le contenu de ce modèle, qui peut 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é. S’il n’est pas spécifié, le nom de base du chemin, précédé de l’ID du run actuel, est utilisé par défaut.

list[str] | None

Alias à appliquer à l’artifact de modèle créé. Valeur par défaut : ["latest"]

ValueError : si le nom contient des caractères spéciaux non valides.

méthode Run.mark_preempting()

self

Marque ce run comme étant en cours de préemption. Indique également au processus interne de le signaler immédiatement au serveur.

méthode Run.pin_config_keys()

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

Épingle des clés de configuration à afficher dans la section References de la page Run Overview. Les clés épinglées sont mises en évidence au-dessus de la section Notes de la page Run Overview. Les valeurs de type chaîne sont rendues en markdown ; les autres valeurs sont rendues en texte brut. Tout nouvel appel remplace la liste précédemment épinglée.

Sequence[str]

Noms des clés de configuration à épingler, correspondant aux clés définies via run.config. Il s’agit des chaînes exactes des clés (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, le fichier n’est téléchargé que s’il n’existe pas déjà.

str

Le nom du fichier.

str | None

Chemin facultatif vers le run depuis lequel récupérer les fichiers, par exemple username/project_name/run_id. Ce paramètre est requis si wandb.init n’a pas été appelé.

bool

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

str | None

Le répertoire dans lequel télécharger le fichier. Par défaut, il s’agit du répertoire courant, ou du répertoire du run si wandb.init a été appelé.

CommError : si W&B ne parvient pas à se connecter au backend W&B.
ValueError : si le fichier est introuvable ou si run_path ne peut pas être trouvé.

méthode Run.save()

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

Synchronise un ou plusieurs fichiers avec W&B. Les chemins relatifs sont résolus par rapport au répertoire de travail actuel. Un glob Unix, tel que « myfiles/* », est développé au moment où save est appelé, quelle que soit la policy. Autrement dit, les nouveaux fichiers ne sont pas pris en compte automatiquement. glob_str est développé à l’aide du module glob de Python : voir https://docs.python.org/3/library/glob.html pour connaître 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 figurent dans un véritable nom de fichier (par exemple « 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 entièrement le développement des motifs et traiter glob_str comme un chemin littéral. Vous pouvez fournir un base_path pour contrôler l’arborescence des fichiers téléversés. Il doit s’agir d’un préfixe de glob_str, et l’arborescence située en dessous est conservée. Lorsqu’un chemin absolu ou un glob est fourni sans base_path, un seul niveau de répertoire est conservé, comme dans l’exemple ci-dessus. Les fichiers sont automatiquement dédupliqués : appeler save() plusieurs fois sur un même fichier non modifié ne le téléverse pas à nouveau.

str | os.PathLike

Un chemin relatif ou absolu, ou un glob Unix.

str | os.PathLike | None

Chemin utilisé pour déduire l’arborescence des répertoires ; voir les exemples.

PolicyName

L’une des valeurs live, now ou end.

live : téléverser le fichier à chaque modification, en écrasant 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 si glob_str doit être traité comme un motif glob. La valeur par défaut est True, pour des raisons de rétrocompatibilité. Définissez-la sur False pour traiter glob_str comme un chemin littéral, par exemple lorsque son nom contient des métacaractères glob tels que [, ], * ou ? que vous ne souhaitez pas voir interprétés comme un motif.

méthode Run.status()

self

Obtient auprès du backend interne les informations sur le statut de synchronisation du run actuel.

méthode Run.unwatch()

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

Supprime les hooks de topologie, de gradients et de paramètres du modèle PyTorch.

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éclare un artifact non finalisé comme sortie d’un run (ou y ajoute du contenu). Notez que vous devez appeler run.finish_artifact() pour finaliser l’artifact. C’est utile lorsque plusieurs jobs distribués doivent contribuer au même artifact.

Artifact | str

Chemin vers le contenu de cet artifact, qui peut prendre les formes suivantes :

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

str | None

Nom de l’artifact. Peut être préfixé par « entity/project ». S’il n’est pas spécifié, le nom de base du chemin, précédé de l’ID du run actuel, est utilisé par défaut. 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. Valeur par défaut : ["latest"].

str | None

Chaîne unique partagée par tous les jobs distribués. Si None, le nom du groupe du run est utilisé par défaut.

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.

str | Artifact

Le nom de l’artifact à utiliser. Il peut être préfixé par le nom du projet dans lequel l’artifact a été journalisé (« entity » ou « entity/project »). Si aucune entity n’est indiquée dans le nom, l’entity définie dans les paramètres du Run ou de l’API est utilisée. Les noms valides peuvent prendre les formes suivantes :

name:version
name: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.

import wandb

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

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

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

# Utiliser un artifact via entity/project/name:alias
artifact_c = run.use_artifact(
    artifact_or_name="<entity>/<project>/<name>:<alias>"
)

# Utiliser un artifact via entity/project/name:version
artifact_d = run.use_artifact(
    artifact_or_name="<entity>/<project>/<name>:v<version>"
)

# Terminer explicitement le run, puisqu’aucun gestionnaire de contexte n’est utilisé.
run.finish()

méthode Run.use_model()

self,
name: 'str'

Télécharge les fichiers journalisés dans l’artifact de modèle ‘name’.

str

Nom d’un artifact de modèle. name doit correspondre au nom d’un artifact de modèle journalisé existant. Peut être préfixé par entity/project/. Les noms valides peuvent prendre les formes suivantes :

model_artifact_name:version
model_artifact_name:alias

AssertionError : si le type de l’artifact de modèle ‘name’ 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

S’attache au modèle PyTorch fourni pour surveiller ses gradients et son graphe de calcul. Cette fonction peut suivre les paramètres, les gradients, ou les deux, pendant l’entraînement.

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 (« gradients »), les paramètres (« parameters ») ou les deux (« all »). Définissez la valeur sur None pour désactiver la journalisation. (default=“gradients”).

int

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

int | None

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

bool

Indique s’il faut journaliser le graphe de calcul du modèle. (default=False)

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'

Écrit du texte dans l’onglet Logs du run. Utilisez write_logs pour écrire directement du texte dans l’onglet Logs au lieu de vous appuyer sur la capture automatique de stdout/stderr. Les appels effectués une fois le run terminé sont ignorés sans avertissement. Envisagez d’utiliser le paramètre capture_loggers, qui s’intègre au module logging de Python.

str

Le texte à écrire. Un saut de ligne final est ajouté s’il n’y en a pas.

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

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