Module 4 — LeNet et AlexNet : les premières réussites

Les briques des trois premiers modules — convolution, pas, remplissage, sous-échantillonnage — ne datent pas d'hier. Elles étaient déjà là en 1998, dans LeNet-5, un réseau qui lisait les codes postaux sur les enveloppes de la Poste américaine. Ce qui a manqué pendant quinze ans, ce sont trois ingrédients externes : la ReLU, le dropout, et surtout des accélérateurs assez puissants pour entraîner un réseau plus profond que dense sur un jeu de plus d'un million d'images. AlexNet, en 2012, les a rassemblés. Ce module reproduit LeNet en une dizaine de lignes de Keras, puis explique précisément ce que la victoire d'AlexNet à ImageNet a fait basculer.

LeNet-5, l'architecture minimale utile

Le schéma de LeNet-5 tient sur une seule ligne : convolution, sous-échantillonnage, convolution, sous-échantillonnage, couches denses, sortie. Les auteurs l'appliquaient à des images 32x32 en niveaux de gris — exactement la taille de CIFAR-10, mais monocanal.

from tensorflow import keras
from tensorflow.keras import layers

lenet = keras.Sequential([
    layers.Conv2D(6, kernel_size=5, activation="tanh",
                  padding="same", input_shape=(32, 32, 1)),
    layers.AveragePooling2D(pool_size=2),                 # 32 -> 16
    layers.Conv2D(16, kernel_size=5, activation="tanh", padding="valid"),
    layers.AveragePooling2D(pool_size=2),                 # 12 -> 6
    layers.Flatten(),
    layers.Dense(120, activation="tanh"),
    layers.Dense(84, activation="tanh"),
    layers.Dense(10, activation="softmax"),
])
lenet.summary()

Trois détails d'époque affleurent immédiatement :

• L'activation est tanh, pas relu : la ReLU n'existait pas dans son usage moderne.
• Le sous-échantillonnage est AveragePooling, pas MaxPooling : les deux étaient possibles, la moyenne l'a emporté par tradition.
• Les couches finales sont denses, avec un aplatissement énorme au milieu.

Sur CIFAR-10 en couleur — donc en changeant la profondeur d'entrée à 3 —, LeNet plafonne autour de 68 % d'exactitude de validation. Ce n'est pas mal pour 62 000 paramètres, mais c'est en deçà du petit CNN moderne du module 3.

Ce qu'AlexNet a changé, ligne par ligne

En 2012, AlexNet a remporté le concours ImageNet avec une avance de plus de dix points sur la deuxième méthode. Cinq changements, tous simples, expliquent l'essentiel :

• ReLU à la place de tanh dans les couches cachées. Le gradient de ReLU vaut 1 sur les activations positives, contre une valeur qui tend vers zéro pour tanh quand l'entrée est grande en valeur absolue. Résultat : les gradients traversent le réseau sans saturer, et l'entraînement d'un réseau à huit couches devient possible sur un délai raisonnable.
• Dropout dans les couches denses finales, à taux 0,5. Deux gigantesques couches denses (4096 unités chacune) sont régularisées en désactivant aléatoirement la moitié des unités à chaque lot. Le surajustement des tests précédents s'effondre.
• Sous-échantillonnage max en remplacement de la moyenne. On a vu au module 3 pourquoi : conserver la présence forte d'un motif plutôt que sa valeur moyenne convient mieux à un classifieur.
• Augmentation de données — recadrages aléatoires, retournements horizontaux, variations de couleur — appliquée à ImageNet. Sans elle, un réseau à 60 millions de paramètres sur-ajuste ses 1,2 million d'images d'entraînement.
• Entraînement sur GPU, réparti sur deux cartes NVIDIA GTX 580. Le temps qui se comptait en semaines sur CPU devient six jours sur GPU, ce qui rend l'itération de recherche possible.

Lire une architecture dans un tableau

Un tableau de couches est le format universel de description d'un CNN. Il faut savoir le lire sans lancer le code. Voici AlexNet, simplifié pour tenir dans une page :

