Run - CoreWeave Docs

Classe wandb.apis.public.Run

Un run individuel associé à un entity et à un projet.

(service_api: 'ServiceApi',
entity: 'str',
project: 'str',
run_id: 'str',
attrs: 'Mapping | None' = None,
include_sweeps: 'bool' = False,
lazy: 'bool' = True,
api_key: 'str | None' = None)

Arguments

ServiceApi

Interface vers le service wandb-core qui effectue les appels d’API W&B pour ce run.

str

L’entity associé au run.

str

Le projet associé au run.

str

L’identifiant unique du run.

Mapping | None

Les attributs du run.

bool

Indique s’il faut inclure les sweeps dans le run.

bool

Aucune description fournie.

str | None

Aucune description fournie.

Attributs

tags ([str]) : une liste de tags associés au run
url (str) : l’URL de ce run
id (str) : identifiant unique du run (huit caractères par défaut)
name (str) : le nom du run
state (str) : l’une des valeurs suivantes : running, finished, crashed, killed, preempting, preempted
config (dict) : un dict d’hyperparamètres associés au run
created_at (str) : horodatage ISO du démarrage du run
system_metrics (dict) : les dernières métriques système enregistrées pour le run
summary (dict) : une propriété mutable de type dict qui contient la synthèse actuelle. Un appel à update rend toutes les modifications persistantes.
project (str) : le projet associé au run
entity (str) : le nom de l’entity associé au run
project_internal_id (int) : l’ID interne du projet
user (str) : le nom de l’utilisateur qui a créé le run
path (str) : identifiant unique [entity]/[project]/[run_id]
notes (str) : notes sur le run
read_only (boolean) : indique si le run est modifiable
history_keys (str) : clés des métriques d’historique journalisées avec wandb.Run.log({"key": "value"})
metadata (str) : métadonnées du run issues de wandb-metadata.json

Propriétés

dict[str, Any]

Obtient la configuration de run. Charge automatiquement l’ensemble des données en mode différé (lazy mode).

str

L’entity associé au run.

str

L’identifiant unique du run.

int

Renvoie la dernière étape journalisée dans l’historique du run.

dict[str, Any] | None

Métadonnées du run issues de wandb-metadata.json.Les métadonnées incluent notamment la description du run, ses tags, l’heure de début et l’utilisation de la mémoire.

str | None

Le nom du run.

list[str]

Le chemin du run, sous forme de liste contenant l’entity, le projet et le run_id.

dict[str, Any]

Obtient la configuration de run brute, clés internes comprises. Charge automatiquement l’ensemble des données en mode différé (lazy mode).

str

L’état du run.Le tableau suivant décrit les états possibles d’un run :

État	Description
Crashed	Le run a cessé d’envoyer des signaux de pulsation (heartbeats) dans le processus interne, ce qui peut arriver en cas de plantage de la machine.
Failed	Le run s’est terminé avec un code de sortie non nul.
Finished	Le run s’est terminé après avoir entièrement synchronisé ses données, ou a appelé `wandb.Run.finish()`.
Killed	Le run a été arrêté de force avant d’avoir pu se terminer.
Running	Le run est toujours en cours d’exécution et a récemment envoyé un signal de pulsation.
Pending	Le run est planifié mais n’a pas encore démarré (fréquent avec les sweeps et les jobs Launch).

str

L’identifiant de stockage unique du run.

HTTPSummary

Obtient les métriques de synthèse du run. Charge automatiquement l’ensemble des données en mode différé (lazy mode).

dict[str, Any]

Obtient les métriques de synthèse du run. Charge automatiquement l’ensemble des données en mode différé (lazy mode).

public.Sweep | None

Le sweep associé à ce run. Charge les données du sweep si include_sweeps vaut False.

str | None

Obtient le nom du sweep. Toujours disponible, car sweepName fait partie du fragment allégé.

dict[str, Any]

Obtient les métriques système du run. Charge automatiquement l’ensemble des données en mode différé (lazy mode).

str

L’URL du run.L’URL du run est générée à partir de l’entity, du projet et du run_id. Pour les utilisateurs SaaS, elle prend la forme https://wandb.ai/entity/project/run_id.

str

Cette API est obsolète. Utilisez entity à la place.

Méthodes

méthode Run.beta_scan_history()

self,
keys: 'list[str] | None' = None,
page_size: 'int' = 1000,
min_step: 'int' = 0,
max_step: 'int | None' = None,
use_cache: 'bool' = True

list[str] | None

Aucune description fournie.

int

Aucune description fournie.

int

Aucune description fournie.

int | None

Aucune description fournie.

bool

Aucune description fournie.

méthode Run.console_logs()

