PyTorch

Utilisez W&B pour le suivi des expériences de machine learning, la gestion des versions des jeux de données et la collaboration autour des projets.

Ce que vous trouverez dans ce notebook

Ce tutoriel explique comment intégrer W&B à votre code d’entraînement PyTorch afin de pouvoir suivre les expériences, consigner des métriques et des gradients, et versionner les modèles. Utilisez-le pour ajouter le suivi des expériences à un pipeline PyTorch existant.

Schéma de l’intégration entre PyTorch et W&B

# importer la bibliothèque
import wandb

# capturer un dictionnaire d'hyperparamètres avec config
config = {
    "learning_rate": 0.001,
    "epochs": 100,
    "batch_size": 128
}

# lancer une nouvelle expérience
with wandb.init(project="new-sota-model", config=config) as run:

    # configurer le modèle et les données
    model, dataloader = get_model(), get_data()

    # optionnel : suivre les gradients
    run.watch(model)

    for batch in dataloader:
        metrics = model.training_step()
        # consigner des métriques dans votre boucle d'entraînement pour visualiser les performances du modèle
        run.log(metrics)

    # optionnel : sauvegarder le modèle à la fin
    model.to_onnx()
    run.save("model.onnx")

Suivez ce tutoriel vidéo. Les sections commençant par Étape suffisent pour intégrer W&B à un pipeline existant. Le reste se limite à charger les données et à définir un modèle.

Installer, importer et se connecter

Avant de définir l’expérience, configurez l’environnement et connectez-vous à W&B.

import os
import random

import numpy as np
import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms
from tqdm.auto import tqdm

# Garantir un comportement déterministe
torch.backends.cudnn.deterministic = True
random.seed(hash("setting random seeds") % 2**32 - 1)
np.random.seed(hash("improves reproducibility") % 2**32 - 1)
torch.manual_seed(hash("by removing stochasticity") % 2**32 - 1)
torch.cuda.manual_seed_all(hash("so runs are repeatable") % 2**32 - 1)

# Configuration du périphérique
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

# supprimer le miroir lent de la liste des miroirs MNIST
torchvision.datasets.MNIST.mirrors = [mirror for mirror in torchvision.datasets.MNIST.mirrors
                                      if not mirror.startswith("http://yann.lecun.com")]

Étape 0 : Installer W&B

Pour commencer, vous devez installer la bibliothèque wandb avec pip.

!pip install wandb onnx -Uq

Étape 1 : Importer W&B et vous connecter

Pour journaliser des données sur le service W&B, vous devez vous connecter. Si c’est la première fois que vous utilisez W&B, inscrivez-vous pour obtenir un compte gratuit via le lien qui s’affiche.

import wandb

wandb.login()

Définir l’expérience et le pipeline

Une fois W&B installé et votre session authentifiée, définissez la configuration de l’expérience ainsi que le pipeline d’entraînement qui l’utilisera.

Suivre les métadonnées et les hyperparamètres avec `wandb.init()`

Dans le code, commencez par définir votre expérience. Quels sont les hyperparamètres ? Quelles métadonnées sont associées à ce run ? Une approche courante consiste à stocker ces informations dans un dictionnaire config (ou un objet similaire), puis à y accéder au besoin. Cet exemple ne fait varier que quelques hyperparamètres et code le reste à la main. N’importe quelle partie de votre modèle peut faire partie de config. L’exemple inclut également des métadonnées sur le dataset MNIST et une architecture convolutionnelle. Si vous travaillez plus tard, par exemple, avec des architectures entièrement connectées sur CIFAR dans le même projet, ces métadonnées vous aideront à distinguer vos runs.

config = dict(
    epochs=5,
    classes=10,
    kernels=[16, 32],
    batch_size=128,
    learning_rate=0.005,
    dataset="MNIST",
    architecture="CNN")

Ensuite, définissons le pipeline global, ce qui est assez typique pour l’entraînement d’un modèle :

make un modèle, ainsi que les données et l’optimiseur associés.
train le modèle en conséquence.
le test pour voir comment l’entraînement s’est déroulé.

Le code suivant implémente ces fonctions.

def model_pipeline(hyperparameters):

    # indiquer à wandb de démarrer
    with wandb.init(project="pytorch-demo", config=hyperparameters) as run:
        # accéder à tous les HPs via run.config, pour que la journalisation corresponde à l'exécution.
        config = run.config

        # créer le modèle, les données et le problème d'optimisation
        model, train_loader, test_loader, criterion, optimizer = make(config)
        print(model)

        # et les utiliser pour entraîner le modèle
        train(model, train_loader, criterion, optimizer, config)

        # et tester ses performances finales
        test(model, test_loader)

    return model

