1. Pourquoi des convolutions ?

Un MLP appliqué à des images perd la structure spatiale : 200×200×3 = 120 000 entrées, et un voisinage local n'a aucune priorité. Les réseaux convolutifs (CNN, LeCun 1989) exploitent trois biais inductifs :

• Localité : un pixel est plus lié à ses voisins qu'aux distants
• Partage de poids : un filtre se déplace sur toute l'image (translation equivariance)
• Hiérarchie : pixels → arêtes → motifs → objets

LeCun Y., Bengio Y., Hinton G., « Deep learning », Nature 521, 2015, nature.com/articles/nature14539

2. Anatomie d'un CNN

2.1 Couche Conv2D

Un filtre (kernel) 3×3 ou 5×5 glisse sur l'image avec un stride (déplacement) et un padding (bordures). Produit une feature map par filtre.

2.2 Pooling

MaxPooling2D(2,2) réduit chaque feature map en gardant le max d'une fenêtre 2×2. Réduit la dimension et apporte une légère invariance à la translation. Alternative moderne : stride 2 dans Conv2D (utilisé dans ResNet).

2.3 Architecture typique

Input(224,224,3)
→ Conv2D(64, 7×7, stride=2) → BatchNorm → ReLU
→ MaxPool 3×3
→ Conv2D(128, 3×3) ×2 → BatchNorm → ReLU
→ MaxPool 2×2
→ Conv2D(256, 3×3) ×2 → BatchNorm → ReLU
→ GlobalAveragePooling2D()
→ Dense(num_classes, softmax)

3. Architectures de référence

He K., Zhang X., Ren S., Sun J., « Deep Residual Learning for Image Recognition », CVPR 2016, arXiv:1512.03385 — résout le gradient vanishing pour les très profonds réseaux.

4. Transfer learning — la pratique gagnante

Entraîner un CNN from-scratch sur ImageNet demande des semaines et 1M+ images. Transfer learning : utiliser un modèle pré-entraîné, geler les couches basses (features génériques), fine-tuner les couches hautes sur sa tâche.

import tensorflow as tf
from tensorflow.keras.applications import EfficientNetB0
from tensorflow.keras import layers, Model

base = EfficientNetB0(weights='imagenet', include_top=False, input_shape=(224,224,3))
base.trainable = False                      # gel des poids

x = base.output
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dropout(0.3)(x)
out = layers.Dense(NUM_CLASSES, activation='softmax')(x)
model = Model(base.input, out)

model.compile(optimizer=tf.keras.optimizers.AdamW(1e-3),
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# Étape 1 : entraîner uniquement la tête
model.fit(train_ds, validation_data=val_ds, epochs=10)

# Étape 2 : fine-tuning des dernières couches
base.trainable = True
for layer in base.layers[:-30]:
    layer.trainable = False
model.compile(optimizer=tf.keras.optimizers.AdamW(1e-5), loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(train_ds, validation_data=val_ds, epochs=10)

5. Data augmentation

5.1 Augmentations classiques

• Flip horizontal (jamais vertical pour images naturelles)
• Rotation aléatoire ±15°
• Random crop / resize
• Color jitter (luminosité, contraste, saturation)
• Gaussian noise, blur

5.2 Augmentations modernes

• MixUp (Zhang 2018) : λ × image_A + (1-λ) × image_B → label mixé
• CutMix (Yun 2019) : coller un patch d'image_B sur image_A
• RandAugment (Cubuk 2020) : compositions aléatoires de N augmentations
• AutoAugment : policy apprise par RL sur ImageNet

import albumentations as A
from albumentations.pytorch import ToTensorV2

train_tfm = A.Compose([
    A.Resize(256, 256),
    A.RandomCrop(224, 224),
    A.HorizontalFlip(p=0.5),
    A.ColorJitter(brightness=0.2, contrast=0.2),
    A.Normalize(mean=[0.485,0.456,0.406], std=[0.229,0.224,0.225]),
    ToTensorV2()
])

6. Vision Transformers (ViT)

Dosovitskiy et al. (Google 2020) ont démontré qu'un Transformer pur (sans aucune convolution) bat les meilleurs CNN sur ImageNet, à condition d'avoir ≥ 100 M d'images de pré-training (JFT-300M, LAION).

6.1 Principe ViT

1. Découper l'image en patches 16×16 (224×224 → 196 patches)
2. Linéariser chaque patch (vecteur 768)
3. Ajouter un positional encoding
4. Passer dans un Transformer encoder (12-24 couches multi-head self-attention)
5. Token [CLS] → tête de classification

Dosovitskiy A. et al., « An Image is Worth 16×16 Words: Transformers for Image Recognition at Scale », ICLR 2021, arXiv:2010.11929

6.2 ViT vs CNN — Comparaison

7. Synthèse et points-clés

• Conv2D 3×3 + BatchNorm + ReLU = brique CNN moderne
• ResNet et ses skip connections = standard de facto depuis 2015
• Transfer learning : geler la base + tête custom → fine-tuner avec lr/100
• Data augmentation modernes : MixUp, CutMix, RandAugment
• ViT nécessite >> de données, mais plafonds plus hauts
• Toujours appliquer la normalisation ImageNet (mean/std) lors du transfer
• Utiliser GlobalAveragePooling au lieu de Flatten pour réduire les paramètres

Pour aller plus loin

• TensorFlow — Image classification
• PyTorch — Transfer Learning Tutorial
• Dosovitskiy et al., ViT, ICLR 2021
• Albumentations — Image augmentation library
• Chollet F., Deep Learning with Python, Manning 2e éd. 2021, chapitres 8-9