Tutoriel : entraîner un modèle PyTorch

Découvrez comment entraîner un modèle PyTorch dans un environnement W&B Sandbox grâce à ce tutoriel pas à pas.

W&B Sandboxes est en préversion privée, accessible uniquement sur invitation. Pour demander à y accéder, contactez l’assistance ou votre AISE.

Dans ce tutoriel, vous allez entraîner un modèle PyTorch dans un environnement W&B Sandbox. Pour ce faire, vous allez démarrer un sandbox avec les variables d’environnement appropriées, installer les dépendances nécessaires et exécuter un script Python qui entraîne un réseau de neurones simple sur le jeu de données UCI Zoo.

​

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

​

Installez le SDK Python de W&B

Installez le SDK Python de W&B. Vous pouvez le faire à l’aide de pip :

pip install wandb

​

Connectez-vous et authentifiez-vous auprès de W&B

Si ce n’est pas déjà fait, connectez-vous à W&B. Utilisez la commande CLI wandb login et suivez les instructions pour vous connecter à votre compte W&B :

wandb login

Voir la documentation de référence wandb login pour plus d’informations sur la manière dont W&B recherche les informations d’authentification.

​

Copiez le script d’entraînement et les dépendances

Développez la liste déroulante ci-dessous pour accéder au code requis pour ce tutoriel. Faites un copier-coller du code dans trois fichiers distincts, dans le même répertoire que ce tutoriel. Dans la section suivante, vous exécuterez un script qui lit ces fichiers et entraîne un modèle PyTorch dans un environnement W&B Sandbox.

Script d'entraînement du modèle PyTorch

Copiez-collez le code suivant dans un fichier nommé requirements.txt. Ce fichier contient les dépendances du script d’entraînement.

requirements.txt

torch
pandas
ucimlrepo
scikit-learn
pyyaml

Copiez-collez le code suivant dans un fichier YAML nommé hyperparameters.yaml. Ce fichier contient les hyperparamètres du script d’entraînement.

hyperparameters.yaml

learning_rate: 0.1
epochs: 1000
model_type: Multivariate_neural_network_classifier

Copiez-collez le code suivant dans un fichier nommé train.py. Ce script entraîne un modèle PyTorch simple sur le jeu de données UCI Zoo et enregistre le modèle entraîné dans un fichier nommé zoo_wandb.pth.

train.py

import argparse
import torch
from torch import nn
import yaml
import pandas as pd
from ucimlrepo import fetch_ucirepo

from sklearn.model_selection import train_test_split

