Aller au contenu
Data science

Les réseaux convolutifs (CNN)

⏱ 1 h 30

Prérequis : Les images et la convolution · Mesurer une classification

À la fin de ce chapitre, vous saurez :
  • expliquer le rôle du pooling et ses limites ;
  • calculer une valeur de sortie d'une convolution à plusieurs canaux ;
  • suivre une image à travers les couches et expliquer comment des motifs simples se combinent en motifs complexes ;
  • expliquer le champ récepteur et l'apprentissage des filtres par descente de gradient ;
  • décrire l'architecture complète d'un CNN, de l'image à la softmax ;
  • compter les paramètres d'un CNN couche par couche ;
  • entraîner et évaluer un CNN (courbes, matrice de confusion, top-k, erreurs) ;
  • situer les grandes architectures (LeNet, AlexNet, VGG, ResNet).

Après une convolution, les cartes ont presque la taille de l’image. Le pooling les réduit : on découpe chaque carte en fenêtres (souvent 2 × 2, avec un pas de 2) et on résume chaque fenêtre par une seule valeur. Avec le max pooling, la plus grande ; avec l’average pooling, la moyenne.

Trois effets :

  • la taille des cartes est divisée par 2 dans chaque direction (4 fois moins de valeurs) : moins de calculs, et surtout moins de paramètres dans les couches denses qui suivent ;
  • le max pooling tolère les petits décalages : si le motif bouge d’un pixel sans quitter sa fenêtre, le maximum ne change pas. Faites glisser le curseur : à partir d’un certain décalage, des valeurs changent. Le pooling n’apporte qu’une robustesse locale ;
  • en résumant, il garde l’essentiel (« le motif est présent dans cette zone ») et oublie la position exacte.

Pour les bords : avec padding="valid" (le défaut de Keras), une fenêtre incomplète est ignorée (une carte 5 × 5 donne 2 × 2) ; avec padding="same", elle est gardée (3 × 3).

Au chapitre précédent, un filtre glissait sur une image à un seul canal. Dans un CNN, chaque couche reçoit plusieurs cartes : les 3 canaux d’une image en couleur pour la première, les cartes produites par la couche précédente pour les suivantes. Un filtre doit donc les regarder toutes à la fois.

  • Un filtre « 3 × 3 » d’une couche qui reçoit CC cartes est en réalité un bloc de 3×3×C3 \times 3 \times C poids : une tranche 3 × 3 par carte d’entrée.
  • À chaque position (i,j)(i, j), il fait la somme des produits terme à terme sur chaque tranche, additionne ces CC sommes, ajoute son biais, puis applique ReLU :
sortie(i,j)=ReLU(b+∑c=1C∑a=02∑d=02xc(i+a,j+d) wc(a,d)).\text{sortie}(i, j) = \mathrm{ReLU}\Big(b + \sum_{c=1}^{C} \sum_{a=0}^{2} \sum_{d=0}^{2} x_c(i + a, j + d)\, w_c(a, d)\Big).
  • Il produit une seule carte, quel que soit CC. Une couche de FF filtres produit FF cartes, qui deviennent les FF canaux d’entrée de la couche suivante.

Comme les poids s’additionnent sur toutes les cartes, un filtre de la 2ᵉ couche peut exiger que plusieurs motifs soient présents ensemble au même endroit : « un trait horizontal ici et une diagonale juste en dessous ». Le biais, négatif, sert de seuil : un seul des deux motifs ne suffit pas à dépasser 0, et ReLU renvoie alors 0. C’est un « ET » appris.

Voici un CNN miniature dont tous les filtres sont lisibles. Ses poids ont été choisis à la main pour l’exemple (un vrai CNN les apprend, voir plus bas) :

  • convolution 1 : 4 détecteurs de traits fins, horizontal, vertical et les deux diagonales, chacun suivi de ReLU ;
  • pooling 1 : max 2 × 2, les cartes passent de 12 × 12 à 6 × 6 ;
  • convolution 2 : 3 filtres de 3 × 3 × 4 poids qui combinent les cartes de traits, un « coin ⌝ », un « croisement + » et un « angle droit ⌞ » ;
  • pooling 2, puis aplatissement en 12 valeurs, l’entrée des couches denses.

