> ## 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.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()`](/fr/products/wandb/ref/python/functions/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é](/fr/products/wandb/track/log/distributed-training).
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](/fr/products/wandb/track/create-an-experiment) ou la page de référence de l’API
[`wandb.init`](/fr/products/wandb/ref/python/functions/init).
Il existe un autre objet `Run` dans le
namespace [`wandb.apis.public`](/fr/products/wandb/ref/python/public-api/api).
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](/fr/products/wandb/track/log/log-summary).
Exemples
Créez un run avec `wandb.init()` :
```python theme={"system"}
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
Objet de configuration associé à ce run.
Objet de configuration statique associé à ce run.
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`.
True si le run est désactivé, False sinon.
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.
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.
Identifiant de ce run.
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](/fr/products/wandb/runs#organize-runs).
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.
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$`.
True si le run est hors ligne, False sinon.
Chemin du run.
Les chemins de run comprennent l’entity, le projet et l’ID du run, au format
`entity/project/run_id`.
Nom du projet W\&B associé au run.
URL du projet W\&B associé au run, le cas échéant.
Les runs hors ligne n’ont pas d’URL de projet.
True si le run a été repris, False sinon.
Copie figée de l’objet Settings du run.
Horodatage Unix (en secondes) du démarrage du run.
Step W\&B du prochain appel à `log()`.
Lève une erreur pour les runs en mode="shared".
Identifiant du sweep associé au run, le cas échéant.
URL du sweep associé au run, le cas échéant.
Les runs hors ligne n’ont pas d’URL de sweep.
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.
Tags associés au run, le cas échéant.
URL du run W\&B, le cas échéant.
Les runs hors ligne n’ont pas d’URL.
Méthodes
méthode Run.alert()
```python theme={"system"}
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.
Arguments
Le titre de l’alerte, qui doit comporter moins de 64 caractères.
Le corps du texte de l’alerte.
Le niveau d’alerte à utiliser, parmi : `INFO`, `WARN` ou `ERROR`.
Le délai d’attente (en secondes) avant d’envoyer une autre alerte portant ce titre.
Le nom de la métrique à personnaliser.
Le nom d’une autre métrique à utiliser comme axe X pour cette métrique dans les graphiques générés automatiquement.
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é.
Masque cette métrique dans les graphiques automatiques.
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é.
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()
```python theme={"system"}
self,
height: 'int' = 420,
hidden: 'bool' = False
```
Affiche ce run dans Jupyter.
```python theme={"system"}
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.
Arguments
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()
```python theme={"system"}
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.
Arguments
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`.
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.
Type d’artifact à journaliser, par exemple `dataset` ou `model`
Alias à appliquer à cet artifact. Par défaut : `["latest"]`
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()
```python theme={"system"}
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.
Arguments
L’objet artifact à lier à la collection.
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}`.
Ajoutez un ou plusieurs alias à l’artifact lié. L’alias « latest » est automatiquement attribué au dernier artifact que vous liez.
Exemples
```python theme={"system"}
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()
```python theme={"system"}
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.
Arguments
(str) Chemin vers le contenu de ce modèle, qui peut prendre les
formes suivantes :
* `/local/directory`
* `/local/directory/file.txt`
* `s3://bucket/path`
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.
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.
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é.
Exceptions levées
* `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()
```python theme={"system"}
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](/fr/products/wandb/track/log) pour
obtenir des extraits de code, des bonnes pratiques et plus encore.
Utilisation de base :
```python theme={"system"}
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](https://wandb.ai)
ou localement sur une [instance autohébergée](/fr/products/wandb/platform/hosting)
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](/fr/products/wandb/track/public-api-guide).
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](/fr/products/wandb/ref/python/data-types),
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](/fr/products/wandb/tables/tables-walkthrough).
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 » :
```python theme={"system"}
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](/fr/products/wandb/track/log/customize-logging-axes)
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.
```python theme={"system"}
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 :
```python theme={"system"}
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)
```
Arguments
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.
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.
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`.
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 des exemples plus nombreux et plus détaillés, consultez
[nos guides sur la journalisation](/fr/products/wandb/track/log).
Utilisation de base
```python theme={"system"}
import wandb
with wandb.init() as run:
run.log({"train-loss": 0.5, "accuracy": 0.9
```
Journalisation incrémentielle
```python theme={"system"}
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
```python theme={"system"}
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
```python theme={"system"}
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
```python theme={"system"}
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
```python theme={"system"}
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
```python theme={"system"}
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
```python theme={"system"}
import wandb
with wandb.init() as run:
run.log({"pr": wandb.plot.pr_curve(y_test, y_probas, labels)})
```
Objet 3D
```python theme={"system"}
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")),
]
}
)
```
(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, 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) Type de l’artifact à journaliser, par exemple `dataset` ou `model`
(list, facultatif) Alias à appliquer à cet artifact. Valeur par défaut : `["latest"]`
(list, facultatif) Tags éventuels à appliquer à cet artifact.
méthode Run.log\_code()
```python theme={"system"}
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`.
Arguments
Le chemin relatif (par rapport à `os.getcwd()`) ou absolu à partir duquel rechercher le code de manière récursive.
(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.
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")`.
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 `/.wandb/` et `/wandb/`.
Exemples
Utilisation de base
```python theme={"system"}
import wandb
with wandb.init() as run:
run.log_code()
```
Utilisation avancée
```python theme={"system"}
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()
```python theme={"system"}
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.
Arguments
(str) Chemin vers le contenu de ce modèle,
qui peut prendre les formes suivantes :
* `/local/directory`
* `/local/directory/file.txt`
* `s3://bucket/path`
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.
Alias à appliquer à l’artifact de modèle créé. Valeur par défaut : `["latest"]`
Exceptions levées
* `ValueError` : si le nom contient des caractères spéciaux non valides.
méthode Run.mark\_preempting()
```python theme={"system"}
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()
```python theme={"system"}
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.
Arguments
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()
```python theme={"system"}
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à.
Arguments
Le nom du fichier.
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é.
Indique s’il faut télécharger le fichier même s’il existe déjà en local
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é.
Exceptions levées
* `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()
```python theme={"system"}
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](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.
Arguments
Un chemin relatif ou absolu, ou un glob Unix.
Chemin utilisé pour déduire l’arborescence des répertoires ; voir les exemples.
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
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()
```python theme={"system"}
self
```
Obtient auprès du backend interne les informations sur le statut de synchronisation du run actuel.
méthode Run.unwatch()
```python theme={"system"}
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.
Arguments
Liste facultative de modèles PyTorch sur lesquels `watch` a été appelé.
méthode Run.upsert\_artifact()
```python theme={"system"}
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.
Arguments
Chemin vers le contenu de cet artifact,
qui peut prendre les formes suivantes :
* `/local/directory`
* `/local/directory/file.txt`
* `s3://bucket/path`
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
Type d’artifact à journaliser. Exemples courants : `dataset`, `model`.
Alias à appliquer à cet artifact. Valeur par défaut : `["latest"]`.
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()
```python theme={"system"}
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
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
Le type d’artifact à utiliser.
Alias à appliquer à cet artifact
Cet argument est obsolète et n’a aucun effet.
Exemples
```python theme={"system"}
import wandb
run = wandb.init(project="")
# Utiliser un artifact par son nom et son alias
artifact_a = run.use_artifact(artifact_or_name=":")
# Utiliser un artifact par son nom et sa version
artifact_b = run.use_artifact(artifact_or_name=":v")
# Utiliser un artifact via entity/project/name:alias
artifact_c = run.use_artifact(
artifact_or_name="//:"
)
# Utiliser un artifact via entity/project/name:version
artifact_d = run.use_artifact(
artifact_or_name="//:v"
)
# Terminer explicitement le run, puisqu’aucun gestionnaire de contexte n’est utilisé.
run.finish()
```
méthode Run.use\_model()
```python theme={"system"}
self,
name: 'str'
```
Télécharge les fichiers journalisés dans l’artifact de modèle 'name'.
Arguments
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
Exceptions levées
* `AssertionError` : si le type de l’artifact de modèle 'name' ne contient pas la sous-chaîne 'model'.
méthode Run.watch()
```python theme={"system"}
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.
Arguments
Un modèle unique ou une séquence de modèles à surveiller.
La fonction de perte à optimiser (facultatif).
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").
Fréquence (en lots) de journalisation des gradients et des paramètres. (default=1000)
Index utilisé pour suivre plusieurs modèles avec `wandb.watch`. (default=None)
Indique s’il faut journaliser le graphe de calcul du modèle. (default=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()
```python theme={"system"}
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.
Arguments
Le texte à écrire. Un saut de ligne final est ajouté s’il n’y en a pas.
## Related topics
- [Run](/fr/products/wandb/ref/python/public-api/run.md)