Exporter et mettre à jour des données

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, journalisez des données depuis votre script. Pour plus de détails, consultez le Démarrage rapide. Cas d’utilisation de l’API publique

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

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

Exporter les données d’un run

Téléchargez les données d’un run terminé ou actif. Cette fonctionnalité sert notamment à télécharger un dataframe pour effectuer une analyse personnalisée dans un notebook Jupyter, ou à appliquer 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 les suivants :

Attribut	Signification
`run.config`	Un dictionnaire contenant les informations de configuration du run, comme 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 évoluent 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 synthétise 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()` affecte à la synthèse la valeur finale d’une série temporelle journalisée. Le contenu de la synthèse peut également être défini directement. Considérez la synthèse comme les sorties du run.

Vous pouvez également modifier ou mettre à jour les données de runs antérieurs. Par défaut, une même instance d’un objet api met en cache toutes les requêtes réseau. Si votre cas d’usage nécessite des informations en temps réel dans un script en cours d’exécution, appelez api.flush() pour obtenir des valeurs à jour.

Interroger plusieurs runs

DataFrame et CSV
Style MongoDB

Cet exemple de script trouve un projet et génère un fichier CSV des runs contenant leur nom, leurs configurations et leurs statistiques de synthèse. Remplacez <entity> et <project> respectivement par votre entity W&B et le nom de votre projet.

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 comme 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 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 permet également d’interroger les runs d’un projet avec api.runs(). Le cas d’usage le plus courant consiste à exporter les données des runs pour une analyse personnalisée. L’interface de requête est identique à celle de 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 les runs séquentiellement, par lots de 50, au fur et à mesure des besoins, mais vous pouvez modifier le nombre de runs chargés 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 aussi trier selon des valeurs de configuration 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 inspecter l’exception d’origine via l’attribut exc.

Obtenir le nom et l’ID d’un run pendant son 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 suit :

ID unique du run (hachage de 8 caractères) : run.id
Nom aléatoire du run (lisible) : run.name

Si vous cherchez comment attribuer des identifiants utiles à vos runs, voici nos recommandations :

ID du run : conservez le hachage généré. Cet identifiant doit être unique parmi les runs de votre projet.
Nom du run : choisissez un nom court, lisible et de préférence unique, afin de pouvoir distinguer les différentes courbes de vos graphiques.
Notes du run : c’est l’endroit idéal pour décrire brièvement ce que fait votre run. Vous pouvez les définir avec wandb.init(notes="your notes here")
Tags du run : utilisez les tags du run pour suivre des informations de manière dynamique, et appliquez des filtres dans l’interface utilisateur pour n’afficher dans votre tableau que les runs qui vous intéressent. Vous pouvez définir des tags depuis votre script, puis les modifier dans l’interface utilisateur, aussi bien dans le tableau des runs que dans l’onglet Vue d’ensemble de la page du run. Consultez les instructions détaillées ici.

Exemples d’utilisation de l’API publique

Lire les métriques d’un run

Cet exemple affiche l’horodatage et la précision journalisés avec run.log({"accuracy": acc}) pour un run enregistré dans "<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"])

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. Par défaut, run.history() renvoie 500 échantillons. Les steps journalisés qui ne contiennent pas une métrique donnée apparaissent dans le dataframe de sortie avec la valeur NaN. L’argument keys indique à l’API d’échantillonner plus fréquemment les steps qui contiennent les clés de métriques indiqué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

Ce code affiche les paramètres de configuration qui diffèrent entre run1 et run2.

import pandas as pd
import wandb

api = wandb.Api()

# remplacez <entity>, <project> et <run_id> par vos propres valeurs
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 une fois celui-ci terminé

Cet exemple définit la précision d’un run précédent à 0.9 :

import wandb

api = wandb.Api()

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

Renommer une métrique dans un run terminé

Cet exemple renomme une colonne de synthèse 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 renommage d’une colonne ne s’applique qu’aux tableaux. Les graphiques continueront de se référer aux métriques par leur nom d’origine.

Mettre à jour la configuration d’un run existant

Cet exemple met à jour l’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()

Pour plus d’informations, consultez Configurer des expériences.

Exporter la consommation des ressources système vers un fichier CSV

L’extrait de code ci-dessous permet de trouver la consommation des ressources système d’un run, puis de l’enregistrer dans un fichier CSV.

import wandb

run = wandb.Api().run("<entity>/<project>/<run_id>")
system_metrics = run.history(stream="events")
system_metrics.to_csv("sys_metrics.csv")

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

Lorsque vous récupérez des données depuis l’historique, elles sont échantillonnées par défaut à 500 points. Pour obtenir l’ensemble des points de données journalisés, utilisez run.scan_history(). Voici un exemple qui télécharge tous les points de données loss journalisé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 depuis l’historique

Pour récupérer l’historique complet et non échantillonné d’un run, utilisez run.scan_history(). L’historique non échantillonné contient tous les enregistrements d’historique du run. À l’inverse, la vue échantillonnée renvoyée par run.history() peut omettre certains enregistrements. Le paramètre page_size définit le nombre maximum d’enregistrements d’historique récupérés par requête API. Sa valeur par défaut est 1000. Si les requêtes sont lentes ou expirent, essayez une taille de page plus petite. Des pages plus petites réduisent le risque d’expiration, mais nécessitent davantage de requêtes API. Le paramètre keys permet, indépendamment, de filtrer 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 vers un fichier CSV

Ce script récupère les runs d’un projet et génère un dataframe ainsi qu’un fichier CSV répertoriant les runs avec leurs noms, leurs configurations et leurs statistiques de synthèse. Remplacez <entity> et <project> respectivement par votre entity W&B et le nom de votre projet.

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
    #  des métriques telles que la précision.
    #  On appelle ._json_dict pour exclure les fichiers volumineux
    summary_list.append(run.summary._json_dict)

    # .config contient les hyperparamètres.
    #  On supprime les valeurs spéciales commençant 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

Téléverser des fichiers dans un run terminé

L’extrait de code ci-dessous téléverse le 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 depuis un run

Cet exemple recherche le fichier “model-best.h5” associé au run d’ID uxte44z7 dans le projet cifar, puis 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

Ce code récupère tous les fichiers associés à un run et les enregistre en local.

import wandb

api = wandb.Api()

run = api.run("<entity>/<project>/<run_id>")
for file in run.files():
    file.download()

Obtenir les runs d’un sweep spécifique

Cet extrait télécharge tous les runs associés à un sweep donné.

import wandb

api = wandb.Api()

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

Obtenir le meilleur run d’un sweep

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

import wandb

api = wandb.Api()

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

Le best_run est le run qui obtient la meilleure métrique, telle que définie par le paramètre metric de la configuration du sweep.

Télécharger le fichier du meilleur modèle d’un sweep

Cet extrait télécharge le fichier de modèle ayant la meilleure précision de validation dans un sweep dont les runs ont enregistré leurs fichiers de modèle dans 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 de synthèse

Vous pouvez transmettre un dictionnaire pour mettre à jour les métriques de synthèse.

summary.update({"key": val})

Obtenir la commande qui a lancé le run

Chaque run capture la commande qui l’a lancé et l’affiche 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"]

​Exporter des données

​Exporter les données d’un run

​Interroger plusieurs runs

​Gestion des erreurs

​Obtenir le nom et l’ID d’un run pendant son exécution

​Exemples d’utilisation de l’API publique

​Lire les métriques d’un run

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

​Comparer deux runs

​Mettre à jour les métriques d’un run une fois celui-ci terminé

​Renommer une métrique dans un run terminé

​Mettre à jour la configuration d’un run existant

​Exporter la consommation des ressources système vers un fichier CSV

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

​Obtenir des données paginées depuis l’historique

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

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

​Téléverser des fichiers dans un run terminé

​Télécharger un fichier depuis un run

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

​Obtenir les runs d’un sweep spécifique

​Obtenir le meilleur run d’un sweep

​Télécharger le fichier du meilleur modèle d’un sweep

​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 de synthèse

​Obtenir la commande qui a lancé le run

Exporter des données

Exporter les données d’un run

Interroger plusieurs runs

Gestion des erreurs

Obtenir le nom et l’ID d’un run pendant son exécution

Exemples d’utilisation de l’API publique

Lire les métriques d’un run

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

Comparer deux runs

Mettre à jour les métriques d’un run une fois celui-ci terminé

Renommer une métrique dans un run terminé

Mettre à jour la configuration d’un run existant

Exporter la consommation des ressources système vers un fichier CSV

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

Obtenir des données paginées depuis l’historique

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

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

Téléverser des fichiers dans un run terminé

Télécharger un fichier depuis un run

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

Obtenir les runs d’un sweep spécifique

Obtenir le meilleur run d’un sweep

Télécharger le fichier du meilleur modèle d’un sweep

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 de synthèse

Obtenir la commande qui a lancé le run