Passer au contenu principal

​
class Run

Un run individuel associé à une entité et à un projet.

​
méthode Run.__init__

__init__(
    client: 'RetryingClient',
    entity: 'str',
    project: 'str',
    run_id: 'str',
    attrs: 'Mapping | None' = None,
    include_sweeps: 'bool' = True,
    lazy: 'bool' = True,
    service_api: 'ServiceApi | None' = None
)
Arguments :
  • client: Le client de l’API W&B.
  • entity: L’entité associée au run.
  • project: Le projet associé au run.
  • run_id: L’identifiant unique du run.
  • attrs: Les attributs du run.
  • include_sweeps: Indique s’il faut inclure les Sweeps dans le run.
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 summary actuelle. L’appel à update enregistre toutes les modifications.
  • project (str): le projet associé au run
  • entity (str): le nom de l’entité associée 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 de l’historique enregistrées avec wandb.Run.log({"key": "value"})
  • metadata (str): métadonnées sur le run provenant de wandb-metadata.json
Initialise un objet Run. Run est toujours initialisé en appelant api.runs(), où api est une instance de wandb.Api.

​
propriété Run.config

Renvoie la configuration du run. Charge automatiquement l’ensemble des données en mode lazy. Retourne :
  • dict[str, Any]: La valeur de la propriété configuration.

​
propriété Run.entity

L’entité associée au run. Retourne :
  • str : La valeur de la propriété entité.

​
propriété Run.id

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

​
propriété Run.lastHistoryStep

Renvoie la dernière étape enregistrée dans l’historique du run. Retourne :
  • int : La valeur de la propriété lastHistoryStep.

​
propriété Run.metadata

Métadonnées du run issues de wandb-metadata.json. Les métadonnées incluent la description du run, les tags, l’heure de début, l’utilisation de la mémoire, etc. Retourne :
  • dict[str, Any] | None: La valeur de la propriété metadata.

​
propriété Run.name

Le nom du run. Retourne :
  • str | None : La valeur de la propriété name.

​
propriété Run.path

Le chemin du run. Le chemin est une liste qui contient l’entité, le projet et le run_id. Retourne :
  • list[str] : La valeur de la propriété path.

​
propriété Run.rawconfig

Renvoie la configuration brute du run, y compris les clés internes. Charge automatiquement toutes les données en mode lazy. Retourne :
  • dict[str, Any]: La valeur de la propriété rawconfig.

​
propriété Run.state

État du run. Peut prendre l’une des valeurs suivantes : Finished, Failed, Crashed ou Running. Retourne :
  • str : La valeur de la propriété state.

​
propriété Run.storage_id

L’identifiant de stockage unique du run. Retourne :
  • str : La valeur de la propriété storage_id.

​
propriété Run.summary

Obtient les métriques du summary du run. Charge automatiquement l’ensemble des données en mode lazy. Retourne :
  • HTTPSummary : La valeur de la propriété summary.

​
propriété Run.summary_metrics

Obtient les métriques summary du run. Charge automatiquement les données complètes en mode lazy. Retourne :
  • dict[str, Any]: La valeur de la propriété summary_metrics.

​
propriété Run.sweep_name

Obtient le nom du balayage. Toujours disponible, car sweepName se trouve dans le fragment léger. Retourne :
  • str | None : La valeur de la propriété sweep_name.

​
propriété Run.system_metrics

Renvoie les métriques système du run. Charge automatiquement toutes les données en mode lazy. Retourne :
  • dict[str, Any]: La valeur de la propriété system_metrics.

​
propriété Run.url

L’URL du run. L’URL du run est générée à partir de l’entité, du projet et de run_id. Pour les utilisateurs du SaaS, elle se présente sous la forme https://wandb.ai/entity/project/run_id. Retourne :
  • str : La valeur de la propriété url.

​
propriété Run.username

Cette API est obsolète. Utilisez plutôt entity. Retourne :
  • str : La valeur de la propriété username.