Ce qu’il faut observer :

  1. La 1ʳᵉ couche sépare les traits. Sur le 7, la carte « horizontal » s’allume sur la barre du haut, la carte « diagonale / » sur le jambage. Cliquez sur une case : le calcul s’affiche, et sa fenêtre 3 × 3 est encadrée dans l’image.
  2. Le pooling résume. Chaque carte est 4 fois plus petite, mais les traits sont toujours là, au même endroit à un pixel près.
  3. La 2ᵉ couche combine. Cliquez sur une case de la carte « coin » : le détail montre la contribution de chaque carte de la 1ʳᵉ couche, puis le biais qui fait seuil. Le 7 allume le coin, le 4 le croisement, le L l’angle droit ; le 1, fait d’un seul trait, n’allume aucune combinaison.
  4. Modifiez l’image. Choisissez le 1, puis cliquez sur des pixels pour tracer une barre horizontale qui le traverse vers le milieu : le « croisement » s’allume (et l’« angle droit » aussi : une croix contient quatre angles droits), alors qu’aucun poids de la 2ᵉ couche ne regarde directement l’image.
  5. L’aplatissement oublie l’image. Les 12 valeurs finales ne disent plus « quel pixel est noir », mais « quel motif est présent, et dans quel quart de l’image ». C’est sur ce résumé que les couches denses prennent leur décision.

Chaque case d’une carte ne dépend que d’une zone de l’image : son champ récepteur, encadré en rouge dans le widget quand on clique. Il grandit à chaque couche :

Couche Taille des cartes Champ récepteur d’une case
convolution 1 (3 × 3) 12 × 12 3 × 3 pixels
pooling 1 (2 × 2) 6 × 6 4 × 4 pixels
convolution 2 (3 × 3) 4 × 4 8 × 8 pixels
pooling 2 (2 × 2) 2 × 2 10 × 10 pixels

En profondeur, les neurones voient des zones de plus en plus grandes et combinent les motifs des couches précédentes : bords et traits → coins, courbes, croisements → parties (une boucle, une barre) → objets entiers. Dans un grand réseau (ResNet-50), les dernières couches voient toute l’image.

Personne n’écrit les filtres d’un vrai CNN : ils partent de valeurs au hasard et sont réglés par descente de gradient, comme les poids d’un réseau dense. Pour le voir à petite échelle, demandons à un filtre 3 × 3 de reproduire la sortie d’un détecteur de bords, à partir de poids aléatoires :

À chaque itération, chacun des 9 poids bouge dans le sens qui réduit l’erreur, et le filtre converge vers le détecteur de Sobel. Deux remarques :

  • le gradient d’un poids est une somme sur toutes les positions de l’image : le même poids sert partout (partage des poids), donc toutes les positions votent pour sa correction. C’est pour cela qu’un filtre apprend avec peu d’images ;
  • dans un vrai CNN, il n’y a pas de « sortie voulue » pour chaque carte. Le gradient vient de la perte de classification (l’entropie croisée), rétropropagée de la softmax jusqu’aux filtres de la 1ʳᵉ couche. Le réseau invente donc les motifs utiles pour reconnaître les classes, et il retrouve souvent, en 1ʳᵉ couche, des détecteurs de bords proches de Sobel (le simulateur les montre).
🎓 Pour aller plus loin : la rétropropagation dans une convolution

Notons y(i,j)=b+∑a,dx(i+a,j+d) w(a,d)y(i, j) = b + \sum_{a, d} x(i + a, j + d)\, w(a, d) une carte de sortie, et δ(i,j)=∂L/∂y(i,j)\delta(i, j) = \partial L / \partial y(i, j) le gradient qui arrive de la couche suivante.

Gradient des poids. Chaque poids w(a,d)w(a, d) intervient dans toutes les sorties :

∂L∂w(a,d)=∑i,jδ(i,j) x(i+a,j+d),∂L∂b=∑i,jδ(i,j).\frac{\partial L}{\partial w(a, d)} = \sum_{i, j} \delta(i, j)\, x(i + a, j + d), \qquad \frac{\partial L}{\partial b} = \sum_{i, j} \delta(i, j).

C’est une corrélation de l’entrée par la carte des gradients δ\delta. Le widget l’utilise avec δ=2N(sortie−voulue)\delta = \frac{2}{N}(\text{sortie} - \text{voulue}), la dérivée de l’erreur quadratique moyenne, et l’optimiseur Adam.

