Appendice · La backprop à la main

Tu as appelé loss.backward() au chapitre 5, puis à chaque chapitre suivant. Ça remplit silencieusement .grad sur chaque paramètre du modèle. Cet appendice déballe ce que cette ligne fait, en dérivant à la main les gradients d’un petit réseau, puis en vérifiant contre PyTorch.

Une fois fait, chaque loss.backward() ultérieur cesse d’être magique.

1. Le réseau

Le plus petit réseau intéressant : 2 entrées, 1 unité cachée, 1 sortie. Sigmoid sur le caché, identité en sortie. Loss quadratique contre une seule cible.

Trois paramètres (w₁, w₂, v), quatre intermédiaires (z, h, ŷ, L), deux entrées et une cible.

Valeurs concrètes :

2. Passe avant à la main

Huit opérations arithmétiques pour transformer deux entrées en un seul nombre.

3. Passe arrière par la règle de la chaîne

On veut ∂L/∂v, ∂L/∂w₁, ∂L/∂w₂ — un nombre par paramètre. La règle de la chaîne remonte le graphe.

Étape 1. Sensibilité de la loss à la sortie :

Étape 2. Pousser à travers v :

v est fini. Pour w₁ et w₂, le chemin est plus long.

Étape 3. Pousser à travers h, puis à travers z. La dérivée de sigmoid est h(1 − h) :

Étape 4. Enfin à travers les linéaires z = w₁ x₁ + w₂ x₂ :

Trois nombres : ∂L/∂v ≈ -0.6220, ∂L/∂w₁ ≈ -0.1651, ∂L/∂w₂ ≈ -0.0825.

Écris la chain rule toi-même. La cellule pré-remplit la passe avant ; tu remplis les quatre lignes de la passe arrière et regardes les gradients tomber :

4. Vérification avec PyTorch

"""check_backprop.py — verify hand-derived gradients match PyTorch."""
import math
import torch
 
x = torch.tensor([1.0, 0.5])
y = torch.tensor(1.0)
w = torch.tensor([0.4, 0.6], requires_grad=True)
v = torch.tensor(0.8, requires_grad=True)
 
z = (w * x).sum()
h = torch.sigmoid(z)
y_hat = v * h
loss = (y_hat - y) ** 2
 
loss.backward()
 
print(f"forward:  z={z.item():.4f} h={h.item():.4f} y_hat={y_hat.item():.4f} loss={loss.item():.4f}")
print(f"grads:    w1={w.grad[0].item():.4f} w2={w.grad[1].item():.4f} v={v.grad.item():.4f}")
 
expected = {"w1": -0.1651, "w2": -0.0825, "v": -0.6220}
assert math.isclose(w.grad[0].item(), expected["w1"], abs_tol=1e-3)
assert math.isclose(w.grad[1].item(), expected["w2"], abs_tol=1e-3)
assert math.isclose(v.grad.item(), expected["v"], abs_tol=1e-3)
print("✓ hand-derived gradients match PyTorch")

Sortie attendue :

forward:  z=0.7000 h=0.6682 y_hat=0.5346 loss=0.2166
grads:    w1=-0.1651 w2=-0.0825 v=-0.6220
✓ hand-derived gradients match PyTorch

Les nombres collent à quatre décimales. C’est ce que loss.backward() fait pour chaque paramètre de chaque modèle du livre. Le mécanisme est identique ; seul le graphe est plus gros.

5. Pourquoi ça généralise

Un vrai modèle a des millions à des milliards de paramètres. La dérivation à la main ne passe pas à l’échelle, mais la règle de la chaîne, oui :

1. Le graphe de calcul est construit automatiquement pendant la passe avant. Chaque opération enregistre ses entrées et sa dérivée locale.
2. La passe arrière parcourt le graphe de la loss vers chaque paramètre, multipliant les dérivées locales. Un nombre par paramètre, écrit dans .grad.
3. Le coût est du même ordre que la passe avant — 2 à 3× plus cher, pas exponentiellement plus. C’est toute la raison pour laquelle l’entraînement moderne est possible.

Quand le module d’attention du chapitre 8 appelle loss.backward(), le graphe parcouru a des centaines d’opérations et des dizaines de milliers de paramètres, mais chaque arête individuelle est l’une des règles simples de cet appendice.

Pour aller plus loin

• 3blue1brown, « Backpropagation calculus ».
• micrograd de Karpathy — bibliothèque autodiff de 150 lignes en Python. À lire de bout en bout au moins une fois.
• Notes autograd de PyTorch.