~/teaching · machine learning · référence

Le deep learning, l'essentiel : rétropropagation, batch norm, ResNet, convolution, LSTM, attention, VAE et GAN, dérivés et vérifiés

Neuf notions dans l'ordre où elles dépendent les unes des autres, chacune avec un calcul à la main, sa dérivation et dix lignes de PyTorch.

Sitraka Forler, Centrale Méditerranée

Révision 16 octobre 2026 · environ 22 minutes

Résumé

Ce deck de référence du cours de Machine Learning de Centrale Méditerranée (option DDEFI, 2026-2027) n'est pas une séance. C'est le document qu'on ouvre quand un article, un entretien d'embauche ou un collègue parle de connexion résiduelle, de batch norm ou d'attention, et qu'on veut savoir en quelques minutes ce que c'est, pourquoi on l'a inventé et comment le vérifier à la main. Il reprend là où s'arrête la séance sur les réseaux de neurones : le neurone, la rétropropagation, Adam, l'initialisation et le dropout sont supposés connus.

Neuf notions sont traitées, dans l'ordre de leurs dépendances plutôt que dans celui des manuels : le graphe de calcul, ce qu'estime un réseau entraîné à l'erreur quadratique sur des cibles 0/1, le pas de gradient et le conditionnement, la normalisation et la batch norm, la profondeur et ResNet, la convolution, les réseaux récurrents et la LSTM, l'attention, puis les modèles génératifs (autoencodeur, VAE, GAN). Chacune suit la même grille : l'idée avec un petit exemple chiffré, la formule symbole par symbole, la dérivation seule comme au tableau, les mêmes lignes expliquées, une vérification, un court listing PyTorch, l'histoire et l'état de l'art actuel.

Le deck s'adresse à un groupe en deux moitiés, ceux qui préfèrent les dérivations et ceux qui préfèrent le code, et demande à chaque moitié de lire la piste de l'autre. À la fin, vous savez refaire chaque dérivation sur papier, prédire le nombre qu'un listing va afficher, et lire une architecture dans un article ou une fiche de modèle en sachant pourquoi elle a cette forme.

Les slides

Le deep learning, l'essentiel : les concepts clés, pourquoi les connaître, les maths au tableau, et un mini-TD

Référence. Machine Learning, Centrale Méditerranée, option DDEFI, 2026-2027.