Gradient de l’entrée (pour continuer à remonter vers les couches précédentes) : chaque pixel x(p,q)x(p, q) a contribué à toutes les sorties dont la fenêtre le couvre,

∂L∂x(p,q)=∑a,dδ(p−a,q−d) w(a,d),\frac{\partial L}{\partial x(p, q)} = \sum_{a, d} \delta(p - a, q - d)\, w(a, d),

une convolution de δ\delta (bordée de zéros) par le filtre retourné. Le pooling max, lui, ne fait que transmettre le gradient à la case qui était le maximum ; les autres reçoivent 0. La ReLU le transmet là où l’entrée était positive.

Un CNN classique empile des blocs convolution + ReLU + pooling, puis termine comme un réseau dense :

  1. [Convolution + ReLU → Pooling] × n : les cartes deviennent de plus en plus petites et de plus en plus nombreuses (par exemple 28 × 28 × 1 → 13 × 13 × 8 → 5 × 5 × 16) ;
  2. Aplatissement (flattening) : on met bout à bout toutes les valeurs des dernières cartes, un seul vecteur ;
  3. Couches denses : elles combinent les motifs détectés ;
  4. Sortie : un neurone par classe avec la softmax (ou un seul neurone sigmoïde pour 2 classes), et l’entropie croisée comme perte, comme au chapitre Du neurone au réseau.

Tous les poids (filtres et couches denses) sont appris ensemble, par rétropropagation.

Le schéma ci-dessous dessine l’architecture à l’échelle : chaque pile représente les cartes d’une couche (leur nombre est indiqué quand il dépasse 8), le cône rouge relie une fenêtre de filtre à la valeur qu’elle produit. Il part de LeNet-5, le réseau de Yann LeCun qui lisait les chèques dès 1998 ; changez l’architecture ou ses réglages, le tableau des formes et des paramètres se met à jour.

Trois expériences :

  • Décochez le pooling : les cartes restent grandes, l’aplatissement passe de 400 à plusieurs milliers de valeurs, et la première couche dense explose.
  • Passez l’image en 224 × 224 couleur (la taille d’ImageNet) avec deux blocs : les convolutions ont presque autant de poids, mais la couche dense en a des millions. C’est pourquoi les grands réseaux empilent plus de blocs, ou utilisent un pooling global (encadré ci-dessous).
  • Comparez « valid » et « same » : avec « same », la convolution garde la taille, et seul le pooling la réduit.

Le modèle de référence du simulateur, pour MNIST :

Couche Sortie Paramètres Calcul
Entrée 28 × 28 × 1 0
Convolution, 8 filtres 3 × 3 26 × 26 × 8 80 (3 × 3 × 1 + 1) × 8
Max pooling 2 × 2 13 × 13 × 8 0
Convolution, 16 filtres 3 × 3 11 × 11 × 16 1 168 (3 × 3 × 8 + 1) × 16
Max pooling 2 × 2 5 × 5 × 16 0
Aplatissement 400 0 5 × 5 × 16
Dense 64 64 25 664 (400 + 1) × 64
Sortie softmax 10 650 (64 + 1) × 10
Total 27 562

Les convolutions ne pèsent presque rien ; la première couche dense concentre plus de 90 % des paramètres. Un réseau dense (784 → 64 → 10) en a 50 890, et fait moins bien. Sans pooling, l’aplatissement passerait de 400 à 24 × 24 × 16 = 9 216 valeurs, et la couche dense à près de 590 000 poids.

🎓 Pour aller plus loin : se passer de l'aplatissement : le global average pooling

Les architectures modernes remplacent souvent l’aplatissement et les grandes couches denses par un pooling global : GlobalAveragePooling2D fait la moyenne de chaque carte entière, et transforme 5 × 5 × 64 en un vecteur de 64 valeurs. Avantages : beaucoup moins de paramètres (donc moins de surapprentissage), et un réseau qui accepte des images de n’importe quelle taille.

On peut aussi remplacer le pooling par une convolution de pas 2, qui réduit la taille tout en apprenant comment le faire. Et la normalisation par lots (BatchNormalization) s’insère couramment entre chaque convolution et sa ReLU.

🔬Un CNN sur MNIST, en direct

Entraînez le modèle par défaut (quelques secondes) : regardez les courbes, les filtres de la première couche se former, puis dessinez un chiffre et suivez-le à travers les couches.

