Ajouter 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 pourrez utiliser W&B Sweeps pour explorer différentes valeurs d’hyperparamètres, journaliser les métriques d’entraînement et de validation, et identifier la configuration qui offre les meilleures 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 y ajouter la prise en charge des sweeps d’hyperparamètres. Les sections suivantes présentent un exemple de script d’entraînement, puis expliquent comment l’adapter pour qu’il fonctionne avec W&B Sweeps.

Script d’entraînement d’origine

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 le jeu 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 pilotent le processus d’entraînement. Vous définissez ensuite 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 jeux de données d’entraînement et de validation.

Ce code est un script d’entraînement fictif. Il n’entraîne aucun modèle, mais simule le processus d’entraînement en générant des valeurs aléatoires de précision et de perte. Il a pour but 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 config contenant 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 pour suivre les hyperparamètres et les métriques pendant l’entraînement. L’objectif est d’utiliser W&B pour trouver les hyperparamètres qui maximisent la précision de validation (val_acc).

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

Cette section explique comment modifier le script d’entraînement d’origine pour que l’agent de sweep puisse transmettre des valeurs d’hyperparamètres à chaque run et que W&B puisse enregistrer les métriques obtenues. La manière d’intégrer W&B dans votre script Python ou votre notebook dépend de la façon dont vous gérez les sweeps. Si vous utilisez le SDK Python W&B pour démarrer, arrêter et gérer les sweeps, suivez les instructions de l’onglet Script Python ou notebook. Si vous préférez utiliser la CLI W&B, suivez les instructions de l’onglet CLI.

CLI
Script Python ou notebook

Créez un fichier de configuration YAML contenant votre configuration de sweep. Ce fichier définit les hyperparamètres que le sweep doit explorer. Dans l’exemple suivant, le sweep fait varier les hyperparamètres batch_size, epochs et lr à chaque run.

# 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 de sweep.Vous devez indiquer le nom de votre script Python comme valeur de la clé program dans votre fichier YAML.Ajoutez ensuite les éléments suivants à l’exemple de code :

Importez le SDK Python W&B (wandb) et PyYAML (yaml). Utilisez PyYAML pour lire votre fichier de configuration YAML.
Lisez le fichier de configuration.
Utilisez wandb.init() pour démarrer un processus en arrière-plan qui synchronise et journalise les données sous forme de run W&B. Passez l’objet de configuration 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.
Journalisez la métrique à optimiser avec wandb.Run.log(). Vous devez journaliser la métrique définie dans votre configuration. Dans le dictionnaire de configuration (ici, sweep_configuration), le sweep est défini 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():
    # Configurer les 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,
                }
            )

# Appeler la fonction main.
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 en indiquant le nom du fichier YAML. Vous pouvez également définir l’option --project sur le nom du projet :
wandb sweep --project sweep-demo-cli config.yaml
Cette commande renvoie un ID de sweep. Pour plus d’informations, voir Initialiser des sweeps.
Copiez l’ID du sweep et remplacez [SWEEP-ID] dans la commande suivante pour démarrer le job de sweep avec la commande wandb agent. Remplacez [YOUR-ENTITY] par le nom de votre entity W&B. Vous pouvez également définir --count pour limiter le nombre de runs que l’agent tente d’exécuter (ici, cinq) :
wandb agent --count 5 [YOUR-ENTITY]/sweep-demo-cli/[SWEEP-ID]

L’agent de sweep exécute votre script d’entraînement de manière répétée, chaque fois avec une combinaison différente de valeurs d’hyperparamètres tirées 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 objet dictionnaire dont les paires clé-valeur définissent une configuration de sweep. La configuration de sweep définit les hyperparamètres que W&B doit explorer, ainsi que la métrique à optimiser. Dans la continuité de 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 le goal de la métrique sur maximize et son name sur val_acc.
Transmettez le dictionnaire de configuration de sweep à wandb.sweep(). Cette fonction initialise le sweep et renvoie un ID de sweep (sweep_id). Pour plus d’informations, voir Initialiser des sweeps.
En haut de votre script, importez le SDK Python W&B (wandb).
Dans votre fonction main, utilisez wandb.init() pour lancer un processus en arrière-plan chargé de synchroniser et de journaliser les données sous la forme d’un W&B Run. Transmettez le nom du projet en paramètre à la méthode wandb.init(). Si vous ne transmettez 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. Vous pouvez ainsi utiliser les valeurs d’hyperparamètres définies dans le dictionnaire de configuration de sweep plutôt que des valeurs codées en dur.
Journalisez dans W&B la métrique que vous optimisez à l’aide de wandb.Run.log(). Vous devez journaliser la métrique définie dans votre configuration. Par exemple, si vous définissez val_acc comme métrique à optimiser, vous devez journaliser val_acc. Si vous ne journalisez pas la métrique, W&B ne peut pas effectuer l’optimisation. Dans le dictionnaire de configuration (sweep_configuration dans cet exemple), le sweep est défini de façon à maximiser la valeur val_acc.
Lancez 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 fixez le nombre maximum de runs à quatre (count=4).

Une fois tous ces éléments réunis, votre script pourrait ressembler à ceci :

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):
    # Lorsque la fonction est appelée par l’agent de sweep, args vaut None :
    # on utilise donc le projet défini dans 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écuter la boucle d’entraînement et journaliser les métriques 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 à optimiser
                    "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 le 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 indiquez 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 lui passant le dictionnaire de configuration
    sweep_id = wandb.sweep(sweep=sweep_configuration, project=args.project)

    # Lancer 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, puis journalise les métriques de chaque run pour vous permettre de comparer les résultats dans l’application W&B.

Consigner des métriques dans W&B lors d’un sweepLa métrique que vous définissez et que vous cherchez à optimiser doit être à la fois déclarée dans votre configuration de sweep et journalisée avec wandb.Run.log(). Par exemple, si vous définissez val_acc comme métrique à optimiser dans votre configuration de sweep, vous devez également journaliser val_acc dans W&B. Si vous ne journalisez pas la 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 manière incorrecte de journaliser la métrique dans W&B. La configuration de sweep optimise 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
                }
            }
        )

​Script d’entraînement d’origine

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

Script d’entraînement d’origine

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