∇ML · POSTECH

Réseaux de neuronesNeural Networks for Classification — Backpropagation · Cours 9 & 10 (10/8, 10/13)

Slides 6-neural-network (45 p.) PRML §5.1–5.3 p.227–244 DL ch. 6 Deep Neural Networks DL ch. 8 Backpropagation

Ce chapitre répond à une seule question : au lieu de choisir à la main les fonctions de base $\bphi$ (chapitre 1) ou le noyau (chapitre 3), peut-on apprendre la représentation des données en même temps que le classifieur ? La réponse — empiler des couches « linéaire puis non-linéarité » et tout entraîner par descente de gradient — demande trois ingrédients : une classe de modèles (le perceptron multicouche), une perte (la cross-entropy, déjà vue au chapitre 2), et un moyen efficace de calculer le gradient par rapport à tous les poids (la rétropropagation). Au début de chaque section, un encadré Où on en est fait le point.

Feuille de route

Slides p.3–4 (objectif et plan)

Les slides partent de l'ERM, $\min_{f\in\mathcal H}\frac1N\sum_n\ell(y_n,f(\bx_n))$, et posent trois questions : quel $\mathcal H$ ? (le perceptron multicouche), quelle perte $\ell$ ? (la cross-entropy), comment minimiser ? (gradient + rétropropagation). Puis viennent les détails pratiques. La chaîne complète, cliquable :

① Motivation · §1XOR : aucune droite ne sépareil faut apprendre les features $\bphi(\bx)$
→
② Unités cachées · §2perceptrons empilés : ET, OU, régionstoute fonction booléenne, puis toute fonction continue
→
③ Modèle · §3MLP : $\bh^{(\ell)} = \varphi(W_\ell\bh^{(\ell-1)}+\bb_\ell)$activations lisses pour pouvoir dériver
→
④ Perte · §4sigmoïde + BCE, softmax + cross-entropygradient au logit : $\mathbf p-\by$
→
⑤ Gradient · §5rétropropagation = règle de la chaîne en sens inverse$\delta\bh\T$, $W\T\delta$, $\odot\varphi'$
→
⑥ Pratique · §6mini-batchs, boucle d'entraînement, piègesmodèle ≠ gradient ≠ optimiseur

Le raisonnement, maillon par maillon

  1. ①Le problème. Un classifieur linéaire ne sait tracer qu'une droite (un hyperplan). Les données XOR ne sont séparables par aucune droite. Les chapitres précédents contournaient cela avec des features $\bphi(\bx)$ ou un noyau choisis à la main. → Idée : modéliser $\bphi$ avec des paramètres, et l'apprendre.
  2. ②La brique et l'assemblage. Un perceptron $\mathrm{sign}(\bw\T\bx+b)$ teste un demi-plan. Deux perceptrons cachés (OU, ET) suffisent pour XOR ; plusieurs, combinés par ET/OU, découpent des régions ; on peut représenter toute fonction booléenne, et approcher toute fonction continue. La profondeur permet de réutiliser des features intermédiaires.
  3. ③Le modèle général. Le perceptron multicouche alterne couche affine et activation non linéaire, puis une couche de sortie qui donne des scores de classe (logits). Pour l'entraîner par gradient, on remplace sign (dérivée nulle) par une activation lisse : ReLU, sigmoïde, tanh.
  4. ④La perte. Comme au chapitre 2 : sigmoïde + BCE pour 2 classes, softmax + cross-entropy pour $K$ classes, toutes deux des log-vraisemblances négatives. Le gradient par rapport aux logits est remarquablement simple : $\mathbf p-\by$. C'est le point de départ de la rétropropagation.
  5. ⑤Le calcul du gradient. Il faut $\partial\hL/\partial\theta$ pour chaque poids. La règle de la chaîne, appliquée en sens inverse dans le graphe de calcul, réutilise les valeurs de la passe avant et les gradients déjà calculés : trois règles locales (couche affine, activation, branches) donnent tous les gradients en une seule passe arrière.
  6. ⑥Entraîner en pratique. On estime le gradient sur des mini-batchs (SGD du chapitre 1), on enchaîne passe avant → perte → rétropropagation → pas de l'optimiseur, et on évite les erreurs classiques (softmax appliquée deux fois, confondre rétropropagation et descente de gradient…).
À la fin du chapitre, tu dois savoir…
  • prouver qu'aucune droite ne sépare XOR, et construire un réseau à 2 unités cachées qui le résout ;
  • expliquer comment des unités cachées combinées par ET/OU représentent des régions et toute fonction booléenne ;
  • écrire la passe avant d'un MLP avec les dimensions de chaque $W_\ell$, $\bb_\ell$, $\bz^{(\ell)}$, $\bh^{(\ell)}$ ;
  • dériver $\partial\ell_{\text{BCE}}/\partial z = p-y$ et $\partial\ell_{\text{CE}}/\partial z_k = p_k-y_k$, et les propriétés de la softmax ;
  • faire une passe avant et une passe arrière à la main sur un graphe de calcul ;
  • démontrer les règles $\partial\hL/\partial W = \boldsymbol\delta\bh\T$, $\partial\hL/\partial\bb = \boldsymbol\delta$, $\partial\hL/\partial\bh = W\T\boldsymbol\delta$, $\partial\hL/\partial\bz = \partial\hL/\partial\bh\odot\varphi'(\bz)$ ;
  • décrire une boucle d'entraînement par mini-batchs et distinguer modèle, rétropropagation et optimiseur.
Où se trouve chaque question du HW5 dans ce chapitre
P2.(1)–(2) invariance et softmax stable → §4, softmax · P2.(3)–(4) overflow, log-softmax, cross-entropy depuis les logits → §4, cross-entropy, pourquoi des logits · P3.(1) graphe de calcul → §5 · P3.(2) gradients à travers $AV$, la softmax et $QK^\top$ → règles locales, algorithme. Indices et corrigés : page Devoirs.

Notations du chapitre

Toutes les lettres utilisées dans la page (et dans les slides), au même endroit. Plusieurs lettres ont deux sens : voir l'encadré qui suit le tableau.