​
méthode Run.beta_scan_history

beta_scan_history(
    keys: 'list[str] | None' = None,
    page_size: 'int' = 1000,
    min_step: 'int' = 0,
    max_step: 'int | None' = None,
    use_cache: 'bool' = True
) → public.BetaHistoryScan
Renvoie une collection itérable de tous les enregistrements de l’historique d’un run. Cette fonction est encore en cours de développement et peut ne pas fonctionner comme prévu. Elle utilise wandb-core pour lire localement l’historique à partir de l’historique Parquet exporté d’un run. Arguments :
  • keys: liste des métriques à lire dans l’historique du run. Si aucune clé n’est fournie, toutes les métriques sont renvoyées.
  • page_size: le nombre d’enregistrements d’historique à lire à la fois.
  • min_step: l’étape minimale à partir de laquelle commencer à lire l’historique (inclus).
  • max_step: l’étape maximale jusqu’à laquelle lire l’historique (exclus).
  • use_cache: lorsqu’il est défini sur True, vérifie si l’historique d’un run est présent dans WANDB_CACHE_DIR. Si l’historique du run n’est pas trouvé dans le cache, il sera téléchargé depuis le serveur. S’il est défini sur False, l’historique du run sera téléchargé à chaque fois.
Retourne : Un objet BetaHistoryScan, sur lequel il est possible d’itérer pour obtenir les enregistrements de l’historique.

​
classmethod Run.create

create(
    api: 'public.Api',
    run_id: 'str | None' = None,
    project: 'str | None' = None,
    entity: 'str | None' = None,
    state: "Literal['running', 'pending']" = 'running'
) → Self
Crée un run pour le projet donné. Dans la plupart des cas, utilisez wandb.init(). wandb.init() offre un mécanisme plus robuste pour créer et mettre à jour des runs. wandb.apis.public.Run.create est destiné à des cas spécifiques, comme la création de runs à l’état “pending” pour des jobs qui peuvent ne pas être planifiables (par exemple, dans un cluster Kubernetes avec un nombre insuffisant de GPU ou une forte contention). Ces runs en attente peuvent ensuite être repris et suivis par W&B. Les runs créés avec cette méthode ont des capacités limitées. L’appel à update() sur un run créé de cette manière peut ne pas fonctionner comme prévu. Arguments :
  • api : Instance de l’API W&B.
  • run_id : ID de run facultatif. S’il n’est pas fourni, un ID aléatoire sera généré.
  • project : Nom du projet facultatif. Par défaut, le projet défini dans les paramètres de l’API est utilisé, ou “uncategorized”.
  • entity : Nom de l’entité facultatif (utilisateur ou équipe).
  • state : État initial du run. Utilisez “pending” pour les runs qui seront repris plus tard, ou “running” pour une exécution immédiate.
Retourne : Un objet Run représentant le run créé. Exemple : Création d’un run en attente pour une exécution ultérieure 
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

delete(delete_artifacts: 'bool' = False) → None
Supprime le run spécifié du backend wandb. Arguments :
  • delete_artifacts (bool, facultatif) : Indique s’il faut supprimer les artifacts associés au run.

​
méthode Run.download_history_exports

download_history_exports(
    download_dir: 'pathlib.Path | str',
    require_complete_history: 'bool' = True
) → runhistory.DownloadHistoryResult
Télécharge tous les fichiers parquet de l’historique du run dans le répertoire indiqué. Arguments :
  • download_dir: Répertoire dans lequel télécharger les fichiers d’historique.
  • require_complete_history: Indique s’il faut exiger le téléchargement de l’historique complet. Si cette valeur est true et que le run contient des données qui n’ont pas encore été exportées en fichiers parquet, une IncompleteRunHistoryError est levée.
Retourne : Un DownloadHistoryResult. Exceptions levées :
  • IncompleteRunHistoryError: Si require_complete_history vaut True et que le run contient des données qui n’ont pas encore été exportées en fichiers parquet.
  • WandbApiFailedError: Si la requête API échoue pour une raison autre qu’un historique incomplet.

