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.

- Motiver la convolution à partir de la localité, de l'équivariance à la translation et du partage de paramètres.

- Définir la convolution 2D (corrélation croisée) utilisée en apprentissage profond.

- Calculer la taille de sortie à partir de la taille d'entrée, du noyau, du remplissage et du pas.

- Étendre un filtre à plusieurs canaux d'entrée et de sortie (cartes de caractéristiques).

- Utiliser le max pooling et l'average pooling pour sous-échantillonner et ajouter une petite invariance à la translation.

- Comparer le nombre de paramètres d'une convolution à celui d'une couche dense équivalente.

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.

*Remarque :* rappelez-vous la notation de l'Introduction. Une couche $l$ calcule $z^{[l]} = W^{[l]} a^{[l-1]} + b^{[l]}$ et $a^{[l]} = g^{[l]}(z^{[l]})$, avec un biais explicite $b^{[l]}$. Une convolution n'est qu'un $W^{[l]}$ structuré dont les entrées sont liées entre elles et majoritairement nulles, donc la même équation de couche reste valable.

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

L'intérêt du partage de paramètres, c'est la taille. Prenons une entrée de $32 \times 32 \times 3$ et une couche produisant une sortie de $32 \times 32 \times 16$ avec un noyau $3 \times 3$ (remplissage "same"). La convolution partage un petit banc de filtres sur toutes les positions, tandis qu'une couche dense reliant chaque entrée à chaque sortie ne le fait pas.

| Couche | Poids | Biais | Total des paramètres |

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

| Convolution ($3\times3$, $16$ filtres) | $3 \cdot 3 \cdot 3 \cdot 16 = 432$ | $16$ | $448$ |

| Couche dense équivalente | $(32\cdot32\cdot3)\cdot(32\cdot32\cdot16) \approx 5.0\times10^{10}$ | $16{,}384$ | $\approx 5.0\times10^{10}$ |

La convolution utilise quelques centaines de paramètres contre environ cinquante milliards pour la couche dense, et elle généralise mieux car le même détecteur de caractéristiques est réutilisé partout plutôt que réappris à chaque position.

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.

---

Suivant : [Architectures de CNN](/fr/Deep%20Learning/11%20CNN%20architectures) · [Vue d'ensemble du cours](/fr/Deep%20Learning)