Deep Learning 5 — Réseaux convolutifs et traitement d'images : transfer learning et détection d'objets

Les chapitres précédents ont introduit les réseaux convolutifs : briques de base (convolution, pooling, normalisation), architectures profondes inspirées de VGG ou ResNet, et entraînement sur des jeux d'images. Une question reste cependant en suspens. Construire et entraîner un CNN moderne « à la main » sur ImageNet demanderait des semaines de calcul, un cluster GPU, et un dataset que nous n'avons pas. Comment, dans la pratique d'un ingénieur ou d'un chercheur, exploiter la puissance des grands réseaux convolutifs sans les ré-entraîner depuis zéro ?

Ce dernier chapitre de la séquence Deep Learning aborde deux idées qui répondent directement à cette question :

1. le zoo de modèles et le transfer learning, qui permettent de réutiliser des poids pré-entraînés sur ImageNet pour résoudre, avec très peu de données, une tâche de classification spécialisée ;
2. la détection d'objets, qui généralise la classification d'image à la localisation simultanée du quoi et du où, et dont l'archétype moderne est la famille YOLO (You Only Look Once).

Le fil conducteur reste le dataset Intel Image Classification (six classes : buildings, forest, glacier, mountain, sea, street, en RGB 224×224), déjà manipulé dans le chapitre précédent.

1. Du « from scratch » au transfer learning

1.1 Un CNN modeste comme point de comparaison

Avant de parler de transfer learning, il est utile d'avoir une référence. Sur le dataset Intel, on peut entraîner from scratch un petit CNN à trois couches convolutives, avec normalisation par lot et dropout. L'idée est classique : trois blocs Conv → BatchNorm → ReLU → MaxPool, puis un global average pooling (GAP) pour résumer chaque canal en un scalaire, suivi d'un dropout et d'une couche linéaire de classification.

import torch.nn as nn

class SimpleCNN_BN_DO(nn.Module):
    def __init__(self, num_classes=6, dropout_p=0.5):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 16, 3, padding=1)
        self.bn1   = nn.BatchNorm2d(16)
        self.conv2 = nn.Conv2d(16, 32, 3, padding=1)
        self.bn2   = nn.BatchNorm2d(32)
        self.conv3 = nn.Conv2d(32, 64, 3, padding=1)
        self.bn3   = nn.BatchNorm2d(64)
        self.relu  = nn.ReLU()
        self.pool  = nn.MaxPool2d(2)
        self.gap   = nn.AdaptiveAvgPool2d((1, 1))   # remplace un Flatten énorme
        self.dropout = nn.Dropout(p=dropout_p)
        self.fc    = nn.Linear(64, num_classes)

    def forward(self, x):
        x = self.pool(self.relu(self.bn1(self.conv1(x))))   # 224 -> 112
        x = self.relu(self.bn2(self.conv2(x)))              # 112
        x = self.pool(self.relu(self.bn3(self.conv3(x))))   # 112 -> 56
        x = self.gap(x)                                     # (B, 64, 1, 1)
        x = torch.flatten(x, 1)                             # (B, 64)
        x = self.dropout(x)
        x = self.fc(x)
        return x

Trois remarques pédagogiques sur cette architecture :

• la normalisation par lot (BatchNorm2d) stabilise l'entraînement en recentrant et en redimensionnant les activations sur chaque canal ;
• le GAP remplace un Flatten qui produirait un vecteur de plusieurs centaines de milliers d'éléments, et donc une couche linéaire gigantesque ;
• le dropout désactive aléatoirement une fraction des neurones de la tête lors de l'entraînement, ce qui agit comme régularisateur.

Point clé. Sur quatre époques avec un batch size de 32, ce modèle atteint typiquement une accuracy honorable sur Intel, mais reste sensible à la taille des données et plafonne rapidement. C'est précisément là que l'idée du transfer learning prend tout son intérêt.

1.2 Préparation mémoire et device

Quand on enchaîne plusieurs entraînements de gros CNN sur un GPU partagé (Kaggle, Colab), il est prudent de libérer explicitement la mémoire entre deux essais :

