Aller au contenu
ELECTRONICS ENGINEERINGelectronics-engineering.com
Apprentissage automatique et réseaux de neurones

Rétropropagation : équations démontrées sous forme matricielle et vérification numérique du gradient

La règle de dérivation en chaîne sur le graphe de calcul, les équations de rétropropagation démontrées, un coût indépendant du nombre de paramètres, la différentiation automatique, une réalisation NumPy de zéro vérifiée par différences centrées.

https://www.electronics-engineering.com/fr/retropropagation-verification-du-gradient/

Pas encore de vote : soyez le premier à noter cette page.

Pour entraîner un réseau par descente de gradient, il faut la dérivée de la perte par rapport à chaque poids : des millions, ou des milliards de dérivées à chaque pas. Les calculer une à une serait impossible. La rétropropagation (backpropagation, popularisée par Rumelhart, Hinton et Williams en 1986) les calcule toutes pour un coût du même ordre que l’évaluation du réseau (environ trois fois en tout), en appliquant la règle de dérivation en chaîne à rebours, de la sortie vers l’entrée. Cette leçon l’établit sous forme matricielle pour un réseau multicouche, explique pourquoi elle est si efficace, la réalise de zéro en NumPy et la vérifie avec la vérification numérique du gradient.

Le graphe de calcul et la règle de dérivation en chaîne

Un réseau est une composition de fonctions : L = \ell(f_L(\dots f_2(f_1(\mathbf x)))). Par la règle de dérivation en chaîne, la dérivée par rapport à un paramètre d’une couche interne est le produit des dérivées de toutes les couches qui la suivent. L’observation clé est que ces produits ont des facteurs communs : la dérivée par rapport à la sortie de la couche l est nécessaire pour les paramètres de la couche l et aussi, multipliée par un facteur de plus, pour toutes les couches précédentes. La calculer une seule fois, en partant de la fin, évite de répéter le travail. C’est le même principe que la programmation dynamique.

La rétropropagation pour un réseau multicouche

Pour un réseau de couches \mathbf z_l = W_l\mathbf h_{l-1} + \mathbf b_l, \mathbf h_l = \phi(\mathbf z_l) (avec \mathbf h_0 = \mathbf x), l’erreur de couche se définit comme \boldsymbol\delta_l = \partial L/\partial\mathbf z_l.

