> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-sdk-testing-latest.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# 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` :
```bash theme={null}
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 :
```bash theme={null}
wandb login
```
Voir la documentation de référence [`wandb login`](/fr/models/ref/cli/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.
Copiez-collez le code suivant dans un fichier nommé `requirements.txt`. Ce fichier contient les dépendances du script d'entraînement.
```txt title="requirements.txt" theme={null}
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.
```yaml title="hyperparameters.yaml" theme={null}
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`.
```python title="train.py" theme={null}
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.
```python Show lines title="train_in_sandbox.py" theme={null}
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.