> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-update-service-api-9.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Run
export const GitHubLink = ({url, compact = false}) =>
{compact ? "voir la source" : <>
Source GitHub
}
;
## Classe wandb.Run
Une unité de calcul journalisée par W\&B. Il s'agit généralement d'une expérience de machine learning.
Appelez [`wandb.init()`](https://docs.wandb.ai/models/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 run unique.
Voir [Log distributed training experiments](https://docs.wandb.ai/models/track/log/distributed-training)
pour plus d'informations.
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. Voir
[Create an experiment](https://docs.wandb.ai/models/track/create-an-experiment) ou
la page de référence de l'API [`wandb.init`](https://docs.wandb.ai/models/ref/python/functions/init)
pour plus d'informations.
Il existe un autre objet `Run` dans l'espace de noms
[`wandb.apis.public`](https://docs.wandb.ai/models/ref/python/public-api/api).
Utilisez cet objet pour interagir avec des runs déjà
créés.
## Attributs
* `summary`: (Synthèse) Synthèse du run, sous la forme d'un objet de type dictionnaire. Pour plus d'informations, voir [Log summary metrics](https://docs.wandb.ai/models/track/log/log-summary).
## Exemples
Créez un run avec `wandb.init()` :
```python theme={null}
import wandb
# Démarrer un nouveau run et enregistrer des données
# Utiliser un gestionnaire de contexte (instruction `with`) pour terminer automatiquement le run
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 sont enregistrés les fichiers d'un run.
Cela concerne les fichiers enregistrés avec `run.save()`, y compris ceux créés
automatiquement pour certains types de données transmis à `run.log()`. Pour le
répertoire contenant toutes les données d'un run, voir `run.sync_dir`.
True si le run est désactivé, False sinon.
Nom de l'entité W\&B associée au run.
L'entité peut être un nom d'utilisateur ou le nom d'une équipe ou d'une organisation.
Renvoie le nom du groupe associé à ce run.
Le regroupement de runs permet d'organiser et de visualiser ensemble des expériences
associées dans l'interface W\&B. Cela est particulièrement utile dans des scénarios tels
que l'entraînement distribué ou la validation croisée, où plusieurs runs doivent être
consultés et gérés comme une expérience unifiée.
En mode partagé, où tous les processus partagent le même objet run,
il n'est généralement pas nécessaire de définir un groupe, puisqu'il n'y a qu'un seul
run et qu'aucun regroupement n'est requis.
Identifiant de ce run.
Nom du type de tâche associé au run.
Consultez le type de tâche d'un run sur sa page Aperçu dans W\&B App.
Vous pouvez l'utiliser pour catégoriser les runs selon leur type de tâche, par exemple
« training », « evaluation » ou « inference ». Cela est utile pour organiser
et filtrer les runs dans l'interface W\&B, en particulier lorsque plusieurs
runs de types de tâches différents se trouvent dans le même projet. Pour plus
d'informations, voir [Organiser les runs](https://docs.wandb.ai/models/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 multiligne et inclure des équations Markdown et LaTeX
entre `$$`, comme `$x + 3$`.
True si le run est hors ligne, False sinon.
Chemin du run.
Les chemins de run comprennent l'entité, 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ébut du run.
Étape 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 toutes les données d'un run.
Il peut être transmis à `wandb sync` pour téléverser ou retéléverser le run.
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={null}
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 indiqués.
##### Arguments
Le titre de l’alerte, qui doit comporter moins de 64 caractères.
Le corps du message de l’alerte.
Le niveau d’alerte à utiliser : `INFO`, `WARN` ou `ERROR`.
Le délai d’attente (en secondes) avant d’envoyer une autre alerte avec ce titre.
### méthode Run.define\_metric()
```python theme={null}
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
```
Personnalisez les métriques journalisées avec `wandb.Run.log()`.
##### Arguments
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. Par défaut, True si step\_metric est spécifiée.
Masque cette métrique des graphiques générés automatiquement.
Spécifiez les agrégations de métriques ajoutées à la synthèse. Les agrégations prises en charge incluent « 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, en utilisant leurs valeurs pour tous les paramètres non spécifiés. Si true, les paramètres non spécifiés remplacent les valeurs définies par les appels précédents.
### méthode Run.display()
```python theme={null}
self,
height: 'int' = 420,
hidden: 'bool' = False
```
Affiche ce run dans Jupyter.
##### Arguments
Aucune description fournie.
Aucune description fournie.
### méthode Run.finish()
```python theme={null}
self,
exit_code: 'int | None' = None
```
Terminez un run et téléversez 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.
Run States:
* Running : run actif qui journalise des données et/ou envoie des signaux de pulsation.
* Crashed : run qui a cessé d’envoyer des signaux de pulsation de façon 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 statut de sortie du run. Utilisez 0 pour signaler une réussite ; toute autre valeur marque le run comme échoué.
### méthode Run.finish\_artifact()
```python theme={null}
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é comme sortie d’un run.
Les "upserts" ultérieurs avec le même ID distribué créeront une nouvelle version.
##### Arguments
Chemin vers le contenu de cet artifact,
pouvant 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`.
Nom d’un artifact. Peut être préfixé par entité/projet.
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 sera le nom de base du chemin, précédé de l’ID du run actuel.
Le type d’artifact à journaliser, par exemple `dataset`, `model`
Alias à appliquer à cet artifact, valeurs 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={null}
self,
artifact: 'Artifact',
target_path: 'str',
aliases: 'list[str] | None' = None
```
Liez l'artifact à une collection.
Le terme « link » désigne des pointeurs qui relient l’emplacement où W\&B stocke l'artifact à celui où l'artifact est accessible dans le registre. W\&B ne duplique pas les artifacts lorsque vous liez un artifact à une collection.
Affichez les artifacts liés dans l’interface utilisateur du registre pour la collection spécifiée.
##### Arguments
L’objet artifact à lier à la collection.
Le chemin de la collection. Il se compose du préfixe « wandb-registry- », ainsi que du nom du registre et du nom de la collection : `wandb-registry-{REGISTRY_NAME}/{COLLECTION_NAME}`.
Ajoutez un ou plusieurs alias à l'artifact lié. L’alias « latest » est automatiquement appliqué à l'artifact le plus récent que vous liez.
##### Exemples
```python theme={null}
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={null}
self,
path: 'StrPath',
registered_model_name: 'str',
name: 'str | None' = None,
aliases: 'list[str] | None' = None
```
Journaliser une version d’un artifact de modèle et la lier à un modèle enregistré dans le registre de modèles.
Les versions de modèle liées sont visibles dans l’UI pour le modèle enregistré spécifié.
Cette méthode :
* Vérifie si l’artifact de modèle 'name' a été journalisé. Si c’est le cas, utilise la version de l’artifact correspondant aux fichiers
situés à 'path' ou journalise une nouvelle version. Sinon, elle journalise les fichiers sous 'path' en tant que nouvel artifact de modèle, 'name',
de type 'model'.
* Vérifie si un modèle enregistré nommé 'registered\_model\_name' existe dans le projet 'model-registry'.
Sinon, crée un nouveau modèle enregistré nommé 'registered\_model\_name'.
* Lie la version de l’artifact de modèle 'name' au modèle enregistré 'registered\_model\_name'.
* Attache les alias de la liste 'aliases' à la version de l’artifact de modèle nouvellement liée.
##### Arguments
(str) Chemin vers le contenu de ce modèle, pouvant 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, représentant généralement une tâche de ML propre à une équipe. L’entité à laquelle ce modèle enregistré appartient est dérivée du run.
Nom de l’artifact de modèle dans lequel les fichiers de 'path' seront journalisés. Par défaut, il s’agit du nom de base du chemin, précédé de l’ID du run actuel, s’il n’est pas spécifié.
Alias appliqués uniquement à cet artifact lié dans le modèle enregistré. L’alias "latest" est toujours appliqué à la version la plus récente d’un artifact lié.
##### Exceptions levées
* `AssertionError`: Si registered\_model\_name est un chemin ou si l’artifact de modèle 'name' est d’un type ne contenant pas la sous-chaîne 'model'.
* `ValueError`: Si name contient des caractères spéciaux non valides.
### méthode Run.log()
```python theme={null}
self,
data: 'dict[str, Any]',
step: 'int | None' = None,
commit: 'bool | None' = None
```
Téléversez les données d'un run.
Utilisez `log` pour journaliser les données des runs, comme des scalaires, des images, des vidéos,
des histogrammes, des graphiques et des tableaux. Voir [Journaliser des objets et des médias](https://docs.wandb.ai/models/track/log) pour
des extraits de code, des bonnes pratiques, etc.
Utilisation de base :
```python theme={null}
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 espace de travail sur [wandb.ai](https://wandb.ai), ou localement sur une [instance auto-hébergée](https://docs.wandb.ai/platform/hosting) de l’application W\&B, ou exportez les données pour les visualiser et les explorer en local, par exemple dans un notebook Jupyter, avec l’[API publique](https://docs.wandb.ai/models/track/public-api-guide).
Les valeurs journalisées ne doivent pas nécessairement être des scalaires. Vous pouvez journaliser n’importe quel [type de données pris en charge par W\&B](https://docs.wandb.ai/models/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. Voir le tutoriel [Journaliser des tableaux, visualiser et interroger des données](https://docs.wandb.ai/models/tables/tables-walkthrough) pour plus de détails.
W\&B organise les métriques dont le nom contient une barre oblique (`/`) en sections nommées d’après le texte situé avant la dernière barre oblique. Par exemple, le résultat suivant comporte deux sections nommées "train" et "validate" :
```python theme={null}
with wandb.init() as run:
# Journaliser les 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})`
crée 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 votre journalisation à une fois toutes les N itérations,
ou collectez les données sur plusieurs itérations et journalisez-les en une seule étape.
Par défaut, chaque appel à `log` crée une nouvelle "étape".
L’étape doit toujours augmenter, et il n’est pas possible de journaliser des données
sur une étape précédente. Vous pouvez utiliser n’importe quelle métrique comme axe des X dans les graphiques.
Voir [Axes de journalisation personnalisés](https://docs.wandb.ai/models/track/log/customize-logging-axes)
pour plus de détails.
Dans de nombreux cas, il est préférable de traiter l’étape W\&B comme
un horodatage plutôt que comme une étape d’entraînement.
```python theme={null}
with wandb.init() as run:
# Exemple : journaliser une métrique "epoch" à utiliser comme axe X.
run.log({"epoch": 40, "train-loss": 0.5})
```
Il est possible d’utiliser plusieurs appels à `wandb.Run.log()` pour journaliser des données à la même étape à l’aide des paramètres `step` et `commit`.
Les exemples suivants sont tous équivalents :
```python theme={null}
with wandb.init() as run:
# Utilisation normale :
run.log({"train-loss": 0.5, "accuracy": 0.8})
run.log({"train-loss": 0.4, "accuracy": 0.9})
# Étape implicite sans auto-incrémentation :
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})
# Étape 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` avec des clés `str` et des valeurs qui sont des objets Python sérialisables, y compris : `int`, `float` et `string` ; n’importe lequel des `wandb.data_types` ; des listes, tuples et tableaux NumPy d’objets Python sérialisables ; d’autres `dict` de cette structure.
Le numéro d’étape à journaliser. Si `None`, une étape implicite avec auto-incrémentation est utilisée. Voir les notes dans la description.
Si vrai, finalisez et téléversez l’étape. Si faux, accumulez les données pour l’étape. Voir les notes dans la description. Si `step` est `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 davantage d’exemples, plus détaillés, voir
[nos guides sur la journalisation](https://docs.wandb.ai/models/track/log).
Utilisation de base
```python theme={null}
import wandb
with wandb.init() as run:
run.log({"train-loss": 0.5, "accuracy": 0.9
```
Journalisation incrémentielle
```python theme={null}
import wandb
with wandb.init() as run:
run.log({"loss": 0.2}, commit=False)
# Ailleurs, quand je suis prêt à enregistrer cette étape :
run.log({"accuracy": 0.8})
```
Histogramme
```python theme={null}
import numpy as np
import wandb
# échantillonner des gradients aléatoirement depuis une distribution normale
gradients = np.random.randn(100, 100)
with wandb.init() as run:
run.log({"gradients": wandb.Histogram(gradients)})
```
Image depuis NumPy
```python theme={null}
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 provenant de PIL
```python theme={null}
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 depuis NumPy
```python theme={null}
import numpy as np
import wandb
with wandb.init() as run:
# les axes sont (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={null}
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) # graphique y = x^2
run.log({"chart": fig})
```
Courbe précision-rappel
```python theme={null}
import wandb
with wandb.init() as run:
run.log({"pr": wandb.plot.pr_curve(y_test, y_probas, labels)})
```
Objet 3D
```python theme={null}
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()
```python theme={null}
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.
##### Arguments
(str ou Artifact) Chemin vers le contenu de cet artifact,
sous l’une des formes suivantes :
* `/local/directory`
* `/local/directory/file.txt`
* `s3://bucket/path`
Vous pouvez également transmettre un objet Artifact créé en appelant
`wandb.Artifact`.
(str, facultatif) Nom d’artifact. Les noms valides peuvent prendre les formes suivantes :
* name:version
* name:alias
* digest
Si ce paramètre n’est pas spécifié, la valeur par défaut est le nom de base du chemin, préfixé par l’ID du run actuel.
(str) Type d’artifact à journaliser, par exemple `dataset`, `model`
(list, facultatif) Alias à appliquer à cet artifact. La valeur par défaut est `["latest"]`
(list, facultatif) Tags à appliquer à cet artifact, le cas échéant.
### méthode Run.log\_code()
```python theme={null}
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 le nom se termine par `.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 notre artifact de code. Par défaut, l'artifact sera nommé `source-$PROJECT_ID-$ENTRYPOINT_RELPATH`. Dans certains cas, vous pouvez vouloir que plusieurs runs partagent le même artifact. Spécifier un nom vous permet de le faire.
Une fonction qui accepte un chemin de fichier et, éventuellement, un chemin racine, puis renvoie `True` s’il doit être inclus et `False` sinon. Par défaut, c’est `lambda path, root: path.endswith(".py")`.
Une fonction qui accepte un chemin de fichier et, éventuellement, un chemin racine, puis renvoie `True` s’il doit être exclu et `False` sinon. Par défaut, une fonction exclut tous les fichiers des répertoires `/.wandb/` et `/wandb/`.
##### Exemples
Utilisation de base
```python theme={null}
import wandb
with wandb.init() as run:
run.log_code()
```
Utilisation avancée
```python theme={null}
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={null}
self,
path: 'StrPath',
name: 'str | None' = None,
aliases: 'list[str] | None' = None
```
Journalise un artifact de modèle contenant le contenu du 'path' dans un run 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 traits de soulignement et des traits d'union.
##### Arguments
(str) Chemin vers le contenu de ce modèle,
pouvant 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é. Par défaut, il s'agit du nom de base du chemin, précédé de l'ID du run actuel, s'il n'est pas spécifié.
Alias à appliquer à l'artifact de modèle créé, avec `["latest"]` comme valeur par défaut
##### Exceptions levées
* `ValueError`: Si `name` contient des caractères spéciaux non valides.
### méthode Run.mark\_preempting()
```python theme={null}
self
```
Marquez cette run comme préemptée.
Indique également au processus interne de le signaler immédiatement au serveur.
### méthode Run.pin\_config\_keys()
```python theme={null}
self,
keys: 'Sequence[str]' = ()
```
Épinglez les clés de configuration à afficher dans la section References de Run Aperçu.
Les clés épinglées apparaissent bien en évidence au-dessus de Notes sur la page Run Aperçu. Les valeurs de type chaîne sont affichées en markdown ; les valeurs non textuelles sont affichées en texte brut. Un 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 de chaînes de clés exactes (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={null}
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, il n’est téléchargé que s’il n’existe pas déjà.
##### Arguments
Le nom du fichier.
Chemin facultatif vers un run à partir duquel récupérer des fichiers, c.-à-d. `username/project_name/run_id` si wandb.init n’a pas été appelé, ce paramètre est requis.
Indique s’il faut télécharger le fichier même s’il existe déjà localement
Le répertoire dans lequel télécharger le fichier. Valeur par défaut : le répertoire courant, ou le répertoire du run si wandb.init a été appelé.
##### Exceptions levées
* `CommError`: Si W\&B ne peut pas se connecter au backend W\&B.
* `ValueError`: Si le fichier est introuvable ou si `run_path` est introuvable.
### méthode Run.save()
```python theme={null}
self,
glob_str: 'str | os.PathLike',
base_path: 'str | os.PathLike | None' = None,
policy: 'PolicyName' = 'live',
glob: 'bool' = True
```
Synchronisez un ou plusieurs fichiers dans W\&B.
Les chemins relatifs sont interprétés par rapport au répertoire de travail actuel.
Un glob Unix, tel que "myfiles/\*", est développé au moment de l'appel à `save`, quelle que soit la valeur de `policy`. En particulier, les nouveaux fichiers ne sont pas ajoutés 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 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 apparaissent dans un
nom de fichier réel (par ex. "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 complètement l'expansion
des motifs et traiter `glob_str` comme un chemin littéral.
Vous pouvez fournir un `base_path` pour contrôler la structure de répertoires des fichiers téléversés. Il doit être un préfixe de `glob_str`, et la structure de répertoires située en dessous est conservée.
Lorsqu'un chemin absolu ou un glob est fourni sans `base_path`, un niveau de répertoire est conservé, comme dans l'exemple ci-dessus.
Les fichiers sont automatiquement dédupliqués : appeler `save()` plusieurs fois sur le même fichier sans le modifier ne le téléverse pas à nouveau.
##### Arguments
Un chemin relatif ou absolu, ou un glob Unix.
Un chemin utilisé pour déduire une structure de répertoires ; voir les exemples.
L'une des valeurs `live`, `now` ou `end`.
* live: téléverser le fichier à mesure qu'il change, en remplaçant 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 s'il faut traiter `glob_str` comme un motif glob. La valeur par défaut est `True` pour assurer la compatibilité descendante. Définissez `False` pour traiter `glob_str` comme un chemin littéral, par exemple lorsque son nom contient des métacaractères de glob comme `[`, `]`, `*` ou `?` que vous ne souhaitez pas voir interprétés comme un motif.
### méthode Run.status()
```python theme={null}
self
```
Obtenir les informations de synchronisation du run actuel depuis le backend interne.
### méthode Run.unwatch()
```python theme={null}
self,
models: 'torch.nn.Module | Sequence[torch.nn.Module] | None' = None
```
Supprime la topologie du modèle PyTorch ainsi que les hooks de gradient et de paramètres.
##### Arguments
Liste facultative de modèles PyTorch sur lesquels `watch` a été appelé.
### méthode Run.upsert\_artifact()
```python theme={null}
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éclarez (ou ajoutez à) un artifact non finalisé comme sortie d’un run.
Notez que vous devez appeler run.finish\_artifact() pour finaliser l’artifact.
Cela est utile lorsque plusieurs jobs distribués doivent tous contribuer au même artifact.
##### Arguments
Chemin vers le contenu de cet artifact. Il peut prendre les formes suivantes :
* `/local/directory`
* `/local/directory/file.txt`
* `s3://bucket/path`
Nom d’artifact. Peut être préfixé par "entité/projet". Par défaut, s’il n’est pas spécifié, il correspond au nom de base du chemin, précédé du run actuel ID. 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. La valeur par défaut est `["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.use\_artifact()
```python theme={null}
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é enregistré
("entité" ou "entité/projet"). Si aucune
entité n'est spécifiée dans le nom, l'entité du Run ou de la configuration de l'API est utilisée.
Les noms valides peuvent prendre les formes suivantes
* nom:version
* nom:alias
Le type d'artifact à utiliser.
Alias à appliquer à cet artifact
Cet argument est obsolète et n'a aucun effet.
##### Exemples
```python theme={null}
import wandb
run = wandb.init(project="")
# Utiliser un artifact par nom et alias
artifact_a = run.use_artifact(artifact_or_name=":")
# Utiliser un artifact par nom et version
artifact_b = run.use_artifact(artifact_or_name=":v")
# Utiliser un artifact par entité/projet/nom:alias
artifact_c = run.use_artifact(
artifact_or_name="//:"
)
# Utiliser un artifact par entité/projet/nom:version
artifact_d = run.use_artifact(
artifact_or_name="//:v"
)
# Terminer explicitement le run car aucun gestionnaire de contexte n'est utilisé.
run.finish()
```
### méthode Run.use\_model()
```python theme={null}
self,
name: 'str'
```
Télécharge les fichiers enregistrés dans un artifact de modèle `name`.
##### Arguments
nom d’un artifact de modèle. `name` doit correspondre au nom d’un artifact de modèle existant déjà enregistré. 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 l’artifact de modèle `name` est d’un type qui ne contient pas la sous-chaîne `model`.
### méthode Run.watch()
```python theme={null}
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
```
Ajoutez un hook au modèle PyTorch donné pour surveiller les gradients et le graphe de calcul du modèle.
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 », les « parameters » ou « all ». Définissez cette valeur sur None pour désactiver la journalisation. (par défaut="gradients").
Fréquence (en lots) de journalisation des gradients et des paramètres. (par défaut=1000)
Index utilisé pour suivre plusieurs modèles avec `wandb.watch`. (par défaut=None)
Indique s’il faut journaliser le graphe de calcul du modèle. (par défaut=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={null}
self,
text: 'str'
```
Écrivez du texte dans l'onglet Logs du run.
Utilisez `write_logs` pour écrire directement du texte dans l'onglet Logs, au lieu de
vous fier à la capture automatique de stdout/stderr. Les appels effectués après la fin du run sont
simplement ignorés.
Vous pouvez 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'est pas déjà présent.