import gc, torch
gc.collect()
torch.cuda.empty_cache()

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

Un batch_size=32 est un compromis raisonnable pour des images 224×224 et des architectures de type ResNet18 sur un GPU grand public.

2. Le zoo de modèles

2.1 De quoi parle-t-on ?

Le zoo de modèles désigne une collection de réseaux pré-entraînés, distribués clé en main par les bibliothèques de deep learning (PyTorch, TensorFlow, Hugging Face…). En PyTorch, ce zoo est accessible via torchvision.models. Chaque modèle est livré avec :

• une architecture validée par la communauté ;
• des poids déjà optimisés sur un grand dataset (le plus souvent ImageNet, ses 1 000 classes et ses 1,2 million d'images) ;
• des performances de référence documentées.

Quelques familles emblématiques :

L'idée fondamentale est simple : ne pas repartir de zéro.

2.2 Du zoo aux modèles de fondation

Cette idée de réutilisation a évolué. Les modèles de fondation (foundation models) modernes prolongent et radicalisent la logique du zoo :

• entraînés sur des volumes massifs de données (souvent des milliards d'exemples) ;
• en mode auto-supervisé ou faiblement supervisé, sans annotations manuelles à grande échelle ;
• capables d'être adaptés à de nombreuses tâches par simple fine-tuning léger ou prompting.

Un CNN ImageNet jouait déjà ce rôle à petite échelle : il offre des représentations utilisables pour la classification fine, la détection ou la segmentation. Les modèles récents (CLIP, DINO, SAM en vision, ou BERT, GPT, Llama en texte) vont plus loin et offrent une généralisation et une capacité de transfert beaucoup plus larges.

À retenir. Le zoo de modèles peut être vu comme l'ancêtre pratique des modèles de fondation. Le principe — apprendre une représentation générale, puis l'adapter efficacement — n'a pas changé ; ce sont l'échelle et la généralité qui ont explosé.

3. Transfer learning : principes

3.1 L'intuition

Les CNN profonds ont une propriété remarquable, mise en évidence par les travaux sur la visualisation des filtres (Zeiler et Fergus, 2014) : leurs couches sont organisées en hiérarchie de représentations.

Les premières couches apprennent des représentations générales — bords, gradients, textures, couleurs. Les dernières couches apprennent des concepts spécifiques à la tâche — types d'objets, scènes, postures.

L'observation empirique est que les premières couches d'un CNN entraîné sur ImageNet sont réutilisables presque telles quelles pour à peu près n'importe quelle tâche de vision. Seules les couches finales doivent être ré-entraînées.

3.2 Deux stratégies

Le transfer learning se décline en deux familles principales.

a) Extraction de caractéristiques (feature extraction)

On gèle la totalité du modèle pré-entraîné et on n'entraîne qu'une nouvelle couche de classification, plaquée à la fin :

• très rapide ;
• peu de données suffisent ;
• risque de sur-apprentissage faible, puisque très peu de paramètres sont libres.

C'est la baseline naturelle dès que la cible est proche d'ImageNet (photos naturelles).

b) Fine-tuning

On dé-gèle une partie ou la totalité du modèle, et on poursuit l'entraînement sur la nouvelle tâche, généralement avec un learning rate plus petit :

• meilleures performances quand on dispose d'assez de données ;
• risque d'overfitting si le dataset cible est trop petit ;
• plus coûteux en calcul.

En pratique, la stratégie la plus efficace combine les deux :

1. feature extraction d'abord, pour entraîner la nouvelle tête à partir d'une initialisation cohérente ;
2. fine-tuning ensuite, en dé-gelant les derniers blocs (par exemple layer4 d'un ResNet) avec un learning rate faible.

Mathématiquement, si l'on note $\theta = (\theta_b, \theta_h)$ les paramètres décomposés en backbone $\theta_b$ et tête $\theta_h$, la phase de feature extraction résout

où $\theta_b^{\star}$ sont les poids ImageNet, gelés. Le fine-tuning qui suit relâche cette contrainte sur une partie de $\theta_b$.

4. Mise en pratique : ResNet sur Intel Image Classification

4.1 Le pipeline ImageFolder

Pour des images organisées par sous-dossiers (un sous-dossier par classe), torchvision fournit l'utilitaire ImageFolder :

from torchvision import datasets, transforms
from torch.utils.data import DataLoader

transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    # Pour un modèle pré-entraîné ImageNet, on ajoute typiquement :
    # transforms.Normalize(mean=(0.485, 0.456, 0.406),
    #                      std=(0.229, 0.224, 0.225)),
])

