Code de référence
📖 Vocabulaire - français / anglais
- framework ↔ *framework* (une boîte à outils prête à l'emploi)
- descente de gradient ↔ *gradient descent* (
SGD) - fonction de perte ↔ *loss function* (mesure l'erreur, ici
MSELoss)
import torch
import torch.nn as nn
class PetitReseau(nn.Module):
def __init__(self):
super().__init__()
self.couche1 = nn.Linear(2, 3)
self.couche2 = nn.Linear(3, 1)
self.activation = nn.Sigmoid()
def forward(self, x):
x = self.activation(self.couche1(x))
return self.activation(self.couche2(x))
modele = PetitReseau()
optimizer = torch.optim.SGD(modele.parameters(), lr=0.5)
critere = nn.MSELoss()
X = torch.FloatTensor([[1.4, 0.2], [1.3, 0.2], [4.5, 1.5], [5.1, 1.8]])
y = torch.FloatTensor([[0], [0], [1], [1]])
for epoch in range(10000):
optimizer.zero_grad()
prediction = modele(X)
loss = critere(prediction, y)
loss.backward()
optimizer.step()
if epoch % 1000 == 0:
print(f"Époque {epoch}, perte: {loss.item():.4f}")
Exercice 6.1 - Ce que PyTorch fait pour toi
✍️ À toi de jouer
Compare ce code PyTorch avec le code NumPy de la Phase 3.
- Où est la rétropropagation dans le code NumPy ? Et dans PyTorch ?
- Que fait
loss.backward()exactement ? - Pourquoi faut-il
optimizer.zero_grad()à chaque époque ?
Besoin d'un indice ?
En NumPy tu écrivais delta2, delta1, puis quatre mises à jour de poids. Cherche la seule ligne PyTorch qui remplace tout ça.
Voir la réponse
- En NumPy, tu calculais
delta2,delta1et mettais les poids à jour à la main. En PyTorch,loss.backward()fait tout ça automatiquement. loss.backward()calcule la dérivée de la perte par rapport à chaque poids. C'est la rétropropagation (l'« autograd »).zero_grad()remet les gradients à zéro. Sinon PyTorch les accumulerait d'une époque à l'autre et les poids exploseraient.
La leçon : PyTorch ne change pas la recette. Il écrit juste les étapes répétitives à ta place - et comme tu sais ce qu'elles cachent, ce n'est pas une boîte noire pour toi.