→

Tout ce que vous savez de l’évaluation reste vrai :

  • Courbes d’apprentissage : un écart qui se creuse entre entraînement et validation signale le surapprentissage. Avec 1 000 images seulement, il apparaît vite ; le dropout et l’augmentation de données (chapitre suivant) le réduisent.
  • Matrice de confusion : quelles classes sont confondues ? Sur MNIST, souvent 4 et 9, 3 et 5, 7 et 2. Sur des photos, chat et chien, loup et husky.
  • Exactitude top-k : avec 1 000 classes (ImageNet), on donne souvent le top-5 : la bonne classe est-elle parmi les 5 plus probables ?
  • Regarder les erreurs : les images mal classées avec une grande confiance sont les plus instructives. Certaines sont ambiguës, d’autres sont des erreurs d’étiquetage du jeu de données lui-même.
🔬Peu de données, pas de régularisation

1 000 images, 15 époques, sans dropout : la validation décroche de l’entraînement. Recommencez avec 25 % de dropout, puis avec l’augmentation.

→

Un CNN n’est pas une boîte totalement noire :

  • on peut afficher les filtres de la première couche (souvent des détecteurs de bords et de couleurs) ;
  • on peut afficher les cartes d’activation pour une image : quelles zones allument quels filtres (c’est ce que montre le simulateur, couche par couche) ;
  • la méthode Grad-CAM calcule, à partir des gradients, une carte de chaleur des zones de l’image qui ont le plus pesé dans la décision. Elle révèle parfois qu’un modèle « regarde » le mauvais endroit : la neige derrière le loup plutôt que le loup.
Année Réseau Ce qu’il apporte
1998 LeNet-5 (Yann LeCun) lit les chèques : 2 convolutions, 60 000 paramètres
2012 AlexNet gagne ImageNet de loin grâce aux GPU, à ReLU et au dropout : le début de l’apprentissage profond
2014 VGG empile simplement des convolutions 3 × 3 : 16 à 19 couches
2015 ResNet les connexions résiduelles (x+F(x)x + F(x)) permettent d’entraîner 50, 100, 150 couches
2017-2019 MobileNet, EfficientNet légers et rapides, pour les téléphones

Les erreurs sur ImageNet (1,2 million d’images, 1 000 classes) sont passées de 26 % (top-5) en 2011 à moins de 4 % en 2015, sous le niveau d’un humain attentif.

import keras
from keras import layers
(x, y), (x_test, y_test) = keras.datasets.mnist.load_data()
x, x_test = x[..., None] / 255, x_test[..., None] / 255 # (n, 28, 28, 1), valeurs entre 0 et 1
modele = keras.Sequential([
keras.Input(shape=(28, 28, 1)),
layers.Conv2D(8, 3, activation="relu"),
layers.MaxPooling2D(2),
layers.Conv2D(16, 3, activation="relu"),
layers.MaxPooling2D(2),
layers.Flatten(),
layers.Dropout(0.25),
layers.Dense(64, activation="relu"),
layers.Dense(10, activation="softmax"),
])
modele.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])
modele.summary() # 27 562 paramètres
modele.fit(x, y, validation_split=0.1, epochs=5, batch_size=64)
modele.evaluate(x_test, y_test)
# top-3 et matrice de confusion
import numpy as np
from sklearn.metrics import confusion_matrix
p = modele.predict(x_test)
print(keras.metrics.top_k_categorical_accuracy(keras.utils.to_categorical(y_test), p, k=3).numpy().mean())
print(confusion_matrix(y_test, p.argmax(1)))

✅ Vérifiez vos acquis

1. Que fait un max pooling 2 × 2 de pas 2 sur une carte 26 × 26 ?
2. Un filtre 3 × 3 de la 2ᵉ couche reçoit 8 cartes. Combien de poids a-t-il, biais compris ?
3. Pourquoi le filtre « coin » du widget a-t-il un biais négatif ?
4. Le max pooling rend le réseau insensible…
5. Dans quel ordre sont les couches d'un CNN classique ?
6. Combien de valeurs donne l'aplatissement de 32 cartes de 7 × 7 ?
7. Que montre l'exactitude top-5 ?
8. Quelle innovation a permis d'entraîner des réseaux de plus de 100 couches ?