​
méthode Run.file

file(name: 'str') → public.File
Renvoie le chemin d’un fichier portant le nom indiqué dans l’artifact. Arguments :
  • name (str): nom du fichier demandé.
Retourne : Un File correspondant à l’argument name.

​
méthode Run.files

files(
    names: 'list[str] | None' = None,
    pattern: 'str | None' = None,
    per_page: 'int' = 50
) → public.Files
Renvoie un objet Files pour tous les fichiers du run qui correspondent aux critères spécifiés. Vous pouvez spécifier une liste exacte de noms de fichiers à faire correspondre, ou un motif de correspondance. Si les deux sont fournis, le motif sera ignoré. Arguments :
  • names (liste) : noms des fichiers demandés ; si vide, renvoie tous les fichiers
  • pattern (str, facultatif) : motif à utiliser pour renvoyer les fichiers depuis W&B. Ce motif utilise la syntaxe LIKE de MySQL ; pour faire correspondre tous les fichiers se terminant par .json, utilisez “%.json”. Si names et pattern sont tous deux fournis, une ValueError sera levée.
  • per_page (int) : nombre de résultats par page.
Retourne : Un objet Files, qui est un itérateur sur des objets File.

​
méthode Run.history

history(
    samples: 'int' = 500,
    keys: 'list[str] | None' = None,
    x_axis: 'str' = '_step',
    pandas: 'bool' = True,
    stream: "Literal['default', 'system']" = 'default'
) → list[dict[str, Any]] | pd.DataFrame
Renvoie un échantillon des métriques de l’historique pour un run. Cette méthode est plus simple et plus rapide si vous acceptez que les enregistrements de l’historique soient échantillonnés. Arguments :
  • samples : (int, facultatif) Le nombre d’échantillons à renvoyer
  • pandas : (bool, facultatif) Renvoie un dataframe pandas
  • keys : (list, facultatif) Renvoie uniquement les métriques correspondant à des clés spécifiques
  • x_axis : (str, facultatif) Utiliser cette métrique comme xAxis ; la valeur par défaut est _step
  • stream : (str, facultatif) “default” pour les métriques, “system” pour les métriques système
Retourne :
  • pandas.DataFrame: Si pandas=True, renvoie un pandas.DataFrame des métriques de l’historique.
  • list of dicts: Si pandas=False, renvoie une liste de dicts contenant les métriques de l’historique.

​
méthode Run.load

load(force: 'bool' = False) → dict[str, Any]
Charge les données du run en utilisant le fragment approprié selon le mode lazy.

​
méthode Run.load_full_data

load_full_data(force: 'bool' = False) → dict[str, Any]
Chargez l’ensemble des données du run, y compris les champs volumineux comme config, systemMetrics et summaryMetrics. Cette méthode est utile si vous avez initialement utilisé lazy=True pour lister des runs, mais que vous devez accéder aux données complètes de certains runs. Arguments :
  • force : Force le rechargement même si les données sont déjà chargées
Retourne : Les attributs chargés du run

​
méthode Run.log_artifact

log_artifact(
    artifact: 'wandb.Artifact',
    aliases: 'Collection[str] | None' = None,
    tags: 'Collection[str] | None' = None
) → wandb.Artifact
Déclarer un artifact en tant que sortie d’un run. Arguments :
  • artifact (Artifact) : Un artifact renvoyé par wandb.Api().artifact(name).
  • aliases (liste, facultatif) : Alias à appliquer à cet artifact.
  • tags : (liste, facultatif) Tags à appliquer à cet artifact, le cas échéant.
Retourne : Un objet Artifact.

​
méthode Run.logged_artifacts

logged_artifacts(per_page: 'int' = 100) → public.RunArtifacts
Récupère tous les artifacts enregistrés par ce run. Récupère tous les artifacts de sortie qui ont été enregistrés pendant le run. Retourne un résultat paginé qui peut être parcouru ou rassemblé dans une seule liste. Arguments :
  • per_page: Nombre d’artifacts à récupérer par requête API.