self, *,
per_page: 'int' = 1000,
last: 'int | None' = None

Renvoie la sortie console capturée du run. Pendant l’exécution d’un run, W&B capture ce que son processus écrit sur stdout et stderr, et l’enregistre comme journal de console du run — le même journal que celui affiché dans l’onglet « Logs » de la page du run dans l’application W&B. Cette méthode relit ce journal, que le run soit terminé ou encore en cours d’exécution.

int

Nombre de lignes à récupérer par requête lors de la lecture du journal depuis le début. Ignoré si last est fourni.

int | None

S’il est défini, récupère uniquement les N dernières lignes du journal en une seule requête, ce qui est pratique pour suivre un run en cours ou diagnostiquer un plantage. Le backend limite le nombre de lignes renvoyées par requête : si vous demandez davantage de lignes, seules les plus récentes sont conservées.

CommError : si une requête échoue pendant l’itération. La lecture du journal depuis le début nécessite le serveur W&B 0.77 ou une version ultérieure ; avec les serveurs plus anciens, lisez plutôt les N dernières lignes.

import wandb

run = wandb.Api().run("entity/project/run_id")

# Lire l’intégralité du journal, de la ligne la plus ancienne à la plus récente.
for line in run.console_logs():
    print(line.content)

# Lire uniquement les 100 dernières lignes.
for line in run.console_logs(last=100):
    print(line.timestamp, line.content)

méthode Run.create()

api: 'public.Api',
run_id: 'str | None' = None,
project: 'str | None' = None,
entity: 'str | None' = None,
state: "Literal['running', 'pending']" = 'running'

Crée un run pour le projet indiqué. Dans la plupart des cas, utilisez wandb.init(). wandb.init() fournit une logique plus robuste pour créer et mettre à jour des runs. wandb.apis.public.Run.create est destiné à des scénarios spécifiques, comme la création de runs à l’état « pending » pour des jobs qui risquent de ne pas pouvoir être planifiés (par exemple, dans un cluster Kubernetes qui ne dispose pas de suffisamment de GPU ou qui est fortement sollicité). Ces runs en attente peuvent ensuite être repris et suivis par W&B. Les runs créés avec cette méthode offrent des fonctionnalités limitées. Appeler update() sur un run créé de cette manière risque de ne pas fonctionner comme prévu.

public.Api

L’instance de l’API W&B.

str | None

ID du run (facultatif). S’il n’est pas fourni, un ID aléatoire est généré.

str | None

Nom du projet (facultatif). Par défaut, le projet défini dans les paramètres de l’API ou « uncategorized ».

str | None

Nom de l’entity (utilisateur ou équipe) (facultatif).

Literal['running', 'pending']

État initial du run. Utilisez « pending » pour les runs qui seront repris ultérieurement, ou « running » pour une exécution immédiate.

Créer un run en attente pour l’exécuter ultérieurement

import wandb

api = wandb.Api()

run_name = "my-pending-run"

run = Run.create(
    api=api,
    project="project",
    entity="entity",
    state="pending",
    run_id=run_name,
)

méthode Run.delete()

self,
delete_artifacts: 'bool' = False

Supprime le run spécifié du backend W&B.

bool

Indique si les artifacts associés au run doivent être supprimés.

méthode Run.download_history_exports()

self,
download_dir: 'pathlib.Path | str',
require_complete_history: 'bool' = True

Télécharge tous les fichiers d’historique Parquet du run dans le répertoire spécifié.

pathlib.Path | str

Le répertoire dans lequel télécharger les fichiers d’historique.

bool

Indique si l’historique doit être téléchargé dans son intégralité. Si la valeur est true et que le run contient des données qui n’ont pas encore été exportées dans des fichiers Parquet, une IncompleteRunHistoryError est levée.

IncompleteRunHistoryError : si require_complete_history vaut True et que le run contient des données qui n’ont pas encore été exportées vers des fichiers Parquet.
WandbApiFailedError : si la requête API échoue pour une raison autre qu’un historique incomplet.

méthode Run.file()

self,
name: 'str'

Renvoie le chemin du fichier portant le nom indiqué dans l’artifact.

str

Nom du fichier demandé.

méthode Run.files()

self,
names: 'list[str] | None' = None,
pattern: 'str | None' = None,
per_page: 'int' = 50

Renvoie un objet Files contenant tous les fichiers du run qui correspondent aux critères indiqués. Vous pouvez spécifier une liste de noms de fichiers exacts à rechercher, ou un motif de correspondance. Si les deux sont fournis, le motif est ignoré.

list[str] | None

noms des fichiers demandés ; si la liste est vide, tous les fichiers sont renvoyés

str | None

