CNN : La Vision par Ordinateur

Pourquoi les CNN ?

Dans le cours précédent, nous avons classé des chiffres MNIST en aplatissant chaque image en un vecteur de 784 pixels. Cette approche a un défaut majeur : elle détruit la structure spatiale de l''image. Le pixel (0,0) n''a aucune raison d''être traité comme voisin du pixel (0,27).

Les Convolutional Neural Networks (CNN) résolvent ce problème en utilisant des filtres qui glissent sur l''image et préservent les relations spatiales entre pixels voisins.

MLP vs CNN sur des images

L''Opération de Convolution

Principe

Un filtre (ou kernel) est une petite matrice (typiquement 3×3 ou 5×5) qui glisse sur l''image. À chaque position, il effectue une multiplication élément par élément puis une somme.

Image (5×5)           Filtre (3×3)        Sortie (3×3)
1  0  1  0  1         1  0  1             4  3  4
0  1  0  1  0    *    0  1  0      =      2  4  3
1  0  1  0  1         1  0  1             4  3  4
0  1  0  1  0
1  0  1  0  1

Chaque filtre apprend à détecter un pattern spécifique :

• Filtre de bords horizontaux
• Filtre de bords verticaux
• Filtre de coins
• Filtre de textures

Paramètres importants

Pooling : Réduire les Dimensions

Après la convolution, on applique un pooling pour réduire la taille spatiale tout en gardant l''information importante.

Max Pooling (le plus utilisé)

On découpe la feature map en blocs (2×2) et on garde la valeur maximale de chaque bloc.

Entrée (4×4)          Max Pool 2×2         Sortie (2×2)
 6  2  3  1                                 6  3
 8  4  7  5       →                         8  9
 1  3  9  2
 0  5  4  8

Avantages :

• Réduit le nombre de paramètres (moins de calcul)
• Apporte une légère invariance à la translation (un objet décalé de quelques pixels est toujours détecté)

Architecture d''un CNN Complet

Le réseau a deux parties :

1. Extracteur de features (Conv + Pool) : apprend les patterns visuels
2. Classifieur (Dense) : utilise ces features pour prédire la classe

Exercice 1 : CNN sur MNIST avec Keras

import numpy as np
from tensorflow import keras
from tensorflow.keras import layers

# Charger MNIST
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# Normaliser et ajouter la dimension canal (28, 28) → (28, 28, 1)
x_train = x_train.astype("float32") / 255.0
x_test = x_test.astype("float32") / 255.0
x_train = np.expand_dims(x_train, -1)
x_test = np.expand_dims(x_test, -1)

# Modèle CNN
model = keras.Sequential([
    layers.Conv2D(32, kernel_size=3, activation="relu", input_shape=(28, 28, 1)),
    layers.MaxPooling2D(pool_size=2),
    layers.Conv2D(64, kernel_size=3, activation="relu"),
    layers.MaxPooling2D(pool_size=2),
    layers.Flatten(),
    layers.Dropout(0.3),
    layers.Dense(128, activation="relu"),
    layers.Dense(10, activation="softmax")
])

model.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])
model.summary()

# Entraînement
history = model.fit(x_train, y_train, epochs=5, batch_size=64, validation_split=0.1)

# Évaluation
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Précision CNN : {test_acc:.4f}")

Les Architectures Classiques

LeNet-5 (1998) — Le pionnier

Créé par Yann LeCun pour la reconnaissance de chèques bancaires. 2 couches de convolution, c''est le premier CNN qui a fonctionné à grande échelle.

AlexNet (2012) — La révolution

A remporté le concours ImageNet 2012 avec une marge colossale. C''est le moment où le monde a compris que le Deep Learning allait tout changer.

Innovations : ReLU (au lieu de Sigmoid), Dropout, GPU training.

VGG-16 (2014) — La simplicité

Architecture simple et régulière : que des convolutions 3×3 empilées. 16 couches, 138 millions de paramètres.

Leçon : empiler des petits filtres (3×3) est plus efficace qu''utiliser de grands filtres (7×7).

ResNet (2015) — Les connexions résiduelles

Le problème des réseaux très profonds : le gradient s''évanouit en traversant trop de couches. ResNet résout cela avec des skip connections qui permettent au gradient de "sauter" des couches.

Sortie = F(x) + x    (au lieu de juste F(x))

Résultat : on peut entraîner des réseaux de 152 couches (voire 1000+).

Transfer Learning : Réutiliser un Modèle Pré-entraîné

Entraîner un CNN de zéro sur ImageNet prend des semaines sur des GPU coûteux. Le transfer learning permet de réutiliser un modèle déjà entraîné et de l''adapter à votre problème.

Le principe

1. Prendre un modèle pré-entraîné (ResNet, EfficientNet)
2. Geler les couches de convolution (elles savent déjà détecter des features visuelles)
3. Remplacer la dernière couche par votre classifieur personnalisé
4. Entraîner seulement les nouvelles couches

Exercice 2 : Transfer Learning avec ResNet

from tensorflow.keras.applications import ResNet50
from tensorflow.keras import layers, Model
from tensorflow.keras.preprocessing.image import ImageDataGenerator

# Charger ResNet50 pré-entraîné (sans la couche de sortie)
base_model = ResNet50(weights="imagenet", include_top=False, input_shape=(224, 224, 3))

# Geler les couches pré-entraînées
base_model.trainable = False

# Ajouter notre classifieur
inputs = layers.Input(shape=(224, 224, 3))
x = base_model(inputs, training=False)
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dropout(0.3)(x)
x = layers.Dense(128, activation="relu")(x)
outputs = layers.Dense(5, activation="softmax")(x)  # 5 classes

model = Model(inputs, outputs)

model.compile(
    optimizer="adam",
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"]
)

model.summary()

Quand utiliser le Transfer Learning ?

Data Augmentation

Quand on a peu d''images, on peut augmenter artificiellement le dataset en appliquant des transformations aléatoires.

from tensorflow.keras.preprocessing.image import ImageDataGenerator

datagen = ImageDataGenerator(
    rotation_range=20,       # Rotation jusqu''à 20°
    width_shift_range=0.2,   # Décalage horizontal
    height_shift_range=0.2,  # Décalage vertical
    horizontal_flip=True,    # Miroir horizontal
    zoom_range=0.1,          # Zoom léger
    fill_mode="nearest"
)

Une image de chat retournée horizontalement reste un chat. Mais attention : ne retournez pas verticalement des chiffres (un 6 à l''envers devient un 9).

Pour Aller Plus Loin

• Exercice bonus : classez les 10 catégories de CIFAR-10 (avions, voitures, oiseaux, etc.) avec un CNN
• Transfer Learning : utilisez un modèle pré-entraîné sur le dataset Flowers 102 pour classifier des espèces de fleurs
• Prochain cours : les Transformers, l''architecture qui a révolutionné le NLP et qui conquiert aussi la vision (Vision Transformers)

A Vous de Jouer !

Mettez vos connaissances en pratique en construisant un CNN complet. Placez les bonnes couches dans le bon ordre pour classifier des images CIFAR-10.