La rétropropagation et la descente de gradient

Un réseau de neurones est une chaîne d’opérations simples, chacune munie de poids réglables. L’entraîner, c’est trouver les poids qui rendent la sortie correcte. Deux idées font tout le travail : la descente de gradient, qui indique dans quelle direction déplacer les poids, et la rétropropagation, qui calcule le gradient efficacement quelle que soit la profondeur de la chaîne.

On décrit souvent la rétropropagation comme difficile. C’est la règle de dérivation en chaîne, appliquée dans un ordre précis. Cet article calcule à la main chaque dérivée d’un petit réseau, puis vérifie les résultats contre un moteur de différentiation automatique.

A. Couches, poids et perte

Une couche dense applique une transformation linéaire suivie d’une non-linéarité élément par élément :

$$\mathbf{a} = g(W\mathbf{x} + \mathbf{b}) ,$$

où $W$ est une matrice de poids, $\mathbf{b}$ un vecteur de biais et $g$ une fonction d’activation. Sans $g$, empiler des couches serait vain : une composition d’applications linéaires n’est qu’une autre application linéaire, et le réseau ne pourrait rien représenter qu’une seule couche ne représente déjà.

Nous employons la ReLU, $g(z) = \max(0, z)$, dont la dérivée vaut $1$ pour $z > 0$ et $0$ pour $z < 0$.

Une fonction de perte note la sortie face à la cible. Pour une sortie scalaire nous utilisons

$$L = \tfrac{1}{2}(\hat y - y)^2 ,$$

le $\tfrac12$ étant une commodité qui s’annule à la dérivation.

Le recadrage clé : les données étant fixées, $L$ est une fonction des poids. Entraîner, c’est minimiser cette fonction.

B. La descente de gradient

Le gradient $\nabla L$ pointe dans la direction de plus forte croissance ; pour faire décroître $L$ nous marchons à contresens :

$$w \leftarrow w - \eta \frac{\partial L}{\partial w} ,$$

avec $\eta$ le taux d’apprentissage. Trop petit, l’entraînement rampe ; trop grand, il dépasse la cible - la défaillance même démontrée numériquement dans La régression logistique, où un pas de $0.5$ dégradait substantiellement l’objectif.

Tout le problème se réduit donc au calcul de $\partial L / \partial w$ pour chaque poids. Un réseau peut en compter des millions, et les calculer un à un serait sans espoir. La rétropropagation les obtient tous en une seule passe arrière.

C. Le réseau que nous allons dériver

Deux entrées, une couche cachée ReLU à deux unités, une sortie linéaire. Les biais sont nuls.

$$\mathbf{x} = \begin{bmatrix}1\\2\end{bmatrix},\quad W^{(1)} = \begin{bmatrix}0.1 & 0.3\\ 0.2 & 0.4\end{bmatrix},\quad W^{(2)} = \begin{bmatrix}0.5 & -0.5\end{bmatrix},\quad y = 1 .$$

Passe avant.

$$\mathbf{z}^{(1)} = W^{(1)}\mathbf{x} = \begin{bmatrix}0.1(1) + 0.3(2)\\ 0.2(1) + 0.4(2)\end{bmatrix} = \begin{bmatrix}0.7\\ 1.0\end{bmatrix} .$$

Les deux entrées sont positives, la ReLU les laisse donc passer inchangées :

$$\mathbf{a}^{(1)} = \begin{bmatrix}0.7\\ 1.0\end{bmatrix} .$$ $$\hat y = z^{(2)} = 0.5(0.7) + (-0.5)(1.0) = 0.35 - 0.5 = -0.15 .$$ $$L = \tfrac12(-0.15 - 1)^2 = \tfrac12(-1.15)^2 = \tfrac12(1.3225) = 0.66125 .$$

D. La passe arrière

Nous remontons maintenant à rebours, en portant à chaque étape la dérivée de $L$ par rapport à chaque quantité. Chaque étape est une application de la règle de dérivation en chaîne.

Étape 1 - la sortie.

$$\frac{\partial L}{\partial \hat y} = \hat y - y = -0.15 - 1 = -1.15 .$$

Étape 2 - les poids de sortie. Comme $\hat y = W^{(2)}\mathbf{a}^{(1)}$, on a $\partial \hat y / \partial W^{(2)}_j = a^{(1)}_j$, donc

$$\frac{\partial L}{\partial W^{(2)}} = \frac{\partial L}{\partial \hat y}\,\mathbf{a}^{(1)} = -1.15 \begin{bmatrix}0.7 & 1.0\end{bmatrix} = \begin{bmatrix}-0.805 & -1.15\end{bmatrix} .$$

Notez la structure : le gradient d’un poids est le signal d’erreur qui lui parvient multiplié par l’activation qui y entre. Ce motif vaut à chaque couche.

Étape 3 - retour à travers la couche de sortie. Pour continuer, il nous faut la variation de $L$ avec les activations cachées :

$$\frac{\partial L}{\partial \mathbf{a}^{(1)}} = \frac{\partial L}{\partial \hat y}\,W^{(2)} = -1.15\begin{bmatrix}0.5 & -0.5\end{bmatrix} = \begin{bmatrix}-0.575 & 0.575\end{bmatrix} .$$

L’erreur est redistribuée vers l’arrière proportionnellement aux poids qui ont porté le signal vers l’avant.

Étape 4 - à travers la ReLU. On multiplie élément par élément par la dérivée de l’activation. Les deux pré-activations étaient positives, les deux dérivées valent donc $1$ :

$$\frac{\partial L}{\partial \mathbf{z}^{(1)}} = \begin{bmatrix}-0.575 & 0.575\end{bmatrix} .$$