Motif utilisé pour filtrer les fichiers renvoyés par W&B. Ce motif suit la syntaxe LIKE de mySQL : par exemple, pour sélectionner tous les fichiers dont le nom se termine par .json, utilisez “%.json”. Si names et pattern sont tous deux fournis, une ValueError est levée.

int

nombre de résultats par page.

méthode Run.history()

self,
samples: 'int' = 500,
keys: 'list[str] | None' = None,
x_axis: 'str' = '_step',
pandas: 'bool' = True,
stream: "Literal['default', 'system']" = 'default'

Renvoie un échantillon des métriques de l’historique d’un run. Cette méthode est plus simple et plus rapide si un échantillonnage des enregistrements de l’historique vous convient.

int

(int, facultatif) Nombre d’échantillons à renvoyer

list[str] | None

(list, facultatif) Renvoyer uniquement les métriques des clés spécifiées

str

(str, facultatif) Métrique à utiliser comme axe des x (xAxis) ; valeur par défaut : _step

bool

(bool, facultatif) Renvoyer un dataframe pandas

Literal['default', 'system']

(str, facultatif) “default” pour les métriques, “system” pour les métriques machine

méthode Run.load()

self,
force: 'bool' = False

Charge les données du run à l’aide du fragment approprié, selon le mode différé.

bool

Si True, récupère à nouveau les données du run depuis le serveur, même si elles sont déjà chargées.

RunNotFoundError : si le run est introuvable ou si ses données ne peuvent pas être chargées.

méthode Run.load_full_data()

self,
force: 'bool' = False

Charge les données complètes du run, y compris les champs volumineux tels que config, systemMetrics et summaryMetrics. Cette méthode est utile lorsque vous avez initialement utilisé lazy=True pour lister les runs, mais que vous avez besoin d’accéder aux données complètes de certains runs.

bool

Force le rechargement, même si les données sont déjà chargées.

méthode Run.log_artifact()

self,
artifact: 'wandb.Artifact',
aliases: 'Collection[str] | None' = None,
tags: 'Collection[str] | None' = None

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

wandb.Artifact

Un artifact renvoyé par wandb.Api().artifact(name).

Collection[str] | None

Alias à appliquer à cet artifact.

Collection[str] | None

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

méthode Run.logged_artifacts()

self,
per_page: 'int' = 100

Récupère tous les artifacts journalisés par ce run. Récupère tous les artifacts de sortie journalisés au cours du run. Renvoie un résultat paginé que vous pouvez parcourir ou regrouper dans une seule liste.

int

Nombre d’artifacts à récupérer par requête API.

import wandb
import tempfile

with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".txt") as tmp:
    tmp.write("This is a test artifact")
    tmp_path = tmp.name
run = wandb.init(project="artifact-example")
artifact = wandb.Artifact("test_artifact", type="dataset")
artifact.add_file(tmp_path)
run.log_artifact(artifact)
run.finish()

api = wandb.Api()

finished_run = api.run(f"{run.entity}/{run.project}/{run.id}")

for logged_artifact in finished_run.logged_artifacts():
    print(logged_artifact.name)

méthode Run.save()

self

Enregistre dans le backend W&B les modifications apportées à l’objet run.

méthode Run.scan_history()

self,
keys: 'list[str] | None' = None,
page_size: 'int' = 1000,
min_step: 'int' = 0,
max_step: 'int | None' = None,
use_cache: 'bool' = True

Renvoie une collection itérable de tous les enregistrements d’historique d’un run.

list[str] | None

Liste des métriques à lire dans l’historique du run. L’analyse ne renvoie que les lignes contenant toutes les clés demandées. Si les clés ont été journalisées à des étapes différentes, effectuez un appel distinct pour chaque clé ou omettez cet argument. Si aucune clé n’est fournie, toutes les métriques sont renvoyées.

int

le nombre d’enregistrements de l’historique à lire à la fois.

int

L’étape minimum à partir de laquelle lire l’historique (incluse).

int | None

L’étape maximum jusqu’à laquelle lire l’historique (exclue).

bool

Si la valeur est True, recherche un historique de run dans WANDB_CACHE_DIR. Si l’historique du run est introuvable dans le cache, il est téléchargé depuis le serveur. Si la valeur est False, l’historique du run est téléchargé à chaque fois.

méthode Run.stop()

self

Demande l’arrêt propre de ce run. Cette méthode active l’indicateur d’arrêt du run sur le backend W&B, soit le même signal que celui envoyé par le bouton « Stop run » dans l’interface de l’application W&B. Le processus qui exécute le run récupère cet indicateur lors de son signal de pulsation régulier et arrête le run proprement. Vous pouvez donc l’utiliser sans risque pour arrêter des runs distants (par exemple, des runs sur des pods Kubernetes). L’arrêt est asynchrone : cette méthode rend la main dès que le backend a marqué le run, et non lorsque le run se termine. L’appeler de nouveau, ou sur un run qui n’est plus en cours d’exécution, n’a aucun effet.

