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 :
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 MlflowImporterimporter = 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 mlflowfrom wandb.apis.importers.mlflow import MlflowRunclient = 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 Namespaceimporter.import_runs(runs, namespace=Namespace(entity, project))
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.
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.
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.
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.
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.
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é.
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.
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.
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 pdimport wandbapi = 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.
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.
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.
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.
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.
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 wandbapi = 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"])
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 wandbapi = 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"])
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.
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 wandbapi = 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 :
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 pdimport wandbapi = 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")
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 wandbapi = 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")
