Une couche dense traite une image comme un vecteur aplati, elle doit donc apprendre un poids distinct pour chaque pixel et oublie que les pixels voisins vont ensemble. Les réseaux convolutifs remplacent cette connectivité dense par un petit filtre qui glisse sur la grille, en réutilisant les mêmes poids partout. Ce module présente la convolution comme une couche structurée pour les données en grille, puis introduit progressivement le pas, le remplissage, les canaux et le pooling.

Considérons une image RVB modeste de $224 \times 224$. Aplatie, elle compte $224 \times 224 \times 3 \approx 150{,}000$ entrées, donc une seule couche dense avec ne serait-ce que $1{,}000$ unités porte environ $150$ millions de poids. Trois faits à propos des images rendent presque tous ces poids inutiles.

- **Localité** : un pixel s'explique par ses voisins (un contour, un coin, une texture), non par des pixels situés à l'autre extrémité de l'image.

- **Équivariance à la translation** : un contour reste un contour où qu'il apparaisse, donc le même détecteur devrait s'appliquer à chaque position. Décaler l'entrée décale la réponse de la même quantité.

- **Partage de paramètres** : parce que le détecteur est indépendant de la position, un petit ensemble de poids peut être réutilisé sur toute l'image au lieu d'apprendre de nouveaux poids par pixel.

Une couche convolutive intègre ces trois principes. Elle utilise un petit filtre (les poids partagés) appliqué à chaque emplacement (localité et équivariance), c'est pourquoi elle a besoin de plusieurs ordres de grandeur de paramètres en moins que la couche dense ci-dessus.