train_dataset = datasets.ImageFolder("…/seg_train/seg_train", transform=transform)
test_dataset  = datasets.ImageFolder("…/seg_test/seg_test",  transform=transform)

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True,
                          num_workers=2, pin_memory=True)
test_loader  = DataLoader(test_dataset,  batch_size=32, shuffle=False,
                          num_workers=2, pin_memory=True)

Attention à la normalisation. Quand on utilise un modèle pré-entraîné sur ImageNet, il est crucial d'appliquer la même normalisation que celle utilisée à l'entraînement (moyennes 0,485 / 0,456 / 0,406 et écarts-types 0,229 / 0,224 / 0,225). Sinon, les activations seront décalées et les performances dégradées.

4.2 Mode A — ResNet from scratch

On charge l'architecture sans poids pré-entraînés et on remplace la tête :

from torchvision import models
import torch.nn as nn

model = models.resnet18(weights=None)            # poids aléatoires
model.fc = nn.Linear(model.fc.in_features, num_classes)
model = model.to(device)

criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

L'entraînement standard (boucle for epoch …) sur quatre époques permet d'obtenir une accuracy correcte mais pas exceptionnelle : les filtres convolutifs partent de zéro et ne disposent que de quelques milliers d'images pour apprendre des représentations utiles.

4.3 Mode B — ResNet pré-entraîné, feature extraction

Le bascule vers le transfer learning consiste à charger les poids ImageNet, geler le backbone, et ne ré-entraîner que la tête :

weights = models.ResNet18_Weights.DEFAULT
model = models.resnet18(weights=weights)
model.fc = nn.Linear(model.fc.in_features, num_classes)
model = model.to(device)

# Geler le backbone
for param in model.parameters():
    param.requires_grad = False

# Dé-geler la tête
for param in model.fc.parameters():
    param.requires_grad = True

optimizer = torch.optim.Adam(model.fc.parameters(), lr=1e-3)

Quelques époques suffisent pour atteindre des accuracies nettement supérieures au mode A, avec un coût de calcul plus faible : les gradients ne se propagent que dans fc, le forward sur le backbone reste utile (il extrait les features) mais aucun gradient n'y est calculé.

4.4 Fine-tuning léger

Une fois la tête suffisamment ajustée, on dé-gèle le dernier bloc résiduel et on poursuit avec un learning rate plus faible :

for name, param in model.named_parameters():
    if name.startswith("layer4") or name.startswith("fc"):
        param.requires_grad = True

optimizer = torch.optim.Adam(
    [p for p in model.parameters() if p.requires_grad],
    lr=1e-4,                   # LR plus petit pour ne pas casser les features
)

Heuristique pratique. Pour le fine-tuning, un learning rate d'un ordre de grandeur plus petit que pour la phase précédente est en général un bon point de départ. Si la perte explose, baisser encore. Si elle plafonne, on peut éventuellement augmenter.

4.5 Évaluation

L'évaluation reste classique : passage en mode eval, parcours du test_loader sans gradient, accumulation des prédictions et calcul de la métrique :

from sklearn.metrics import accuracy_score, confusion_matrix

model.eval()
all_preds, all_targets = [], []
with torch.no_grad():
    for Xb, yb in test_loader:
        Xb = Xb.to(device, non_blocking=True)
        preds = torch.argmax(model(Xb), dim=1).cpu().numpy()
        all_preds.append(preds)
        all_targets.append(yb.numpy())

all_preds = np.concatenate(all_preds)
all_targets = np.concatenate(all_targets)

