Importer et exporter des données - Weights & Biases Documentation

Exportez ou importez des données à l’aide des API publiques de W&B.

Cette fonctionnalité nécessite python>=3.8

Importer des données depuis MLFlow

W&B prend en charge l’importation de données depuis MLFlow, notamment les expériences, les runs, les artifacts, les métriques et d’autres métadonnées. Installez les dépendances :

# remarque : nécessite py38+
pip install wandb[importers]

Connectez-vous à W&B. Suivez les instructions si vous ne vous êtes encore jamais connecté auparavant.

wandb login

Importez tous les runs à partir d’un serveur MLFlow existant :

from wandb.apis.importers.mlflow import MlflowImporter

importer = MlflowImporter(mlflow_tracking_uri="...")

runs = importer.collect_runs()
importer.import_runs(runs)

Par défaut, importer.collect_runs() récupère tous les runs du serveur MLflow. Si vous préférez n’en importer qu’un sous-ensemble particulier, vous pouvez construire votre propre itérable de runs et le passer à l’importateur.

import mlflow
from wandb.apis.importers.mlflow import MlflowRun

client = mlflow.tracking.MlflowClient(mlflow_tracking_uri)

runs: Iterable[MlflowRun] = []
for run in mlflow_client.search_runs(...):
    runs.append(MlflowRun(run, client))

importer.import_runs(runs)

Vous devrez peut-être configurer d’abord la CLI Databricks si vous importez depuis Databricks MLflow.Définissez mlflow-tracking-uri="databricks" lors de l’étape précédente.

Pour ignorer l’import des Artifacts, vous pouvez passer artifacts=False :

importer.import_runs(runs, artifacts=False)

Pour importer dans une entité et un projet W&B spécifiques, vous pouvez fournir un Namespace :

from wandb.apis.importers import Namespace

importer.import_runs(runs, namespace=Namespace(entity, project))

Exporter des données

Utilisez l’API publique pour exporter ou mettre à jour les données que vous avez enregistrées dans W&B. Avant d’utiliser cette API, enregistrez des données à partir de votre script. Consultez le Démarrage rapide pour plus de détails. Cas d’utilisation de l’API publique

Exporter des données : récupérez un dataframe pour effectuer une analyse personnalisée dans un notebook Jupyter. Une fois les données explorées, vous pouvez synchroniser vos résultats en créant un nouveau run d’analyse et en enregistrant les résultats, par exemple : wandb.init(job_type="analysis")
Mettre à jour des Runs existants : vous pouvez mettre à jour les données enregistrées pour un run W&B. Par exemple, vous pouvez vouloir mettre à jour la configuration d’un ensemble de runs afin d’y inclure des informations supplémentaires, comme l’architecture ou un hyperparamètre qui n’avait pas été enregistré à l’origine.

Voir la documentation de référence générée pour plus de détails sur les fonctions disponibles.

Créer une clé API

Une clé API permet d’authentifier votre machine auprès de W&B. Pour créer une clé API, sélectionnez l’onglet Clé API personnelle ou Clé API de compte de service pour en savoir plus.

Clé API personnelle
Clé API de compte de service

Pour créer une clé API personnelle liée à votre ID utilisateur :

Connectez-vous à W&B, cliquez sur l’icône de votre profil, puis sur Paramètres utilisateur.
Cliquez sur Create new API key.
Saisissez un nom descriptif pour votre clé API.
Cliquez sur Create.
Copiez immédiatement la clé API affichée et stockez-la de manière sécurisée.

Pour créer une clé API associée à un compte de service :

Accédez à l’onglet Service Accounts dans les paramètres de votre équipe ou de votre organisation.
Recherchez le compte de service dans la liste.
Cliquez sur le menu d’action (...), puis sur Create API key.
Saisissez un nom pour la clé API, puis cliquez sur Create.
Copiez immédiatement la clé API affichée et stockez-la en lieu sûr.
Cliquez sur Done.

Vous pouvez créer plusieurs clés API pour un même compte de service afin de prendre en charge différents environnements ou flux de travail.

