Les réseaux convolutifs (CNN)
Prérequis : Les images et la convolution · Mesurer une classification
- 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).
Le pooling
Section intitulée « Le pooling »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).
Une couche de convolution, en détail
Section intitulée « Une couche de convolution, en détail »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 cartes est en réalité un bloc de poids : une tranche 3 × 3 par carte d’entrée.
- À chaque position , il fait la somme des produits terme à terme sur chaque tranche, additionne ces sommes, ajoute son biais, puis applique ReLU :
- Il produit une seule carte, quel que soit . Une couche de filtres produit cartes, qui deviennent les 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.
Le parcours d’une image, étape par étape
Section intitulée « Le parcours d’une image, étape par étape »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 :
- 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.
- 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.
- 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.
- 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.
- 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.
Le champ récepteur
Section intitulée « Le champ récepteur »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.
Comment les filtres sont appris
Section intitulée « Comment les filtres sont appris »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 une carte de sortie, et le gradient qui arrive de la couche suivante.
Gradient des poids. Chaque poids intervient dans toutes les sorties :
C’est une corrélation de l’entrée par la carte des gradients . Le widget l’utilise avec , 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 a contribué à toutes les sorties dont la fenêtre le couvre,
une convolution de (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.
L’architecture complète
Section intitulée « L’architecture complète »Un CNN classique empile des blocs convolution + ReLU + pooling, puis termine comme un réseau dense :
- [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) ;
- Aplatissement (flattening) : on met bout à bout toutes les valeurs des dernières cartes, un seul vecteur ;
- Couches denses : elles combinent les motifs détectés ;
- 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.
Combien de paramètres ?
Section intitulée « Combien de paramètres ? »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.
Entraîner et évaluer un CNN
Section intitulée « Entraîner et évaluer un CNN »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.
1 000 images, 15 époques, sans dropout : la validation décroche de l’entraînement. Recommencez avec 25 % de dropout, puis avec l’augmentation.
→Ouvrir la boîte
Section intitulée « Ouvrir la boîte »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.
Les grandes architectures
Section intitulée « Les grandes architectures »| 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 () 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 kerasfrom 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ètresmodele.fit(x, y, validation_split=0.1, epochs=5, batch_size=64)modele.evaluate(x_test, y_test)
# top-3 et matrice de confusionimport numpy as npfrom sklearn.metrics import confusion_matrixp = 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