PyTorch : entraîner un réseau de neurones (exemple GPU)

PyTorch est le framework de deep learning le plus utilisé : il permet de définir un réseau de neurones, de l'entraîner sur CPU ou GPU, et de lui faire apprendre des motifs complexes en quelques lignes. Ce guide construit un réseau de neurones qui apprend une frontière non linéaire, l'entraîne, puis visualise ce qu'il a appris.

Vous verrez comment définir un réseau avec torch.nn, la boucle d'entraînement (forward, perte, rétropropagation, optimiseur), l'exécution sur GPU, et pourquoi un réseau de neurones réussit là où un modèle linéaire échoue. Ce guide prolonge le concept de deep learning. Public : intermédiaire à avancé, à l'aise avec Python.

Ce que vous allez apprendre

• Installer PyTorch (CPU ou GPU).
• Définir un réseau de neurones avec torch.nn.
• Écrire une boucle d'entraînement complète.
• Exécuter le calcul sur GPU avec .to(device).
• Visualiser la frontière de décision apprise.

Qu'est-ce que PyTorch ?

PyTorch est une bibliothèque Python qui manipule des tenseurs (des tableaux multidimensionnels) avec accélération GPU et différentiation automatique. Ces deux briques sont le coeur du deep learning : les tenseurs portent les données et les poids, l'autograd calcule automatiquement les gradients nécessaires à la rétropropagation.

Concrètement, vous décrivez le réseau et la perte à minimiser, et PyTorch se charge de calculer comment ajuster chaque poids. C'est ce qui rend possible l'entraînement de réseaux à des millions de paramètres.

Installer PyTorch

Travaillez toujours dans un environnement virtuel isolé, jamais dans le Python système. Pour une machine sans carte graphique, la version CPU suffit pour ce guide :

python3 -m venv venv && source venv/bin/activate
pip install torch==2.7.1 numpy==2.2.6 matplotlib==3.10.9

Sur une machine équipée d'un GPU NVIDIA, installez la variante CUDA pour profiter de l'accélération :

pip install torch==2.7.1 --index-url https://download.pytorch.org/whl/cu126

Vérifiez que PyTorch voit le GPU :

import torch
print(torch.cuda.is_available())          # True si un GPU est disponible

Préparer des données non linéaires

Pour montrer l'intérêt d'un réseau de neurones, on utilise un jeu de données que la régression linéaire ne peut pas séparer : deux lunes entrelacées. On les génère avec NumPy, puis on les convertit en tenseurs placés sur le bon device (GPU si disponible) :

import torch, time, numpy as np
from torch import nn

torch.manual_seed(42); np.random.seed(42)
device = "cuda" if torch.cuda.is_available() else "cpu"

def make_moons(n=1000, noise=0.15):
    n2 = n // 2; t = np.linspace(0, np.pi, n2)
    x1 = np.stack([np.cos(t), np.sin(t)], 1)
    x2 = np.stack([1 - np.cos(t), 1 - np.sin(t) - 0.5], 1)
    X = np.vstack([x1, x2]); y = np.array([0] * n2 + [1] * n2)
    X += noise * np.random.randn(*X.shape)
    return X.astype("float32"), y.astype("int64")

X, y = make_moons(1000)
idx = np.random.permutation(len(X)); tr, te = idx[:800], idx[800:]
Xtr = torch.tensor(X[tr]).to(device); ytr = torch.tensor(y[tr]).to(device)
Xte = torch.tensor(X[te]).to(device); yte = torch.tensor(y[te]).to(device)

Définir le réseau de neurones

Un réseau se décrit comme un empilement de couches. Ici, deux couches cachées de 16 neurones avec une activation ReLU, et une sortie à deux classes :

model = nn.Sequential(
    nn.Linear(2, 16), nn.ReLU(),
    nn.Linear(16, 16), nn.ReLU(),
    nn.Linear(16, 2),
).to(device)