La clé API complète n’est affichée qu’une seule fois, au moment de sa création. Une fois la boîte de dialogue fermée, vous ne pourrez plus voir la clé API complète. Seul l’ID de la clé (la première partie de la clé) reste visible dans vos paramètres. Si vous perdez la clé API complète, vous devrez créer une nouvelle clé API.

Pour connaître les options de stockage sécurisé, voir Stocker les clés API en toute sécurité.

Stockez et manipulez les clés API en toute sécurité

Les clés API donnent accès à votre compte W&B et doivent être protégées comme des mots de passe. Suivez ces bonnes pratiques :

Méthodes de stockage recommandées

Gestionnaire de secrets : Utilisez un système dédié de gestion des secrets, tel que AWS Secrets Manager, HashiCorp Vault, Azure Key Vault ou Google Secret Manager.
Gestionnaire de mots de passe : Utilisez une application de gestion de mots de passe fiable.
Trousseaux du système d’exploitation : Stockez les clés dans le Trousseau macOS, le Gestionnaire d’identifiants Windows ou le service de secrets Linux. Déconseillé en production.

Ce qu’il faut éviter

N’enregistrez jamais de clés API dans un système de gestion de versions comme Git.
Ne stockez pas de clés API dans des fichiers de configuration en texte brut.
Ne transmettez pas de clés API en ligne de commande, car elles seront visibles dans la sortie de commandes du système d’exploitation telles que ps.
Évitez de partager des clés API par e-mail, via le chat ou par d’autres canaux non chiffrés.
N’intégrez pas de clés API en dur dans votre code source.

Si une clé API est exposée, supprimez-la immédiatement de votre compte W&B et contactez l’assistance ou votre AISE.

Variables d’environnement

Lorsque vous utilisez des clés API dans votre code, transmettez-les via des variables d’environnement :

export WANDB_API_KEY="your-api-key-here"

Cette approche évite d’exposer les clés dans votre code source et facilite leur renouvellement si nécessaire.

Évitez de définir la variable d’environnement sur la même ligne que la commande, car elle sera visible dans la sortie de commandes système comme ps :

# Évitez cette pratique, qui peut exposer la clé API dans les gestionnaires de processus
export WANDB_API_KEY="your-api-key-here" ./my-script.sh

Compatibilité des versions du SDK

Les nouvelles clés API sont plus longues que les clés héritées. Lors de l’authentification avec des versions antérieures des SDK wandb ou weave, vous pouvez rencontrer une erreur liée à la longueur de la clé API. Solution : mettez à jour vers une version plus récente du SDK :

SDK wandb v0.22.3+
```
pip install --upgrade wandb==0.22.3
```
SDK weave v0.52.17+
```
pip install --upgrade weave==0.52.17
```

Si vous ne pouvez pas mettre à jour le SDK immédiatement, utilisez la variable d’environnement WANDB_API_KEY pour définir la clé API en guise de solution de contournement.

Trouver le chemin du run

Pour utiliser l’API publique, vous aurez souvent besoin du chemin du run, au format <entity>/<project>/<run_id>. Dans l’interface de l’application, ouvrez la page d’un run et cliquez sur l’onglet Vue d’ensemble pour obtenir le chemin du run.

Exporter les données d’un run

Téléchargez les données d’un run terminé ou en cours. Les cas d’usage courants incluent le téléchargement d’un dataframe pour une analyse personnalisée dans un notebook Jupyter, ou l’utilisation d’une logique personnalisée dans un environnement automatisé.

import wandb

api = wandb.Api()
run = api.run("<entity>/<project>/<run_id>")

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.

Comprendre les différents attributs d’un run

L’extrait de code suivant montre comment créer un run, consigner des données, puis accéder aux attributs du run :

import wandb
import random

with wandb.init(project="public-api-example") as run:
    n_epochs = 5
    config = {"n_epochs": n_epochs}
    run.config.update(config)
    for n in range(run.config.get("n_epochs")):
        run.log(
            {"val": random.randint(0, 1000), "loss": (random.randint(0, 1000) / 1000.00)}
        )

Les sections suivantes décrivent les différentes sorties associées aux attributs de l’objet run ci-dessus