Soit $I$ une entrée 2D (un canal d'une image) et $K$ un noyau de taille $k \times k$. L'opération utilisée en apprentissage profond fait glisser $K$ sur $I$ et prend, à chaque position $(i, j)$, la somme des produits terme à terme entre le noyau et la fenêtre qu'il couvre :

$$\boxed{ (I * K)_{i,j} = \sum_{m}\sum_{n} I_{i+m,\, j+n}\, K_{m,n} }$$

Chaque valeur de sortie est un produit scalaire entre le noyau et une fenêtre locale de l'entrée, donc un petit noyau $3 \times 3$ regarde neuf pixels quelle que soit la taille de l'image.

*Remarque :* il s'agit techniquement d'une corrélation croisée. La convolution mathématique retourne d'abord le noyau, mais les bibliothèques d'apprentissage profond ne le retournent pas et parlent tout de même de convolution, car le noyau appris absorbe simplement le retournement. Nous suivons cette convention tout au long du cours.

Une couche convolutive applique cette opération, ajoute le biais explicite $b$, et passe le résultat à travers l'activation $g$ :

$$\boxed{ a^{[l]}_{i,j} = g\!\left( (a^{[l-1]} * K)_{i,j} + b \right) }$$

Le biais est un unique scalaire partagé sur chaque position de la sortie, exactement une instance de plus de partage de paramètres.

Deux hyperparamètres contrôlent la manière dont le noyau balaie l'entrée.

- **Pas** $s$ : le déplacement en pixels entre les positions successives du noyau. Un pas plus grand saute des positions et réduit la sortie.

- **Remplissage** $p$ : une bordure de $p$ zéros ajoutée autour de l'entrée. Elle permet au noyau d'atteindre les bords et contrôle la taille de sortie.

Pour une entrée 1D de taille $n$ (la même formule s'applique par axe en 2D), la taille de sortie est :

$$\boxed{ o = \left\lfloor \frac{n + 2p - k}{s} \right\rfloor + 1 }$$

*Remarque :* deux choix courants ont un nom. Le remplissage "valid" utilise $p = 0$, donc la sortie rétrécit de $k - 1$ avec un pas de $1$. Le remplissage "same" choisit $p$ de sorte que $o = n$ avec un pas de $1$, ce qui pour un noyau impair signifie $p = (k - 1)/2$.

Par exemple, avec $n = 32$, $k = 5$, $p = 0$, $s = 1$ la sortie est $\lfloor (32 - 5)/1 \rfloor + 1 = 28$. Ajouter $p = 2$ ("same") donne $\lfloor (32 + 4 - 5)/1 \rfloor + 1 = 32$.

Les vraies images ont des canaux (trois pour le RVB), et un noyau s'étend sur tous. Un filtre pour une entrée à $C_\text{in}$ canaux a la forme $k \times k \times C_\text{in}$, et sa convolution somme sur les positions spatiales et les canaux pour produire une seule sortie 2D, appelée **carte de caractéristiques**.

Pour détecter de nombreux motifs, une couche empile $C_\text{out}$ filtres de ce type, donc la couche a $C_\text{out}$ cartes de caractéristiques et sa sortie est un volume de forme $o \times o \times C_\text{out}$. Chaque carte de caractéristiques répond à un motif appris (une orientation de contour, une tache de couleur, plus tard une texture) à chaque position.

$$\boxed{ W^{[l]} \in \mathbb{R}^{\,k \times k \times C_\text{in} \times C_\text{out}}, \qquad b^{[l]} \in \mathbb{R}^{\,C_\text{out}} }$$

*Remarque :* le nombre de canaux de sortie $C_\text{out}$ d'une couche devient le nombre de canaux d'entrée $C_\text{in}$ de la suivante, donc la profondeur croît à mesure que la taille spatiale rétrécit. Il y a un biais par canal de sortie, c'est pourquoi $b^{[l]}$ a $C_\text{out}$ entrées.

Le pooling sous-échantillonne une carte de caractéristiques en résumant chaque petite fenêtre par un unique nombre, à l'aide d'une règle fixe et sans poids appris. Les deux règles courantes sont le maximum et la moyenne sur chaque fenêtre $k \times k$ :

$$\boxed{ \text{max}: \max_{m,n} a_{i+m,\, j+n} \qquad \text{avg}: \frac{1}{k^2}\sum_{m,n} a_{i+m,\, j+n} }$$

Le pooling avec un pas $s = k$ (fenêtres non chevauchantes) réduit chaque dimension spatiale d'un facteur $k$, ce qui diminue le calcul des couches suivantes. Il confère aussi une petite **invariance à la translation** : un max sur une fenêtre renvoie la même valeur si la réponse forte se déplace à l'intérieur de cette fenêtre.

*Remarque :* le pooling n'a aucun paramètre et réduit la résolution, c'est pourquoi les architectures modernes le remplacent souvent par des convolutions à pas. La convolution est équivariante à la translation (la réponse se déplace avec l'entrée), tandis que le pooling ajoute un peu d'invariance (la réponse ignore les petits déplacements).

Un étage typique enchaîne convolution, activation et pooling, transformant l'image brute en une pile de cartes de caractéristiques que les étages suivants affinent.

*Remarque :* empiler de tels étages fait croître le champ récepteur (la région d'entrée qui influence une valeur de sortie) avec la profondeur, donc les premières couches voient des contours et les couches profondes voient des objets entiers, le tout construit à partir de la même opération locale.

Les réseaux convolutifs marquants partagent tous la même forme : une pile d'étages de convolution et de pooling qui extrait des caractéristiques, puis une petite tête entièrement connectée qui les classe.

Chaque génération a apporté une idée à la même question, comment empiler plus de couches sans que le signal d'entraînement ne se dégrade :

- **LeNet**, l'original, alterne quelques étages de convolution et de pooling pour la reconnaissance de chiffres.

- **AlexNet** a mis ce squelette à l'échelle des grandes images et des GPU, rendu entraînable par les activations ReLU et le dropout.

- **VGG** a rendu chaque convolution $3 \times 3$ et tire sa profondeur de l'empilement : deux couches $3 \times 3$ voient la même région qu'une $5 \times 5$ avec moins de paramètres ($18c^2$ contre $25c^2$) et une non-linéarité de plus.

- **Inception** lance en parallèle des branches de plusieurs tailles de filtres et les concatène, à coût maîtrisé grâce aux convolutions $1 \times 1$, des applications par position sur les canaux qui compriment une carte épaisse avant les filtres coûteux.

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

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

| LeNet | 5 à 7 couches | pile de conv et pool |

| AlexNet | 8 couches | ReLU et dropout à grande échelle |

| VGG | 16 à 19 couches | piles de convolutions $3 \times 3$ |

| Inception | 22 couches | branches parallèles, goulot $1 \times 1$ |

| ResNet | 50 à 152 couches | connexions de saut résiduelles |

*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.