Théorème (les équations de rétropropagation).

    \[ \boldsymbol\delta_L = \frac{\partial L}{\partial\mathbf z_L},\qquad \boldsymbol\delta_l = \big(W_{l+1}^T\boldsymbol\delta_{l+1}\big)\odot\phi'(\mathbf z_l),\qquad \frac{\partial L}{\partial W_l} = \boldsymbol\delta_l\,\mathbf h_{l-1}^T,\qquad \frac{\partial L}{\partial\mathbf b_l} = \boldsymbol\delta_l \]

où \odot est le produit terme à terme.

Démonstration. La composante j de \mathbf z_{l+1} dépend de \mathbf z_l par z_{l+1,j} = \sum_kW_{l+1,jk}\,\phi(z_{l,k}) + b_{l+1,j}. Par la règle de dérivation en chaîne, \frac{\partial L}{\partial z_{l,k}} = \sum_j\frac{\partial L}{\partial z_{l+1,j}}\frac{\partial z_{l+1,j}}{\partial z_{l,k}} = \sum_j\delta_{l+1,j}W_{l+1,jk}\,\phi'(z_{l,k}), ce qui, sous forme vectorielle, est la deuxième équation. Pour les poids : z_{l,j} = \sum_kW_{l,jk}h_{l-1,k} + b_{l,j}, donc \frac{\partial L}{\partial W_{l,jk}} = \delta_{l,j}\,h_{l-1,k} et \frac{\partial L}{\partial b_{l,j}} = \delta_{l,j}. ∎

La dernière couche. Avec la softmax et l’entropie croisée (leçon 1), \boldsymbol\delta_L = \mathbf p - \mathbf y : la probabilité prédite moins la vraie (codée « one-hot », 1 dans la bonne classe et 0 ailleurs). Avec un mini-lot de N exemples, H_{l-1} et \Delta_l deviennent des matrices avec un exemple par ligne, et les formules deviennent \partial L/\partial W_l = H_{l-1}^T\Delta_l (moyennée sur le lot) : des produits de matrices, exactement ce pour quoi les GPU sont très rapides.

Le coût. La passe avant coûte un produit matrice-vecteur par couche ; la passe arrière deux (un pour \boldsymbol\delta, un pour le gradient des poids). En tout, environ trois fois la passe avant seule, quel que soit le nombre de paramètres. Calculer les dérivées par différences finies demanderait au contraire une passe avant pour chaque paramètre.

Les passes avant et arrière
En haut, en bleu, les données traversent les couches de l’entrée x à la sortie et à la perte L ; en bas, en rouge, les erreurs delta remontent multipliées par les matrices de poids transposées et par les dérivées des activations, et donnent à chaque couche le gradient des poids.

La différentiation automatique

Les bibliothèques modernes (PyTorch, JAX, TensorFlow) ne demandent pas d’écrire ces formules. Pendant la passe avant, elles enregistrent chaque opération dans un graphe de calcul ; en appelant backward(), elles le parcourent à rebours en appliquant à chaque opération sa dérivée connue. C’est la différentiation automatique en mode inverse : la rétropropagation généralisée à tout programme, y compris avec conditions et boucles. Ce n’est pas une approximation numérique : les dérivées sont exactes, aux arrondis près.

La vérification numérique du gradient

Quand la rétropropagation (ou une nouvelle couche) est écrite à la main, on la vérifie avec des différences centrées : pour un poids w, \frac{\partial L}{\partial w} \approx \frac{L(w + \varepsilon) - L(w - \varepsilon)}{2\varepsilon}, avec une erreur d’ordre \varepsilon^2 (les ordres impairs du développement de Taylor s’annulent). Avec \varepsilon = 10^{-6} et des calculs en double précision, une réalisation correcte donne une erreur relative d’environ 10^{-9}–10^{-10} ; même une petite erreur dans la formule donne des valeurs d’ordre 10^{-2} ou plus.

import numpy as np

def initialise(sizes, seed=0):
    g = np.random.default_rng(seed)
    return [(g.normal(0, np.sqrt(2 / a), (a, b)), np.zeros(b)) for a, b in zip(sizes[:-1], sizes[1:])]

def forward(params, X):
    activations = [X]
    for i, (W, b) in enumerate(params):
        z = activations[-1] @ W + b
        activations.append(np.maximum(z, 0) if i < len(params) - 1 else z)     # ReLU, last layer linear
    return activations

def loss_and_gradients(params, X, Y):
    act = forward(params, X)
    z = act[-1] - act[-1].max(1, keepdims=True)
    p = np.exp(z); p /= p.sum(1, keepdims=True)                                 # softmax
    N = len(X)
    loss = -np.log(p[np.arange(N), Y]).mean()                                   # cross-entropy
    delta = p.copy(); delta[np.arange(N), Y] -= 1; delta /= N                   # delta of the last layer: p - y
    gradients = []
    for i in range(len(params) - 1, -1, -1):
        W, b = params[i]
        gradients.append((act[i].T @ delta, delta.sum(0)))                      # dL/dW = h^T delta
        if i > 0:
            delta = (delta @ W.T) * (act[i] > 0)                                # delta backwards, ReLU derivative
    return loss, gradients[::-1]

rng = np.random.default_rng(1)
X = rng.normal(0, 1, (8, 5)); Y = rng.integers(0, 3, 8)                         # 8 examples, 5 inputs, 3 classes
par = initialise([5, 7, 3])
_, grad = loss_and_gradients(par, X, Y)

eps, numerical = 1e-6, np.zeros_like(par[0][0])
for i in range(5):
    for j in range(7):
        par[0][0][i, j] += eps;     Lp, _ = loss_and_gradients(par, X, Y)
        par[0][0][i, j] -= 2 * eps; Lm, _ = loss_and_gradients(par, X, Y)
        par[0][0][i, j] += eps
        numerical[i, j] = (Lp - Lm) / (2 * eps)                                 # central differences
error = np.abs(numerical - grad[0][0]).max() / np.abs(numerical).max()
print(f"relative error between backpropagation and central differences: {error:.1e}")

Son exécution donne une erreur relative d’environ 10^{-9}–10^{-10} : la rétropropagation est correcte. Les deux mêmes fonctions, avec une boucle de descente de gradient, suffisent à entraîner un vrai réseau : c’est le projet de la dernière leçon du cours, qui reconnaît des chiffres manuscrits avec 98 % de précision.

S’abonner
Notifier de
guest
1 commentaire
Le plus ancien
Plus récent Les plus votés
1
0
Vous avez apprécié cet article ? Merci de laisser un commentaire.x