`run.config`

{"n_epochs": 5}

`run.summary`

{
    "_step": 4,
    "_timestamp": 1644345412,
    "_wandb": {"runtime": 3},
    "loss": 0.041,
    "val": 525,
}

Échantillonnage

La méthode history par défaut échantillonne les métriques pour n’en conserver qu’un nombre fixe (500 par défaut ; vous pouvez le modifier avec l’argument samples __). Si vous souhaitez exporter toutes les données d’un run de grande taille, vous pouvez utiliser la méthode run.scan_history(). Pour en savoir plus, voir la Référence de l’API.

Interroger plusieurs runs

DataFrame et CSV
Style MongoDB

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 <entity> et <project> par votre entité W&B et le nom de votre projet, respectivement.

import pandas as pd
import wandb

api = wandb.Api()
entity, project = "<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 accuracy.
    #  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'utilisateur 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")

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.

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 summary. 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 dernier commit git via l’API

Dans l’UI, cliquez sur un run, puis sur l’onglet Vue d’ensemble de la page du run pour afficher le dernier commit git. Il figure également dans le fichier wandb-metadata.json . Avec l’API publique, vous pouvez obtenir le hachage git avec run.commit.

Obtenir le nom et l’ID d’un run en cours d’exécution

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.

Exemples d’utilisation de l’API publique

Exporter des données pour les visualiser dans matplotlib ou seaborn

Consultez nos exemples d’API pour voir quelques méthodes d’export courantes. Vous pouvez aussi cliquer sur le bouton de téléchargement d’un graphique personnalisé ou de la vue développée du tableau Runs pour télécharger un fichier CSV depuis votre navigateur.

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 "<entity>/<project>/<run_id>".

import wandb

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")
if run.state == "finished":
    for i, row in run.history().iterrows():
        print(row["_timestamp"], row["accuracy"])

Filtrer les runs

Vous pouvez filtrer à l’aide du langage de requête MongoDB.

Date

runs = api.runs(
    "<entity>/<project>",
    {"$and": [{"created_at": {"$lt": "YYYY-MM-DDT##", "$gt": "YYYY-MM-DDT##"}}]},
)

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.

import wandb

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")
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.

import pandas as pd
import wandb

api = wandb.Api()

# remplacez par votre <entity>, <project> et <run_id>
run1 = api.run("<entity>/<project>/<run_id>")
run2 = api.run("<entity>/<project>/<run_id>")


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. Il modifie également l’histogramme de accuracy d’un run précédent pour qu’il devienne l’histogramme de numpy_array.

import wandb

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")
run.summary["accuracy"] = 0.9
run.summary["accuracy_histogram"] = wandb.Histogram(numpy_array)
run.summary.update()

Renommer une métrique dans un run terminé

Cet exemple renomme une colonne « summary » dans vos tableaux.

import wandb

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")
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.

import wandb

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")
run.config["key"] = updated_value
run.update()

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.

import wandb

with wandb.Api().run("<entity>/<project>/<run_id>") as 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.

import wandb

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")
history = run.scan_history()
losses = [row["loss"] for row in history]

Obtenir des données paginées à partir de l’historique

Si les métriques sont récupérées lentement par notre backend ou si les requêtes d’API expirent, vous pouvez essayer de réduire la taille de page dans scan_history afin d’éviter que les requêtes individuelles n’expirent. La taille de page par défaut est de 500, vous pouvez donc tester différentes valeurs pour voir ce qui fonctionne le mieux :

import wandb

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")
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 <entity> et <project> par votre entité W&B et le nom de votre projet, respectivement.

import pandas as pd
import wandb

api = wandb.Api()
entity, project = "<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 l'accuracy.
    #  On appelle ._json_dict pour omettre les fichiers volumineux
    summary_list.append(run.summary._json_dict)

    # .config contient les hyperparamètres.
    #  On supprime 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 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.

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é.

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.

import wandb

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")
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.

import wandb

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")
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é.

import wandb

api = wandb.Api()

sweep = api.sweep("<entity>/<project>/<sweep_id>")
sweep_runs = sweep.runs

