Les couches et opérations du module précédent se composent en réseaux complets, et une poignée d'architectures marquantes a façonné la manière dont ces pièces s'assemblent. Ce module passe en revue LeNet, AlexNet, VGG, Inception et ResNet, en dégageant l'idée unique apportée par chacune. Le fil conducteur est une quête de profondeur : comment empiler davantage de couches sans que le signal d'entraînement ne se dégrade, ce qui renvoie directement au problème du gradient qui s'évanouit vu à la leçon 7.

- Retracer la progression à partir des premières piles convolutives de LeNet et AlexNet.

- Expliquer pourquoi VGG a remplacé les grands filtres par des piles profondes de petites convolutions $3 \times 3$.

- Lire un module Inception comme des branches parallèles et comprendre la convolution $1 \times 1$ comme un goulot d'étranglement sur les canaux.

- Écrire le bloc résiduel $y = F(x, W) + x$ et relier la connexion de saut au flux du gradient.

- Comparer les cinq architectures selon la profondeur, l'idée clé et la contribution.

Toutes ces architectures partagent la même forme d'ensemble : une pile de couches de convolution et de pooling qui extraient des caractéristiques, suivie d'une petite tête entièrement connectée qui les classe.


LeNet est le réseau convolutif d'origine, conçu pour la reconnaissance de chiffres manuscrits. Il alterne couches de convolution et de pooling pour extraire des caractéristiques, puis se termine par des couches entièrement connectées pour la classification. Une couche $l$ calcule toujours $z^{[l]} = W^{[l]} a^{[l-1]} + b^{[l]}$ suivi de $a^{[l]} = g^{[l]}(z^{[l]})$, mais $W^{[l]}$ est désormais un banc de petits filtres partagés plutôt qu'une matrice dense. L'activation $g^{[l]}$ était une sigmoïde saturante ou une $\tanh$, et le réseau entier n'était profond que de quelques couches.

AlexNet a conservé le squelette convolution-puis-pooling mais l'a mis à l'échelle de grandes images naturelles et l'a entraîné sur des GPU. Deux idées de ce cours ont rendu l'entraînement profond réalisable à cette échelle. D'abord, l'activation ReLU

$$\boxed{\ g(z) = \max(0, z)\ }$$

a remplacé la sigmoïde saturante, si bien que le gradient vaut $1$ partout où $z > 0$ et ne s'évanouit pas pour de grandes entrées positives. Ensuite, le dropout met aléatoirement à zéro une fraction $p$ des activations pendant l'entraînement, ce qui régularise les grandes couches entièrement connectées :

$$\boxed{\ a^{[l]} \leftarrow \frac{1}{1-p}\, m \odot a^{[l]}, \quad m_j \sim \text{Bernoulli}(1-p)\ }$$

*Remarque :* le masque $m$ est appliqué terme à terme via le produit de Hadamard $\odot$, et le facteur $1/(1-p)$ maintient l'activation espérée inchangée, de sorte qu'aucune remise à l'échelle n'est nécessaire au moment du test.

VGG a fait un seul choix de conception et l'a poussé à fond : chaque convolution est $3 \times 3$, et la profondeur vient de l'empilement d'un grand nombre d'entre elles. Deux convolutions $3 \times 3$ empilées voient la même région d'entrée qu'une seule convolution $5 \times 5$, et trois empilées voient la même région qu'une seule $7 \times 7$. La pile est moins coûteuse et plus expressive, car elle insère une non-linéarité entre chaque couche tout en utilisant moins de paramètres.

Pour un filtre de côté $k$ qui envoie $c_{\text{in}}$ canaux d'entrée vers $c_{\text{out}}$ canaux de sortie, le nombre de poids est