La seule différence ici par rapport à un pipeline standard est que tout se passe dans le contexte de wandb.init(). L’appel à cette fonction établit un canal de communication entre votre code et les serveurs de W&B. Le fait de passer le dictionnaire config à wandb.init() enregistre immédiatement toutes ces informations dans W&B, afin que vous sachiez toujours quelles valeurs d’hyperparamètres vous avez choisi d’utiliser pour votre expérience. Pour vous assurer que les valeurs que vous avez choisies et enregistrées sont toujours bien celles qui sont utilisées dans votre modèle, W&B recommande d’utiliser la copie run.config de votre objet. Consultez la définition suivante de make pour voir quelques exemples. Une fois le pipeline défini, les sections suivantes implémentent successivement chacune de ses étapes : configuration des données et du modèle, entraînement et test.

Remarque : W&B exécute son code dans des processus séparés afin que tout problème du côté de W&B ne fasse pas planter votre code. Une fois le problème résolu, vous pouvez synchroniser les données avec wandb sync.

def make(config):
    # Préparer les données
    train, test = get_data(train=True), get_data(train=False)
    train_loader = make_loader(train, batch_size=config.batch_size)
    test_loader = make_loader(test, batch_size=config.batch_size)

    # Créer le modèle
    model = ConvNet(config.kernels, config.classes).to(device)

    # Créer la fonction de perte et l'optimiseur
    criterion = nn.CrossEntropyLoss()
    optimizer = torch.optim.Adam(
        model.parameters(), lr=config.learning_rate)
    
    return model, train_loader, test_loader, criterion, optimizer

Définir le chargement des données et le modèle

Ensuite, précisez comment les données sont chargées et à quoi ressemble le modèle. Cette partie est importante, mais elle n’est pas différente de ce qu’elle serait sans wandb.

def get_data(slice=5, train=True):
    full_dataset = torchvision.datasets.MNIST(root=".",
                                              train=train, 
                                              transform=transforms.ToTensor(),
                                              download=True)
    #  équivalent au slicing avec [::slice] 
    sub_dataset = torch.utils.data.Subset(
      full_dataset, indices=range(0, len(full_dataset), slice))
    
    return sub_dataset


def make_loader(dataset, batch_size):
    loader = torch.utils.data.DataLoader(dataset=dataset,
                                         batch_size=batch_size, 
                                         shuffle=True,
                                         pin_memory=True, num_workers=2)
    return loader

Définir le modèle ne change pas avec wandb, donc cet exemple utilise une architecture ConvNet standard. N’ayez pas peur de le modifier et d’essayer quelques expériences — tous vos résultats seront enregistrés sur wandb.ai.

# Réseau de neurones conventionnel et convolutif

class ConvNet(nn.Module):
    def __init__(self, kernels, classes=10):
        super(ConvNet, self).__init__()
        
        self.layer1 = nn.Sequential(
            nn.Conv2d(1, kernels[0], kernel_size=5, stride=1, padding=2),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2))
        self.layer2 = nn.Sequential(
            nn.Conv2d(16, kernels[1], kernel_size=5, stride=1, padding=2),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2))
        self.fc = nn.Linear(7 * 7 * kernels[-1], classes)
        
    def forward(self, x):
        out = self.layer1(x)
        out = self.layer2(out)
        out = out.reshape(out.size(0), -1)
        out = self.fc(out)
        return out

Définir la logique d’entraînement

En poursuivant dans le model_pipeline, il est temps de préciser comment entraîner. C’est là que l’intégration W&B suit les gradients, les paramètres et les métriques au fil de l’entraînement. Deux fonctions wandb entrent en jeu ici : watch et log.

Suivre les gradients avec `run.watch()` et tout le reste avec `run.log()`

run.watch() journalisera les gradients et les paramètres de votre modèle toutes les log_freq étapes de l’entraînement. Appelez run.watch() avant de commencer l’entraînement. Pour les modes de journalisation, les modèles multiples et les conseils sur les performances, voir Comment puis-je journaliser les gradients et les poids du modèle avec wandb.watch ?. Le reste du code d’entraînement reste le même : parcourez les époques et les lots, effectuez des passes avant et arrière, et appliquez votre optimizer.