Obtenir le meilleur run d’un balayage

L’extrait suivant récupère le meilleur run d’un balayage donné.

import wandb

api = wandb.Api()

sweep = api.sweep("<entity>/<project>/<sweep_id>")
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.

import wandb

api = wandb.Api()

sweep = api.sweep("<entity>/<project>/<sweep_id>")
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"Meilleur run {runs[0].name} avec {val_acc}% de précision de validation")

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.

import wandb

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")

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.

import wandb

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")
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.

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 :

import wandb

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")

meta = json.load(run.file("wandb-metadata.json").download())
program = ["python"] + [meta["program"]] + meta["args"]

Guides

Intégrations

Référence

​Importer des données depuis MLFlow

​Exporter des données

​Créer une clé API

​Stockez et manipulez les clés API en toute sécurité

​Méthodes de stockage recommandées

​Ce qu’il faut éviter

​Variables d’environnement

​Compatibilité des versions du SDK

​Trouver le chemin du run

​Exporter les données d’un run

​Comprendre les différents attributs d’un run

run.config

​run.summary

​Échantillonnage

​Interroger plusieurs runs

​Gestion des erreurs

​Obtenir le dernier commit git via l’API

​Obtenir le nom et l’ID d’un run en cours d’exécution

​Exemples d’utilisation de l’API publique

​Exporter des données pour les visualiser dans matplotlib ou seaborn

​Lire les métriques d’un run

​Filtrer les runs

​Date

​Lire des métriques spécifiques d’un run

​Comparer deux runs

​Mettre à jour les métriques d’un run après la fin du run

​Renommer une métrique dans un run terminé

​Mettre à jour la configuration d’un run existant

​Exporter l’utilisation des ressources système vers un fichier CSV

​Obtenir des données de métriques non échantillonnées

​Obtenir des données paginées à partir de l’historique

​Exporter les métriques de tous les runs d’un projet dans un fichier CSV

​Obtenir l’heure de début d’un run

​Importer des fichiers dans un run terminé

​Télécharger un fichier d’un run

​Télécharger tous les fichiers d’un run

​Obtenir les runs d’un balayage spécifique

​Obtenir le meilleur run d’un balayage

​Télécharger le fichier du meilleur modèle depuis un balayage

​Supprimer d’un run tous les fichiers ayant une extension donnée

​Télécharger les données des métriques système

​Mettre à jour les métriques du summary

​Obtenir la commande qui a lancé le run

Importer des données depuis MLFlow

Exporter des données

Créer une clé API

Stockez et manipulez les clés API en toute sécurité

Méthodes de stockage recommandées

Ce qu’il faut éviter

Variables d’environnement

Compatibilité des versions du SDK

Trouver le chemin du run

Exporter les données d’un run

Comprendre les différents attributs d’un run

`run.config`

`run.summary`

Échantillonnage

Interroger plusieurs runs

Gestion des erreurs

Obtenir le dernier commit git via l’API

Obtenir le nom et l’ID d’un run en cours d’exécution

Exemples d’utilisation de l’API publique

Exporter des données pour les visualiser dans matplotlib ou seaborn

Lire les métriques d’un run

Filtrer les runs

Date

Lire des métriques spécifiques d’un run

Comparer deux runs

Mettre à jour les métriques d’un run après la fin du run

Renommer une métrique dans un run terminé

Mettre à jour la configuration d’un run existant

Exporter l’utilisation des ressources système vers un fichier CSV

Obtenir des données de métriques non échantillonnées

Obtenir des données paginées à partir de l’historique

Exporter les métriques de tous les runs d’un projet dans un fichier CSV

Obtenir l’heure de début d’un run

Importer des fichiers dans un run terminé

Télécharger un fichier d’un run

Télécharger tous les fichiers d’un run

Obtenir les runs d’un balayage spécifique

Obtenir le meilleur run d’un balayage

Télécharger le fichier du meilleur modèle depuis un balayage

Supprimer d’un run tous les fichiers ayant une extension donnée

Télécharger les données des métriques système

Mettre à jour les métriques du summary

Obtenir la commande qui a lancé le run