$$\boxed{\ \#\text{params} = k^2 \cdot c_{\text{in}} \cdot c_{\text{out}} \ }$$

donc avec $c_{\text{in}} = c_{\text{out}} = c$ une seule couche $5 \times 5$ coûte $25 c^2$ poids, tandis que deux couches $3 \times 3$ coûtent $2 \cdot 9 c^2 = 18 c^2$. La pile plus profonde est à la fois plus petite et ajoute un ReLU supplémentaire.

*Remarque :* c'est cette structure régulière qui a fait de VGG un backbone de prédilection. La contrepartie est le coût, car sa large tête entièrement connectée contient la plupart des paramètres.

Au lieu de choisir une seule taille de filtre, un module Inception (GoogLeNet) en exécute plusieurs en parallèle et concatène leurs sorties le long de l'axe des canaux. Une branche est $1 \times 1$, une est $3 \times 3$, une est $5 \times 5$, et une est une branche de pooling, de sorte que le réseau apprend quelle échelle importe à chaque étape plutôt que de la fixer à la main.

L'astuce clé est la convolution $1 \times 1$. Elle n'a aucune étendue spatiale, donc elle ne mélange pas les pixels voisins. Elle agit plutôt comme une application linéaire par position à travers les canaux, calculant à chaque position spatiale $(i, j)$

$$\boxed{\ y_{ij} = W\, a_{ij} + b, \quad W \in \mathbb{R}^{c_{\text{out}} \times c_{\text{in}}}\ }$$

Choisir $c_{\text{out}} < c_{\text{in}}$ en fait un goulot d'étranglement sur les canaux : elle projette une carte de caractéristiques épaisse vers moins de canaux avant une coûteuse convolution $3 \times 3$ ou $5 \times 5$, réduisant nettement le coût de cette convolution. C'est pourquoi Inception peut être à la fois large et abordable.

*Remarque :* une convolution $1 \times 1$ suivie d'un ReLU est exactement un petit réseau entièrement connecté appliqué de manière identique à chaque position spatiale, partageant une même matrice de poids $W$ sur toute la carte de caractéristiques.

Les piles profondes ordinaires s'entraînent moins bien que les peu profondes, non pas parce qu'elles surapprennent mais parce que le signal se dégrade. ResNet corrige cela en faisant apprendre à chaque bloc un résidu et en réinjectant l'entrée via une connexion de saut :

$$\boxed{\ y = F(x, W) + x\ }$$

Ici $F$ est une courte pile de convolutions de poids $W$, et le terme $+x$ est le saut identité. Si l'application optimale d'un bloc est proche de l'identité, le réseau n'a qu'à pousser $F$ vers zéro, ce qui est bien plus facile que d'apprendre l'identité à partir de zéro à travers plusieurs couches non linéaires.


En dérivant le bloc, le saut apporte un terme identité au jacobien :

$$\boxed{\ \frac{\partial y}{\partial x} = \frac{\partial F}{\partial x} + I\ }$$

Lors de la rétropropagation, le gradient amont est multiplié par ce facteur à chaque bloc. Le terme $+I$ donne au gradient une route directe vers l'arrière qui ne rétrécit jamais, si bien que même lorsque les contributions $\partial F / \partial x$ sont petites, le produit à travers de nombreux blocs ne s'effondre pas vers zéro. C'est le remède direct au problème du gradient qui s'évanouit de la leçon 7, où la multiplication répétée par de petits jacobiens dans une pile profonde ordinaire réduit à néant les gradients des premières couches. Avec les connexions de saut, des réseaux de centaines de couches s'entraînent de manière fiable.

*Remarque :* lorsque $F$ change le nombre de canaux ou la taille spatiale, le saut utilise une convolution $1 \times 1$ pour ajuster les dimensions afin que la somme $F(x, W) + x$ soit bien définie.

| Architecture | Profondeur approx. | Idée clé | Contribution |

| --- | --- | --- | --- |

| LeNet | 5 à 7 couches | pile de conv et pool | premier CNN fonctionnel pour les chiffres |

| AlexNet | 8 couches | ReLU et dropout à grande échelle | CNN profonds sur grandes images et GPU |

| VGG | 16 à 19 couches | piles de convolutions $3 \times 3$ | profondeur par petits filtres uniformes |

| Inception | 22 couches | modules multi-branches, goulot $1 \times 1$ | largeur et efficacité ensemble |

| ResNet | 50 à 152 couches | bloc résiduel $y = F(x, W) + x$ | entraîne des réseaux très profonds |

*Remarque :* la tendance est monotone en profondeur, et chaque saut a été débloqué par une correction spécifique : de meilleures activations, des filtres plus petits, des goulots d'étranglement sur les canaux, et enfin les connexions de saut.

---

Suivant : [Plongements et apprentissage de représentations](/fr/Deep%20Learning/12%20Embeddings%20and%20representation%20learning) · [Vue d'ensemble du cours](/fr/Deep%20Learning)