Aller au contenu
Data science

La rétropropagation

⏱ 1 h

Prérequis : Du neurone au réseau · La régression linéaire et la descente de gradient

À la fin de ce chapitre, vous saurez :
  • appliquer la règle de dérivation en chaîne sur un graphe de calcul ;
  • dérouler la propagation avant et la rétropropagation sur un petit réseau ;
  • expliquer pourquoi la rétropropagation est bien plus efficace que les différences finies ;
  • reconnaître l'évanescence et l'explosion du gradient, et citer leurs remèdes.

Entraîner un réseau, c’est faire une descente de gradient (voir la régression linéaire) : chaque poids recule un peu dans le sens qui fait baisser la perte,

w←w−η ∂L∂w.w \leftarrow w - \eta \, \frac{\partial L}{\partial w} .

Il faut donc la dérivée de la perte par rapport à chaque poids. Un réseau moyen en a des millions, un grand modèle de langage des centaines de milliards. Les estimer une par une (« je bouge ce poids un peu, de combien la perte change-t-elle ? ») demanderait une propagation complète par poids : impossible. La rétropropagation (backpropagation) les calcule toutes, exactement, pour le prix d’environ deux propagations.

Un réseau est une composition de fonctions simples : multiplier, additionner, appliquer une activation, comparer à la cible. La règle de dérivation en chaîne dit comment dériver une composition : si LL dépend de hh, qui dépend de ww,

∂L∂w=∂L∂h×∂h∂w.\frac{\partial L}{\partial w} = \frac{\partial L}{\partial h} \times \frac{\partial h}{\partial w} .

L’idée de la rétropropagation : partir de la perte et remonter le réseau, en multipliant à chaque étape par la dérivée locale. Chaque nœud n’a besoin que de deux choses : le gradient qui lui arrive de la droite, et sa propre dérivée locale.

Le réseau ne compte que deux neurones (une entrée xx, un neurone caché tanh, une sortie linéaire), mais toutes les étapes d’un vrai entraînement y sont :

  1. propagation avant (en bleu) : on calcule z1z_1, puis hh, puis y^\hat y, puis la perte LL, en gardant chaque valeur en mémoire ;
  2. rétropropagation (en rouge) : on part de ∂L/∂y^=y^−y\partial L / \partial \hat y = \hat y - y et on remonte. Chaque gradient se calcule à partir du précédent, en une multiplication ;
  3. mise à jour : chaque paramètre recule de η\eta fois son gradient.

Cliquez ensuite sur 🔎 Vérifier numériquement : les gradients calculés coïncident avec les différences finies L(w+ε)−L(w−ε)2ε\frac{L(w + \varepsilon) - L(w - \varepsilon)}{2\varepsilon}. C’est d’ailleurs ainsi qu’on teste une implémentation de la rétropropagation.

🎓 Pour aller plus loin : la rétropropagation en notation matricielle

Pour un réseau dense, notons a(0)=xa^{(0)} = x, puis pour chaque couche ll : z(l)=W(l)⊤a(l−1)+b(l)z^{(l)} = W^{(l)\top} a^{(l-1)} + b^{(l)} et a(l)=f(z(l))a^{(l)} = f(z^{(l)}). Définissons l’erreur de la couche ll : δ(l)=∂L/∂z(l)\delta^{(l)} = \partial L / \partial z^{(l)}.

  • Sortie. Pour une sigmoïde (ou une softmax) suivie de l’entropie croisée, les dérivées se simplifient remarquablement : δ(L)=y^−y\delta^{(L)} = \hat y - y.
  • Récurrence. En remontant d’une couche :
δ(l)=(W(l+1) δ(l+1))⊙f′(z(l)),\delta^{(l)} = \big(W^{(l+1)}\, \delta^{(l+1)}\big) \odot f'\big(z^{(l)}\big),

où ⊙\odot est le produit terme à terme.

  • Gradients des paramètres.
∂L∂W(l)=a(l−1) δ(l)⊤,∂L∂b(l)=δ(l).\frac{\partial L}{\partial W^{(l)}} = a^{(l-1)}\, \delta^{(l)\top}, \qquad \frac{\partial L}{\partial b^{(l)}} = \delta^{(l)} .

Le coût d’un passage arrière est du même ordre que celui d’un passage avant : des produits de matrices de mêmes tailles. C’est pourquoi les cartes graphiques (GPU), faites pour multiplier des matrices, ont rendu possible l’apprentissage profond.

Différentiation automatique. On n’écrit plus ces formules à la main. PyTorch, TensorFlow et JAX enregistrent le graphe de calcul pendant la propagation avant, puis appliquent la dérivation en chaîne à chaque opération, en sens inverse (différentiation automatique en mode inverse). La rétropropagation n’en est qu’un cas particulier.

La rétropropagation multiplie les dérivées couche après couche. Dans un réseau profond, ce produit de dizaines de facteurs peut devenir minuscule ou gigantesque :

Le graphique de gauche montre l’amplitude moyenne du gradient des poids, couche par couche, en échelle logarithmique ; celui de droite, l’étalement des activations.

  • Sigmoïde, 10 couches ou plus : le gradient perd un facteur 10 à 100 à chaque couche. La dérivée de la sigmoïde ne dépasse jamais 0,25 ; les premières couches ne reçoivent presque plus rien et n’apprennent pas. C’est l’évanescence du gradient (vanishing gradient), qui a bloqué les réseaux profonds jusqu’aux années 2010.
  • Initialisation « grande » : à l’inverse, le gradient explose ; les mises à jour deviennent énormes et l’entraînement diverge.
  • ReLU avec l’initialisation de He, ou tanh avec celle de Glorot : le gradient garde le même ordre de grandeur dans toutes les couches.

Les remèdes, souvent combinés :

Remède Idée
activations ReLU dérivée égale à 1 sur la moitié du domaine
initialisation adaptée (Glorot, He) poids tirés avec une variance ∝1/n\propto 1/n (ou 2/n2/n) : chaque couche conserve l’amplitude du signal
normalisation par lots recentre et réduit les activations de chaque couche (chapitre suivant)
connexions résiduelles a(l+1)=a(l)+F(a(l))a^{(l+1)} = a^{(l)} + F(a^{(l)}) : le gradient a un chemin direct vers les premières couches (réseaux ResNet, transformers)
écrêtage du gradient on limite la norme du gradient, contre l’explosion (réseaux récurrents)
🔬Quatre couches de sigmoïdes

Un réseau profond de sigmoïdes, entraîné par SGD, sur les deux lunes : la perte stagne longtemps. Recommencez avec l’activation ReLU et l’optimiseur Adam.

→
import tensorflow as tf
w = tf.Variable(0.8)
x, y = 1.5, 0.6
with tf.GradientTape() as bande: # enregistre le graphe de calcul
h = tf.tanh(w * x - 0.2)
perte = 0.5 * (-0.5 * h + 0.1 - y) ** 2
print(bande.gradient(perte, w)) # ∂L/∂w, par différentiation automatique
# en PyTorch : perte.backward(), puis w.grad

✅ Vérifiez vos acquis

1. Quel est l'intérêt principal de la rétropropagation ?
2. Dans quel ordre se font les calculs d'une itération d'entraînement ?
3. Pour L = ½(ŷ − y)², que vaut ∂L/∂ŷ ?
4. Pourquoi les premières couches d'un réseau profond de sigmoïdes apprennent-elles très lentement ?
5. Quelle technique donne au gradient un « raccourci » vers les premières couches ?
6. Comment vérifier qu'une implémentation de la rétropropagation est correcte ?