opt = torch.optim.Adam(model.parameters(), lr=0.01)
loss_fn = nn.CrossEntropyLoss()

nn.Linear est une couche entièrement connectée, nn.ReLU la fonction d'activation, Adam l'optimiseur qui ajuste les poids, et CrossEntropyLoss la perte adaptée à la classification.

La boucle d'entraînement

Chaque itération (epoch) répète le même cycle : prédire, mesurer l'erreur, rétropropager, mettre à jour les poids :

t0 = time.time()
for epoch in range(200):
    model.train()
    opt.zero_grad()                       # réinitialiser les gradients
    loss = loss_fn(model(Xtr), ytr)       # forward + perte
    loss.backward()                       # rétropropagation
    opt.step()                            # mise à jour des poids
    if (epoch + 1) % 50 == 0:
        model.eval()
        with torch.no_grad():
            acc = (model(Xte).argmax(1) == yte).float().mean().item()
        print(f"Epoch {epoch+1} | loss {loss.item():.3f} | accuracy test {acc:.3f}")
print(f"Entraînement en {time.time()-t0:.2f}s sur {device}")

Sur un GPU NVIDIA H100, l'entraînement complet donne :

Epoch 50 | loss 0.213 | accuracy test 0.900
Epoch 100 | loss 0.045 | accuracy test 0.990
Epoch 150 | loss 0.023 | accuracy test 0.985
Epoch 200 | loss 0.018 | accuracy test 0.985
Entraînement en 1.50s sur cuda

Le réseau atteint 98,5 % de bonnes réponses sur les données de test, en moins de deux secondes.

Le même code tourne sur CPU

Grâce à device = "cuda" if torch.cuda.is_available() else "cpu" et aux .to(device), le même code s'exécute sur CPU si aucun GPU n'est présent. Sur ce petit réseau, le CPU suffit ; l'écart se creuse sur les gros modèles et les grandes images, où le GPU devient indispensable.

Visualiser ce que le réseau a appris

En colorant chaque zone du plan selon la classe prédite, on voit la frontière de décision que le réseau a construite. Elle épouse la forme courbe des deux lunes, ce qu'une droite ne pourrait jamais faire :

C'est toute la puissance d'un réseau de neurones : grâce à ses couches et à ses fonctions d'activation non linéaires, il modélise des relations que les modèles linéaires ne capturent pas.

Questions fréquentes

PyTorch, c'est quoi ?

PyTorch est un framework de deep learning qui manipule des tenseurs avec accélération GPU et différentiation automatique, pour définir et entraîner des réseaux de neurones.

PyTorch a-t-il besoin d'un GPU ?

Non. PyTorch fonctionne sur CPU ; le GPU accélère l'entraînement des gros modèles mais n'est pas obligatoire. Le code reste identique grâce à .to(device).

PyTorch ou TensorFlow ?

PyTorch domine la recherche et gagne en production pour sa souplesse ; TensorFlow reste solide pour le déploiement à grande échelle. Les deux construisent les mêmes réseaux.

À quoi sert la rétropropagation dans le code ?

loss.backward() calcule automatiquement les gradients de la perte par rapport à chaque poids, et opt.step() ajuste les poids pour réduire l'erreur. C'est le coeur de l'apprentissage.

À retenir

1. PyTorch manipule des tenseurs avec GPU et différentiation automatique.
2. Un réseau se décrit comme un empilement de couches avec torch.nn.
3. La boucle d'entraînement répète : forward, perte, backward, step.
4. .to(device) rend le code portable entre CPU et GPU sans le changer.
5. Les couches non linéaires permettent d'apprendre des frontières courbes, hors de portée d'un modèle linéaire.

Prochaines étapes

Deep learning : les concepts Comprendre réseaux de neurones, CNN, RNN et transformers.

Régression linéaire Le modèle linéaire que le réseau de neurones dépasse.

Machine Learning : les bases Revenir au hub de la formation.

×

📖 Voir la documentation →