Passer au contenu principal
Utilisez le SDK Python de W&B pour suivre des expériences de machine learning. Vous pouvez ensuite consulter les résultats dans un tableau de bord interactif ou exporter vos données vers Python pour y accéder par programmation avec l’API publique W&B. Ce guide explique comment utiliser les composants de base de W&B pour créer une expérience W&B.

​
Comment créer une expérience W&B

Créez une expérience W&B en quatre étapes :
  1. Initialiser un run W&B
  2. Enregistrer un dictionnaire d’hyperparamètres
  3. Consigner des métriques dans votre boucle d’entraînement
  4. Enregistrer un artifact dans W&B

​
Initialiser un run W&B

Utilisez wandb.init() pour créer un run W&B. L’extrait suivant crée un run dans un projet W&B nommé “cat-classification”, avec la description “My first experiment”, afin d’identifier plus facilement ce run. Les tags “baseline” et “paper1” sont inclus pour rappeler qu’il s’agit d’une expérience de référence destinée à une future publication d’article. 
import wandb

with wandb.init(
    project="cat-classification",
    notes="My first experiment",
    tags=["baseline", "paper1"],
) as run:
    ...
wandb.init() renvoie un objet Run.
Remarque : les Runs sont ajoutés à des projets existants si ce projet existe déjà lorsque vous appelez wandb.init(). Par exemple, si vous avez déjà un projet nommé “cat-classification”, ce projet continuera d’exister et ne sera pas supprimé. À la place, un nouveau run est ajouté à ce projet.

​
Enregistrez un dictionnaire d’hyperparamètres

Enregistrez un dictionnaire d’hyperparamètres, comme le taux d’apprentissage ou le type de modèle. Les paramètres du modèle que vous consignez dans la configuration vous seront ensuite utiles pour organiser vos résultats et y effectuer des requêtes. 
with wandb.init(
    ...,
    config={"epochs": 100, "learning_rate": 0.001, "batch_size": 128},
) as run:
    ...
Pour en savoir plus sur la configuration d’une expérience, voir Configurer Experiments.

​
Consigner des métriques dans votre boucle d’entraînement

Appelez run.log() pour consigner des métriques à chaque étape d’entraînement, comme l’accuracy et la perte. 
model, dataloader = get_model(), get_data()

for epoch in range(run.config.epochs):
    for batch in dataloader:
        loss, accuracy = model.training_step()
        run.log({"accuracy": accuracy, "loss": loss})
Pour plus d’informations sur les différents types de données que vous pouvez journaliser avec W&B, voir Journaliser des données pendant les Experiments.

​
Journaliser un Artifact dans W&B

Vous pouvez aussi journaliser un W&B Artifact. Les Artifacts facilitent le versionnage des jeux de données et des modèles. 
# Vous pouvez sauvegarder n'importe quel fichier ou même un répertoire. Cet exemple suppose
# que le modèle possède une méthode save() qui génère un fichier ONNX.
model.save("path_to_model.onnx")
run.log_artifact("path_to_model.onnx", name="trained-model", type="model")
Pour en savoir plus sur Artifacts ou sur la gestion des versions des modèles dans le registre.

​
Tout réunir

Le script complet, avec les extraits de code précédents, se trouve ci-dessous : 
import wandb

with wandb.init(
    project="cat-classification",
    notes="",
    tags=["baseline", "paper1"],
    # Enregistrer les hyperparamètres du run.
    config={"epochs": 100, "learning_rate": 0.001, "batch_size": 128},
) as run:
    # Configurer le modèle et les données.
    model, dataloader = get_model(), get_data()

    # Lancez l'entraînement en enregistrant les métriques pour visualiser les performances du modèle.
    for epoch in range(run.config["epochs"]):
        for batch in dataloader:
            loss, accuracy = model.training_step()
            run.log({"accuracy": accuracy, "loss": loss})

    # Charger le modèle entraîné en tant qu'artifact.
    model.save("path_to_model.onnx")
    run.log_artifact("path_to_model.onnx", name="trained-model", type="model")

​
Étapes suivantes : visualisez votre expérience

Utilisez le tableau de bord W&B comme point central pour organiser et visualiser les résultats de vos modèles de machine learning. En quelques clics, créez des graphiques interactifs riches, comme des graphiques en coordonnées parallèles, des analyses d’importance des paramètres et d’autres types de graphiques.
Exemple de tableau de bord Sweeps du Démarrage rapide
Pour en savoir plus sur l’affichage des expériences et de Runs spécifiques, voir Visualiser les résultats des expériences.

​
Bonnes pratiques

Voici quelques recommandations à suivre lorsque vous créez des expériences :
  1. Terminez vos runs : utilisez wandb.init() dans un bloc with pour marquer automatiquement le run comme terminé lorsque le code se termine ou lève une exception.
    • Dans les notebooks Jupyter, il peut être plus pratique de gérer vous-même l’objet Run. Dans ce cas, vous pouvez appeler explicitement finish() sur l’objet Run pour le marquer comme terminé : 
      # Dans une cellule de notebook :
run = wandb.init()

# Dans une autre cellule :
run.finish()
  2. Configuration : suivez les hyperparamètres, l’architecture, le jeu de données et tout ce que vous souhaitez utiliser pour reproduire votre modèle. Ces éléments apparaîtront sous forme de colonnes — utilisez les colonnes de configuration pour regrouper, trier et filtrer les runs de manière dynamique dans l’application.
  3. Projet : un projet est un ensemble d’expériences que vous pouvez comparer entre elles. Chaque projet dispose d’une page de tableau de bord dédiée, et vous pouvez facilement afficher ou masquer différents groupes de runs pour comparer différentes versions de modèle.
  4. Notes : ajoutez un court message de commit directement depuis votre script. Modifiez et consultez les notes dans la section Aperçu d’un run dans l’application W&B.
  5. Tags : identifiez les runs de référence et vos runs favoris. Vous pouvez filtrer les runs à l’aide de tags. Vous pouvez modifier les tags ultérieurement dans la section Aperçu du tableau de bord de votre projet dans l’application W&B.
  6. Créez plusieurs ensembles de runs pour comparer les expériences : lorsque vous comparez des expériences, créez plusieurs ensembles de runs pour faciliter la comparaison des métriques. Vous pouvez activer ou désactiver des ensembles de runs sur un même graphique ou groupe de graphiques.
L’extrait de code suivant montre comment définir une expérience W&B en appliquant les bonnes pratiques listées ci-dessus : 
import wandb

config = {
    "learning_rate": 0.01,
    "momentum": 0.2,
    "architecture": "CNN",
    "dataset_id": "cats-0192",
}

with wandb.init(
    project="detect-cats",
    notes="tweak baseline",
    tags=["baseline", "paper1"],
    config=config,
) as run:
    ...
Pour plus d’informations sur les paramètres disponibles lors de la définition d’une expérience W&B, consultez la documentation de l’API wandb.init() dans le Guide de référence de l’API.