Implémenter manuellement la règle de chaîne
Construire une fonction composée, calculer manuellement les gradients locaux couche par couche et les multiplier, puis vérifier avec sympy.
Après avoir terminé ce cas, vous comprendrez :Le cœur de la rétropropagation est la règle de la chaîne — chaque couche calcule uniquement son propre gradient local, et le gradient final est le produit des gradients de chaque couche.
Introduction en situation réelle
La chaîne de production de dominos
Une usine a trois processus : matière première → semi-fini A → semi-fini B → produit fini. Vous voulez savoir : « Si la matière première augmente de 1 kg, combien de produits finis supplémentaires y aura-t-il ? »
Vous n'avez pas besoin de dériver la formule pour l'ensemble du processus à partir de zéro. Chaque processus calcule uniquement son propre « ratio local » : si le semi-fini A augmente de 1, combien de semi-finis B supplémentaires y aura-t-il ? Si le semi-fini B augmente de 1, combien de produits finis supplémentaires ? Multipliez les trois ratios et vous obtenez la réponse.
C'estla règle de la chaîne—chaque couche ne se soucie que d'elle-même, et l'impact final = le produit des impacts de chaque couche.
Compréhension intuitive
Construire une fonction composée à trois couches :
x^2+1
3*sin(u)
v^2
Exercice pratique Python
Exemple
import numpy as np
def g(x): return x ** 2 + 1
def f(u): return 3 * np.sin(u)
def g_prime(x): return 2 * x
def f_prime(u): return 3 * np.cos(u)
x0 = 1.5
# ---- Règle de chaîne manuelle ----
u0 = g(x0)
dy_du = f_prime(u0) # Gradient local de la couche 2
du_dx = g_prime(x0) # Gradient local de la couche 1
manual_grad = dy_du * du_dx
print("=" * 55)
print("EXEMPLE Règle de chaîne manuelle")
print(f"x0 = {x0}, u = g(x0) = {u0:.4f}")
print(f"dy/du = 3*cos(u) = {dy_du:.4f}")
print(f"du/dx = 2*x0 = {du_dx:.4f}")
print(f"Multiplication en chaîne : dy/dx = {manual_grad:.4f}")
# ---- différenciation automatique sympy (réponse standard) ----
x = sp.Symbol('x')
y_expr = 3 * sp.sin(x**2 + 1)
auto_grad = float(sp.diff(y_expr, x).subs(x, x0))
print(f"\n"EXEMPLE différenciation automatique sympy = {auto_grad:.4f}")
print(f"Les deux méthodes sont cohérentes : {np.isclose(manual_grad, auto_grad)}")
# ---- Extension : composite à trois couches ----
def h(v): return v ** 2
def h_prime(v): return 2 * v
v0 = f(u0)
dy_dv = h_prime(v0)
grad_3layer = dy_dv * dy_du * du_dx
print(f"\n"EXEMPLE propagation de gradient à trois couches : ")
print(f" Couche 3 : {dy_dv:.4f} x Couche 2 : {dy_du:.4f} x Couche 1 : {du_dx:.4f} = {grad_3layer:.4f}")
======================================================= EXAMPLE 手动链式法则 x0 = 1.5, u = g(x0) = 3.2500 dy/du = 3*cos(u) = -2.9838 du/dx = 2*x0 = 3.0000 链式相乘: dy/dx = -8.9514 EXAMPLE sympy 自动求导 = -8.9514 两种方法一致: True EXAMPLE 三层梯度传递： 第3层: 6.5000 x 第2层: -2.9838 x 第1层: 3.0000 = -58.1841
Scénarios d'application en IA
| Scénario | Relation avec la règle de la chaîne |
|---|---|
| Rétropropagation | Chaque couche d’un réseau de neurones ne calcule que son propre gradient local, puis le transmet à la couche précédente. |
| PyTorch autograd | Suivre automatiquement chaque opération pour construire un graphe de calcul, et appliquer automatiquement la règle de la chaîne pendant la rétropropagation |
| Vérification des gradients | Après avoir implémenté manuellement la rétropropagation, vérifier avec des gradients numériques—c'est la méthode 1 vs la méthode 2 dans ce cas |