class NeuralNetwork(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear_stack = nn.Sequential(
            nn.Linear(in_features=16 , out_features=16),
            nn.Sigmoid(),
            nn.Linear(in_features=16, out_features=7)
        )

    def forward(self, x):
        logits = self.linear_stack(x)
        return logits

def main(args):
    # Charger les hyperparamètres à partir du fichier de configuration fourni
    with open(args.config, 'r') as f:
        hyperparameter_config = yaml.safe_load(f)

    # récupérer le jeu de données
    zoo = fetch_ucirepo(id=111)

    # données (sous forme de dataframes pandas)
    X = zoo.data.features
    y = zoo.data.targets

    print("features: ", X.shape, "type: ", type(X))
    print("labels: ", y.shape, "type: ", type(y))

    ## Traiter les données
    # Le type de données doit correspondre à celui du modèle ; le dtype par défaut de nn.Linear est torch.float32
    dataset = torch.tensor(X.values).type(torch.float32)

    # Convertir en tenseur et mettre en forme les labels de 0 à 6 pour l'indexation
    labels = torch.tensor(y.values)  - 1

    print("dataset: ", dataset.shape, "dtype: ",dataset.dtype)
    print("labels: ", labels.shape, "dtype: ",labels.dtype)

    torch.save(dataset, "zoo_dataset.pt")
    torch.save(labels, "zoo_labels.pt")

    # Décrire comment le jeu de données d'entraînement est divisé pour référence ultérieure et reproductibilité.
    config = {
        "random_state" : 42,
        "test_size" : 0.25,
        "shuffle" : True
    }

    # Diviser le jeu de données en ensemble d'entraînement et ensemble de test
    X_train, X_test, y_train, y_test = train_test_split(
        dataset,labels,
        random_state=config["random_state"],
        test_size=config["test_size"],
        shuffle=config["shuffle"]
    )

    # Enregistrer les fichiers localement
    torch.save(X_train, "zoo_dataset_X_train.pt")
    torch.save(y_train, "zoo_labels_y_train.pt")

    torch.save(X_test, "zoo_dataset_X_test.pt")
    torch.save(y_test, "zoo_labels_y_test.pt")


    ## Définir le modèle
    model = NeuralNetwork()
    loss_fn = nn.CrossEntropyLoss()
    optimizer = torch.optim.SGD(model.parameters(), lr=hyperparameter_config["learning_rate"])
    print(model)

    # Définir une valeur de perte initiale fictive pour la comparaison dans la boucle d'entraînement
    prev_best_loss = 1e10

    # Boucle d'entraînement
    for e in range(hyperparameter_config["epochs"] + 1):
        pred = model(X_train)
        loss = loss_fn(pred, y_train.squeeze(1))

        loss.backward()
        optimizer.step()
        optimizer.zero_grad()

        # Enregistrer un point de contrôle / le modèle si la perte s'améliore
        if (e % 100 == 0) and (loss <= prev_best_loss):
            print("epoch: ", e, "loss:", loss.item())

            # Enregistrer la nouvelle meilleure perte
            prev_best_loss = loss

    print("Enregistrement du modèle...")
    PATH = 'zoo_wandb.pth'
    torch.save(model.state_dict(), PATH)

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Entraîner un réseau de neurones simple sur le jeu de données zoo.")
    parser.add_argument("--config", type=str, required=True, help="Chemin vers le fichier de configuration des hyperparamètres.")
    args = parser.parse_args()
    main(args)

​

Créer le sandbox et exécuter le script d’entraînement

L’extrait de code suivant montre comment créer un sandbox, y copier le script d’entraînement et les dépendances, exécuter le script d’entraînement, puis télécharger le fichier de modèle généré. La section suivante fournit une explication du code, ligne par ligne.

Copiez-collez le code suivant dans un fichier Python et exécutez-le. Enregistrez-le dans le même répertoire que les fichiers train.py, requirements.txt et hyperparameters.yaml que vous avez créés à l’étape précédente.

train_in_sandbox.py

from pathlib import Path
from wandb.sandbox import Sandbox, NetworkOptions

# Fichiers à monter dans le sandbox. Indiquez le chemin à l'intérieur du
# sandbox et le contenu de chaque fichier sous forme d'octets dans un dictionnaire
mounted_files = [
    {"mount_path": "train.py", "file_content": Path("train.py").read_bytes()},
    {"mount_path": "requirements.txt", "file_content": Path("requirements.txt").read_bytes()},
        ]

print("Starting sandbox...")
with Sandbox.run(
    mounted_files=mounted_files,
    container_image="python:3.13",
    network=NetworkOptions(egress_mode="internet"),
    max_lifetime_seconds=3600
) as sandbox:
    sandbox.write_file("hyperparameters.yaml", Path("hyperparameters.yaml").read_bytes()).result()

    # Installer les dépendances
    print("Installing dependencies...")
    sandbox.exec(["pip", "install", "-r", "requirements.txt"], check=True).result()

    # Exécuter le script
    print("Running script...")
    result = sandbox.exec(["python", "train.py", "--config", "hyperparameters.yaml"]).result()
    print(result.stdout)
    print(result.stderr)
    print(f"Exit code: {result.returncode}")

    # Enregistrer le fichier de modèle généré localement
    print("Downloading zoo_wandb.pth...")
    model_data = sandbox.read_file("zoo_wandb.pth").result()
    Path("zoo_wandb.pth").write_bytes(model_data)
    print("Saved zoo_wandb.pth")

L’extrait de code précédent effectue les opérations suivantes :

1. (Lignes 6 à 9) Liste les fichiers à monter dans le sandbox : train.py et requirements.txt.
2. (Ligne 12) Démarre le sandbox. Le sandbox est configuré pour utiliser l’image de conteneur python:3.13, disposer d’un accès à Internet et avoir une durée de vie maximale de 3 600 secondes (1 heure).
3. (Ligne 18) Écrit le fichier hyperparameters.yaml dans le sandbox. Cela permet au script d’entraînement (train.py) d’accéder aux hyperparamètres lorsqu’il s’exécute.
4. (Ligne 22) Installe les dépendances. La commande pip install -r requirements.txt est exécutée dans le sandbox pour installer les dépendances nécessaires au script d’entraînement.
5. (Ligne 26) Exécute le script d’entraînement. La commande python train.py --config hyperparameters.yaml est exécutée dans le sandbox pour démarrer le processus d’entraînement. Le script entraîne un modèle PyTorch sur le jeu de données UCI Zoo et enregistre le modèle entraîné dans un fichier nommé zoo_wandb.pth.
6. (Lignes 27 à 29) Affiche la sortie et le code de sortie. Une fois l’exécution du script d’entraînement terminée, la sortie standard, la sortie d’erreur standard et le code de sortie sont affichés dans la console à des fins de débogage et de vérification.
7. (Lignes 33 à 34) Télécharge le fichier de modèle généré. Le fichier zoo_wandb.pth est lu depuis le sandbox à l’aide de la méthode read_file() et enregistré localement.