Ouvrir les slides (mot de passe donné par l'enseignant)

Le deck lui-même est chiffré pour les élèves du cours ; cette page le résume pour tous.

La page du cours · L'attention et le transformer, pas à pas

Plan du deck

Comment lire le deck. Deux pistes, maths et code, les acquis de la séance 8, et pourquoi le deep learning compte pour le texte, les documents et la simulation alors que le boosting gagne encore sur les tables.
Graphe de calcul. Une formule vue comme un graphe, la règle de la chaîne arête par arête, le passage arrière sur un neurone, et la différentiation automatique en mode inverse, de 1964 à PyTorch.
MSE et probabilité. Pourquoi l'erreur quadratique sur des cibles 0/1 estime la probabilité a posteriori, et ce que changent l'entropie croisée et la calibration.
Pas de gradient. Une vallée quadratique étroite, la Hessienne, le plus grand pas stable, le pas optimal et la vitesse fixée par le conditionnement.
Normaliser. La variance d'une somme pondérée, les constantes de Glorot et de He, la batch norm, le gradient qui la traverse, et ses cousines.
Profondeur. Pourquoi une couche de plus multiplie les morceaux affines, le problème de dégradation, le gradient qui s'évanouit et la connexion résiduelle.
Convolution. Un filtre local partagé calculé à la main, la taille de sortie, le nombre de paramètres, le champ réceptif et l'histoire de 1980 aux transformers de vision.
Séquences. Le réseau récurrent, le gradient à travers le temps, les portes de la LSTM et les plongements de mots.
Attention. Une moyenne pondérée par la ressemblance, la formule de 2017 terme par terme, la self-attention comme représentation en contexte, et le transformer.
Modèles génératifs et mini-TD. L'autoencodeur, la borne du VAE, le jeu du GAN et son discriminateur optimal, puis six exercices en version maths et en version code.

Le graphe de calcul : rétropropager, c'est remonter le graphe

Une formule se dessine comme une chaîne de petites opérations ; pour obtenir toutes les dérivées d'un coup, on parcourt cette chaîne depuis la fin, chaque boîte multipliant par sa propre pente.

Tout ce que fait une bibliothèque de deep learning quand on appelle loss.backward() repose sur une décomposition, le graphe de calcul (computational graph). La passe avant enregistre chaque opération élémentaire comme un nœud d'un graphe orienté sans cycle et en remplit la valeur. La passe arrière part de la perte, dont la dérivée par rapport à elle-même vaut 1, et visite les nœuds dans l'ordre inverse. Chaque nœud n'a besoin que de sa dérivée locale : une somme transmet le gradient reçu à chaque entrée sans le changer, un produit scalaire le multiplie par l'autre facteur, un carré le multiplie par deux fois son argument. Quand une grandeur atteint la perte par plusieurs chemins, on additionne les contributions ; c'est pourquoi les gradients s'accumulent dans PyTorch et doivent être remis à zéro avant chaque pas.

\frac{\partial L}{\partial w} = \frac{\partial L}{\partial \hat y}\cdot\frac{\partial \hat y}{\partial u}\cdot\frac{\partial u}{\partial w}, \qquad u = w^{\T}x,\quad \hat y = u + b,\quad L = (y - \hat y)^2

(1)

Le neurone du deck : $x = (1, 1)$ , $w = (0.8, -1.4)$ , $b = 0.6$ , cible $y = 1$

Passe avant. Le produit scalaire donne $u = 0.8 - 1.4 = -0.6$ , le biais ramène la prédiction à $\hat y = 0$ , et la perte quadratique vaut $L = 1$ .
Nœud de perte. La dérivée du carré vaut $-2(y - \hat y) = -2$ . Le signe dit qu'augmenter la prédiction ferait baisser la perte : on est sous la cible.
Nœud somme. Il transmet $-2$ tel quel au biais et à $u$ , donc le gradient de $b$ vaut $-2$ .
Nœud produit scalaire. Il multiplie par l'autre facteur, $x = (1, 1)$ , donc le gradient de $w$ vaut $(-2, -2)$ .
Un pas. Avec un pas d'apprentissage de 0,1, $w$ devient $(1.0, -1.2)$ et $b$ devient 0,8, la prédiction monte à 0,6 et la perte tombe de 1 à 0,16.

import torch
x = torch.tensor([1.0, 1.0])
w = torch.tensor([0.8, -1.4], requires_grad=True)
b = torch.tensor(0.6, requires_grad=True)
loss = (1.0 - (w @ x + b)) ** 2   # le graphe est enregistre ici
loss.backward()                    # parcours du graphe a l envers
print(w.grad, b.grad)              # tensor([-2., -2.]) tensor(-2.)

La propriété décisive est le coût. La différentiation automatique (automatic differentiation) en mode inverse (Linnainmaa, 1970, rendue célèbre pour les réseaux par Rumelhart, Hinton et Williams en 1986) donne le gradient par rapport à tous les paramètres pour le prix d'environ une passe avant, là où les différences finies demanderaient une passe par paramètre. C'est ce qui rend entraînable un modèle d'un milliard de poids. La même technique, sous le nom de différentiation algorithmique adjointe (AAD), calcule toutes les sensibilités d'un portefeuille en une seule passe arrière dans les salles de marché. Sa limite pratique est la mémoire, pas le calcul : le graphe garde toutes les activations intermédiaires, d'où le gradient checkpointing.

Retour au sommaire.

Ce qu'estime la perte, et à quelle vitesse le pas y arrive

Un classifieur entraîné à l'erreur quadratique sur des étiquettes 0/1 finit par prédire une probabilité, et la descente de gradient avance au rythme de la direction la plus plate, avec un pas plafonné par la plus raide.

L'erreur quadratique sur des cibles 0/1 apprend la probabilité a posteriori

Fixons une entrée $x$ et supposons qu'une part $p$ des clients ayant exactement ce profil fasse défaut. L'erreur quadratique moyenne d'une prédiction $F$ sur ces clients est une parabole en $F$ dont le minimum est en $p$ . Avec $p = 0.7$ , le risque vaut 0,250 en $F = 0.5$ , 0,210 en $F = 0.7$ et de nouveau 0,250 en $F = 0.9$ . Un modèle assez souple pour choisir librement sa valeur en chaque $x$ converge donc vers $P(y = 1 \mid x)$ ; rien n'est propre aux réseaux, et un modèle contraint n'atteint que le meilleur compromis au sein de sa famille.

\mathbb{E}_{y\mid x}\big[(F - y)^2\big] = F^2 - 2pF + p \;\Rightarrow\; F^{*}(x) = p = P(y = 1 \mid x)

(2)

L'entropie croisée a le même minimiseur. Ce qui diffère, c'est le gradient par rapport au logit : en erreur quadratique il porte le facteur $\sigma(1 - \sigma)$ , qui écrase l'apprentissage quand un neurone se trompe avec assurance, alors qu'en entropie croisée il vaut simplement $\sigma - y$ . Deux mises en garde pratiques en découlent. Un score n'est une probabilité que si le modèle est calibré, ce qu'on vérifie sur une courbe de fiabilité comme dans la séance sur les seuils de décision. Et suréchantillonner les défauts change le $p$ appris, si bien que la sortie doit être corrigée avant d'être lue comme une probabilité.

La Hessienne et le conditionnement

Près d'un minimum, la perte se comporte comme une cuvette quadratique décrite par sa Hessienne $H$ . Écrit dans la base de ses vecteurs propres, un pas de gradient multiplie la distance au minimum le long de l'axe $i$ par $1 - \varepsilon\lambda_i$ : chaque axe suit sa propre suite géométrique. L'axe le plus raide fixe le plus grand pas qui ne diverge pas, l'axe le plus plat fixe la vitesse, et leur rapport, le conditionnement (condition number) $\kappa$ , résume la difficulté du problème.

w_t - w^{*} = \sum_i a_i (1 - \varepsilon\lambda_i)^{t} u_i, \qquad \varepsilon < \frac{2}{\lambda_{\max}}, \qquad \varepsilon^{*} = \frac{2}{\lambda_{\min} + \lambda_{\max}}, \qquad \text{taux} = \frac{\kappa - 1}{\kappa + 1}

(3)

**Tableau 1 :** La cuvette du deck, $H = \mathrm{diag}(1, 10)$ , partie de $(10, 10)$ : position après $t$ pas pour trois tailles de pas.
Pas $\varepsilon$	$t = 1$	$t = 5$	$t = 20$	Destin
0,10	(9,00 ; 0,00)	(5,90 ; 0,00)	(1,22 ; 0,00)	axe raide réglé d'un coup, axe plat qui rampe
2/11, optimal	(8,18 ; −8,18)	(3,67 ; −3,67)	(0,18 ; 0,18)	les deux axes rétrécissent de 9/11 par pas
0,21	(7,90 ; −11,00)	(3,08 ; −16,11)	(0,09 ; 67,27)	au-delà de 2/10 = 0,2, l'axe raide diverge

Le calcul se vérifie : $10 \times 0.9^{20} \approx 1.22$ et $10 \times (9/11)^{20} \approx 0.18$ . La leçon pour un projet est que la vitesse de convergence dépend de $\kappa$ , pas du nombre de paramètres. Une perte qui explose signale un pas au-dessus de $2/\lambda_{\max}$ ; une perte qui ne bouge plus signale un $\kappa$ élevé, et c'est exactement ce que s'attachent à réduire la normalisation et les pas par coordonnée d'Adam.

Retour au sommaire.

Normalisation et batch norm, avec le gradient qui la traverse

Chaque couche doit passer à la suivante des nombres d'une taille raisonnable ; une initialisation soignée fixe cette échelle au départ, et la batch norm la rétablit pendant l'entraînement, lot après lot.

Une pré-activation est une somme de $d$ produits de termes centrés indépendants, donc sa variance vaut $d\sigma^2$ quand les poids ont pour écart-type $\sigma$ . Avec 100 entrées standardisées et $\sigma = 1$ , la simulation du deck donne une variance proche de 120 : une sigmoïde reçoit alors des valeurs autour de ±10, sature et ne laisse plus passer de gradient. Choisir $\sigma = 1/\sqrt{d}$ ramène la variance à 1. Sur $L$ couches, la variance est multipliée par $(d\sigma^2)^L$ : c'est la face « passe avant » du gradient qui s'évanouit.

\mathrm{Var}(a) = d\,\sigma^{2}, \qquad \text{Glorot : } \sigma^{2} = \frac{2}{d + N_h}, \qquad \text{He (ReLU) : } \sigma^{2} = \frac{2}{d}

(4)

Glorot et Bengio (2010) font la moyenne de la contrainte de l'aller ( $1/d$ ) et de celle du retour ( $1/N_h$ ) ; la version uniforme de leur règle a la même variance. He et ses coauteurs (2015) doublent la variance pour ReLU, qui éteint la moitié des unités. L'initialisation ne fixe toutefois l'échelle qu'au départ. La normalisation par lots (batch norm) (Ioffe et Szegedy, 2015) centre et réduit chaque unité sur le mini-lot courant, puis laisse le réseau remettre à l'échelle avec deux paramètres appris $\gamma$ et $\beta$ , pour qu'il puisse défaire la normalisation là où elle gêne.

\hat x_i = \frac{x_i - \mu_B}{\sqrt{\sigma_B^{2} + \epsilon}}, \qquad y_i = \gamma\,\hat x_i + \beta

(5)

La question d'entretien classique porte sur la passe arrière. Le piège est que chaque entrée agit sur la perte de trois façons : directement, via la moyenne du lot et via sa variance, puisque toutes deux dépendent de chaque $x_i$ . En additionnant les trois chemins et en factorisant, on obtient un résultat compact : le gradient sortant est le gradient entrant, moins sa moyenne, moins sa projection sur $\hat x$ , à l'échelle $\gamma/\sigma_B$ . Cela traduit l'invariance de la couche à une translation et à un changement d'échelle de ses entrées.

\frac{\partial \ell}{\partial \beta} = \sum_i g_i, \quad \frac{\partial \ell}{\partial \gamma} = \sum_i g_i\hat x_i, \quad \frac{\partial \ell}{\partial x_i} = \frac{\gamma}{m\sqrt{\sigma_B^{2} + \epsilon}}\Big[m\,g_i - \sum_j g_j - \hat x_i \sum_j g_j\hat x_j\Big]

(6)

Le lot de quatre du deck : $x = (1, 2, 4, 5)$ , $\gamma = 2$ , $\beta = 0.5$ , gradient entrant $g = (1, 0, -1, 2)$

Statistiques. La moyenne du lot vaut 3 et la variance (divisée par $m = 4$ ) vaut 2,5, donc $\hat x = (-1.265, -0.632, 0.632, 1.265)$ et $y = (-2.030, -0.765, 1.765, 3.030)$ .
Paramètres. Le gradient de $\beta$ est la somme des $g_i$ , soit 2 ; celui de $\gamma$ vaut $\sum g_i \hat x_i = 0.632$ .
Entrées. Le facteur d'échelle vaut $2/(4\sqrt{2.5}) = 0.316$ , et le crochet donne le gradient des entrées $(0.885, -0.506, -2.024, 1.644)$ .
Vérification. L'autograd de PyTorch rend les mêmes quatre nombres à $10^{-4}$ près, ce qui referme la boucle avec le graphe de calcul.

Remarque (Le piège de model.eval()). En inférence, un exemple seul n'a pas de lot : la couche utilise les moyennes glissantes accumulées à l'entraînement. Oublier de passer le modèle en mode évaluation rend les prédictions dépendantes des autres exemples du lot. Sous environ 16 exemples par lot, les statistiques du lot sont du bruit : la layer norm (par exemple, sur ses unités) ou la group norm prennent le relais, et les transformers utilisent toujours la layer norm ou sa variante RMSNorm.

Retour au sommaire.

La profondeur, le gradient qui s'évanouit et la connexion résiduelle

Des couches en plus découpent l'entrée en bien plus de morceaux que des neurones en plus, mais le signal d'erreur s'affaiblit en redescendant, et ResNet corrige cela en ajoutant l'entrée de chaque bloc à sa sortie.

Un réseau ReLU est affine par morceaux, et chaque couche cachée plie l'espace d'entrée, ce qui multiplie le nombre de régions linéaires au lieu de l'augmenter d'un terme (Pascanu, Montúfar et Bengio, 2014). Prenons deux entrées et douze unités ReLU au total : rangées en une seule couche, elles découpent le plan en 79 régions ; rangées en trois couches de quatre, elles en produisent au moins 176.

N_{\text{prof}} \ge 2^{(k-1)p_0}\sum_{j=0}^{p_0}\binom{2p_0}{j} = 2^{4}(1 + 4 + 6) = 176 \quad\text{contre}\quad \sum_{j=0}^{2}\binom{12}{j} = 79

(7)

Pourtant, empiler des couches simples échoue. He, Zhang, Ren et Sun (2015) ont montré un réseau de 56 couches avec une erreur d'entraînement plus forte qu'un réseau de 20, alors qu'il pourrait copier le réseau court en mettant ses couches en trop à l'identité : la capacité est là, l'optimiseur ne la trouve pas. La cause est un produit. Le gradient qui atteint la première couche est le gradient de sortie multiplié par une jacobienne par couche, et avec une sigmoïde chaque facteur vaut au plus le quart de la norme des poids. C'est l'évanouissement du gradient (vanishing gradient).

\frac{\partial \ell}{\partial h_{0}} = \frac{\partial \ell}{\partial h_{L}}\prod_{l=L}^{1}\mathrm{diag}\big(g'(a_l)\big)W_l, \qquad \big(\tfrac14\big)^{10} \approx 10^{-6}

(8)

Dix couches avec des poids d'échelle 1 livrent donc en bas un gradient un million de fois plus petit, et des facteurs supérieurs à 1 le font au contraire exploser. Les remèdes sont ReLU (un facteur de 0 ou 1), la normalisation, et la connexion résiduelle (residual connection) : chaque bloc apprend une correction $F$ et rajoute son entrée. Sa jacobienne vaut l'identité plus quelque chose, donc le produit contient toujours un chemin de norme 1. Initialiser la dernière batch norm de chaque bloc à $\gamma = 0$ fait démarrer le réseau comme l'identité ; c'est ainsi qu'on a entraîné 152 couches pour ImageNet 2015.

h_{l+1} = h_{l} + F(h_{l}), \qquad \frac{\partial h_{l+1}}{\partial h_{l}} = I + \frac{\partial F}{\partial h_{l}}

(9)

DenseNet, U-Net et les pertes auxiliaires de GoogLeNet sont des variantes du même chemin court pour le gradient, et tout transformer est une pile de blocs résiduels. Le deck clôt le chapitre par deux résultats qui bousculent la vision classique du surapprentissage (les réseaux savent apprendre des étiquettes tirées au hasard ; dans les grands réseaux, la plupart des minima locaux valent presque le minimum global) et par une grille de cinq questions pour lire n'importe quelle fiche de modèle : profondeur et largeur, activation, place de la normalisation, connexions résiduelles, et perte.

Retour au sommaire.

La convolution : un petit filtre, le même partout

Une couche convolutive fait glisser un seul petit détecteur sur toute l'image, si bien qu'elle demande très peu de poids et trouve un motif où qu'il apparaisse.

Un neurone dense regarde chaque pixel avec son propre poids ; un filtre convolutif regarde une petite fenêtre et réutilise les mêmes poids à chaque position. Les réseaux de neurones convolutifs (convolutional neural networks, CNN) reposent sur deux hypothèses : les motifs utiles sont locaux (un bord tient dans 3 × 3 pixels) et ils signifient la même chose partout dans l'image. Le deck calcule à la main un filtre de bord vertical sur une image 4 × 4 : en haut à gauche, la colonne de gauche moins celle de droite donne $(1 + 0 + 2) - (0 + 3 + 0) = 0$ , pas de bord ; un pixel plus à droite, elle donne $(2 + 1 + 1) - (1 + 1 + 0) = 2$ .

W_{\text{out}} = \Big\lfloor \frac{W + 2p - k}{s} \Big\rfloor + 1, \qquad \#\text{params} = k^{2} N_{\text{in}} N_{\text{f}} + N_{\text{f}}

(10)

**Tableau 2 :** La formule de taille de sortie sur quatre configurations du deck (largeur d'entrée $W$ , filtre $k$ , marge $p$ , pas $s$ ).
Cas	$W$	$k$	$p$	$s$	$W_{\text{out}}$
LeNet, sans marge	32	5	0	1	28
marge « same »	32	3	1	1	32
un pas de 2 divise par deux	32	3	1	2	16
première couche de ResNet	224	7	3	2	112

Le partage des poids rend la couche économe. Six filtres 3 × 3 sur une image couleur coûtent $3 \times 3 \times 3 \times 6 + 6 = 168$ paramètres, là où une couche dense reliant les mêmes entrées 32 × 32 × 3 aux mêmes sorties 6 × 28 × 28 en demanderait environ 14,5 millions. Le calcul reste conséquent, environ 127 000 multiplications-additions pour cette seule petite image, car chaque filtre est évalué à chaque position : les convolutions portent le calcul, les couches denses finales portent les paramètres, et la moyenne globale (global average pooling) supprime l'essentiel de ces derniers.

Le champ réceptif (receptive field), la zone de l'image dont dépend une unité profonde, grandit de $k - 1$ par couche, multiplié par les pas accumulés en dessous. Trois couches 3 × 3 empilées voient 7 pixels, comme un seul filtre 7 × 7, pour 27 poids contre 49, et avec deux non-linéarités supplémentaires ; VGG s'est construit sur cet argument. L'histoire va du néocognitron de Fukushima (1980) et du LeNet-5 de LeCun qui lisait des chèques bancaires (1998) à AlexNet en 2012, quand l'erreur top-5 sur ImageNet est passée de 26 % à 15 %, puis à ResNet et aux transformers de vision. En entreprise, les usages sont la lecture de documents (dossiers KYC, factures), les images satellites, et l'ajustement d'un réseau pré-entraîné sur quelques milliers d'images maison.

Retour au sommaire.

Séquences et attention : de la LSTM au transformer

Un réseau récurrent lit une séquence pas à pas en tenant un résumé, la LSTM permet de recopier ce résumé sans qu'il s'efface, et l'attention remplace le résumé par un regard pondéré sur chaque élément.

Les réseaux récurrents (recurrent neural networks, RNN) mettent à jour un état caché de taille fixe à partir de l'état précédent et de l'entrée courante, avec les trois mêmes matrices à chaque pas. Déroulé dans le temps, c'est un réseau profond ordinaire dont les couches partagent leurs poids, entraîné par rétropropagation à travers le temps. Le gradient du pas $T$ jusqu'au pas 1 est encore un produit de jacobiennes, mais avec la même matrice $V$ à chaque fois, si bien que sa norme se comporte comme une puissance de $\|V\|$ : en pratique, un RNN simple n'apprend pas de dépendances au-delà de dix ou vingt pas. Couper le gradient (gradient clipping) traite l'explosion ; changer de cellule traite l'effacement.

h_t = \tanh(V h_{t-1} + U x_t), \qquad c_t = f_t \odot c_{t-1} + i_t \odot \tilde c_t, \qquad \frac{\partial c_t}{\partial c_{t-1}} = \mathrm{diag}(f_t)

(11)

La LSTM (Hochreiter et Schmidhuber, 1997) tient une mémoire $c$ mise à jour par addition, contrôlée par des portes sigmoïdes d'oubli, d'écriture et de sortie. Avec une mémoire précédente de 3 et un candidat de −1, les portes $f = 1, i = 0$ recopient le passé ( $\tanh 3 \approx 0.995$ ), $f = 0, i = 1$ le remplacent ( $\tanh(-1) \approx -0.762$ ), et $f = i = 0.5$ mélangent les deux ( $\tanh 1 \approx 0.762$ ). Quand la porte d'oubli est ouverte, le gradient franchit un pas de temps multiplié par un nombre proche de 1 : le chemin additif que ResNet redécouvrira pour la profondeur. Les plongements (embeddings) de mots (word2vec, 2013) font de chaque mot une ligne apprise d'une table, si bien que les mots employés dans des contextes voisins finissent proches.

Le mécanisme d'attention (attention) est une recherche adoucie : pour une requête, on note chaque élément par sa ressemblance, on transforme les notes en poids par un softmax, et on rend la moyenne pondérée. Dans l'exemple du deck, les trois éléments sont $(1, 0)$ , $(0, 1)$ et $(1, 1)$ , et la requête est le troisième.

**Tableau 3 :** Une requête, trois éléments : scores en produit scalaire, poids du softmax et sortie pondérée.
Élément	Vecteur	Score $\langle e_i, q\rangle$	Poids $\alpha_i$
1	(1, 0)	1	0,212
2	(0, 1)	1	0,212
3	(1, 1)	2	0,576
Sortie	(0,788 ; 0,788)		1,000

\mathrm{Attention}(Q, K, V) = \softmax\!\Big(\frac{QK^{\T}}{\sqrt{d_k}}\Big)V, \qquad Q = XW_Q,\ K = XW_K,\ V = XW_V

(12)

En self-attention, chaque mot est tour à tour la requête, et trois projections apprises lui font jouer trois rôles : demander, être trouvé, être lu. La division par $\sqrt{d_k}$ reprend l'argument de variance de la section sur la normalisation : un produit scalaire de $d_k$ termes de variance 1 a une variance $d_k$ , et quand ses entrées sont grandes, le softmax se fige en un argmax dur dont le gradient est nul. L'exemple de phrase du deck montre le bénéfice : à côté de « orange », le vecteur d'« Apple » glisse vers le fruit, à côté de « Microsoft » vers l'entreprise, ce que des plongements fixes ne savent pas faire. Le coût est quadratique en la longueur du contexte. L'exemple complet, avec toutes les matrices, est dans l'article L'attention, pas à pas.

import torch, math

def attention(Q, K, V):
    # scores divises par sqrt(d_k), softmax par ligne, puis moyenne ponderee de V
    w = torch.softmax(Q @ K.T / math.sqrt(K.shape[1]), dim=-1)
    return w @ V

E = torch.tensor([[1., 0.], [0., 1.], [1., 1.]])
print(torch.softmax(E @ E[2], dim=0))   # poids sans division : 0.212, 0.212, 0.576
print(attention(E, E, E)[2])           # sortie avec division : environ (0.752, 0.752)

Retour au sommaire.

Modèles génératifs : autoencodeur, VAE et GAN

Les modèles génératifs apprennent à quoi ressemblent les données normales, soit pour en tirer de nouveaux exemples, soit pour signaler ce qui détonne, et le VAE et le GAN y parviennent par deux chemins très différents.

Un autoencodeur comprime $x$ en un code court $z$ puis le reconstruit ; le goulot est obligatoire, sinon recopier l'entrée est une solution parfaite et inutile. Avec des couches linéaires et une perte quadratique, il retrouve l'analyse en composantes principales. Entraîné sur des transactions normales, il reconstruit mal ce qu'il n'a jamais vu, ce qui fait de l'erreur de reconstruction un signal de fraude ou de panne ; son seuil d'alerte se choisit comme tout seuil de score, en pesant fausses alertes contre cas manqués. Il ne sait pourtant pas générer : les codes ne remplissent pas une région régulière, et un $z$ tiré au hasard ne décode rien de sensé.

L'auto-encodeur variationnel (variational autoencoder, VAE) (Kingma et Welling, 2013) fait rendre à l'encodeur une gaussienne sur $z$ et place une loi a priori gaussienne standard sur les codes. La vraisemblance elle-même est incalculable, donc le modèle maximise une borne inférieure obtenue en quatre lignes : intégrer sur $z$ , multiplier et diviser par la densité de l'encodeur, appliquer l'inégalité de Jensen au logarithme concave, et reconnaître une divergence de Kullback-Leibler. Cette borne inférieure de la vraisemblance (evidence lower bound, ELBO) a deux termes lisibles.

\ln p_\theta(x) \ge \mathbb{E}_{q_e(z\mid x)}\big[\ln p_\theta(x \mid z)\big] - D_{\mathrm{KL}}\big(q_e(z\mid x)\,\|\,p(z)\big), \qquad D_{\mathrm{KL}} = \tfrac12\sum_k\big(\mu_k^{2} + \sigma_k^{2} - 1 - \ln\sigma_k^{2}\big)

(13)

Le premier terme veut que le code dise tout de $x$ , le second qu'il ne dise rien de particulier ; leur compromis est le goulot sous forme probabiliste. La vérification du deck sur la forme close : pour une coordonnée avec $\mu = 1$ et $\sigma = 0.5$ , la divergence vaut $\tfrac12(1 + 0.25 - 1 - \ln 0.25) \approx 0.818$ . L'entraînement par gradient utilise la reparamétrisation $z = \mu(x) + \sigma(x)\xi$ avec un bruit gaussien standard $\xi$ , pour que l'aléa reste hors des paramètres.

Les réseaux antagonistes génératifs (generative adversarial networks, GAN) (Goodfellow et ses coauteurs, 2014) n'écrivent aucune densité. Un générateur transforme du bruit en exemples, un discriminateur est un classifieur ordinaire vrai ou faux entraîné à la log-vraisemblance, et les deux jouent un jeu min-max. À générateur fixé, le meilleur discriminateur s'obtient en maximisant l'intégrande point par point.

V = \mathbb{E}_{p_{\text{data}}}[\ln D(x)] + \mathbb{E}_{p_z}[\ln(1 - D(G(z)))], \qquad D^{*}(x) = \frac{p_{\text{data}}(x)}{p_{\text{data}}(x) + p_g(x)}, \qquad \max_D V = -\ln 4 + 2\,\mathrm{JSD}(p_{\text{data}}\,\|\,p_g)

(14)

Dans l'illustration du deck, un point où la densité des données vaut 0,3 et celle du générateur 0,1 reçoit $D^{*} = 0.75$ , et à l'équilibre la valeur du jeu vaut $-\ln 4 \approx -1.386$ . Face au meilleur discriminateur, le générateur minimise donc une divergence de Jensen-Shannon, nulle seulement s'il reproduit la loi des données. En pratique, le VAE a tendance à flouter et le GAN à oublier des modes ; les pertes de Wasserstein et la normalisation spectrale stabilisent les GAN, et la FID mesure la qualité, à côté d'un œil humain. Depuis 2021, les modèles de diffusion ont pris les images, le son et la vidéo, tandis que GAN et VAE restent dans les outils de données synthétiques tabulaires comme CTGAN, utilisés en finance pour partager un jeu de données sans exposer les clients et pour construire des scénarios de stress.

Remarque (Le mini-TD). Le deck se termine par six exercices de quinze minutes, un par chapitre calculable (le graphe, le pas de gradient, la batch norm, tailles de convolution et champ réceptif, l'attention avec une température, le discriminateur optimal et une divergence de VAE), chacun proposé sur papier pour la piste maths et en notebook pour la piste code, avec un même résultat attendu des deux côtés. Ils se font en binôme mixte ; leurs corrigés restent dans le deck et ne sont pas reproduits ici.

Retour au sommaire.

À retenir

La rétropropagation parcourt le graphe de calcul à l'envers : chaque nœud multiplie le gradient par sa dérivée locale, et les chemins qui se rejoignent s'additionnent.
Minimiser l'erreur quadratique, ou l'entropie croisée, face à une étiquette 0/1 revient à estimer sa probabilité ; l'entropie croisée apprend plus vite quand un neurone se trompe avec assurance, et la calibration reste à vérifier.
Le pas de gradient est plafonné par la direction la plus raide de la perte et sa vitesse fixée par la plus plate : tout dépend du conditionnement.
Garder les activations à variance 1 couche après couche ; la batch norm apprend son échelle et son décalage et renvoie un gradient centré et décorrélé des entrées normalisées.
Les gradients traversent les couches en se multipliant, ce qui les éteint ou les fait exploser ; la connexion résiduelle ajoute un chemin identité qui les laisse toujours passer.
Une convolution est un filtre local partagé, avec peu de paramètres et un champ réceptif qui grandit avec la profondeur ; une LSTM recopie sa mémoire grâce à une addition.
L'attention est une moyenne des valeurs pondérée par un softmax des ressemblances requête-clé ; le VAE maximise une borne sur la vraisemblance, le GAN entraîne un générateur contre un classifieur.

Glossaire

graphe de calcul (computational graph): Le graphe orienté sans cycle des opérations élémentaires, enregistré pendant la passe avant et parcouru à l'envers pour obtenir les gradients.
différentiation automatique (automatic differentiation): Le calcul exact des dérivées par la règle de la chaîne, nœud par nœud ; le mode inverse donne tous les gradients d'une sortie en une seule passe arrière.
conditionnement (condition number): Le rapport entre la plus grande et la plus petite valeur propre de la Hessienne ; il fixe la vitesse de convergence de la descente de gradient.
normalisation par lots (batch norm): Une couche qui centre et réduit chaque unité avec les statistiques du mini-lot, puis la remet à l'échelle avec deux paramètres appris.
évanouissement du gradient (vanishing gradient): Le rétrécissement du gradient multiplié par une jacobienne par couche, ou par pas de temps, sur le chemin du retour.
connexion résiduelle (residual connection): L'ajout de l'entrée d'un bloc à sa sortie, pour que le bloc apprenne une correction et que le gradient garde un chemin direct.
réseaux de neurones convolutifs (convolutional neural networks, CNN): Des réseaux faits de petits filtres dont les poids sont partagés sur toutes les positions d'une image ou d'un signal.
champ réceptif (receptive field): La zone de l'entrée qui influence une unité donnée ; il grandit avec la taille des filtres et les pas accumulés.
réseaux récurrents (recurrent neural networks, RNN): Des réseaux qui mettent à jour un état caché à chaque pas d'une séquence, avec les mêmes poids.
plongements (embeddings): Des vecteurs appris qui représentent une catégorie, par exemple un mot, rangés comme les lignes d'une table entraînable.
mécanisme d'attention (attention): Une moyenne pondérée de valeurs, dont les poids sont un softmax des ressemblances entre une requête et des clés.
borne inférieure de la vraisemblance (evidence lower bound, ELBO): La borne calculable de la log-vraisemblance que maximise un VAE : la reconstruction moins un terme de Kullback-Leibler.
auto-encodeur variationnel (variational autoencoder, VAE): Un autoencodeur dont l'encodeur rend une loi sur les codes, entraîné sur l'ELBO, et dont on peut tirer de nouveaux exemples.
réseaux antagonistes génératifs (generative adversarial networks, GAN): Un générateur et un discriminateur entraînés l'un contre l'autre ; à l'optimum, le générateur reproduit la loi des données.

Les autres fiches du cours

Un résumé public par deck, dans l'ordre du cours.

IntroductionHivers de l'IA, emploi et méthode
OutilsKaggle, GitHub, Python : les outils
Séance 1Cadrage de projet et moindres carrés
Séance 2Vraisemblance et régression logistique
Séance 3Descente de gradient, ridge et lasso
Séance 4Seuil de décision et ML reproductible
DevoirUn modèle de référence défendable
Séance 5Noyaux, SVM et arbres de décision
Séance 6Forêts, boosting, comparaison honnête
Séance 7SHAP, équité, ACP et partitionnement
DevoirUn modèle champion documenté
Séance 8Réseaux de neurones, dérive, prédiction conforme
DevoirUn projet de machine learning livré
Séance 9Soutenir un projet de machine learning
RéférenceProjet de score de défaut de crédit
RéférenceRendements boursiers : XGBoost et sentiment
RéférenceLe code Python de chaque modèle
RéférenceDeep learning, l'essentiel
RéférenceDonnées ouvertes et projets par secteur
RéférenceManuel de l'expert data et IA
RéférenceData engineering, SRE et cloud
RéférencePanorama des modèles de machine learning

Toutes les fiches, en liste de lecture

L'attention et le transformer, pas à pas

À propos de ces fiches

Écrites par l'enseignant à partir des slides du deck, comme un résumé public : les idées clés, les formules et un exemple calculé. Les exercices, leurs corrigés, les contrôles et la notation restent dans le deck, pour les élèves du cours.

Révision : 16 octobre 2026.