Deep Learning 5 — Réseaux convolutifs (3/3)

:::tip Notebook Kaggle Le code complet et exécutable de ce chapitre est sur Kaggle : Ouvrir →

Versions anglaise et chinoise disponibles depuis la page d'accueil. :::

Aujourd'hui, on n'entraîne plus guère de CNN « from scratch » sur des données réelles : on part d'un modèle pré-entraîné. Ce dernier chapitre couvre le transfer learning, puis ouvre sur la détection d'objets avec YOLO.

Pourquoi ce chapitre ?

Vous y voyez :

• le zoo de modèles : ResNet, VGG, MobileNet, EfficientNet ;
• les modèles de fondation comme évolution moderne du zoo ;
• les deux stratégies de transfer learning : feature extraction et fine-tuning ;
• le passage classification → détection d'objets ;
• l'idée et l'utilisation de YOLO.

Le zoo de modèles

Plutôt que de créer une architecture à partir de zéro, on s'appuie sur un zoo de modèles pré-entraînés. En vision, le standard est torchvision.models :

Famille	Variantes	Caractéristique
ResNet	18, 50, 101, 152	Connexions résiduelles, le cheval de bataille
VGG	11, 16, 19	Empilement très profond, beaucoup de paramètres
DenseNet	121, 161, 201	Connexions denses entre couches
MobileNet	V2, V3	Optimisé pour mobile / edge
EfficientNet	B0 à B7	Rapport efficacité / précision optimisé

Chacun a été entraîné sur ImageNet (~1.2 M images, 1000 classes) — un coût de calcul énorme dont nous bénéficions gratuitement.

Modèles de fondation

Le zoo ImageNet est l'ancêtre d'une idée plus large : les modèles de fondation. Entraînés sur des volumes massifs de données (souvent en auto-supervision), ils servent de point de départ pour des dizaines de tâches différentes, avec très peu de données spécifiques.

• Vision : CLIP, DINO, SAM
• Texte : GPT, Llama, Mistral
• Multimodal : tout le bouillonnement actuel

Transfer learning : l'idée centrale

Les premières couches d'un CNN apprennent des représentations générales (bords, textures, motifs simples), les dernières couches apprennent des décisions spécifiques à la tâche.

Conséquence : si nous avons un modèle entraîné sur ImageNet et que nous voulons classifier des radios médicales ou des plantes, nous pouvons réutiliser les premières couches et seulement réapprendre les dernières.

Deux stratégies

1. Feature extraction (gel)

On gèle tout le modèle pré-entraîné, on remplace seulement la dernière couche, on entraîne uniquement cette couche.

from torchvision import models

model = models.resnet18(weights=models.ResNet18_Weights.IMAGENET1K_V1)

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

# Remplacer la tête (1000 classes ImageNet → n_classes nouveau)
model.fc = nn.Linear(model.fc.in_features, n_classes)

# Seuls les paramètres de model.fc sont apprenables
optimizer = torch.optim.Adam(model.fc.parameters(), lr=1e-3)

Avantages : très rapide, peu de risque de surapprentissage, marche même avec très peu de données.

2. Fine-tuning

On dégèle tout (ou seulement les dernières couches) et on continue l'entraînement avec un lr plus petit que d'habitude, pour ne pas casser les bonnes représentations apprises.

for param in model.parameters():
    param.requires_grad = True

optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)   # lr petit !

Avantages : meilleures performances que la feature extraction. Inconvénient : plus coûteux, plus risqué (overfitting si peu de données).

Quand utiliser quelle stratégie ?

Situation	Stratégie
Très peu de données (< 1000)	Feature extraction (gel total)
Beaucoup de données (> 10k)	Fine-tuning complet
Domaine très différent d'ImageNet	Fine-tuning, dégeler les dernières couches d'abord
Production embarquée	Fine-tuning d'un MobileNet ou EfficientNet

Détection d'objets

Classification vs détection

Classification répond à la question « qu'y a-t-il dans cette image ? » avec une seule étiquette.

Détection d'objets répond à « quels objets sont présents, où sont-ils, et de quel type ? » avec potentiellement plusieurs sorties par image.

Une boîte englobante (bounding box) est définie par sa position $(x, y)$ et sa taille $(w, h)$. Le réseau doit prédire, pour chaque objet : sa classe, sa boîte, et un score de confiance.

Pourquoi un classifieur seul ne suffit pas

Un CNN de classification compresse l'image progressivement à travers les MaxPool, perd l'information spatiale fine, et termine par une sortie globale unique. Bon pour reconnaître, mauvais pour localiser.

L'idée de YOLO

YOLO (You Only Look Once, Redmon et al., 2016) propose une révolution simple :

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

Au lieu de découper et reclassifier, YOLO :

• traite l'image en entier d'un coup ;
• la découpe implicitement en une grille (par exemple 13×13) ;
• pour chaque cellule de la grille, prédit directement les classes possibles, plusieurs boîtes candidates, et leur score de confiance.

Une seule forward pass produit toutes les détections. Conséquence : YOLO peut tourner en temps réel (30+ FPS sur GPU moderne).

Format YOLO et entraînement avec Ultralytics

Un dataset au format YOLO :

dataset_yolo/
├── images/
│   ├── train/
│   ├── val/
├── labels/
│   ├── train/
│   ├── val/
└── data.yaml

Chaque image a un fichier .txt associé (même nom de base) dans labels/, avec le format :

id_classe  x_centre  y_centre  largeur  hauteur

Coordonnées normalisées entre 0 et 1.

Entraîner avec Ultralytics

from ultralytics import YOLO

model = YOLO("yolov8n.pt")        # 'n' = nano

model.train(
    data="data.yaml",
    imgsz=640,
    epochs=20,
    batch=16,
)

Le backbone est pré-entraîné sur ImageNet — transfer learning gratuit.

Métriques de détection

Métrique	Description
mAP50	Précision moyenne avec un seuil IoU de 0.5
mAP50-95	Moyenne sur des seuils IoU de 0.5 à 0.95 (plus exigeante)
Précision / rappel	Par classe

L'IoU (Intersection over Union) mesure le chevauchement entre boîte prédite et boîte vérité. Une détection est considérée correcte si IoU ≥ seuil.

Conclusion du parcours

Vous avez maintenant les bases pour aborder la plupart des problèmes de vision par ordinateur modernes :

• comprendre comment un CNN apprend des représentations spatiales ;
• choisir entre feature extraction et fine-tuning selon votre quantité de données ;
• savoir distinguer classification et détection ;
• avoir le réflexe « partir d'un modèle pré-entraîné » plutôt que de tout réinventer.

Pour aller plus loin : segmentation (Mask R-CNN, U-Net), génération (Stable Diffusion), vision-langage (CLIP, BLIP), transformers pour la vision (ViT, DETR).

---

Notebook complet sur Kaggle (forkable) →