print("Accuracy =", accuracy_score(all_targets, all_preds))
print("Matrice de confusion :\n", confusion_matrix(all_targets, all_preds))

La matrice de confusion est ici plus instructive que la simple accuracy : sur Intel, on observe par exemple des confusions structurées entre glacier, mountain et sea, qui partagent des palettes de couleur et des compositions très proches.

4.6 Visualiser le graphe de calcul

Pour pédagogie ou débogage, on peut visualiser le graphe d'un ResNet avec torchviz :

from torchviz import make_dot
import torch

x = torch.randn(1, 3, 224, 224).to(device)
y = model(x)
make_dot(y, params=dict(model.named_parameters()))

Le résultat est un graphe Graphviz qui montre la propagation : les blocs résiduels s'y lisent comme des chemins parallèles, dont l'un est purement identity (ou une 1×1 downsample).

Anatomie d'un ResNet18. Une Conv2d(3, 64, 7×7, stride=2) suivie d'un MaxPool2d(3, stride=2), puis quatre étages (layer1 à layer4) de deux BasicBlocks chacun, doublant les canaux et divisant la résolution à chaque étage (64 → 128 → 256 → 512), terminés par un AdaptiveAvgPool2d(1) et une couche linéaire. Onze millions de paramètres seulement, mais des représentations remarquablement transférables.

5. De la classification à la détection d'objets

5.1 Changer de question

Toutes les architectures précédentes répondent à une question simple :

Qu'y a-t-il dans l'image ?

Sortie : une seule classe.

image → [classe]

La détection d'objets demande beaucoup plus :

Quels objets sont présents, où sont-ils, et de quel type sont-ils ?

Sortie : une liste de couples (classe, boîte).

image → [(classe, boîte), (classe, boîte), …]

Une boîte englobante (bounding box) est typiquement définie par quatre nombres : un centre $(x_c, y_c)$ et une taille $(w, h)$, ou par deux coins $(x_1, y_1, x_2, y_2)$. Les coordonnées sont en général normalisées entre 0 et 1.

5.2 Pourquoi un CNN de classification ne suffit pas

Un ResNet ou un VGG empilent du pooling et des strides pour produire, à la fin, une prédiction globale unique. La structure spatiale fine est progressivement détruite : le réseau est excellent pour reconnaître, médiocre pour localiser.

5.3 L'approche naïve : la fenêtre glissante

Première idée, intuitive : utiliser un CNN de classification comme un microscope qu'on promène sur l'image.

1. extraire une petite région ;
2. la redimensionner ;
3. la passer dans le CNN ;
4. répéter à chaque position et chaque échelle.

Le problème est computationnel : pour une image 224×224 et plusieurs échelles, on parle facilement de dizaines de milliers de passes dans le CNN. Cette approche, appelée sliding window, est conceptuellement simple mais incompatible avec le temps réel.

5.4 Pourquoi transposer un CNN classifieur est difficile

Un CNN de classification produit une seule prédiction. Pour la détection, il faudrait :

• une prédiction dense, à chaque position spatiale ;
• à plusieurs échelles simultanément ;
• avec plusieurs boîtes possibles par position (un pixel peut appartenir à plusieurs objets).

Cela nécessite :

• de conserver la structure spatiale jusqu'à la sortie ;
• de prédire localisation et classe dans une même architecture ;
• sans multiplier les passes dans le réseau.

C'est précisément ce que YOLO accomplit.

6. YOLO : You Only Look Once

6.1 L'idée clé

YOLO (Redmon et al., 2016) repose sur un retournement de perspective :

Faire la détection en une seule passe du réseau.

Au lieu de découper l'image puis de classifier chaque morceau, YOLO :

• traite l'image entière en une seule passe ;
• la découpe implicitement en une grille (par exemple 7×7 ou 13×13) ;
• prédit directement, pour chaque case, plusieurs boîtes candidates et leur classe.

Schématiquement :

image → CNN → tenseur de prédictions (classes + boîtes + confiances)

6.2 Pourquoi c'est rapide

YOLO doit sa rapidité à plusieurs choix architecturaux :