def train(model, loader, criterion, optimizer, config):
    # Indiquer à wandb de surveiller ce que fait le modèle : gradients, poids, etc.
    run = wandb.init(project="pytorch-demo", config=config)
    run.watch(model, criterion, log="all", log_freq=10)

    # Lancer l'entraînement et le suivre avec wandb
    total_batches = len(loader) * config.epochs
    example_ct = 0  # nombre d'exemples vus
    batch_ct = 0
    for epoch in tqdm(range(config.epochs)):
        for _, (images, labels) in enumerate(loader):

            loss = train_batch(images, labels, model, optimizer, criterion)
            example_ct +=  len(images)
            batch_ct += 1

            # Consigner les métriques tous les 25 batches
            if ((batch_ct + 1) % 25) == 0:
                train_log(loss, example_ct, epoch)


def train_batch(images, labels, model, optimizer, criterion):
    images, labels = images.to(device), labels.to(device)
    
    # Passe avant ➡
    outputs = model(images)
    loss = criterion(outputs, labels)
    
    # Passe arrière ⬅
    optimizer.zero_grad()
    loss.backward()

    # Étape avec l'optimiseur
    optimizer.step()

    return loss

La seule différence réside dans le code de journalisation : alors qu’auparavant vous pouviez consigner des métriques en les affichant dans le terminal, vous transmettez maintenant les mêmes informations à run.log(). run.log() attend un dictionnaire dont les clés sont des chaînes de caractères. Ces chaînes identifient les objets enregistrés, qui constituent les valeurs. Vous pouvez aussi indiquer, de façon facultative, à quelle step d’entraînement vous en êtes.

Remarque : utiliser le nombre d’exemples que le modèle a vus facilite la comparaison entre différentes tailles de lot, mais vous pouvez utiliser les étapes brutes ou le nombre de lots. Pour des runs d’entraînement plus longs, il peut aussi être pertinent de journaliser par epoch.

def train_log(loss, example_ct, epoch):
    with wandb.init(project="pytorch-demo") as run:
        # Consigner la perte et le numéro d'époque
        # C'est ici que nous consignons les métriques dans W&B
        run.log({"epoch": epoch, "loss": loss}, step=example_ct)
        print(f"Loss after {str(example_ct).zfill(5)} examples: {loss:.3f}")

Définir la logique de test

Une fois l’entraînement du modèle terminé, testez-le : exécutez-le sur de nouvelles données de production, par exemple, ou appliquez-le à des exemples soigneusement sélectionnés à la main. Les tests vous offrent également un moment naturel pour enregistrer le modèle entraîné.

Facultatif : Appelez `run.save()`

C’est aussi le bon moment pour enregistrer l’architecture du modèle et les paramètres finaux sur le disque. Pour une compatibilité étendue, exportez le modèle au format Open Neural Network eXchange (ONNX). En passant ce nom de fichier à run.save(), vous vous assurez que les paramètres du modèle sont enregistrés sur les serveurs de W&B : fini les pertes de repères pour savoir quel fichier .h5 ou .pb correspond à quel run d’entraînement. Pour des fonctionnalités wandb plus avancées pour le stockage, la gestion des versions et la distribution de modèles, consultez les outils Artifacts.

def test(model, test_loader):
    model.eval()

    with wandb.init(project="pytorch-demo") as run:
        # Exécuter le modèle sur quelques exemples de test
        with torch.no_grad():
            correct, total = 0, 0
            for images, labels in test_loader:
                images, labels = images.to(device), labels.to(device)
                outputs = model(images)
                _, predicted = torch.max(outputs.data, 1)
                total += labels.size(0)
                correct += (predicted == labels).sum().item()

            print(f"Accuracy of the model on the {total} " +
                f"test images: {correct / total:%}")
            
            run.log({"test_accuracy": correct / total})

        # Enregistrer le modèle au format ONNX interopérable
        torch.onnx.export(model, images, "model.onnx")
        run.save("model.onnx")

Exécutez l’entraînement et regardez vos métriques en direct sur wandb.ai

Maintenant que vous avez défini l’ensemble du pipeline et ajouté ces quelques lignes de code W&B, vous êtes prêt à exécuter votre expérience avec un suivi complet. W&B affiche quelques liens : la documentation, la page Project (qui organise tous les runs d’un project) et la page Run (où sont stockés les résultats de ce run). Accédez à la page Run et consultez les onglets suivants :