SymboleSe lit / signifieNatureOù
Données et objectif
$N,\ n$nombre d'exemples ; indice d'un exempleentierspartout
$\bx_n,\ d_{\text{in}}$entrée ; sa dimension$\R^{d_{\text{in}}}$partout
$y_n$étiquette : $\{0,1\}$ pour la BCE, $\{-1,+1\}$ pour les sorties sign du perceptron, $\{1..K\}$ ou vecteur one-hot $\by\in\{0,1\}^K$ en multiclasseselon le cas§2, §4
$\mathcal H$espace d'hypothèses (classe de prédicteurs)ensemble de fonctions§1
$\ell(y,f(\bx))$perte d'un exempleréel $\ge0$§1, §4
$\hL_N(\theta)$risque empirique : moyenne des pertes sur les $N$ exemplesréel§4, §5
Perceptron et unités cachées (§2)
$\hat y = \mathrm{sign}(\bw\T\bx+b)$perceptron : un neurone à seuil, sortie $\pm1$$\{-1,+1\}$§2
$h_i(\bx)$sortie de la $i$-ième unité cachée (un perceptron intermédiaire)$\{-1,+1\}$§2
$h_{ab},\ w_{ab},\ b_{\text{out}}$détecteur du coin $(a,b)\in\{0,1\}^2$ ; poids de sortie ; biais de sortie—§2 (booléens)
$\bphi(\bx)$carte de features (chapitre 1) — ici apprise : $\bphi(\bx) = \bh^{(L-1)}$$\R^{d_{\text{feat}}}$§1, §3
Perceptron multicouche (§3)
$L,\ \ell$ (indice)nombre de couches (affines) ; indice de couche $\ell = 1,\dots,L$entiers§3, §5
$W_\ell,\ \bb_\ell$poids et biais de la couche $\ell$ : $W_\ell\in\R^{d_\ell\times d_{\ell-1}}$, $\bb_\ell\in\R^{d_\ell}$matrice, vecteur§3 →
$\bz^{(\ell)}$pré-activation $W_\ell\bh^{(\ell-1)}+\bb_\ell$$\R^{d_\ell}$§3 →
$\varphi_\ell,\ \bh^{(\ell)}$activation appliquée composante par composante ; activation de la couche $\bh^{(\ell)} = \varphi_\ell(\bz^{(\ell)})$, avec $\bh^{(0)} = \bx$$\R\to\R$ ; $\R^{d_\ell}$§3 →
$\bz^{(L)} = f_\theta(\bx)$scores de classe = logits (sortie de la dernière couche, sans activation)$\R$ ou $\R^K$§3, §4
$\theta$tous les paramètres $\{(W_\ell,\bb_\ell)\}_{\ell=1}^L$—§3 →
$H,\ D$ (slide 16)nombre de sorties et d'entrées d'une couche : $W\in\R^{H\times D}$entiers§3
Sorties et pertes (§4)
$\sigma,\ p$sigmoïde ; probabilité de la classe 1, $p = \sigma(z)$$(0,1)$§4
$\mathbf p = \mathrm{softmax}(\bz)$vecteur des probabilités de classes, $p_k = e^{z_k}/\sum_je^{z_j}$simplexe de $\R^K$§4
$p_y$probabilité donnée à la bonne classe$(0,1)$§4
$T$température de la softmaxréel $>0$§4
$\ell_{\text{BCE}},\ \ell_{\text{CE}}$binary cross-entropy ; cross-entropy catégorielleréels $\ge0$§4
Rétropropagation (§5)
$\boldsymbol\delta$gradient amont $\partial\hL_N/\partial\bz$ reçu par une couchemême taille que $\bz$§5
$\odot$produit composante par composante (Hadamard)opération§5
$\eta$pas d'apprentissage (le $\gamma$ du chapitre 1)réel $>0$§5, §6
$\frac{\partial\hL_N}{\partial W}$matrice de même forme que $W$, d'entrées $\frac{\partial\hL_N}{\partial W_{ij}}$matrice§5
Pièges de notation (ils viennent des slides)
  1. $\ell$ a deux sens : la perte $\ell(y,f(\bx))$, et l'indice de couche $\ell = 1,\dots,L$ (slide 15). Le contexte tranche : $\ell(\cdot,\cdot)$ avec des arguments est une perte, $W_\ell$ ou $\bh^{(\ell)}$ un numéro de couche.
  2. $\varphi$ (ou $\phi$) a deux sens : la carte de features $\bphi(\bx)$ du chapitre 1 (slides 2, 7), et l'activation $\varphi_\ell$ d'une couche (slide 15). Ici les deux se rejoignent : la carte de features apprise est $\bphi(\bx) = \bh^{(L-1)}$, construite avec les activations $\varphi_\ell$.
  3. $H$ a deux sens : l'espace d'hypothèses $\mathcal H$ (slide 3), et le nombre d'unités de sortie d'une couche (slide 16, $W\in\R^{H\times D}$). Et $\bh$, $h_i$ désignent des activations cachées.
  4. $z$ a deux sens : la pré-activation $\bz^{(\ell)}$ (les logits pour $\ell = L$), mais aussi une simple variable d'entrée dans l'exemple du graphe $f(x,y,z) = (x+y)z$ (slides 32–34).
  5. $L$ et $\hL$ : $L$ = nombre de couches ; $\hL_N(\theta)$ = risque empirique. Au chapitre 4, $L(f)$ était l'erreur de généralisation.
  6. Étiquettes : $\{0,1\}$ pour la BCE ; mais les perceptrons des slides 9–12 sortent $\pm1$ (« faux/vrai » = $-1/+1$) alors que les entrées XOR valent 0/1.
  7. $\eta$ au lieu de $\gamma$ pour le pas ; $\alpha$ est ici la pente de la Leaky ReLU (au chapitre 1 c'était le momentum, au chapitre 3 les multiplicateurs).
  8. Ordre des indices de $W$ : $W_{ji}$ relie l'entrée $i$ à la sortie $j$ ($z_j = \sum_iW_{ji}h_i+b_j$) — ligne = sortie, colonne = entrée.
Mode d'emploi des scènes
  • 2D : les points à halo se déplacent à la souris. 3D : glisser = tourner, molette = zoom.
  • ▶ Lecture lance l'entraînement en direct ; « Pas +1 » avance d'un cran ; ↺ recommence avec une autre initialisation.
  • ◉ Affichage (en haut à droite) masque ou affiche les éléments de chaque figure.

1Pourquoi apprendre les features ?

Slides p.2–7DL §6.1 Limitations of fixed basis functions
Où on en est
Acquis
Chapitres 1–3 : des prédicteurs linéaires en des features $\bphi(\bx)$ (fonctions de base, noyaux) choisies avant l'entraînement ; seule la dernière couche $\bw$ est apprise.
Il manque
Choisir $\bphi$ à la main (famille, positions, échelles) est difficile, surtout en grande dimension (images, texte).
Cette partie
On voit sur XOR qu'un classifieur linéaire en $\bx$ échoue, et on pose l'idée du chapitre : apprendre $\bphi$ et $\bw$ ensemble.
▶ Vidéosen anglais · s'ouvrent sur YouTube
▶3Blue1BrownBut what is a neural network? | Deep learning chapter 1Couches, poids, biais, activations : la structure d'un réseau, très visuelle.▶StatQuestThe Essential Main Ideas of Neural NetworksComment des activations simples, décalées et pondérées, fabriquent une courbe compliquée.
Minimisation du risque empirique (rappel, slide 3)
$$\min_{f\in\mathcal H}\ \hL(f),\qquad\hL(f) = \frac1N\sum_{n=1}^N\ell\big(y_n,f(\bx_n)\big).$$ Trois questions : (1) quel espace d'hypothèses $\mathcal H$ ? → le perceptron multicouche ; (2) quelle perte $\ell$ ? → la cross-entropy ; (3) comment minimiser ? → gradient calculé par rétropropagation.
Les objets en jeu
$\phi_j(\bx)$, $\bphi(\bx)$
fonction de base, carte de features$\phi_j:\R^{d_{\text{in}}}\to\R$ extrait une feature ; $\bphi:\R^{d_{\text{in}}}\to\R^{d_{\text{feat}}}$ les rassemble. Aux chapitres 1–3, elles étaient fixées à la main.
$\mathcal H = \{\bx\mapsto\bw\T\bphi(\bx) : \bw,\bphi\}$
espace d'hypothèsesSlide 7 : la nouveauté est que $\bphi$ fait partie de ce qu'on apprend (« learn $\bphi$, learn $\bw$ »). La sortie reste linéaire en les features.
XOR
fonction booléenne« ou exclusif » : $x_1\oplus x_2 = 1$ si les deux bits diffèrent, 0 sinon. Classe 1 : $(0,1)$, $(1,0)$ ; classe 0 : $(0,0)$, $(1,1)$.
Preuve — aucune droite ne sépare XOR hors slides
Ce qu'on suppose (par l'absurde). Un classifieur linéaire $f(\bx) = w_1x_1+w_2x_2+b$ classe correctement les 4 points : $f\ge0$ sur la classe 1 et $f<0$ sur la classe 0.
Classe 1. $f(0,1) = w_2+b\ge0$ et $f(1,0) = w_1+b\ge0$. En additionnant : $w_1+w_2+2b\ge0$.
Classe 0. $f(0,0) = b<0$ et $f(1,1) = w_1+w_2+b<0$. En additionnant : $w_1+w_2+2b<0$.
Contradiction. Le même nombre $w_1+w_2+2b$ ne peut pas être à la fois $\ge0$ et $<0$. Donc aucun $(w_1,w_2,b)$ ne convient.
Géométriquement : les deux diagonales du carré ont le même milieu $(\frac12,\frac12)$. Comme $f$ est affine, $f(\frac12,\frac12)$ est la moyenne de $f$ aux deux extrémités de chaque diagonale : elle serait à la fois $\ge0$ (diagonale de la classe 1) et $<0$ (diagonale de la classe 0). C'est le même argument que le « centre de gravité » du HW3.
∎