C’est de là que viennent les unités mortes. Si une pré-activation avait été négative, la dérivée de la ReLU vaudrait $0$ et le gradient serait anéanti - > aucun signal d’erreur n’atteint les poids qui alimentent cette unité, et elle ne peut pas apprendre. Une unité restée négative pour toutes les entrées est une unité morte, et c’est la motivation standard de variantes comme la leaky ReLU.

Étape 5 - les poids d’entrée. Même motif qu’à l’étape 2 : signal d’erreur fois activation entrante, ici l’entrée elle-même.

$$\frac{\partial L}{\partial W^{(1)}} = \frac{\partial L}{\partial \mathbf{z}^{(1)}} \mathbf{x}^{\top} = \begin{bmatrix}-0.575\\ 0.575\end{bmatrix}\begin{bmatrix}1 & 2\end{bmatrix} = \begin{bmatrix}-0.575 & -1.15\\ 0.575 & 1.15\end{bmatrix} .$$

Tous les gradients du réseau, à partir d’une passe avant et d’une passe arrière.

E. Vérification contre autograd

Les dérivations à la main sont sujettes à l’erreur, et il n’y a aucune raison de faire confiance à l’une d’elles sans vérification :

Les deux affichent True : les gradients calculés à la main s’accordent avec l’autograd de PyTorch à la précision flottante près.

F. Faire le pas

Chaque poids se déplace à l’encontre de son propre gradient. Avec $\eta = 0.1$ :

$$W^{(2)} \leftarrow \begin{bmatrix}0.5 & -0.5\end{bmatrix} - 0.1\begin{bmatrix}-0.805 & -1.15\end{bmatrix} = \begin{bmatrix}0.5805 & -0.385\end{bmatrix} ,$$ $$W^{(1)} \leftarrow \begin{bmatrix}0.1 & 0.3\\ 0.2 & 0.4\end{bmatrix} - 0.1\begin{bmatrix}-0.575 & -1.15\\ 0.575 & 1.15\end{bmatrix} = \begin{bmatrix}0.1575 & 0.415\\ 0.1425 & 0.285\end{bmatrix} .$$

En recalculant la passe avant avec les deux matrices mises à jour, on obtient $\hat y = 0.2989$ et

$$L = \tfrac12(0.2989 - 1)^2 = 0.2457 ,$$

contre $0.66125$ auparavant. Un pas a plus que divisé la perte par deux. Notez que $\hat y$ est passé de $-0.15$ vers la cible $y = 1$ - il n’a rien dépassé, il s’est simplement déplacé dans la bonne direction, ce qui est tout ce qu’un pas de gradient promet.

La figure ci-dessous est ce réseau avec tous ses nombres : les activations sur les unités, et sur chaque poids le gradient qui lui parvient. Vérifiez-en n’importe lequel contre l’arithmétique ci-dessus. Déplacez ensuite le taux d’apprentissage. La leçon a raison de dire que les pas rétrécissent d’eux-mêmes près d’un minimum ; il vaut la peine de savoir à quelle distance se trouve la falaise de l’autre côté : à 0,5, cinq fois le taux utilisé ici, le premier pas trop grand rend une unité cachée négative et le troisième rend l’autre négative, ReLU bloque alors tout gradient en dessous, et le réseau reste à une perte de 0,5 pour toujours. Ce n’est pas une divergence, c’est une mort, et elle prend trois pas.

G. Les lots, et pourquoi l’algorithme passe à l’échelle

L’entraînement réel n’utilise pas un seul exemple. La descente de gradient stochastique calcule le gradient sur un petit mini-lot aléatoire et effectue un pas, en répétant sur le jeu de données. Le gradient d’un lot est plus bruité que celui du jeu complet mais infiniment moins coûteux, et le bruit est souvent utile - il peut sortir les paramètres de régions médiocres.

L’efficacité de la rétropropagation est ce qui rend tout cela réalisable : une passe avant et une passe arrière donnent la dérivée par rapport à chaque paramètre, à un coût proportionnel à la passe avant plutôt qu’au nombre de paramètres. Calculer séparément chacune d’un million de dérivées partielles par différences finies exigerait un million de passes avant.

Le gradient est local, et la surface de perte n’est pas convexe. Contrairement aux moindres carrés, la perte d’un réseau possède de nombreux minima et points-selles, et la descente de gradient n’offre aucune garantie de trouver le meilleur. En pratique les minima suffisamment bons sont fréquents, mais « ça a convergé » n’est pas « ça a trouvé l’optimum ».

À retenir

• L’entraînement recadre la perte comme une fonction des poids et la minimise par descente de gradient, $w \leftarrow w - \eta\,\partial L/\partial w$.
• Les activations non linéaires sont essentielles ; des couches linéaires empilées se réduisent à une seule.
• La rétropropagation est la règle de dérivation en chaîne appliquée à rebours, réutilisant chaque dérivée intermédiaire.
• Chaque gradient de poids est activation entrante × signal d’erreur sortant - la même règle à chaque couche.
• Notre réseau : $L = 0.66125$, $\partial L/\partial W^{(2)} = [-0.805, -1.15]$, $\partial L/\partial W^{(1)} = [[-0.575, -1.15], [0.575, 1.15]]$, confirmés contre autograd.
• Les unités ReLU à pré-activation négative transmettent un gradient nul et peuvent mourir.

La suite

La même passe arrière entraîne l’architecture derrière les modèles de langue modernes, mais ces modèles ont besoin d’un mécanisme permettant à chaque position d’une séquence de consulter toutes les autres. Ce mécanisme, c’est L’attention et l’auto-attention.