• une seule passe forward quelle que soit la complexité de la scène ;
• pas de fenêtre glissante, pas de réseau répété ;
• entraînement end-to-end : la même fonction de perte combine la classification et la régression des boîtes.

C'est un changement de paradigme : on ne déplace plus le CNN sur l'image, on projette la détection dans l'espace de sortie du réseau. Les versions modernes (YOLOv5, YOLOv8, YOLO11…) atteignent plusieurs dizaines, voire centaines de FPS sur GPU, tout en restant compétitives en précision avec les détecteurs deux étages de type Faster R-CNN.

6.3 La perte multi-tâche (vue d'ensemble)

Sans entrer dans les détails — qui dépendent de la version — la perte de YOLO combine trois termes :

où :

• $\mathcal{L}_{\text{box}}$ est une régression géométrique (CIoU ou GIoU le plus souvent) sur les coordonnées des boîtes ;
• $\mathcal{L}_{\text{obj}}$ est une binary cross-entropy sur la présence d'un objet dans la case ;
• $\mathcal{L}_{\text{cls}}$ est la cross-entropy multiclasse sur le type d'objet.

Les coefficients $\lambda_{\bullet}$ équilibrent les contributions et sont généralement laissés à leurs valeurs par défaut.

7. Mise en pratique YOLO : Ultralytics

7.1 Format YOLO et préparation des données

Un dataset au format YOLO est structuré ainsi :

dataset_yolo/
├── images/
│   ├── train/
│   ├── val/
│   └── test/        (optionnel)
├── labels/
│   ├── train/
│   ├── val/
│   └── test/        (optionnel)
└── data.yaml

Chaque image possède un fichier .txt de même nom dans labels/, avec une ligne par objet :

id_classe x_centre y_centre largeur hauteur

• coordonnées normalisées entre 0 et 1 ;
• origine en haut à gauche ;
• $(x_c, y_c)$ est le centre de la boîte.

Le fichier data.yaml décrit les chemins des dossiers et la liste des classes :

path: /kaggle/input/mon-dataset-yolo
train: images/train
val:   images/val
nc: 3
names: ['voiture', 'pieton', 'velo']

7.2 Roboflow et l'écosystème

Roboflow est devenu le standard de fait pour annoter des images, convertir d'un format à l'autre, et exporter en format YOLO. Le workflow type est :

1. importer les images dans Roboflow ;
2. annoter (boîtes, masques, points) ;
3. choisir l'export YOLOv8 ou YOLO11 ;
4. télécharger le zip ou le pousser directement vers Kaggle.

La majorité des datasets « clé en main » au format YOLO disponibles publiquement proviennent de Roboflow.

7.3 Entraînement avec Ultralytics

La bibliothèque Ultralytics fournit une API très concise :

!pip install -q ultralytics

from ultralytics import YOLO
import torch

print("CUDA disponible :", torch.cuda.is_available())

# Modèle pré-entraîné COCO (variante "nano", la plus légère)
model = YOLO("yolov8n.pt")

model.train(
    data="/kaggle/input/mon-dataset-yolo/data.yaml",
    imgsz=640,
    epochs=20,
    batch=16,        # à réduire si erreur mémoire
    workers=2,
)

L'argument data pointe vers le data.yaml ; imgsz fixe la taille d'entrée carrée (640 par défaut) ; epochs et batch sont les hyperparamètres habituels.

7.4 Évaluation et prédiction

L'évaluation se fait en une ligne :

metrics = model.val(
    data="/kaggle/input/mon-dataset-yolo/data.yaml",
    imgsz=640,
)
print(metrics)

Les métriques principales en détection sont :

• mAP@50 : mean Average Precision avec un seuil d'IoU de 0,5 ;
• mAP@50:95 : moyenne des mAP pour des seuils d'IoU de 0,5 à 0,95 par pas de 0,05 ;
• précision et rappel par classe.

Pour produire des images annotées sur un dossier de validation :

model.predict(
    source="/kaggle/input/mon-dataset-yolo/images/val",
    imgsz=640,
    conf=0.25,
    save=True,
)

Les images résultantes, avec boîtes et labels superposés, sont sauvegardées dans runs/detect/predict/.

7.5 Conseils pratiques sur Kaggle

• commencer simple : yolov8n.pt, imgsz=640, batch=8 ou 16 ;
• en cas d'erreur mémoire : diminuer batch, ou réduire imgsz à 512 ;
• YOLO est beaucoup plus rapide qu'un CNN + sliding window, mais le temps d'entraînement (qui dépend du nombre d'époques et de la taille des données) reste à anticiper ;
• l'augmentation de données intégrée à Ultralytics (mosaïque, mixup, flip, HSV…) joue un rôle majeur ; elle est activée par défaut.

8. Exercices

Exercice 1 — Intel Image Classification avec un CNN simple

Charger le dataset Intel Image Classification (seg_train/seg_train et seg_test/seg_test) avec ImageFolder, en redimensionnant les images en RGB 224×224. Construire un DataLoader avec batch_size=32, libérer la mémoire GPU avant entraînement, puis entraîner un CNN simple (avec éventuellement BatchNorm et Dropout) sur quatre époques. Évaluer sur seg_test en termes d'accuracy et de matrice de confusion.

Exercice 2 — Intel Image Classification avec ResNet

Reprendre le pipeline de l'exercice 1 et le comparer à deux variantes ResNet :

• Mode A : resnet18 from scratch (poids aléatoires) ;
• Mode B : resnet18 pré-entraîné ImageNet, backbone gelé, seule fc est ré-entraînée.

Optionnellement, dé-geler layer4 et fc pour un fine-tuning léger avec un learning rate plus faible ($10^{-4}$). Comparer les accuracies et les temps d'entraînement.

Indication. Pour le mode B, ajouter transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)) dans le pipeline, sinon les activations seront décalées par rapport aux statistiques ImageNet.

