Ajoutez W&B (wandb) à votre code

Ce guide fournit des recommandations pour intégrer W&B à votre script d’entraînement Python ou à votre notebook afin d’optimiser la recherche d’hyperparamètres. En suivant ces recommandations, vous pouvez utiliser les balayages W&B pour explorer les valeurs d’hyperparamètres, journaliser les métriques d’entraînement et de validation, et identifier la configuration qui permet d’obtenir de bonnes performances du modèle. Ce guide s’adresse aux praticiens du machine learning qui disposent déjà d’un script d’entraînement Python et souhaitent ajouter la prise en charge des balayages d’hyperparamètres. Les sections suivantes présentent un exemple de script d’entraînement, puis montrent comment le mettre à jour pour qu’il fonctionne avec les balayages W&B.

Script d’entraînement original

Supposons que vous disposiez d’un script Python qui entraîne un modèle (voir le code ci-dessous). Votre objectif est de trouver les hyperparamètres qui maximisent la précision de validation (val_acc). Dans votre script Python, vous définissez deux fonctions : train_one_epoch et evaluate_one_epoch. La fonction train_one_epoch simule l’entraînement sur une époque et renvoie la précision et la perte d’entraînement. La fonction evaluate_one_epoch simule l’évaluation du modèle sur l’ensemble de données de validation et renvoie la précision et la perte de validation. Vous définissez un dictionnaire de configuration nommé config qui contient des valeurs d’hyperparamètres telles que le taux d’apprentissage, la taille de lot et le nombre d’époques. Les valeurs de ce dictionnaire de configuration contrôlent le processus d’entraînement. Ensuite, vous définissez une fonction appelée main qui reproduit une boucle d’entraînement classique. À chaque époque, le script calcule la précision et la perte sur les ensembles de données d’entraînement et de validation.

Ce code est un script d’entraînement fictif. Il n’entraîne pas réellement de modèle, mais simule le processus d’entraînement en générant des valeurs aléatoires de précision et de perte. L’objectif de ce code est de montrer comment intégrer W&B dans votre script d’entraînement.

import random
import numpy as np

def train_one_epoch(epoch, lr, batch_size):
    acc = 0.25 + ((epoch / 30) + (random.random() / 10))
    loss = 0.2 + (1 - ((epoch - 1) / 10 + random.random() / 5))
    return acc, loss

def evaluate_one_epoch(epoch):
    acc = 0.1 + ((epoch / 20) + (random.random() / 10))
    loss = 0.25 + (1 - ((epoch - 1) / 10 + random.random() / 6))
    return acc, loss

# variable de configuration avec les valeurs des hyperparamètres
config = {"lr": 0.0001, "batch_size": 16, "epochs": 5}

def main():
    lr = config["lr"]
    batch_size = config["batch_size"]
    epochs = config["epochs"]

    for epoch in np.arange(1, epochs):
        train_acc, train_loss = train_one_epoch(epoch, lr, batch_size)
        val_acc, val_loss = evaluate_one_epoch(epoch)

        print("epoch: ", epoch)
        print("training accuracy:", train_acc, "training loss:", train_loss)
        print("validation accuracy:", val_acc, "validation loss:", val_loss)

if __name__ == "__main__":
    main()

La section suivante montre comment ajouter W&B à votre script Python afin de suivre les hyperparamètres et les métriques pendant l’entraînement. Vous souhaitez utiliser W&B pour trouver les meilleurs hyperparamètres afin de maximiser la précision de validation (val_acc).

Ajoutez W&B à votre script d’entraînement

Cette section montre comment modifier le script d’entraînement original afin que l’agent de balayage puisse transmettre des valeurs d’hyperparamètre à chaque run et que W&B puisse enregistrer les métriques obtenues. La manière d’intégrer W&B à votre script Python ou notebook dépend de la façon dont vous gérez les Sweeps. Pour utiliser le W&B Python SDK afin de démarrer, d’arrêter et de gérer les Sweeps, suivez les instructions de l’onglet Python script or notebook. Pour utiliser le W&B CLI à la place, suivez les instructions de l’onglet CLI.

CLI
Script Python ou notebook

Créez un fichier de configuration YAML pour votre sweep. Ce fichier contient les hyperparamètres que vous voulez explorer avec le sweep. Dans l’exemple suivant, le sweep fait varier les hyperparamètres batch_size, epochs et lr à chaque exécution.

# config.yaml
program: train.py
method: random
name: sweep
metric:
  goal: maximize
  name: val_acc
parameters:
  batch_size:
    values: [16, 32, 64]
  lr:
    min: 0.0001
    max: 0.1
  epochs:
    values: [5, 10, 15]