Charts, où les gradients du modèle, les valeurs des paramètres et la perte sont enregistrés tout au long de l’entraînement.
System, qui contient les métriques système, y compris l’utilisation des E/S disque ainsi que les métriques CPU et GPU.
Logs, qui contient une copie de tout ce qui a été envoyé sur la sortie standard pendant l’entraînement.
Files, où, une fois l’entraînement terminé, vous pouvez cliquer sur model.onnx pour visualiser votre réseau avec le visualiseur de modèles Netron.

Une fois le run terminé, à la fin du bloc with wandb.init(), W&B affiche également une synthèse des résultats dans la sortie de la cellule.

# Construire, entraîner et analyser le modèle avec le pipeline
model = model_pipeline(config)

Tester des hyperparamètres avec des balayages

Cet exemple ne portait que sur un seul ensemble d’hyperparamètres. Or, dans la plupart des flux de travail de ML, il est essentiel de faire varier plusieurs hyperparamètres. Vous pouvez utiliser les balayages W&B pour automatiser les tests d’hyperparamètres et explorer l’espace des modèles et des stratégies d’optimisation possibles. Cela vous permet d’aller au-delà de l’exécution précédente à configuration unique. Consultez ce notebook Colab montrant l’optimisation d’hyperparamètres avec les balayages W&B. L’exécution d’un balayage d’hyperparamètres avec W&B se déroule en trois étapes :

Définir le balayage : créez un dictionnaire ou un fichier YAML qui spécifie les paramètres à explorer, la stratégie de recherche, la métrique d’optimisation, etc.
Initialiser le balayage : sweep_id = wandb.sweep(sweep_config).
Exécuter l’agent de balayage : wandb.agent(sweep_id, function=train).

C’est tout ce qu’il faut pour exécuter un balayage d’hyperparamètres.

Galerie d’exemples

Explorez des exemples de projets suivis et visualisés avec W&B dans la Galerie.

Configuration avancée

Les options suivantes peuvent étendre le flux de travail de base précédent pour les environnements de production, hors ligne ou gérés :

Variables d’environnement : définissez des clés API dans les variables d’environnement pour pouvoir lancer des entraînements sur un cluster géré.
Mode hors ligne : utilisez le mode dryrun pour entraîner hors ligne et synchroniser les résultats plus tard.
Sur site : installez W&B dans un cloud privé ou sur des serveurs isolés du réseau au sein de votre propre infrastructure.
Sweeps : configurez rapidement une recherche d’hyperparamètres avec un outil léger de réglage.

Guides

Intégrations

Référence

Ce que vous trouverez dans ce notebook

Installer, importer et se connecter

Étape 0 : Installer W&B

Étape 1 : Importer W&B et vous connecter

Définir l’expérience et le pipeline

Suivre les métadonnées et les hyperparamètres avec `wandb.init()`

Définir le chargement des données et le modèle

Définir la logique d’entraînement

Suivre les gradients avec `run.watch()` et tout le reste avec `run.log()`

Définir la logique de test

Facultatif : Appelez `run.save()`

Exécutez l’entraînement et regardez vos métriques en direct sur wandb.ai

Tester des hyperparamètres avec des balayages

Galerie d’exemples

Configuration avancée

​Ce que vous trouverez dans ce notebook

​Installer, importer et se connecter

​Étape 0 : Installer W&B

​Étape 1 : Importer W&B et vous connecter

​Définir l’expérience et le pipeline

​Suivre les métadonnées et les hyperparamètres avec wandb.init()

​Définir le chargement des données et le modèle

​Définir la logique d’entraînement

​Suivre les gradients avec run.watch() et tout le reste avec run.log()

​Définir la logique de test

​Facultatif : Appelez run.save()

​Exécutez l’entraînement et regardez vos métriques en direct sur wandb.ai

​Tester des hyperparamètres avec des balayages

​Galerie d’exemples

​Configuration avancée

Ce que vous trouverez dans ce notebook

Installer, importer et se connecter

Étape 0 : Installer W&B

Étape 1 : Importer W&B et vous connecter

Définir l’expérience et le pipeline

Suivre les métadonnées et les hyperparamètres avec `wandb.init()`

Définir le chargement des données et le modèle

Définir la logique d’entraînement

Suivre les gradients avec `run.watch()` et tout le reste avec `run.log()`

Définir la logique de test

Facultatif : Appelez `run.save()`

Exécutez l’entraînement et regardez vos métriques en direct sur wandb.ai

Tester des hyperparamètres avec des balayages

Galerie d’exemples

Configuration avancée