Retourne : Une collection itérable de tous les objets Artifact enregistrés comme sorties pendant ce run. Exemple : 
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

save() → None
Enregistrez les modifications apportées à l’objet run sur le backend W&B.

​
méthode Run.scan_history

scan_history(
    keys: 'list[str] | None' = None,
    page_size: 'int' = 1000,
    min_step: 'int | None' = None,
    max_step: 'int | None' = None
) → Iterator[dict[str, Any]]
Renvoie une collection itérable de tous les enregistrements de l’historique d’un run. Arguments :
  • keys ([str], facultatif) : récupère uniquement ces clés, et uniquement les lignes pour lesquelles toutes ces clés sont définies.
  • page_size (int, facultatif) : taille des pages à récupérer depuis l’API.
  • min_step (int, facultatif) : nombre minimal de pages à analyser à la fois.
  • max_step (int, facultatif) : nombre maximal de pages à analyser à la fois.
Retourne : Une collection itérable d’enregistrements de l’historique (dict). Exemple : Exporter toutes les valeurs de perte d’un run d’exemple 
run = api.run("entity/project-name/run-id")
history = run.scan_history(keys=["Loss"])
losses = [row["Loss"] for row in history]

​
méthode Run.to_html

to_html(height: 'int' = 420, hidden: 'bool' = False) → str
Générez le code HTML contenant une iframe qui affiche ce run.

​
méthode Run.update

update() → None
Enregistre les modifications de l’objet run sur le backend wandb.

​
méthode Run.update_state

update_state(state: "Literal['pending']") → bool
Met à jour l’état d’un run. Permet de faire passer les runs de ‘failed’ ou ‘crashed’ à ‘pending’. Arguments :
  • state : L’état cible du run. Seul "pending" est pris en charge.
Retourne : True si l’état a bien été mis à jour. Exceptions levées :
  • 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

upload_file(path: 'str', root: 'str' = '.') → public.File
Téléverse un fichier local sur W&B et l’associe à ce run. Arguments :
  • path (str) : Chemin du fichier à téléverser. Il peut être absolu ou relatif.
  • root (str) : Chemin racine auquel le fichier est enregistré relativement. Par exemple, si vous souhaitez que le fichier soit enregistré dans le run sous la forme “my_dir/file.txt” et que vous vous trouvez actuellement dans “my_dir”, vous devez définir root sur ”../”. La valeur par défaut est le répertoire courant (”.”).
Retourne : Un objet File représentant le fichier téléversé.

​
méthode Run.use_artifact

use_artifact(
    artifact: 'wandb.Artifact',
    use_as: 'str | None' = None
) → wandb.Artifact
Déclarez un artifact comme entrée d’un run. Arguments :
  • artifact (Artifact) : Un artifact renvoyé par wandb.Api().artifact(name)
  • use_as (string, facultatif) : Une chaîne qui indique comment l’artifact est utilisé dans le script. Elle sert à différencier facilement les artifacts utilisés dans un run lors de l’utilisation de la fonctionnalité bêta d’échange d’artifacts de wandb Launch.
Retourne : Un objet Artifact.

​
méthode Run.used_artifacts

used_artifacts(per_page: 'int' = 100) → public.RunArtifacts
Récupère les artifacts explicitement utilisés par ce run. Récupère uniquement les artifacts d’entrée qui ont été explicitement déclarés comme utilisés lors du run, généralement via run.use_artifact(). Renvoie un résultat paginé qui peut être parcouru ou regroupé dans une seule liste. Arguments :
  • per_page: Nombre d’artifacts à récupérer par requête API.
Retourne : Une collection itérable d’objets Artifact explicitement utilisés en entrée dans ce run. Exemple : 
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

wait_until_finished() → None
Vérifiez l’état du run jusqu’à ce qu’il se termine.