Pour plus d’informations, voir Définir la configuration du sweep.Vous devez fournir le nom de votre script Python pour la clé program dans votre fichier YAML.Ensuite, ajoutez ce qui suit à l’exemple de code :

Importez le SDK Python de W&B (wandb) et PyYAML (yaml). Utilisez PyYAML pour lire votre fichier de configuration YAML.
Chargez le fichier de configuration.
Utilisez wandb.init() pour démarrer un processus d’arrière-plan afin de synchroniser et d’enregistrer les données en tant que W&B Run. Passez l’objet config au paramètre config.
Définissez les valeurs des hyperparamètres à partir de wandb.Run.config au lieu d’utiliser des valeurs codées en dur.
Enregistrez la métrique que vous souhaitez optimiser avec wandb.Run.log(). Vous devez enregistrer la métrique définie dans votre configuration. Dans le dictionnaire de configuration (sweep_configuration dans cet exemple), vous définissez le sweep de manière à maximiser la valeur val_acc.

import wandb
import yaml
import random
import numpy as np


def train_one_epoch(epoch, lr, batch_size):
    acc = 0.25 + ((epoch / 30) + (random.random() / 10))
    loss = 0.2 + (1 - ((epoch - 1) / 10 + random.random() / 5))
    return acc, loss


def evaluate_one_epoch(epoch):
    acc = 0.1 + ((epoch / 20) + (random.random() / 10))
    loss = 0.25 + (1 - ((epoch - 1) / 10 + random.random() / 6))
    return acc, loss


def main():
    # Configurez vos hyperparamètres par défaut
    with open("./config.yaml") as file:
        config = yaml.load(file, Loader=yaml.FullLoader)

    with wandb.init(config=config) as run:
        for epoch in np.arange(1, run.config['epochs']):
            train_acc, train_loss = train_one_epoch(epoch, run.config['lr'], run.config['batch_size'])
            val_acc, val_loss = evaluate_one_epoch(epoch)
            run.log(
                {
                    "epoch": epoch,
                    "train_acc": train_acc,
                    "train_loss": train_loss,
                    "val_acc": val_acc,
                    "val_loss": val_loss,
                }
            )

# Appelez la fonction principale.
main()

Après avoir mis à jour votre script d’entraînement, initialisez et démarrez le sweep depuis votre CLI :

Initialisez le sweep avec la commande wandb sweep. Fournissez le nom du fichier YAML. Si vous le souhaitez, définissez l’option --project sur le nom du projet :
wandb sweep --project sweep-demo-cli config.yaml
Cela renvoie un ID de sweep. Pour plus d’informations, voir Initialiser les sweeps.
Copiez l’ID du sweep et remplacez [SWEEP-ID] dans la commande suivante pour démarrer le job du sweep avec la commande wandb agent. Remplacez [YOUR-ENTITY] par le nom de votre entité W&B. Si vous le souhaitez, définissez --count pour limiter le nombre de runs que l’agent lance (cet exemple le définit sur cinq) :
wandb agent --count 5 [YOUR-ENTITY]/sweep-demo-cli/[SWEEP-ID]

L’agent de sweep exécute votre script d’entraînement de façon répétée, chaque fois avec une combinaison différente de valeurs d’hyperparamètres issues de votre configuration YAML, et journalise les résultats dans W&B. Pour plus d’informations, voir Démarrer des jobs de sweep.

Suivez ces étapes pour ajouter W&B à votre script Python :

Créez un dictionnaire dans lequel les paires clé-valeur définissent une configuration de sweep. La configuration du sweep définit les hyperparamètres que vous souhaitez voir W&B explorer, ainsi que la métrique que vous souhaitez optimiser. En reprenant l’exemple précédent, faites varier les hyperparamètres batch_size, epochs et lr à chaque sweep. Pour maximiser la précision de validation, définissez goal de la métrique sur maximize et son name sur val_acc.
Passez le dictionnaire de configuration du sweep à wandb.sweep(). Cela initialise le sweep et renvoie un ID de sweep (sweep_id). Pour plus d’informations, voir Initialize sweeps.
En haut de votre script, importez le SDK Python de W&B (wandb).
Dans votre fonction main, utilisez wandb.init() pour générer un processus en arrière-plan afin de synchroniser et d’enregistrer les données sous forme de W&B Run. Passez le nom du projet comme paramètre à la méthode wandb.init(). Si vous ne fournissez pas de nom de projet, W&B utilise le nom de projet par défaut.
Récupérez les valeurs des hyperparamètres à partir de l’objet wandb.Run.config. Cela vous permet d’utiliser les valeurs d’hyperparamètres définies dans le dictionnaire de configuration du sweep au lieu de valeurs codées en dur.
Enregistrez dans W&B la métrique que vous optimisez à l’aide de wandb.Run.log(). Vous devez enregistrer la métrique définie dans votre configuration. Par exemple, si vous définissez la métrique à optimiser comme val_acc, vous devez enregistrer val_acc. Si vous n’enregistrez pas la métrique, W&B ne peut pas effectuer l’optimisation. Dans le dictionnaire de configuration (sweep_configuration dans cet exemple), vous définissez le sweep pour maximiser la valeur val_acc.
Démarrez le sweep avec wandb.agent(). Fournissez l’ID du sweep et le nom de la fonction exécutée par le sweep (function=main), puis définissez le nombre maximal de runs sur quatre (count=4).

