> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-sa-registry-access.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# PyTorch
> Intégrez W&B à PyTorch pour le suivi des expériences, la gestion des versions des jeux de données et l’enregistrement des métriques, des gradients et des modèles.
export const ColabLink = ({url}) =>
Essayer sur Colab
;
Utilisez [W\&B](https://wandb.ai) 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.
```python theme={null}
# 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](https://wandb.me/pytorch-video).
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.
```python theme={null}
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`.
```python theme={null}
!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.
```python theme={null}
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.
```python theme={null}
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 :
1. `make` un modèle, ainsi que les données et l’optimiseur associés.
2. `train` le modèle en conséquence.
3. le `test` pour voir comment l’entraînement s’est déroulé.
Le code suivant implémente ces fonctions.
```python theme={null}
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`.
```python theme={null}
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`.
```python theme={null}
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](https://wandb.ai).
```python theme={null}
# 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 ?](/fr/support/models/articles/how-do-i-log-gradients-and-model-weights-with-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`.
```python theme={null}
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`.
```python theme={null}
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)](https://onnx.ai/).
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](https://www.wandb.com/artifacts).
```python theme={null}
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 :
1. **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.
2. **System**, qui contient les métriques système, y compris l'utilisation des E/S disque ainsi que les métriques CPU et GPU.
3. **Logs**, qui contient une copie de tout ce qui a été envoyé sur la sortie standard pendant l'entraînement.
4. **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](https://github.com/lutzroeder/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.
```python theme={null}
# 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](https://wandb.me/sweeps-colab).
L’exécution d’un balayage d’hyperparamètres avec W\&B se déroule en trois étapes :
1. **Définir le balayage :** créez un dictionnaire ou un [fichier YAML](/fr/models/sweeps/define-sweep-configuration/) qui spécifie les paramètres à explorer, la stratégie de recherche, la métrique d’optimisation, etc.
2. **Initialiser le balayage :** `sweep_id = wandb.sweep(sweep_config)`.
3. **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](https://app.wandb.ai/gallery).
## 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](/fr/platform/hosting/env-vars/) : 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](/fr/support/models/articles/how-do-i-run-wandb-offline) : utilisez le mode `dryrun` pour entraîner hors ligne et synchroniser les résultats plus tard.
* [Sur site](/fr/platform/hosting/hosting-options/self-managed) : installez W\&B dans un cloud privé ou sur des serveurs isolés du réseau au sein de votre propre infrastructure.
* [Sweeps](/fr/models/sweeps/) : configurez rapidement une recherche d'hyperparamètres avec un outil léger de réglage.
```python theme={null}
# 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](https://wandb.me/pytorch-video).
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.