Dans la scène, choisis « un seul perceptron » et essaie de déplacer la droite : tu ne descendras jamais sous 1 erreur. Puis passe au réseau à deux unités cachées : dans l'espace $(h_1,h_2)$, les données deviennent séparables par une droite.

L'idée du chapitre (slide 6) : un réseau de neurones apprend à la fois la carte de features (la représentation) et le classifieur linéaire final. La frontière est non linéaire dans l'espace d'entrée, mais linéaire dans l'espace des features appris. La scène ci-dessous le montre en direct : un réseau à 3 unités cachées plie le plan d'entrée dans l'espace 3D des features, jusqu'à ce qu'un plan sépare les classes.

2Perceptrons et unités cachées

Slides p.8–14DL §6.2.2 Universal approximationPRML §5.1 p.230
Où on en est
Acquis
XOR n'est pas linéairement séparable ; il faut une représentation intermédiaire.
Il manque
Une brique de base pour construire cette représentation, et la preuve qu'en les empilant on peut représenter beaucoup de choses.
Cette partie
Le perceptron (un demi-plan), les unités cachées combinées par ET/OU (XOR, régions, toute fonction booléenne), l'approximation universelle, et l'intérêt de la profondeur. On utilise ici sign : l'entraînement viendra au §3–5.
▶ Vidéosen anglais · s'ouvrent sur YouTube
▶Michael NielsenThe Universal Approximation Theorem for neural networksLa construction « marches de sigmoïdes » de l'approximation universelle, à la main.▶Emergent GardenWhy Neural Networks can learn (almost) anythingPourquoi empiler des fonctions simples donne des approximateurs universels.
Perceptron (slide 8) · unité cachée (slide 9)
$$\hat y = \mathrm{sign}(\bw\T\bx+b)\in\{-1,+1\}.$$ Un perceptron (Rosenblatt, 1957) est un neurone à seuil : il dit $+1$ d'un côté de l'hyperplan $\bw\T\bx+b = 0$ et $-1$ de l'autre. Une unité cachée est un neurone d'une couche intermédiaire : sa sortie n'est pas la prédiction, mais une feature utilisée par la couche suivante.

XOR avec deux unités cachées

On utilise $x_1\oplus x_2 = (x_1\vee x_2)\wedge\neg(x_1\wedge x_2)$ : « au moins un » ET PAS « les deux ». Conventions des slides : entrées 0/1, sorties d'unités $-1/+1$ (faux/vrai).

$$h_1(\bx) = \mathrm{sign}(x_1+x_2-0.5)\ (\text{OU}),\qquad h_2(\bx) = \mathrm{sign}(x_1+x_2-1.5)\ (\text{ET}),\qquad\hat y = \mathrm{sign}\big(\tfrac12h_1-\tfrac12h_2-\tfrac12\big).$$
Preuve — ce réseau calcule exactement XOR (vérification des 4 cas)
$h_1$ = OU. $x_1+x_2-0.5$ vaut $-0.5$ en $(0,0)$ et $\ge0.5$ dès qu'un bit vaut 1. Donc $h_1 = +1$ ssi au moins une entrée vaut 1.
$h_2$ = ET. $x_1+x_2-1.5$ vaut $0.5$ en $(1,1)$ et $\le-0.5$ sinon. Donc $h_2 = +1$ ssi les deux entrées valent 1.
La sortie. $s := \frac12h_1-\frac12h_2-\frac12$.
  • $(0,0)$ : $h_1 = -1$, $h_2 = -1$ ⇒ $s = -\frac12+\frac12-\frac12 = -\frac12$ ⇒ $\hat y = -1$ (classe 0). ✓
  • $(0,1)$ et $(1,0)$ : $h_1 = +1$, $h_2 = -1$ ⇒ $s = \frac12+\frac12-\frac12 = \frac12$ ⇒ $\hat y = +1$ (classe 1). ✓
  • $(1,1)$ : $h_1 = +1$, $h_2 = +1$ ⇒ $s = \frac12-\frac12-\frac12 = -\frac12$ ⇒ $\hat y = -1$ (classe 0). ✓
Lecture géométrique (slide 10). Entre les deux droites parallèles $x_1+x_2 = 0.5$ et $x_1+x_2 = 1.5$ on a $h_1 = +1$, $h_2 = -1$, donc $\hat y = +1$ ; de part et d'autre, $h_1 = h_2$ et $\hat y = -1$. Dans l'espace $(h_1,h_2)$, les deux points de la classe 1 tombent au même endroit $(+1,-1)$, que la droite $h_1-h_2 = 1$ sépare des deux autres.
∎

Unités cachées = détecteurs de demi-plans

Chaque unité $h_i(\bx) = \mathrm{sign}(\bw_i\T\bx+b_i)$ teste un demi-plan. En orientant les trois demi-plans d'un triangle vers l'intérieur, le triangle est exactement la région où les trois unités disent $+1$ : on les combine par un ET, $\hat y = \mathrm{sign}\big(\sum_{i=1}^3h_i(\bx)-2\big)$ (slide 11). Avec deux couches cachées, on peut réutiliser un test commun à deux régions et les réunir par un OU (slide 14).

Preuve — $\mathrm{sign}\big(\sum_{i=1}^Kh_i-(K-1)\big)$ est un ET, $\mathrm{sign}(g_A+g_B+1)$ est un OU
Valeurs possibles de la somme. Si $m$ unités valent $+1$ et $K-m$ valent $-1$ : $\sum_ih_i = m-(K-m) = 2m-K$.
ET. $\sum_ih_i-(K-1) = 2m-2K+1$. Si $m = K$ (toutes disent $+1$) : $= 1>0$, sortie $+1$. Si $m\le K-1$ : $\le2(K-1)-2K+1 = -1<0$, sortie $-1$. Donc la sortie vaut $+1$ exactement quand toutes les unités valent $+1$. Pour $K = 3$ : seuil $K-1 = 2$ (slide 11).
OU de deux tests $\pm1$. $g_A+g_B+1$ vaut $3$ si les deux sont vrais, $1$ si un seul est vrai, $-1$ si aucun. Son signe est $+1$ dès qu'au moins un test est vrai : c'est un OU.
Réutilisation (slide 14). Les régions A (3 demi-plans) et B (4 demi-plans) ont le même bord inférieur $x_2 = c$. Une seule unité $h_s(\bx) = \mathrm{sign}(x_2-c)$ sert aux deux ET : la première couche cachée passe de $3+4 = 7$ à $3+4-1 = 6$ unités. La deuxième couche calcule $g_A$, $g_B$ (ET), la sortie leur OU.
∎

Toute fonction booléenne, puis toute fonction continue

