")
```
Les attributs les plus couramment utilisés d'un objet run sont :
| Attribute | Meaning |
| --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `run.config` | Un dictionnaire contenant les informations de configuration du run, telles que les hyperparamètres d'un run d'entraînement ou les méthodes de prétraitement d'un run qui crée un Artifact de jeu de données. Considérez-les comme les entrées du run. |
| `run.history()` | Une liste de dictionnaires destinée à stocker les valeurs qui changent pendant l'entraînement du modèle, comme la perte. La commande `run.log()` ajoute des éléments à cet objet. |
| `run.summary` | Un dictionnaire d'informations qui résume les résultats du run. Il peut s'agir de scalaires comme la précision et la perte, ou de fichiers volumineux. Par défaut, `run.log()` définit le summary sur la dernière valeur d'une série temporelle enregistrée. Le contenu du summary peut aussi être défini directement. Considérez le summary comme les sorties du run. |
Vous pouvez également modifier ou mettre à jour les données de runs passés. Par défaut, une seule instance d'un objet API met en cache toutes les requêtes réseau. Si votre cas d'utilisation nécessite des informations en temps réel dans un script en cours d'exécution, appelez `api.flush()` pour obtenir des valeurs mises à jour.
### Interroger plusieurs runs
Ce script d’exemple recherche un projet et génère un CSV des runs avec leur nom, leur configuration et leurs statistiques de synthèse. Remplacez `` et `` par votre entité W\&B et le nom de votre projet, respectivement.
```python theme={null}
import pandas as pd
import wandb
api = wandb.Api()
entity, project = "", ""
runs = api.runs(entity + "/" + project)
summary_list, config_list, name_list = [], [], []
for run in runs:
# .summary contient les clés/valeurs de sortie pour
# des métriques telles que la précision.
# Nous appelons ._json_dict pour omettre les fichiers volumineux
summary_list.append(run.summary._json_dict)
# .config contient les hyperparamètres.
# Nous supprimons les valeurs spéciales qui commencent par _.
config_list.append({k: v for k, v in run.config.items() if not k.startswith("_")})
# .name est le nom du run lisible par l’utilisateur.
name_list.append(run.name)
runs_df = pd.DataFrame(
{"summary": summary_list, "config": config_list, "name": name_list}
)
runs_df.to_csv("project.csv")
run.finish()
```
L’API W\&B vous permet également d’effectuer des requêtes sur les runs d’un projet avec api.runs(). Le cas d’usage le plus courant consiste à exporter les données de runs pour une analyse personnalisée. L’interface de requête est la même que celle [utilisée par MongoDB](https://www.mongodb.com/docs/manual/reference/mql/query-predicates/).
```python theme={null}
runs = api.runs(
"username/project",
{"$or": [{"config.experiment_name": "foo"}, {"config.experiment_name": "bar"}]},
)
print(f"Found {len(runs)} runs")
```
L’appel à `api.runs` renvoie un objet `Runs` itérable qui se comporte comme une liste. Par défaut, l’objet charge 50 runs à la fois, séquentiellement et selon les besoins, mais vous pouvez modifier le nombre chargé par page avec l’argument nommé `per_page`.
`api.runs` accepte également un argument nommé `order`. L’ordre par défaut est `-created_at`. Pour trier les résultats par ordre croissant, indiquez `+created_at`. Vous pouvez également trier par des valeurs de config ou de synthèse. Par exemple, `summary.val_acc` ou `config.experiment_name`.
### Gestion des erreurs
Si des erreurs surviennent lors de la communication avec les serveurs W\&B, une exception `wandb.CommError` est levée. Vous pouvez examiner l’exception d’origine via l’attribut `exc`.
### Obtenir le nom et l’ID d’un run pendant un run actif
Après avoir appelé `wandb.init()`, vous pouvez accéder depuis votre script à l’ID aléatoire du run ou à son nom lisible, comme ceci :
* ID unique du run (hachage de 8 caractères) : `run.id`
* Nom aléatoire du run (lisible) : `run.name`
Si vous cherchez un bon moyen de définir des identifiants utiles pour vos runs, voici ce que nous recommandons :
* **ID du run** : laissez le hachage généré tel quel. Il doit être unique parmi les runs de votre projet.
* **Nom du run** : il doit être court, lisible et de préférence unique, afin que vous puissiez distinguer les différentes lignes sur vos graphiques.
* **Notes du run** : c’est l’endroit idéal pour ajouter une brève description de ce que vous faites dans ce run. Vous pouvez les définir avec `wandb.init(notes="your notes here")`
* **Tags du run** : utilisez les tags du run pour suivre des éléments de manière dynamique, puis utilisez des filtres dans l’UI pour n’afficher dans votre tableau que les runs qui vous intéressent. Vous pouvez définir les tags depuis votre script, puis les modifier dans l’UI, à la fois dans le tableau des Runs et dans l’onglet Vue d’ensemble de la page du run. Voir les instructions détaillées [ici](/fr/models/runs/tags/).
## Exemples d’utilisation de l’API publique
### Lire les métriques d’un run
Cet exemple affiche le timestamp et la précision enregistrés avec `run.log({"accuracy": acc})` pour un run enregistré sous `"//"`.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
if run.state == "finished":
for i, row in run.history().iterrows():
print(row["_timestamp"], row["accuracy"])
```
### Lire des métriques spécifiques d’un run
Pour récupérer des métriques spécifiques d’un run, utilisez l’argument `keys`. Le nombre d’échantillons par défaut lors de l’utilisation de `run.history()` est de 500. Les étapes enregistrées qui n’incluent pas de métrique spécifique apparaîtront dans le dataframe de sortie sous la forme de `NaN`. L’argument `keys` fera en sorte que l’API échantillonne plus fréquemment les étapes qui incluent les clés de métrique listées.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
if run.state == "finished":
for i, row in run.history(keys=["accuracy"]).iterrows():
print(row["_timestamp"], row["accuracy"])
```
### Comparer deux runs
Cette commande affiche les paramètres de configuration qui diffèrent entre `run1` et `run2`.
```python theme={null}
import pandas as pd
import wandb
api = wandb.Api()
# remplacez par votre , et
run1 = api.run("//")
run2 = api.run("//")
df = pd.DataFrame([run1.config, run2.config]).transpose()
df.columns = [run1.name, run2.name]
print(df[df[run1.name] != df[run2.name]])
```
Sorties :
```
c_10_sgd_0.025_0.01_long_switch base_adam_4_conv_2fc
batch_size 32 16
n_conv_layers 5 4
optimizer rmsprop adam
```
### Mettre à jour les métriques d’un run après la fin du run
Cet exemple définit `accuracy` d’un run précédent à `0.9` :
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
run.summary["accuracy"] = 0.9
run.summary.update()
```
### Renommer une métrique dans un run terminé
Cet exemple renomme une colonne « summary » dans vos tableaux.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
run.summary["new_name"] = run.summary["old_name"]
del run.summary["old_name"]
run.summary.update()
```
Le changement de nom d’une colonne s’applique uniquement aux tableaux. Les graphiques continueront d’utiliser les noms d’origine des métriques.
### Mettre à jour la configuration d’un run existant
Cet exemple met à jour un de vos paramètres de configuration.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
run.config["key"] = updated_value
run.update()
```
Voir [Configurer les expériences](/fr/models/track/config#existing-run) pour en savoir plus.
### Exporter l’utilisation des ressources système vers un fichier CSV
L’extrait ci-dessous permet de trouver l’utilisation des ressources système, puis de l’enregistrer dans un fichier CSV.
```python theme={null}
import wandb
run = wandb.Api().run("//")
system_metrics = run.history(stream="events")
system_metrics.to_csv("sys_metrics.csv")
```
### Obtenir des données de métriques non échantillonnées
Lorsque vous récupérez des données depuis l’historique, elles sont, par défaut, échantillonnées à 500 points. Récupérez tous les points de données enregistrés avec `run.scan_history()`. Voici un exemple qui télécharge tous les points de données `loss` enregistrés dans l’historique.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
history = run.scan_history()
losses = [row["loss"] for row in history]
```
### Obtenir des données paginées dans l’historique
Pour récupérer l’historique complet non échantillonné d’un run, utilisez `run.scan_history()`. L’historique non échantillonné inclut chaque enregistrement de l’historique du run. En revanche, la vue échantillonnée de `run.history()` peut omettre certains enregistrements.
Le paramètre `page_size` contrôle le nombre maximum d’enregistrements d’historique récupérés par requête API et vaut par défaut `1000`. Si les requêtes sont lentes ou expirent, essayez une taille de page plus petite. Des pages plus petites peuvent réduire le risque d’expiration, mais nécessitent davantage de requêtes API.
Le paramètre `keys` permet de filtrer indépendamment les métriques renvoyées.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
run.scan_history(keys=sorted(cols), page_size=100)
```
### Exporter les métriques de tous les runs d’un projet dans un fichier CSV
Ce script récupère les runs d’un projet et génère un dataframe ainsi qu’un fichier CSV contenant leurs noms, leurs configurations et leurs statistiques de synthèse. Remplacez `` et `` par votre entité W\&B et le nom de votre projet, respectivement.
```python theme={null}
import pandas as pd
import wandb
api = wandb.Api()
entity, project = "", ""
runs = api.runs(entity + "/" + project)
summary_list, config_list, name_list = [], [], []
for run in runs:
# .summary contient les clés/valeurs de sortie
# pour les métriques telles que la précision.
# Nous appelons ._json_dict pour omettre les fichiers volumineux
summary_list.append(run.summary._json_dict)
# .config contient les hyperparamètres.
# Nous supprimons les valeurs spéciales qui commencent par _.
config_list.append({k: v for k, v in run.config.items() if not k.startswith("_")})
# .name est le nom lisible par l'homme du run.
name_list.append(run.name)
runs_df = pd.DataFrame(
{"summary": summary_list, "config": config_list, "name": name_list}
)
runs_df.to_csv("project.csv")
```
### Obtenir l’heure de début d’un run
Cet extrait de code récupère l’heure de création du run.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("entity/project/run_id")
start_time = run.created_at
```
### Importer des fichiers dans un run terminé
L’extrait de code ci-dessous importe un fichier sélectionné dans un run terminé.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("entity/project/run_id")
run.upload_file("file_name.extension")
```
### Télécharger un fichier d’un run
Cet exemple localise le fichier "model-best.h5" associé au run ID uxte44z7 dans le projet cifar et l’enregistre localement.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
run.file("model-best.h5").download()
```
### Télécharger tous les fichiers d’un run
Cette commande récupère tous les fichiers associés à un run et les enregistre localement.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
for file in run.files():
file.download()
```
### Obtenir les runs d’un balayage spécifique
Cet extrait télécharge tous les runs associés à un balayage donné.
```python theme={null}
import wandb
api = wandb.Api()
sweep = api.sweep("//")
sweep_runs = sweep.runs
```
### Obtenir le meilleur run d’un balayage
L’extrait suivant récupère le meilleur run d’un balayage donné.
```python theme={null}
import wandb
api = wandb.Api()
sweep = api.sweep("//")
best_run = sweep.best_run()
```
Le `best_run` correspond au run présentant la meilleure métrique, telle que définie par le paramètre `metric` dans la configuration du balayage.
### Télécharger le fichier du meilleur modèle depuis un balayage
Cet extrait télécharge le fichier de modèle avec la meilleure précision de validation depuis un balayage contenant des runs qui ont enregistré des fichiers de modèle sous `model.h5`.
```python theme={null}
import wandb
api = wandb.Api()
sweep = api.sweep("//")
runs = sorted(sweep.runs, key=lambda run: run.summary.get("val_acc", 0), reverse=True)
val_acc = runs[0].summary.get("val_acc", 0)
print(f"Best run {runs[0].name} with {val_acc}% val accuracy")
runs[0].file("model.h5").download(replace=True)
print("Best model saved to model-best.h5")
```
### Supprimer d’un run tous les fichiers ayant une extension donnée
Cet extrait supprime d’un run les fichiers ayant une extension donnée.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
extension = ".png"
files = run.files()
for file in files:
if file.name.endswith(extension):
file.delete()
```
### Télécharger les données des métriques système
Cet extrait génère un dataframe contenant toutes les métriques de consommation des ressources système d’un run, puis l’enregistre dans un fichier CSV.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
system_metrics = run.history(stream="events")
system_metrics.to_csv("sys_metrics.csv")
```
### Mettre à jour les métriques du summary
Vous pouvez transmettre un dictionnaire pour mettre à jour les métriques du summary.
```python theme={null}
summary.update({"key": val})
```
### Obtenir la commande qui a lancé le run
Chaque run enregistre la commande qui l’a lancé sur la page d’aperçu du run. Pour récupérer cette commande depuis l’API, vous pouvez exécuter :
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
meta = json.load(run.file("wandb-metadata.json").download())
program = ["python"] + [meta["program"]] + meta["args"]
```