Tutoriel : entraîner un modèle PyTorch

Découvrez comment entraîner un modèle PyTorch dans un environnement Serverless Sandbox grâce à ce tutoriel étape par étape.

Serverless Sandboxes est en préversion publique.

Dans ce tutoriel, vous entraînez un modèle PyTorch dans un environnement Serverless Sandbox. Pour ce faire, vous démarrez un sandbox avec les variables d’environnement appropriées, installez les dépendances nécessaires et exécutez un script Python. Le script entraîne un réseau de neurones sur le jeu de données UCI Zoo.

À la fin de ce tutoriel, vous disposez d’un fichier de modèle PyTorch entraîné enregistré localement. Cela montre comment utiliser un Serverless Sandbox pour exécuter des charges de travail d’entraînement ML isolées sans avoir à configurer d’infrastructure locale. Ce tutoriel s’adresse aux praticiens du ML et aux développeurs qui souhaitent évaluer Serverless Sandboxes pour des tâches d’entraînement reproductibles.

​

Prérequis

Avant de commencer, suivez les étapes de configuration suivantes.

​

Installez le SDK Python de W&B

Le SDK Python de W&B fournit l’interface Sandbox, que vous utiliserez plus tard pour créer le Serverless Sandbox et interagir avec lui. Installez-le à l’aide de pip :

pip install wandb

​

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

Les Serverless Sandboxes W&B s’exécutent dans votre compte W&B, vous devez donc vous authentifier avant d’en créer un. Utilisez la commande CLI wandb login et suivez les instructions pour vous connecter :

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

Préparez les trois fichiers requis pour ce tutoriel : un fichier requirements, un fichier d’hyperparamètres et un script d’entraînement. Ouvrez le menu déroulant ci-dessous, puis copiez chaque exemple de code dans un fichier distinct 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 W&B Serverless 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 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

Une fois vos fichiers d’entraînement en place, créez et gérez un W&B Serverless Sandbox à partir d’un seul script Python. L’extrait de code suivant crée un sandbox, y copie le script d’entraînement et les dépendances, exécute le script d’entraînement, puis télécharge le fichier de modèle généré.

La section suivante explique le 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.

Une fois le script terminé, vous disposez d’un modèle PyTorch entraîné enregistré sous le nom zoo_wandb.pth dans votre répertoire de travail. Le sandbox qui l’a produit est créé, utilisé, puis supprimé à la demande.