> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Run
export const GitHubLink = ({url, compact = false}) =>
{compact ? "View source" : <>
GitHub source
}
;
Classe wandb.apis.public.Run
Un run individuel associé à un entity et à un projet.
```python theme={"system"}
(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
Interface vers le service wandb-core qui effectue les appels d’API W\&B pour ce run.
L’entity associé au run.
Le projet associé au run.
L’identifiant unique du run.
Les attributs du run.
Indique s’il faut inclure les sweeps dans le run.
Aucune description fournie.
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
Obtient la configuration de run. Charge automatiquement l’ensemble des données en mode différé (lazy mode).
L’entity associé au run.
L’identifiant unique du run.
Renvoie la dernière étape journalisée dans l’historique du run.
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.
Le nom du run.
Le chemin du run, sous forme de liste contenant l’entity, le projet et le run\_id.
Obtient la configuration de run brute, clés internes comprises. Charge automatiquement l’ensemble des données en mode différé (lazy mode).
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). |
L’identifiant de stockage unique du run.
Obtient les métriques de synthèse du run. Charge automatiquement l’ensemble des données en mode différé (lazy mode).
Obtient les métriques de synthèse du run. Charge automatiquement l’ensemble des données en mode différé (lazy mode).
Le sweep associé à ce run. Charge les données du sweep si include\_sweeps vaut False.
Obtient le nom du sweep. Toujours disponible, car sweepName fait partie du fragment allégé.
Obtient les métriques système du run. Charge automatiquement l’ensemble des données en mode différé (lazy mode).
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`.
Cette API est obsolète. Utilisez `entity` à la place.
```python theme={"system"}
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.
Arguments
Nombre de lignes à récupérer par requête lors de la lecture du journal depuis le début. Ignoré si `last` est fourni.
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.
Exceptions levé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.
Exemples
```python theme={"system"}
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()
```python theme={"system"}
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.
Arguments
L’instance de l’API W\&B.
ID du run (facultatif). S’il n’est pas fourni, un ID aléatoire est généré.
Nom du projet (facultatif). Par défaut, le projet défini dans les paramètres de l’API ou « uncategorized ».
Nom de l’entity (utilisateur ou équipe) (facultatif).
État initial du run. Utilisez « pending » pour les runs qui seront repris ultérieurement, ou « running » pour une exécution immédiate.
Exemples
Créer un run en attente pour l’exécuter ultérieurement
```python theme={"system"}
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()
```python theme={"system"}
self,
delete_artifacts: 'bool' = False
```
Supprime le run spécifié du backend W\&B.
Arguments
Indique si les artifacts associés au run doivent être supprimés.
méthode Run.download\_history\_exports()
```python theme={"system"}
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é.
Arguments
Le répertoire dans lequel télécharger les fichiers d’historique.
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.
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 vers des fichiers Parquet.
* `WandbApiFailedError` : si la requête API échoue pour une raison autre qu’un historique incomplet.
méthode Run.file()
```python theme={"system"}
self,
name: 'str'
```
Renvoie le chemin du fichier portant le nom indiqué dans l’artifact.
Arguments
Nom du fichier demandé.
méthode Run.files()
```python theme={"system"}
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é.
Arguments
noms des fichiers demandés ; si la liste est vide, tous les fichiers sont renvoyés
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.
nombre de résultats par page.
méthode Run.history()
```python theme={"system"}
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.
Arguments
(int, facultatif) Nombre d’échantillons à renvoyer
(list, facultatif) Renvoyer uniquement les métriques des clés spécifiées
(str, facultatif) Métrique à utiliser comme axe des x (xAxis) ; valeur par défaut : \_step
(bool, facultatif) Renvoyer un dataframe pandas
(str, facultatif) "default" pour les métriques, "system" pour les métriques machine
méthode Run.load()
```python theme={"system"}
self,
force: 'bool' = False
```
Charge les données du run à l’aide du fragment approprié, selon le mode différé.
Arguments
Si `True`, récupère à nouveau les données du run depuis le serveur, même si elles sont déjà chargées.
Exceptions levées
* `RunNotFoundError` : si le run est introuvable ou si ses données ne peuvent pas être chargées.
méthode Run.load\_full\_data()
```python theme={"system"}
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.
Arguments
Force le rechargement, même si les données sont déjà chargées.
méthode Run.log\_artifact()
```python theme={"system"}
self,
artifact: 'wandb.Artifact',
aliases: 'Collection[str] | None' = None,
tags: 'Collection[str] | None' = None
```
Déclare un artifact comme sortie d’un run.
Arguments
Un artifact renvoyé par `wandb.Api().artifact(name)`.
Alias à appliquer à cet artifact.
(liste, facultatif) Tags à appliquer à cet artifact, le cas échéant.
méthode Run.logged\_artifacts()
```python theme={"system"}
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.
Arguments
Nombre d’artifacts à récupérer par requête API.
Exemples
```python theme={"system"}
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()
```python theme={"system"}
self
```
Enregistre dans le backend W\&B les modifications apportées à l’objet run.
méthode Run.scan\_history()
```python theme={"system"}
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.
Arguments
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.
le nombre d’enregistrements de l’historique à lire à la fois.
L’étape minimum à partir de laquelle lire l’historique (incluse).
L’étape maximum jusqu’à laquelle lire l’historique (exclue).
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()
```python theme={"system"}
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.
Exceptions levées
* `wandb.Error` : si la requête échoue.
Exemples
```python theme={"system"}
import wandb
run = wandb.Api().run("entity/project/run_id")
run.stop()
```
méthode Run.to\_html()
```python theme={"system"}
self,
height: 'int' = 420,
hidden: 'bool' = False
```
Génère du code HTML contenant une iframe qui affiche ce run.
```python theme={"system"}
self
```
Enregistre les modifications de l’objet run dans le backend W\&B.
méthode Run.update\_state()
```python theme={"system"}
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.
Arguments
L’état cible du run. Valeurs possibles : `"pending"` ou `"failed"`.
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()
```python theme={"system"}
self,
path: 'str',
root: 'str' = '.'
```
Téléverse un fichier local vers W\&B et l’associe à ce run.
Arguments
Chemin du fichier à téléverser. Il peut être absolu ou relatif.
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()
```python theme={"system"}
self,
artifact: 'wandb.Artifact',
use_as: 'str | None' = None
```
Déclare un artifact comme entrée d’un run.
Arguments
Un artifact renvoyé par `wandb.Api().artifact(name)`
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()
```python theme={"system"}
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.
Arguments
Nombre d’artifacts à récupérer par requête API.
Exemples
```python theme={"system"}
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()
```python theme={"system"}
self
```
Vérifie l’état du run jusqu’à ce qu’il soit terminé.