Représentation universelle des fonctions booléennes (slide 12)
Sur l'espace fini $\{0,1\}^D$, un réseau avec suffisamment de perceptrons représente exactement n'importe quelle fonction booléenne. Pour $D = 2$, un détecteur par coin $(a,b)\in\{0,1\}^2$ : $$h_{ab}(\bx) = \mathrm{sign}\big((2a-1)x_1+(2b-1)x_2-a-b+\tfrac12\big),\qquad\hat y = \mathrm{sign}\Big(\sum_{a,b}w_{ab}h_{ab}(\bx)+b_{\text{out}}\Big),\quad w_{ab} = f(a,b),\ b_{\text{out}} = \sum_{a,b}w_{ab}.$$
Preuve — exactement un détecteur s'allume, et la sortie vaut $f(\bx)$
L'argument de $h_{ab}$ en un coin $\bx = (a',b')$. Il vaut $\big[(2a-1)a'-a\big] + \big[(2b-1)b'-b\big] + \frac12$. Regardons un seul crochet, avec $a,a'\in\{0,1\}$ (donc $a^2 = a$) :
  • si $a' = a$ : $(2a-1)a-a = 2a^2-2a = 2a-2a = 0$ ;
  • si $a' = 1-a$ : $(2a-1)(1-a)-a = 2a-2a^2-1+a-a = 2a-2a-1 = -1$.
Chaque coordonnée apporte 0 si elle coïncide avec le coin du détecteur, $-1$ sinon.
Donc l'argument vaut $\frac12-(\text{nombre de coordonnées différentes})$ : $+\frac12$ si $(a',b') = (a,b)$, et $\le-\frac12$ sinon. Le détecteur $h_{ab}$ vaut $+1$ seulement en son propre coin : en chaque coin, exactement un détecteur vaut $+1$ et les trois autres $-1$.
La sortie en $\bx = (a,b)$. $\sum_{a',b'}w_{a'b'}h_{a'b'} = w_{ab} - \sum_{(a',b')\ne(a,b)}w_{a'b'}$. On ajoute $b_{\text{out}} = \sum_{\text{tous}}w = w_{ab}+\sum_{\text{autres}}w$ : il reste $2w_{ab}$. Son signe est $w_{ab} = f(a,b)$. ✓
Exemple XOR : $(w_{00},w_{01},w_{10},w_{11}) = (-1,+1,+1,-1)$ et $b_{\text{out}} = 0$. En dimension $D$, la même construction utilise un détecteur par coin : jusqu'à $2^D$ unités — d'où l'intérêt de constructions plus compactes (profondeur).
∎
Approximation universelle (slide 12, Cybenko 1989)
Un réseau suffisamment large, avec une couche cachée de sigmoïdes et une sortie linéaire, peut approcher n'importe quelle fonction continue sur un domaine compact, aussi bien qu'on veut. Mais pouvoir représenter ne garantit ni un apprentissage efficace, ni une bonne généralisation (chapitre 4).

Idée de la preuve en 1D Hors slides. Une sigmoïde très raide $\sigma(s(x-t))$ est presque une marche de hauteur 1 en $x = t$. On découpe $[0,1]$ en $N$ morceaux de centres $a_k$ et on empile des marches de hauteur $f^\star(a_k)-f^\star(a_{k-1})$ : on obtient un escalier qui suit $f^\star$. Comme $f^\star$ est continue sur un compact, elle est uniformément continue : avec $N$ assez grand, chaque marche est petite et l'escalier reste à $\varepsilon$ près de $f^\star$ ; avec $s$ assez grand, les sigmoïdes sont assez proches des marches. Le résultat est bien un réseau à une couche cachée (les $\sigma(s(x-t_k))$) et une sortie linéaire (la somme pondérée).

Pourquoi plusieurs couches cachées ? (slide 13)
Une représentation universelle n'est pas forcément compacte : l'énumération des coins utilise jusqu'à $2^D$ détecteurs. La profondeur permet de composer et réutiliser des features intermédiaires (une même feature alimente plusieurs unités plus loin). Pour des fonctions à structure compositionnelle, cela réduit le nombre d'unités ; pour certaines familles de fonctions, un réseau peu profond a besoin d'exponentiellement plus d'unités pour la même précision (Telgarsky, 2016).

3Le perceptron multicouche (MLP)

Slides p.15–20PRML §5.1 p.227–232DL §6.2 Multilayer networks
Où on en est
Acquis
Des perceptrons empilés représentent des régions, des fonctions booléennes, et approchent toute fonction continue.
Il manque
On a construit les poids à la main. Pour les apprendre, il faut une écriture générale du modèle et des briques dérivables.
Cette partie
La définition du MLP (couches affines + activations), les dimensions, les activations lisses (ReLU, sigmoïde, tanh) qui remplacent sign, la passe avant et les têtes de sortie (logits → probabilités).
Perceptron multicouche (slide 15) · couche entièrement connectée (slide 16)
Un MLP à $L$ couches est une composition $f_\theta = f^{(L)}\circ\cdots\circ f^{(1)}$ : $$\bh^{(0)} = \bx,\qquad\bz^{(\ell)} = W_\ell\bh^{(\ell-1)}+\bb_\ell,\qquad\bh^{(\ell)} = \varphi_\ell\big(\bz^{(\ell)}\big)\quad(\ell = 1,\dots,L-1),\qquad f_\theta(\bx) = \bz^{(L)} = W_L\bh^{(L-1)}+\bb_L.$$ Tous les poids et biais sont entraînables : $\theta = \{(W_\ell,\bb_\ell)\}_{\ell=1}^L$. Il y a $L-1$ couches cachées ; la carte de features apprise est $\bphi(\bx) = \bh^{(L-1)}$, et la dernière couche est un classifieur linéaire sur ces features.
Les objets en jeu
$d_\ell$
entierNombre d'unités de la couche $\ell$ ($d_0 = d_{\text{in}}$, $d_L$ = nombre de scores de classe).
$W_\ell\in\R^{d_\ell\times d_{\ell-1}}$
matriceUne ligne par unité de sortie, une colonne par entrée. $W_{ji}$ relie l'entrée $i$ à la sortie $j$. Une couche entièrement connectée : chaque sortie reçoit toutes les entrées.
$\bb_\ell\in\R^{d_\ell}$
vecteurUn biais par unité.
$\bz^{(\ell)}$
vecteur $\R^{d_\ell}$Pré-activation : la partie affine. Composante $j$ : $z_j = \sum_iW_{ji}h_i+b_j$.
$\varphi_\ell$
fonction $\R\to\R$Activation, appliquée à chaque composante séparément. Sans elle, la composition de couches affines serait encore affine (preuve plus bas).
$\bh^{(\ell)}$
vecteur $\R^{d_\ell}$Activation de la couche (sa sortie). $\bh^{(0)} = \bx$.
$\bz^{(L)}$
$\R$ ou $\R^K$Scores de classe = logits. Pas d'activation : c'est la tête de sortie (§4) qui les transforme en probabilités.
Preuve — sans activation non linéaire, un MLP n'est qu'un modèle linéaire ; nombre de paramètres
Deux couches affines. Si $\varphi$ est l'identité : $\bz^{(2)} = W_2(W_1\bx+\bb_1)+\bb_2 = (W_2W_1)\bx + (W_2\bb_1+\bb_2)$. C'est encore $W'\bx+\bb'$ avec $W' = W_2W_1$, $\bb' = W_2\bb_1+\bb_2$.
Par récurrence, $L$ couches affines composées donnent une seule application affine : la frontière de décision resterait un hyperplan, et XOR resterait impossible. Toute la puissance vient des activations non linéaires.
Nombre de paramètres. La couche $\ell$ a $d_\ell d_{\ell-1}$ poids et $d_\ell$ biais, soit $d_\ell(d_{\ell-1}+1)$. Total : $\sum_{\ell=1}^Ld_\ell(d_{\ell-1}+1)$. Exemple : $2\to8\to1$ donne $8\cdot3+1\cdot9 = 33$ paramètres.
∎

Fonctions d'activation

Slide 17 : peut-on trouver les paramètres de perceptrons par gradient ? Avec sign, non : sa dérivée est nulle partout (sauf en 0 où elle n'existe pas), donc tout gradient qui la traverse est multiplié par 0. On la remplace par des fonctions dérivables (presque partout).

Preuve — dérivées des activations ; $\tanh z = 2\sigma(2z)-1$
ReLU $\max\{0,z\}$ : vaut $z$ si $z>0$ (dérivée 1) et 0 si $z<0$ (dérivée 0). En $z = 0$ elle n'est pas dérivable ; en pratique on prend 0 ou 1, cela ne change rien (un point isolé). Leaky ReLU : dérivée 1 ou $\alpha$.
Sigmoïde : $\sigma'(z) = \sigma(z)(1-\sigma(z))$ (chapitre 2, §3), maximale en 0 où elle vaut $\frac14$.
tanh : $\tanh z = \frac{e^z-e^{-z}}{e^z+e^{-z}}$. Dérivée d'un quotient : $\frac{(e^z+e^{-z})^2-(e^z-e^{-z})^2}{(e^z+e^{-z})^2} = 1-\tanh^2z$.
Lien tanh / sigmoïde Hors slides : $2\sigma(2z)-1 = \frac{2}{1+e^{-2z}}-1 = \frac{1-e^{-2z}}{1+e^{-2z}}$ ; en multipliant haut et bas par $e^z$ : $\frac{e^z-e^{-z}}{e^z+e^{-z}} = \tanh z$. Donc tanh est une sigmoïde étirée et recentrée sur $(-1,1)$.
∎

Passe avant et têtes de sortie

Passe avant (slide 18) · tête de sortie (slides 19–20)
La passe avant évalue le réseau de l'entrée vers les scores : $\bh^{(0)} = \bx$, puis pour $\ell = 1,\dots,L-1$ : $\bz^{(\ell)} = W_\ell\bh^{(\ell-1)}+\bb_\ell$, $\bh^{(\ell)} = \varphi_\ell(\bz^{(\ell)})$, et enfin $\bz^{(L)} = W_L\bh^{(L-1)}+\bb_L$.
La tête de sortie convertit les scores en probabilités : binaire, un score $z\in\R$ et $p = \sigma(z)$ ; multiclasse, $\bz\in\R^K$ et $\mathbf p = \mathrm{softmax}(\bz)$. Les couches cachées créent la représentation, la tête la convertit, et la perte doit correspondre au modèle de sortie et au codage des étiquettes.

4Pertes de classification

Slides p.22–26chapitre 2, §5DL §6.4 Error functionsPRML §5.2 p.235–236
Où on en est
Acquis
Le modèle : un MLP qui sort des logits $\bz^{(L)}$, convertis en probabilités par sigmoïde ou softmax.
Il manque
Un critère pour dire si ces probabilités sont bonnes : la perte $\ell$ de l'ERM.
Cette partie
BCE (2 classes) et cross-entropy (K classes), les propriétés de la softmax, et surtout le gradient par rapport aux logits, $\mathbf p-\by$ : c'est là que commencera la rétropropagation.
Perte et risque empirique (slide 22)
Une perte $\ell(y,f_\theta(\bx))$ donne une pénalité numérique à une prédiction. Le risque empirique est la perte moyenne : $\hL_N(\theta) = \frac1N\sum_{n=1}^N\ell\big(y_n,f_\theta(\bx_n)\big)$, et l'ERM choisit les $\theta$ qui le minimisent. La perte définit ce qu'est une bonne prédiction.

Classification binaire : sigmoïde et BCE

Binary cross-entropy (slide 23)
Pour un logit $z$, $p = \sigma(z)$ et une étiquette $y\in\{0,1\}$ : $$\ell_{\text{BCE}}(y,z) = -y\log p-(1-y)\log(1-p),\qquad\frac{\partial\ell_{\text{BCE}}}{\partial z} = p-y.$$ $p$ modélise la probabilité de la classe 1 ; la perte est la log-vraisemblance négative d'une loi de Bernoulli (chapitre 2).
Preuve — $\partial\ell_{\text{BCE}}/\partial z = p-y$, et pourquoi la descente rapproche $p$ de $y$
Règle de la chaîne. $\ell$ dépend de $z$ à travers $p = \sigma(z)$ : $\frac{\partial\ell}{\partial z} = \frac{\partial\ell}{\partial p}\cdot\frac{dp}{dz}$.
Premier facteur. $\frac{\partial\ell}{\partial p} = -\frac yp+\frac{1-y}{1-p}$ (dérivée de $\log u$ = $1/u$ ; le signe $+$ vient de la dérivée de $1-p$, qui vaut $-1$).
Second facteur. $\frac{dp}{dz} = \sigma'(z) = p(1-p)$.
Produit. $\Big(-\frac yp+\frac{1-y}{1-p}\Big)p(1-p) = -y(1-p)+(1-y)p = -y+yp+p-yp = p-y$. Les facteurs $p(1-p)$ se simplifient exactement.
Pourquoi la descente rapproche $p$ de $y$ (question de la slide 23). Un pas fait $z\leftarrow z-\eta(p-y)$. Si $y = 1$ : $p-y = p-1<0$, donc $z$ augmente, et $p = \sigma(z)$ augmente (σ est croissante) vers 1. Si $y = 0$ : $p-y = p>0$, $z$ diminue, $p$ diminue vers 0. La taille du pas est proportionnelle à l'erreur $|p-y|$ : grande quand le modèle se trompe, presque nulle quand $p\approx y$.
∎

Multiclasse : softmax

Softmax (slide 24)
Pour $K$ classes mutuellement exclusives, la softmax convertit des logits $\bz\in\R^K$ en probabilités : $$p_k = \frac{\exp(z_k)}{\sum_{j=1}^K\exp(z_j)},\qquad\text{avec température }T>0 :\ p_k(T) = \frac{\exp(z_k/T)}{\sum_j\exp(z_j/T)}.$$ Augmenter un logit augmente sa probabilité relativement aux autres ; ajouter la même constante à tous les logits ne change rien ; $T>1$ adoucit, $0\lt T\lt 1$ durcit, l'argmax ne change pas.
Preuve — les quatre propriétés de la softmax et la version stable (log-softmax)
C'est une loi de probabilité. Chaque $p_k>0$ (exponentielle) et $\sum_kp_k = \frac{\sum_ke^{z_k}}{\sum_je^{z_j}} = 1$.
Invariance par translation. Pour toute constante $c$ : $\frac{e^{z_k+c}}{\sum_je^{z_j+c}} = \frac{e^ce^{z_k}}{e^c\sum_je^{z_j}} = p_k$ (le facteur $e^c$ se simplifie). Seules les différences de logits comptent (comme au HW2, P1.(1)).
Monotonie. $\frac{p_k}{p_j} = e^{z_k-z_j}$ : augmenter $z_k$ augmente le rapport de $p_k$ à chaque autre $p_j$.
Température. $p_k(T)/p_j(T) = e^{(z_k-z_j)/T}$. Comme $T>0$, le signe de $(z_k-z_j)/T$ est celui de $z_k-z_j$ : l'ordre des probabilités, donc l'argmax, est inchangé. $T$ grand rapproche tous les exposants de 0 (distribution plus uniforme) ; $T$ petit amplifie les écarts (distribution qui se concentre sur l'argmax).
Calcul stable. Avec $m = \max_jz_j$ (translation par $c = -m$) : $p_k = \frac{e^{z_k-m}}{\sum_je^{z_j-m}}$, où tous les exposants sont $\le0$ : pas de dépassement de $e^{1000}$. Et $\log p_k = z_k-m-\log\sum_je^{z_j-m}$ (log-softmax) évite de calculer $\log$ d'un nombre arrondi à 0.
∎

Cross-entropy et son gradient

Cross-entropy catégorielle (slide 25) · gradient au logit (slide 26)
Pour un label one-hot $\by$ et $\mathbf p = \mathrm{softmax}(\bz)$ : $$\ell_{\text{CE}}(\by,\mathbf p) = -\sum_{k=1}^Ky_k\log p_k = -\log p_y,\qquad\frac{\partial\ell}{\partial z_k} = p_k-y_k.$$ La bonne classe reçoit le gradient $p_y-1<0$, chaque mauvaise classe le gradient $p_k>0$ : la descente monte le bon logit par rapport aux autres.
Preuve — $\partial\ell_{\text{CE}}/\partial z_k = p_k-y_k$ (pas à pas)
Écrire la perte avec les logits. $\log p_y = z_y-\log\sum_je^{z_j}$, donc $\ell = -\log p_y = -z_y+\log\sum_{j=1}^Ke^{z_j}$.
Dériver le premier terme. $\frac{\partial}{\partial z_k}(-z_y) = -1$ si $k = y$, $0$ sinon, c'est-à-dire $-y_k$ (codage one-hot : $y_k = 1$ seulement pour la bonne classe).
Dériver le second. $\frac{\partial}{\partial z_k}\log\sum_je^{z_j} = \frac{1}{\sum_je^{z_j}}\cdot\frac{\partial}{\partial z_k}\sum_je^{z_j} = \frac{e^{z_k}}{\sum_je^{z_j}} = p_k$ (dans la somme, seul le terme $j = k$ dépend de $z_k$).
Somme. $\frac{\partial\ell}{\partial z_k} = p_k-y_k$. En vecteur : $\nabla_\bz\ell = \mathbf p-\by$.
Les composantes somment à $\sum_kp_k-\sum_ky_k = 1-1 = 0$ : ce que la descente ajoute au bon logit, elle l'enlève aux autres. C'est le « couplage » de la slide 26 : toutes les probabilités partagent le même dénominateur.
Cross-entropy = log-vraisemblance négative. $p_y$ est la probabilité que le modèle donne à l'étiquette observée ; minimiser $\frac1N\sum_n-\log p_{y_n}$, c'est maximiser $\prod_np_{y_n}$, la vraisemblance des données (exactement comme au chapitre 2). Une erreur confiante ($p_y\to0$) coûte $-\log p_y\to+\infty$.
∎

5Rétropropagation

Slides p.28–40PRML §5.3 p.241–244DL §8.1 Evaluation of gradientsDL §8.2.2 Reverse-mode AD
Où on en est
Acquis
Modèle (MLP) et perte (BCE / cross-entropy) ; on sait déjà $\partial\ell/\partial\bz^{(L)} = \mathbf p-\by$.
Il manque
La descente de gradient $\theta\leftarrow\theta-\eta\nabla_\theta\hL_N$ demande la dérivée par rapport à chaque poids de chaque couche — des milliers ou des milliards de nombres.
Cette partie
La règle de la chaîne, le graphe de calcul, les passes avant et arrière, trois règles locales (couche affine, activation, branches), et l'algorithme complet couche par couche.
▶ Vidéosen anglais · s'ouvrent sur YouTube
▶3Blue1BrownBackpropagation, intuitively | Deep Learning Chapter 3Ce que fait la rétropropagation, sans formules.▶3Blue1BrownBackpropagation calculus | Deep Learning Chapter 4La règle de la chaîne couche par couche, avec les indices.▶Stanford CS231nLecture 4 | Introduction to Neural NetworksGraphes de calcul et l'exemple exact des slides, $f = (x+y)z$ avec $x = -2$, $y = 5$, $z = -4$.▶Andrej KarpathyThe spelled-out intro to neural networks and backpropagation: building microgradCoder la différentiation automatique de zéro, nœud par nœud (2 h, la référence).
Objectif et gradient (slides 28–29)
$$\hL_N(\theta) = \frac1N\sum_{n=1}^N\ell\big(y_n,f_\theta(\bx_n)\big),\qquad\theta\leftarrow\theta-\eta\nabla_\theta\hL_N.$$ Le gradient $\nabla_\theta\hL_N$ rassemble les dérivées partielles de la perte par rapport à tous les paramètres. Les calculer séparément répète sans cesse les mêmes calculs intermédiaires ; la rétropropagation réutilise les valeurs stockées et calcule tous les gradients en une traversée arrière.
Règle de la chaîne (slide 31) · graphe de calcul (slide 32)
Pour $q = g(x)$ et $f = h(q)$ : $\frac{df}{dx} = \frac{df}{dq}\frac{dq}{dx} = h'(q)\,g'(x)$. La dérivée d'une composition est le produit des dérivées de ses étapes.
Un graphe de calcul est un graphe orienté sans cycle : nœuds = valeurs intermédiaires, arêtes = dépendances. Passe avant : évaluer dans l'ordre des dépendances, en stockant les valeurs. Passe arrière : calculer les gradients dans l'ordre inverse avec la règle de la chaîne.
Calcul — $f(x,y,z) = (x+y)z$ en $x = -2$, $y = 5$, $z = -4$ (slides 33–34)
Avant. $q = x+y = 3$ (on le stocke), puis $f = qz = 3\cdot(-4) = -12$.
Arrière, départ. $\frac{\partial f}{\partial f} = 1$.
Nœud $\times$ ($f = qz$) : dérivées locales $\frac{\partial f}{\partial q} = z = -4$ et $\frac{\partial f}{\partial z} = q = 3$. On a besoin de $q$ : c'est pourquoi la passe avant le stocke (question de la slide 33).
Nœud $+$ ($q = x+y$) : dérivées locales $\frac{\partial q}{\partial x} = \frac{\partial q}{\partial y} = 1$. Chaîne : $\frac{\partial f}{\partial x} = \frac{\partial f}{\partial q}\cdot1 = -4$, $\frac{\partial f}{\partial y} = -4$. Le gradient amont $-4$ est calculé une fois et réutilisé deux fois.
Résultat. $\nabla_{(x,y,z)}f = (z,\ z,\ x+y) = (-4,-4,3)$. Vérification directe : $f = xz+yz$, donc $\partial_xf = z$, $\partial_yf = z$, $\partial_zf = x+y$. ✓
∎

Les règles locales

Règle locale (slide 35) · accumulation aux branches (slide 36)
Pour une opération $z = g(x_1,\dots,x_m)$, si chaque $x_i$ n'atteint la perte qu'à travers $z$ : $$\underbrace{\frac{\partial\hL_N}{\partial x_i}}_{\text{envoyé à }x_i} = \underbrace{\frac{\partial\hL_N}{\partial z}}_{\text{gradient amont}}\cdot\underbrace{\frac{\partial z}{\partial x_i}}_{\text{dérivée locale}}.$$ Si $x$ atteint la perte par deux chemins, $z_1 = g_1(x)$ et $z_2 = g_2(x)$, les contributions s'additionnent : $$\frac{\partial\hL_N}{\partial x} = \frac{\partial\hL_N}{\partial z_1}\frac{\partial z_1}{\partial x}+\frac{\partial\hL_N}{\partial z_2}\frac{\partial z_2}{\partial x}.$$
Pourquoi on additionne aux branches (règle de la chaîne à plusieurs variables)
On écrit $\hL_N(x) = h\big(g_1(x),g_2(x)\big)$. Bougeons $x$ d'un petit $\Delta x$ : $z_1$ bouge d'environ $g_1'(x)\Delta x$ et $z_2$ d'environ $g_2'(x)\Delta x$.
Au premier ordre, la variation de $h$ est la somme des effets de chaque argument : $\Delta\hL_N\approx\frac{\partial h}{\partial z_1}\Delta z_1+\frac{\partial h}{\partial z_2}\Delta z_2 = \Big(\frac{\partial h}{\partial z_1}g_1'(x)+\frac{\partial h}{\partial z_2}g_2'(x)\Big)\Delta x$.
En divisant par $\Delta x$ et en faisant $\Delta x\to0$ on obtient la formule. Intuition : $x$ influence la perte par deux canaux ; l'effet total est la somme des effets par chaque canal. Dans l'exemple ci-dessus, si $x$ servait aussi ailleurs, on ajouterait la contribution de cet autre chemin.
∎
Couche affine (slide 37) · activation (slide 38)
Pour $\bz = W\bh+\bb$ et $\boldsymbol\delta = \partial\hL_N/\partial\bz$ le gradient amont : $$\frac{\partial\hL_N}{\partial W} = \boldsymbol\delta\,\bh\T,\qquad\frac{\partial\hL_N}{\partial\bb} = \boldsymbol\delta,\qquad\frac{\partial\hL_N}{\partial\bh} = W\T\boldsymbol\delta.$$ Pour une activation composante par composante $\bh = \varphi(\bz)$ : $$\frac{\partial\hL_N}{\partial\bz} = \frac{\partial\hL_N}{\partial\bh}\odot\varphi'(\bz).$$ ReLU laisse passer le gradient quand $z>0$ et le bloque quand $z<0$ ; pour la sigmoïde, $\sigma'(z) = \sigma(z)(1-\sigma(z))$.
Preuve — les trois gradients de la couche affine, composante par composante
Écrire une composante. $z_i = \sum_kW_{ik}h_k+b_i$. On note $\delta_i = \partial\hL_N/\partial z_i$ (connu : c'est ce que la couche du dessus nous envoie).
Par rapport à un poids $W_{ij}$. $W_{ij}$ n'apparaît que dans $z_i$ (ligne $i$), multiplié par $h_j$ : $\frac{\partial z_i}{\partial W_{ij}} = h_j$, et $\frac{\partial z_{i'}}{\partial W_{ij}} = 0$ pour $i'\ne i$. Règle locale : $\frac{\partial\hL_N}{\partial W_{ij}} = \delta_i\,h_j$. La matrice d'entrées $\delta_ih_j$ est exactement le produit colonne × ligne $\boldsymbol\delta\bh\T$ (ligne $i$ de $\boldsymbol\delta$, colonne $j$ de $\bh\T$).
Vérification des tailles : $\boldsymbol\delta\in\R^{d_{\text{out}}}$, $\bh\T\in\R^{1\times d_{\text{in}}}$, donc $\boldsymbol\delta\bh\T\in\R^{d_{\text{out}}\times d_{\text{in}}}$ : même forme que $W$. Toujours vérifier les formes (slide 44).
Par rapport à un biais $b_i$. $b_i$ entre dans $z_i$ avec la dérivée 1 : $\frac{\partial\hL_N}{\partial b_i} = \delta_i\cdot1 = \delta_i$, donc $\frac{\partial\hL_N}{\partial\bb} = \boldsymbol\delta$.
Par rapport à une entrée $h_j$. $h_j$ intervient dans toutes les sorties $z_1,\dots,z_m$ (couche entièrement connectée), avec $\frac{\partial z_i}{\partial h_j} = W_{ij}$. Ce sont des branches : on additionne (règle précédente) : $\frac{\partial\hL_N}{\partial h_j} = \sum_i\delta_iW_{ij}$. Or $\sum_iW_{ij}\delta_i$ est la composante $j$ de $W\T\boldsymbol\delta$ (la colonne $j$ de $W$ devient la ligne $j$ de $W\T$). Donc $\frac{\partial\hL_N}{\partial\bh} = W\T\boldsymbol\delta$.
Activation. $h_i = \varphi(z_i)$ ne dépend que de $z_i$ (pas des autres $z_k$). Une seule branche : $\frac{\partial\hL_N}{\partial z_i} = \frac{\partial\hL_N}{\partial h_i}\varphi'(z_i)$. Pour tout $i$ à la fois : le produit composante par composante $\odot$.
∎

L'algorithme complet, couche par couche

Rétropropagation dans un MLP (slide 39)
  1. Passe avant : calculer et stocker tous les $\bz^{(\ell)}$, $\bh^{(\ell)}$.
  2. Départ (softmax + cross-entropy, un exemple) : $\boldsymbol\delta^{(L)} = \partial\ell/\partial\bz^{(L)} = \mathbf p-\by$.
  3. Pour $\ell = L,\dots,1$ : $\frac{\partial\ell}{\partial W_\ell} = \boldsymbol\delta^{(\ell)}\bh^{(\ell-1)\top}$, $\frac{\partial\ell}{\partial\bb_\ell} = \boldsymbol\delta^{(\ell)}$, puis si $\ell>1$ : $\boldsymbol\delta^{(\ell-1)} = \big(W_\ell\T\boldsymbol\delta^{(\ell)}\big)\odot\varphi_{\ell-1}'\big(\bz^{(\ell-1)}\big)$.
  4. Accumuler (moyenner) les gradients sur les exemples du mini-batch, et pour les paramètres partagés.

La scène suivante fait tout cela sur un petit réseau $2\to2\to1$, étape par étape, et compare chaque dérivée obtenue par rétropropagation à une estimation par différences finies : les deux colonnes coïncident.

Pourquoi visiter les couches à l'envers, et pourquoi c'est efficace (questions des slides 29 et 39)
À l'envers, parce que la perte est au bout. Pour connaître $\partial\ell/\partial W_\ell$, il faut $\boldsymbol\delta^{(\ell)}$, qui mesure comment la perte réagit à $\bz^{(\ell)}$. Cette réaction passe par toutes les couches au-dessus de $\ell$ : on ne peut la connaître qu'après avoir traité les couches $L, L-1,\dots,\ell+1$. La récurrence $\boldsymbol\delta^{(\ell-1)} = (W_\ell\T\boldsymbol\delta^{(\ell)})\odot\varphi'$ part donc de la sortie.
Réutilisation. $\boldsymbol\delta^{(\ell)}$ sert à tous les poids de la couche $\ell$ et à calculer $\boldsymbol\delta^{(\ell-1)}$. Sans rétropropagation, on recalculerait le chemin « couche $\ell$ → perte » pour chaque poids séparément.
Coût Hors slides. La passe arrière fait, par couche, un produit $W\T\boldsymbol\delta$ et un produit extérieur $\boldsymbol\delta\bh\T$ : le même ordre de grandeur d'opérations que la passe avant ($W\bh$). Le gradient complet coûte donc quelques passes avant, quel que soit le nombre de paramètres $P$. Une approche « une dérivée à la fois » (différences finies) coûterait $P$ passes avant : impossible avec des millions de poids. En revanche, il faut stocker les activations de la passe avant (coût mémoire).
∎
Différentiation automatique (slide 40)
Les bibliothèques (PyTorch, JAX…) enregistrent les opérations élémentaires pendant la passe avant (le graphe de calcul), puis appliquent leurs règles de dérivation locales dans l'ordre inverse. On obtient les dérivées exactes du programme exécuté. La rétropropagation est le mode « inverse » de la différentiation automatique, adapté à une perte scalaire. La différentiation automatique ne choisit ni le modèle, ni la perte, ni l'optimiseur.

6Entraîner un réseau en pratique

Slides p.42–44chapitre 1, SGDDL §7.2.3 Stochastic gradient descent
Où on en est
Acquis
Le modèle, la perte, et le calcul exact du gradient par rétropropagation.
Il manque
Assembler le tout en une boucle d'entraînement efficace, et éviter les erreurs classiques.
Cette partie
Les mini-batchs et les époques, la boucle d'entraînement PyTorch, et les confusions à éviter. La scène permet d'entraîner un MLP en changeant l'architecture, l'activation et la taille des mini-batchs.
▶ Vidéosen anglais · s'ouvrent sur YouTube
▶3Blue1BrownGradient descent, how neural networks learn | Deep Learning Chapter 2Coût, gradient en très grande dimension, et ce que le réseau apprend vraiment.▶Emergent GardenWatching Neural Networks LearnDes réseaux qui apprennent des fonctions en direct : l'effet de la largeur, de la profondeur, des activations.
Mini-batch et époque (slide 42)
Un mini-batch est un sous-ensemble d'exemples utilisé pour estimer le gradient d'une mise à jour. Boucle : (1) tirer un mini-batch ; (2) passe avant et perte moyenne du batch ; (3) rétropropagation ; (4) un pas de l'optimiseur, puis mini-batch suivant. Une époque traite chaque exemple une fois en moyenne : avec $N$ exemples et des batchs de taille $B$, cela fait environ $N/B$ mises à jour.
Le compromis de la taille du mini-batch (question de la slide 42)
Sans biais. Le gradient d'un mini-batch tiré au hasard est un estimateur sans biais du gradient complet (preuve du chapitre 1, HW1 Q4.(4)).
Bruit. Sa variance décroît comme $1/B$ : un petit $B$ donne des pas bruités (courbe de perte irrégulière), un grand $B$ des pas précis.
Coût. Un pas coûte $\propto B$. Pour un même calcul (une époque), un petit $B$ fait beaucoup de pas imprécis, un grand $B$ peu de pas précis. En pratique on prend un $B$ moyen (32–512) qui exploite le parallélisme du matériel ; le bruit des petits batchs aide parfois à sortir de mauvais minima locaux, au prix d'un pas plus petit à choisir.
∎
La boucle d'entraînement PyTorch (slide 43)
for x, y in loader:                      # un mini-batch
    optimizer.zero_grad()                # effacer les gradients du pas précédent (sinon ils s'accumulent)
    logits = model(x)                    # 1. passe avant : le modèle renvoie des LOGITS
    loss = criterion(logits, y)          # 2. perte stable (CrossEntropyLoss = log-softmax + NLL)
    loss.backward()                      # 3. rétropropagation (différentiation automatique en mode inverse)
    optimizer.step()                     # 4. mise à jour des paramètres (ex. SGD : θ ← θ − η ∇θ)
Pourquoi CrossEntropyLoss reçoit des logits et pas des probabilités (question de la slide 43)
Elle applique déjà la softmax. CrossEntropyLoss(z, y) calcule $-\log\mathrm{softmax}(\bz)_y$ en une seule opération. Lui donner $\mathbf p = \mathrm{softmax}(\bz)$ reviendrait à calculer $-\log\mathrm{softmax}(\mathbf p)_y$ : une softmax appliquée deux fois. Le programme tourne sans erreur, mais il optimise une autre fonction, aux gradients écrasés (les $p_k\in(0,1)$ sont très proches les uns des autres, donc leur softmax est presque uniforme).
Stabilité numérique. Calculée à partir des logits, la perte s'écrit $-z_y+m+\log\sum_je^{z_j-m}$ (log-sum-exp avec $m = \max_jz_j$, §4) : aucun débordement, et jamais de $\log 0$. À partir de probabilités déjà arrondies (par exemple $p_y = 0$ en précision finie), $-\log p_y$ donnerait $+\infty$.
∎
Erreurs conceptuelles fréquentes (slide 44)
Trois composants distincts : le modèle définit les prédictions, la rétropropagation calcule les gradients, l'optimiseur met à jour les paramètres.
  • Appliquer une softmax avant une perte qui combine déjà softmax et cross-entropy. ← programme valide, objectif faux (réponse à la question de la slide).
  • Confondre rétropropagation et descente de gradient (la première calcule $\nabla\hL_N$, la seconde s'en sert).
  • Croire qu'une plus grande capacité de représentation garantit une meilleure généralisation (chapitre 4).
  • Ignorer les formes des tenseurs en dérivant les gradients de couche ($\partial\hL/\partial W$ a la forme de $W$).
  • Utiliser une softmax multiclasse pour des étiquettes non mutuellement exclusives (une image peut contenir un chat et un chien : il faut alors une sigmoïde par classe).

7Résumé & questions des slides

Tout le chapitre en une chaîne
$$\underbrace{\bh^{(\ell)} = \varphi\big(W_\ell\bh^{(\ell-1)}+\bb_\ell\big)}_{\text{§2–3 : features apprises}}\ \to\ \underbrace{\bz^{(L)} = W_L\bh^{(L-1)}+\bb_L,\ \ \mathbf p = \mathrm{softmax}(\bz^{(L)})}_{\text{§3–4 : logits, probabilités}}\ \to\ \underbrace{\ell = -\log p_y,\ \ \tfrac{\partial\ell}{\partial\bz^{(L)}} = \mathbf p-\by}_{\text{§4 : perte}}$$ $$\to\ \underbrace{\tfrac{\partial\ell}{\partial W_\ell} = \boldsymbol\delta^{(\ell)}\bh^{(\ell-1)\top},\ \ \boldsymbol\delta^{(\ell-1)} = \big(W_\ell\T\boldsymbol\delta^{(\ell)}\big)\odot\varphi'\big(\bz^{(\ell-1)}\big)}_{\text{§5 : rétropropagation}}\ \to\ \underbrace{\theta\leftarrow\theta-\eta\,\nabla_\theta\hL_{\mathcal B}}_{\text{§6 : mini-batch}}$$
Messages clés (slide 45)
Un réseau de neurones apprend une représentation et un prédicteur en minimisant une perte, avec des gradients calculés à travers ses opérations composées. Les couches cachées transforment des unités non linéaires simples en cartes de features flexibles. La rétropropagation réutilise les dérivées locales pour calculer tous les gradients. Sigmoïde + BCE pour des étiquettes binaires, softmax + cross-entropy pour une classe parmi $K$. Représentation, optimisation et généralisation sont trois questions différentes.
Le couplage de la softmax aide-t-il la convergence ? (slide 26)
Réponse

Les probabilités partagent le même dénominateur, donc le gradient $\mathbf p-\by$ agit sur tous les logits à la fois : chaque pas monte le bon logit et descend les mauvais, en proportion de la probabilité qu'ils volent ($p_k$). Les classes concurrentes les plus menaçantes sont corrigées en priorité, et les composantes du gradient somment à 0. Une fois $p_y\approx1$, tous les gradients s'éteignent ensemble. (Le couplage n'empêche pas la saturation : une erreur très confiante garde un gradient de taille $\approx1$, ce qui est justement souhaitable.)

Quelles valeurs de la passe avant faut-il garder ? (slide 33)
Réponse

Celles qui apparaissent dans les dérivées locales : pour $f = qz$, il faut $q$ et $z$ ; pour une couche affine, l'entrée $\bh^{(\ell-1)}$ (pour $\boldsymbol\delta\bh\T$) et les poids $W_\ell$ (pour $W\T\boldsymbol\delta$) ; pour une activation, $\bz^{(\ell)}$ ou $\bh^{(\ell)}$ (pour $\varphi'$ : $\sigma' = h(1-h)$, $\tanh' = 1-h^2$, ReLU : le signe de $z$).

Pourquoi la rétropropagation visite-t-elle les couches dans l'ordre inverse ? (slide 39)
Réponse

Parce que la perte est calculée à la fin : le gradient de la perte par rapport à une couche dépend de tout ce qui se passe après elle. On part de $\partial\ell/\partial\bz^{(L)} = \mathbf p-\by$ et chaque couche transforme le gradient reçu ($W\T\boldsymbol\delta$, $\odot\varphi'$) pour la couche précédente, en réutilisant ce qui a déjà été calculé. Voir la preuve « Pourquoi visiter les couches à l'envers » au §5.

Quelle erreur donnerait un programme valide mais un objectif d'apprentissage faux ? (slide 44)
Réponse

Appliquer une softmax avant CrossEntropyLoss, qui contient déjà la softmax : aucune erreur à l'exécution, la perte diminue même un peu, mais on optimise $-\log\mathrm{softmax}(\mathrm{softmax}(\bz))_y$ au lieu de la cross-entropy, avec des gradients écrasés. (Utiliser une softmax pour des étiquettes non exclusives est un autre exemple : le programme tourne, mais le modèle de probabilité est faux.)

Pour s'entraîner : exercices à trous (filtre « 5 · réseaux »).