10. Réseaux convolutifs
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.
Objectifs
- 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.
- Reconnaître les architectures marquantes, de LeNet à ResNet, et l'idée que chacune a apportée.
10.1 Pourquoi pas une couche dense
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.
10.2 La convolution 2D
10.2.1 Corrélation croisée
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.
Une convolution fait glisser un petit noyau sur l'entrée, et chaque position produit une cellule de la carte de caractéristiques de sortie.
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.
10.2.2 La sortie de la couche
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.
10.3 Pas, remplissage et taille de sortie
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\).
10.4 Canaux et cartes de caractéristiques
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.
10.5 Pooling
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.
Le max pooling sous-échantillonne chaque région à sa plus grande valeur, réduisant la carte de caractéristiques et ajoutant une petite invariance à la translation.
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).
10.6 Le gain en paramètres
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.
10.7 Un étage convolutif
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.
Un étage convolutif : convolution, activation, puis pooling, répété pour construire des cartes de caractéristiques.
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.
10.8 Des couches aux architectures
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.
Un CNN profond réduit progressivement la taille spatiale tout en augmentant la profondeur en canaux, puis aplatit vers des couches entièrement connectées.
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.
- ResNet fait apprendre à chaque bloc une correction autour d'un saut identité :
Le \(+I\) donne au gradient une route vers l'arrière qui ne rétrécit jamais, le remède direct au gradient qui s'évanouit de la leçon 7, et des réseaux de centaines de couches s'entraînent de manière fiable.
Un bloc résiduel ajoute une connexion de saut identité autour du chemin de convolution, de sorte que la couche n'a qu'à apprendre une correction F(x).
| 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.
Ces piles profondes apprennent des cartes de caractéristiques dont les activations profondes se comportent comme des représentations réutilisables, la porte d'entrée du module suivant sur les plongements et l'apprentissage de représentations.
Suivant : Plongements et apprentissage de représentations · Vue d'ensemble du cours