Backpropagation et training loop

La boucle d'entraînement : le rituel universel

Tout entraînement deep, du MLP jouet au LLM géant, répète ces cinq pas :

pour chaque batch :
  1. forward   : prédictions = réseau(X_batch)
  2. loss      : erreur = comparer(prédictions, y_batch)
  3. backward  : gradients de la loss pour CHAQUE paramètre   ← backprop
  4. update    : paramètres -= lr × gradients                 ← descente (module 2 !)
  5. zéro      : remettre les gradients à zéro

La backprop : la chain rule, mécanisée

Le réseau est une composition de fonctions : loss(softmax(W₂ · relu(W₁ · x))). La règle de dérivation en chaîne permet de calculer la dérivée de la loss par rapport à chaque W en remontant la chaîne : chaque couche reçoit le gradient de l'aval, calcule sa contribution, transmet à l'amont. Rien de plus — mais appliqué à des millions de paramètres, automatiquement.

La preuve par le code : un réseau qui apprend XOR

XOR est impossible pour un modèle linéaire (aucune droite ne sépare les classes). Deux couches + ReLU suffisent — la démonstration historique de l'utilité de la profondeur :

🐍 À toi de jouer

# Un réseau 2-8-1 avec backprop À LA MAIN — le deep learning sans magie
import numpy as np
rng = np.random.default_rng(0)

# XOR : le problème que la régression logistique ne PEUT PAS résoudre
X = np.array([[0,0],[0,1],[1,0],[1,1]], float)
y = np.array([[0],[1],[1],[0]], float)

W1 = rng.normal(0, 1, (2, 8)); b1 = np.zeros(8)   # couche cachée (8 neurones)
W2 = rng.normal(0, 1, (8, 1)); b2 = np.zeros(1)   # couche de sortie
lr = 0.5

def sigmoide(z): return 1 / (1 + np.exp(-z))

for step in range(3000):
    # 1-2. forward + loss
    h = np.maximum(0, X @ W1 + b1)          # ReLU(X·W1)
    p = sigmoide(h @ W2 + b2)               # proba de sortie
    loss = -(y*np.log(p+1e-9) + (1-y)*np.log(1-p+1e-9)).mean()
    # 3. backward : chain rule couche par couche, de la sortie vers l'entrée
    dz2 = (p - y) / len(X)                  # gradient à la sortie
    dW2 = h.T @ dz2; db2 = dz2.sum(0)
    dh  = dz2 @ W2.T                        # on transmet à l'amont…
    dz1 = dh * (h > 0)                      # …à travers la ReLU
    dW1 = X.T @ dz1; db1 = dz1.sum(0)
    # 4. update (descente de gradient, module 2)
    W2 -= lr*dW2; b2 -= lr*db2; W1 -= lr*dW1; b1 -= lr*db1
    if step % 1000 == 0: print(f"step {step:4d}  loss={loss:.4f}")

print("\nprédictions XOR :", p.round(2).ravel(), " (attendu : 0 1 1 0)")

Les gardiens de la boucle

loss qui ne descend pas → learning rate, données, ou bug de shapes ;
loss → NaN → learning rate trop grand, ou log(0) non protégé ;
train ↓ mais validation ↑ → overfitting : dropout, early stopping, plus de données ;
le premier réflexe pro : sur-apprendre volontairement UN batch minuscule. Si le réseau n'y arrive pas, le bug est dans le code, pas dans les hyperparamètres.

🧩 Quiz1/3

Dans la training loop, la backprop correspond à l'étape…

🃏 Flashcards1/4