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 vous permet d’importer des données depuis MLFlow, y compris les experiments, les runs, les artefacts, 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. Si c’est votre première connexion, suivez les instructions affichées.

wandb login

Importez toutes les exécutions à 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() collecte toutes les exécutions du serveur MLFlow. Si vous préférez téléverser uniquement un sous-ensemble particulier, vous pouvez créer 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 le Databricks CLI si vous importez depuis Databricks MLflow.Lors de l’étape précédente, définissez mlflow-tracking-uri="databricks".

Pour ignorer l’import des artefacts, 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, puis cliquez sur l’icône de votre profil > 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.

W&B affiche la clé API complète une seule fois, au moment où vous la créez. Une fois la boîte de dialogue fermée, vous ne pourrez plus voir la clé API complète. Vos paramètres n’affichent que l’ID de la clé (la première partie de la clé). 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. Les sections suivantes décrivent les méthodes de stockage recommandées, les pratiques à éviter, la façon de transmettre les clés à votre code et les exigences de version du SDK pour les clés plus récentes.

Méthodes de stockage recommandées

Utilisez l’une des méthodes suivantes pour stocker votre clé API en toute sécurité.

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

Évitez les pratiques suivantes, qui peuvent exposer votre clé API :

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]"

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 est 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]" ./my-script.sh

Compatibilité des versions du SDK

Si vous utilisez une clé API plus récente, vérifiez que votre version du SDK la prend en charge. 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 :

wandb SDK v0.22.3+
pip install --upgrade wandb==0.22.3
weave SDK 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 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.

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

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

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

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

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"]

Reproduire des expériences

Variables d’environnement

​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 pendant un run actif

​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 dans 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 pendant un run actif

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 dans 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