#rétropropagation — Réseaux de neurones

Le graphe de calcul rejoué à l'envers : chaque nœud reçoit ∂L/∂(lui) et la règle de la chaîne fait le reste.

Ce que tu vas manipuler

Bienvenue dans #rétropropagation. À l'écran, un graphe de calcul : deux entrées bleues x1, x2, deux neurones cachés roses h1, h2 (tanh), une sortie verte o (sigmoïde) et, tout à droite, la perte jaune L = ½(o − y)². Chaque connexion porte un poids. On va d'abord calculer de gauche à droite, puis dériver de droite à gauche : chaque nœud recevra ∂L/∂(lui) et la règle de la chaîne fera le reste.
Commençons par le passage avant. Tape /avant : les valeurs s'allument de gauche à droite, des entrées jusqu'à la perte, et les connexions traversées passent en bleu.
La perte est connue. Maintenant, on remonte. Première étape arrière : ∂L/∂o. Tape /etape.
Un nœud plus loin : ∂L/∂zo = ∂L/∂o · σ'(zo), avec σ'(zo) = o(1 − o). C'est toute la règle de la chaîne : à chaque nœud traversé à l'envers, une multiplication par la dérivée locale. Tape /etape.
Le motif est toujours le même, alors laissons le gradient remonter jusqu'aux entrées d'un coup : /arriere. Observe l'épaisseur des connexions rouges : les gradients des poids de la première couche (w11, w12, w21, w22) sont plus petits que ceux de la sortie, car ils ont subi davantage de multiplications successives.
On connaît ∂L/∂w pour chacun des neuf paramètres. Mettons-les à jour : w ← w − lr · ∂L/∂w. Tape /maj et compare la perte avant / après dans la réponse et le panneau de droite.
Change la cible : /cible 0. Le réseau doit maintenant prédire 0 au lieu de 1. Refais /avant puis /arriere librement : les gradients changent de signe, la descente pousse les poids dans l'autre sens.
C'est exactement ce que PyTorch fait quand tu écris loss.backward() : il rejoue le graphe de calcul à l'envers, une dérivée locale par nœud, et optimizer.step() applique le /maj. Joue librement : /entree 1.5 -1, /lr 1.5, /reinit. Prochaine étape : le canal #sur-apprentissage, où l'on verra ce qui arrive quand on fait trop de pas.

Commandes du canal

/etape — Révèle l'opération suivante du graphe (avant puis arrière).
/avant — Déroule tout le passage avant jusqu'à la perte.
/arriere — Déroule tout le passage arrière : tous les gradients d'un coup.
/entree <x1=-2..2> <x2=-2..2> — Change les deux entrées et recalcule le graphe.
/cible <0|1> — Change la cible y (0 ou 1) et recalcule le graphe.
/maj — Applique une descente de gradient (w ← w − lr · ∂L/∂w) et recalcule.
/lr <0.01..2> — Fixe le pas d'apprentissage utilisé par /maj.
/reinit — Remet entrées, cible, poids et curseur à leur valeur initiale.

Glossaire

Rétropropagation: Algorithme qui calcule le gradient de la perte par rapport à chaque poids en propageant l'erreur de la sortie vers l'entrée, grâce à la règle de la chaîne. Efficace : un seul passage arrière pour tous les poids.
Passe avant: Calcul de la sortie du réseau à partir de l'entrée, couche par couche. On mémorise les activations : la passe arrière en aura besoin.
Passe arrière: Le retour : à partir de l'erreur en sortie, on calcule les gradients couche après couche en sens inverse.
Règle de la chaîne: Dérivée d'une composition : (f∘g)' = f'(g)·g'. La rétropropagation n'est que cette règle appliquée à des milliers de fonctions emboîtées.
Delta: Le gradient de la perte par rapport à la pré-activation d'un neurone, δ = ∂L/∂z. Il se transmet de couche en couche ; le gradient d'un poids est δ × activation d'entrée.
Gradient local: Dérivée d'un nœud par rapport à ses entrées immédiates (par exemple la dérivée de l'activation). Le gradient global est le produit des gradients locaux le long du chemin.
Graphe de calcul: Représentation des opérations comme un graphe orienté. PyTorch et TensorFlow le construisent automatiquement pour dériver n'importe quel modèle (différentiation automatique).
Mise à jour des poids: Une fois les gradients connus : w ← w − η·∂L/∂w. Un pas de descente de gradient par poids, tous en même temps.

Autres canaux du thème Réseaux de neurones

#neurone — Décomposons un neurone : entrées, poids, somme, activation.
#dropout — Régularisation par dropout : le meilleur ami des réseaux profonds.
#activation — Pourquoi une activation ? ReLU, sigmoid, tanh, Leaky ReLU, GELU et le gradient qui disparaît.
#descente-de-gradient — La perte est un paysage. Le gradient dit où ça monte, on fait un pas dans l'autre sens.
#rétropropagation — Le graphe de calcul rejoué à l'envers : chaque nœud reçoit ∂L/∂(lui) et la règle de la chaîne fait le reste.
#sur-apprentissage — Un gros modèle sur peu de données : la frontière de décision se tord jusqu'à mémoriser le bruit.
#cnn-filtres — Une image est une grille de nombres. Un filtre 3×3 glisse dessus, multiplie, additionne : c'est une convolution.
#is-it-einstein — Is it Einstein ? Deux visages passent au scanner d’un réseau qui n’a appris qu’Einstein : Haythem → NON, Einstein → OUI. Regarder est gratuit ; toucher est Premium.
#embeddings-3d — Un mot devient un vecteur : proches dans l'espace = proches en sens, et on peut calculer dessus.