wandb.Error : si la requête échoue.

import wandb

run = wandb.Api().run("entity/project/run_id")
run.stop()

méthode Run.to_html()

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

Génère du code HTML contenant une iframe qui affiche ce run.

int

Aucune description fournie.

bool

Aucune description fournie.

méthode Run.update()

self

Enregistre les modifications de l’objet run dans le backend W&B.

méthode Run.update_state()

self,
state: 'str'

Met à jour l’état d’un run. Transitions prises en charge :

vers pending depuis running, failed, crashed ou preempted (par exemple, pour remettre en file d’attente un run terminé ou en cours)
- vers failed depuis pending ou running (par exemple, pour marquer comme échoué un run préempté ou perdu)

Il est impossible de mettre à jour l’état des runs de sweep. Consultez Run.state pour obtenir la liste des états de run possibles.

str

L’état cible du run. Valeurs possibles : "pending" ou "failed".

wandb.Error : si la transition d’état demandée n’est pas autorisée ou si le serveur ne prend pas en charge cette opération.

méthode Run.upload_file()

self,
path: 'str',
root: 'str' = '.'

Téléverse un fichier local vers W&B et l’associe à ce run.

str

Chemin du fichier à téléverser. Il peut être absolu ou relatif.

str

Chemin racine par rapport auquel le fichier est enregistré. Par exemple, pour que le fichier soit enregistré dans le run sous « my_dir/file.txt » alors que vous vous trouvez dans « my_dir », définissez root sur « ../ ». Par défaut, il s’agit du répertoire courant (« . »).

méthode Run.use_artifact()

self,
artifact: 'wandb.Artifact',
use_as: 'str | None' = None

Déclare un artifact comme entrée d’un run.

wandb.Artifact

Un artifact renvoyé par wandb.Api().artifact(name)

str | None

Chaîne qui identifie la manière dont l’artifact est utilisé dans le script. Permet de distinguer facilement les artifacts utilisés dans un run lorsque vous utilisez la fonctionnalité de remplacement d’artifacts de wandb launch (bêta).

méthode Run.used_artifacts()

self,
per_page: 'int' = 100

Récupère les artifacts explicitement utilisés par ce run. Récupère uniquement les artifacts d’entrée explicitement déclarés comme utilisés pendant le run, généralement via run.use_artifact(). Renvoie un résultat paginé que vous pouvez parcourir élément par élément ou regrouper dans une liste unique.

int

Nombre d’artifacts à récupérer par requête API.

import wandb

run = wandb.init(project="artifact-example")
run.use_artifact("test_artifact:latest")
run.finish()

api = wandb.Api()
finished_run = api.run(f"{run.entity}/{run.project}/{run.id}")
for used_artifact in finished_run.used_artifacts():
    print(used_artifact.name)
test_artifact

méthode Run.wait_until_finished()

self

Vérifie l’état du run jusqu’à ce qu’il soit terminé.

​Classe wandb.apis.public.Run

​Arguments

​Attributs

​Propriétés

​Méthodes

​méthode Run.beta_scan_history()

​méthode Run.console_logs()

​méthode Run.create()

​méthode Run.delete()

​méthode Run.download_history_exports()

​méthode Run.file()

​méthode Run.files()

​méthode Run.history()

​méthode Run.load()

​méthode Run.load_full_data()

​méthode Run.log_artifact()

​méthode Run.logged_artifacts()

​méthode Run.save()

​méthode Run.scan_history()

​méthode Run.stop()

​méthode Run.to_html()

​méthode Run.update()

​méthode Run.update_state()

​méthode Run.upload_file()

​méthode Run.use_artifact()

​méthode Run.used_artifacts()

​méthode Run.wait_until_finished()

Classe wandb.apis.public.Run

Arguments

Attributs

Propriétés

Méthodes

méthode Run.beta_scan_history()

méthode Run.console_logs()

méthode Run.create()

méthode Run.delete()

méthode Run.download_history_exports()

méthode Run.file()

méthode Run.files()

méthode Run.history()

méthode Run.load()

méthode Run.load_full_data()

méthode Run.log_artifact()

méthode Run.logged_artifacts()

méthode Run.save()

méthode Run.scan_history()

méthode Run.stop()

méthode Run.to_html()

méthode Run.update()

méthode Run.update_state()

méthode Run.upload_file()

méthode Run.use_artifact()

méthode Run.used_artifacts()

méthode Run.wait_until_finished()