En combinant le tout, votre script pourrait ressembler à ce qui suit :

import wandb # Importer le SDK Python W&B
import numpy as np
import random
import argparse

def train_one_epoch(epoch, lr, batch_size):
    acc = 0.25 + ((epoch / 30) + (random.random() / 10))
    loss = 0.2 + (1 - ((epoch - 1) / 10 + random.random() / 5))
    return acc, loss

def evaluate_one_epoch(epoch):
    acc = 0.1 + ((epoch / 20) + (random.random() / 10))
    loss = 0.25 + (1 - ((epoch - 1) / 10 + random.random() / 6))
    return acc, loss

def main(args=None):
    # Lorsqu'il est appelé par l'agent de balayage, args est None,
    # on utilise donc le projet issu de la configuration du sweep
    project = args.project if args else None
    
    with wandb.init(project=project) as run:
        # Récupère les valeurs des hyperparamètres depuis l'objet `wandb.Run.config`
        lr = run.config["lr"]
        batch_size = run.config["batch_size"]
        epochs = run.config["epochs"]

        # Exécute la boucle d'entraînement et consigne les valeurs de performances dans W&B
        for epoch in np.arange(1, epochs):
            train_acc, train_loss = train_one_epoch(epoch, lr, batch_size)
            val_acc, val_loss = evaluate_one_epoch(epoch)
            run.log(
                {
                    "epoch": epoch,
                    "train_acc": train_acc,
                    "train_loss": train_loss,
                    "val_acc": val_acc, # Métrique optimisée
                    "val_loss": val_loss,
                }
            )

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--project", type=str, default="sweep-example", help="W&B project name")
    args = parser.parse_args()

    # Définir un dictionnaire de configuration du sweep
    sweep_configuration = {
        "method": "random",
        "name": "sweep",
        # Métrique à optimiser
        # Par exemple, pour maximiser la précision de validation,
        # définissez "goal": "maximize" et le nom de la variable
        # à optimiser, ici "val_acc"
        "metric": {
            "goal": "maximize",
            "name": "val_acc"
            },
        "parameters": {
            "batch_size": {"values": [16, 32, 64]},
            "epochs": {"values": [5, 10, 15]},
            "lr": {"max": 0.1, "min": 0.0001},
        },
    }

    # Initialiser le sweep en transmettant le dictionnaire de configuration
    sweep_id = wandb.sweep(sweep=sweep_configuration, project=args.project)

    # Démarrer le job de sweep
    wandb.agent(sweep_id, function=main, count=4)

Lorsque vous exécutez ce script, W&B lance le sweep, exécute la fonction main jusqu’à quatre fois avec différentes combinaisons d’hyperparamètres et journalise les métriques de chaque run afin de vous permettre de comparer les résultats dans l’application W&B.

Journal des métriques dans W&B lors d’un balayageVous devez journaliser la métrique que vous définissez et que vous optimisez, à la fois dans votre configuration de balayage et avec wandb.Run.log(). Par exemple, si vous définissez val_acc comme métrique à optimiser dans votre configuration de balayage, vous devez également journaliser val_acc dans W&B. Si vous ne journalisez pas cette métrique, W&B ne peut pas effectuer l’optimisation.

with wandb.init() as run:
    val_loss, val_acc = train()
    run.log(
        {
            "val_loss": val_loss,
            "val_acc": val_acc
            }
        )

L’exemple suivant montre une journalisation incorrecte de la métrique dans W&B. La métrique optimisée dans la configuration de balayage est val_acc, mais le code journalise val_acc dans un dictionnaire imbriqué sous la clé validation. Vous devez journaliser la métrique directement, et non dans un dictionnaire imbriqué.

with wandb.init() as run:
    val_loss, val_acc = train()
    run.log(
        {
            "validation": {
                "val_loss": val_loss, 
                "val_acc": val_acc
                }
            }
        )

Guides

Intégrations

Référence

Script d’entraînement original

Ajoutez W&B à votre script d’entraînement

​Script d’entraînement original

​Ajoutez W&B à votre script d’entraînement

Script d’entraînement original

Ajoutez W&B à votre script d’entraînement