Exercice 3 — Entraîner YOLO sur un dataset Kaggle

Choisir un dataset Kaggle au format YOLO (typiquement exporté depuis Roboflow), inspecter son data.yaml, puis :

1. installer ultralytics et charger yolov8n.pt ;
2. lancer un entraînement de 20 époques en imgsz=640, batch=16 ;
3. évaluer le modèle (model.val) et noter le mAP@50 et le mAP@50:95 ;
4. produire des prédictions visuelles sur le dossier de validation et en commenter au moins trois exemples (vrai positif, faux positif, faux négatif).

Pour aller plus loin

• Articles fondateurs. Krizhevsky et al., ImageNet Classification with Deep Convolutional Neural Networks (AlexNet, 2012) ; Simonyan et Zisserman, Very Deep Convolutional Networks (VGG, 2014) ; He et al., Deep Residual Learning for Image Recognition (ResNet, 2015) ; Redmon et al., You Only Look Once (YOLO, 2016).
• Transfer learning. Yosinski et al., How transferable are features in deep neural networks? (NeurIPS 2014) — l'étude de référence sur la transférabilité couche par couche.
• Détecteurs deux étages. Faster R-CNN (Ren et al., 2015), Mask R-CNN (He et al., 2017) pour la détection et la segmentation d'instances.
• Modèles de fondation en vision. CLIP (Radford et al., 2021) pour la vision-langage, DINO et DINOv2 (Caron et al., 2021 ; Oquab et al., 2023) pour l'auto-supervision, SAM (Kirillov et al., 2023) pour la segmentation universelle.
• Documentation Ultralytics. docs.ultralytics.com — guides à jour sur YOLOv8, YOLO11, formats de données, hyperparamètres et déploiement.
• Roboflow Universe. universe.roboflow.com — milliers de datasets de détection annotés, exportables au format YOLO en un clic.

Conclusion de la séquence Deep Learning. Nous avons parcouru en cinq chapitres le chemin qui mène du perceptron multicouche aux CNN modernes, du from scratch au transfer learning, et de la classification d'image à la détection d'objets. Les architectures changeront — transformers en vision, modèles de fondation, modèles génératifs — mais les principes restent. Construire la bonne représentation, la transférer intelligemment, mesurer rigoureusement : voilà l'essentiel du métier.