#	Couche	Filtres	Noyau	Pas	Sortie	Paramètres
1	Conv + ReLU	96	11	4	55x55x96	34 944
2	MaxPool	—	3	2	27x27x96	0
3	Conv + ReLU	256	5	1	27x27x256	614 656
4	MaxPool	—	3	2	13x13x256	0
5	Conv + ReLU	384	3	1	13x13x384	885 120
6	Conv + ReLU	384	3	1	13x13x384	1 327 488
7	Conv + ReLU	256	3	1	13x13x256	884 992
8	MaxPool	—	3	2	6x6x256	0
9	Dense + ReLU + Dropout	4096	—	—	4096	37 752 832
10	Dense + ReLU + Dropout	4096	—	—	4096	16 781 312
11	Dense + Softmax	1000	—	—	1000	4 097 000

Trois lectures immédiates :

• La quasi-totalité des paramètres est dans les couches denses finales : 58 millions sur 62. C'est ce que le GlobalAveragePooling2D du module 3, popularisé plus tard, viendra corriger.
• Le premier filtre 11x11 à pas 4 rétrécit l'entrée 227x227 en 55x55 en une seule couche. Cette agressivité initiale sera critiquée par VGG (module 5) qui montre qu'un empilement de 3x3 fait mieux.
• Le champ récepteur croît vite grâce aux pas 4 et 2 successifs ; la dernière couche convolutive voit une région d'environ 195 pixels sur l'entrée 227x227, soit presque toute l'image.

Sur CIFAR-10, LeNet est un point de départ, pas une ambition

Reproduire AlexNet sur CIFAR-10 est un mauvais exercice : le premier 11x11 à pas 4 laisse une carte de 6x6, absurde sur une entrée de 32. Les architectures modernes adaptées à CIFAR-10 (comme ResNet20) commencent par un 3x3 à pas 1 et sous-échantillonnent en trois étapes. C'est cette adaptation qu'on retrouvera au module 6.

Reproduire AlexNet réduit sur CIFAR-10

Comme AlexNet est calibré pour du 224x224 et qu'on veut rester sur CIFAR-10, on en garde l'esprit — cinq blocs convolutifs suivis de couches denses — mais on adapte les noyaux :

from tensorflow.keras import layers, Sequential

alexnet_cifar = Sequential([
    layers.Conv2D(64, 3, activation="relu", padding="same",
                  input_shape=(32, 32, 3)),
    layers.MaxPooling2D(),                        # 32 -> 16
    layers.Conv2D(128, 3, activation="relu", padding="same"),
    layers.MaxPooling2D(),                        # 16 -> 8
    layers.Conv2D(256, 3, activation="relu", padding="same"),
    layers.Conv2D(256, 3, activation="relu", padding="same"),
    layers.Conv2D(128, 3, activation="relu", padding="same"),
    layers.MaxPooling2D(),                        # 8 -> 4
    layers.Flatten(),
    layers.Dense(1024, activation="relu"),
    layers.Dropout(0.5),
    layers.Dense(1024, activation="relu"),
    layers.Dropout(0.5),
    layers.Dense(10, activation="softmax"),
])

Ce réseau atteint 80 à 82 % sur CIFAR-10 avec augmentation basique, contre 75 % pour le petit CNN du module 3. Le gain vient surtout de la profondeur — cinq couches convolutives contre trois — et du dropout dans les couches denses. Mais on paie ce gain en paramètres : environ 4,7 millions ici, presque vingt fois le petit CNN.

L'idée que l'histoire a démentie

Pendant longtemps, on a cru qu'ajouter des couches convolutives augmentait toujours les performances jusqu'à un plafond fixé par la quantité de données. La suite de l'histoire — VGG au module 5, puis surtout ResNet au module 6 — montrera qu'un réseau trop profond entraîné naïvement se met à régresser en exactitude, y compris en apprentissage. Le problème n'est pas le surajustement, c'est l'optimisation elle-même qui échoue. La solution — les connexions résiduelles — est la contribution majeure du CNN post-2015.

En résumé

• LeNet-5 (1998) contient déjà toutes les briques architecturales d'un CNN moderne, à la ReLU et au dropout près.
• AlexNet (2012) a gagné ImageNet par cinq changements simples : ReLU, dropout, max, augmentation, GPU — chacun facile à isoler et à retester.
• La quasi-totalité des paramètres d'AlexNet vit dans ses couches denses finales, ce qui motive le GlobalAveragePooling2D des architectures ultérieures.
• Un tableau de couches se lit sans lancer le code : sortie spatiale, canaux, paramètres, champ récepteur — ces quatre colonnes suffisent à juger une architecture.

Module suivant : VGG, qui remplace les gros filtres d'AlexNet par des piles de 3x3 et systématise la profondeur.