Accueil › Glossaire › CNN

CNN (Convolutional Neural Network)

Un CNN (Convolutional Neural Network, ou réseau de neurones convolutif) est une architecture de deep learning spécialisée dans le traitement de données présentant une structure spatiale, principalement les images. Il apprend automatiquement des hiérarchies de features (contours, textures, formes, objets) grâce à des filtres de convolution appliqués de manière locale et partagée sur toute l’entrée.

Pourquoi les CNN ont révolutionné la vision par ordinateur

Avant les CNN, la vision par ordinateur reposait sur des features manuelles : des ingénieurs concevaient à la main des détecteurs de contours, de textures et de formes (SIFT, HOG, Haar), puis les passaient à un classifieur classique comme un SVM. Cette approche était laborieuse, fragile et plafonnait en performance.

En 2012, AlexNet (Alex Krizhevsky, Ilya Sutskever, Geoffrey Hinton) a remporté le challenge ImageNet avec un taux d’erreur de 15.3%, contre 26.2% pour le second. Cet écart de 10 points a déclenché la révolution du deep learning. La raison du succès : le CNN apprend ses propres features directement à partir des pixels, sans intervention humaine. Les couches basses détectent les contours et les textures ; les couches intermédiaires reconnaissent des motifs plus complexes (yeux, roues, fenêtres) ; les couches hautes identifient des objets entiers.

Depuis, les CNN ont dominé la quasi-totalité des tâches de vision par ordinateur : classification d’images, détection d’objets, segmentation, reconnaissance faciale, imagerie médicale, conduite autonome.

Architecture d’un CNN

Un CNN typique se compose de trois types de couches empilées en séquence, suivies de couches fully connected pour la décision finale.

La couche de convolution

C’est le cœur du CNN. Un filtre (ou kernel), typiquement de taille 3×3 ou 5×5, glisse sur l’image d’entrée. À chaque position, il calcule un produit scalaire entre ses poids et la zone locale de l’image, produisant une valeur dans la feature map de sortie.

Chaque filtre apprend à détecter un motif spécifique (contour horizontal, contour vertical, texture, couleur). Une couche de convolution contient plusieurs filtres, donc produit plusieurs feature maps en parallèle.

Deux propriétés fondamentales rendent les CNN efficaces :

Partage des poids : le même filtre est appliqué à toutes les positions de l’image. Un filtre qui détecte un contour en haut à gauche le détecte aussi en bas à droite. Cela réduit drastiquement le nombre de paramètres par rapport à un réseau fully connected.

Connectivité locale : chaque neurone de sortie ne dépend que d’une petite zone de l’entrée (le champ récepteur). Cela exploite la structure spatiale des images, où les pixels voisins sont corrélés.

La fonction d’activation

Après chaque convolution, une fonction d’activation non linéaire est appliquée. La plus utilisée est ReLU (Rectified Linear Unit) : f(x) = max(0, x). Elle met simplement les valeurs négatives à zéro.

ReLU a remplacé les fonctions sigmoïde et tanh qui souffraient du problème de gradient qui s’évanouit (vanishing gradient). ReLU est rapide à calculer et permet d’entraîner des réseaux profonds sans que le gradient ne disparaisse dans les couches basses.

Des variantes existent : Leaky ReLU (laisse passer une petite fraction des valeurs négatives), ELU, GELU (utilisée dans les Transformers), Swish (utilisée dans EfficientNet).

La couche de pooling

Le pooling réduit la taille spatiale des feature maps, ce qui diminue le nombre de paramètres et le coût de calcul, tout en rendant les features plus robustes aux petites translations.

Max pooling : prend la valeur maximale dans chaque zone (typiquement 2×2 avec stride 2). C’est la forme la plus courante. Elle préserve les features les plus saillantes.

Average pooling : prend la moyenne de chaque zone. Plus lisse, parfois utilisé dans les couches finales (Global Average Pooling).

Global Average Pooling (GAP) : prend la moyenne de toute la feature map. Utilisé comme remplacement des couches fully connected dans les architectures modernes (GoogLeNet, ResNet). Réduit drastiquement le nombre de paramètres et l’overfitting.

Les couches fully connected

En fin de réseau, les feature maps sont aplaties (flattened) en un vecteur 1D, puis passées à une ou plusieurs couches entièrement connectées qui produisent la prédiction finale. La dernière couche utilise généralement une activation softmax pour la classification multiclasse ou sigmoïde pour la classification binaire.

Dans les architectures modernes, les couches fully connected sont souvent remplacées par un Global Average Pooling suivi d’une seule couche linéaire, ce qui réduit considérablement le nombre de paramètres.

Les architectures CNN qui ont marqué l’histoire

ResNet : la révolution des skip connections

ResNet (He et al., 2015) a résolu le problème de la dégradation : empiler plus de couches ne produisait pas toujours de meilleurs résultats car le gradient s’évanouissait ou explosait. Les connexions résiduelles (skip connections) permettent au gradient de « sauter » des couches, facilitant l’entraînement de réseaux de 50, 101, voire 152 couches. C’est l’architecture CNN la plus influente de la dernière décennie.

EfficientNet : le scaling intelligent

EfficientNet (Tan & Le, 2019) a montré qu’augmenter la profondeur, la largeur et la résolution d’entrée de manière coordonnée (compound scaling) produit de meilleurs résultats qu’augmenter une seule dimension. Sa famille de modèles (B0 à B7) couvre un spectre allant des appareils mobiles aux serveurs haute performance.

ConvNeXt : le CNN qui rivalise avec les Transformers

ConvNeXt (Facebook Research, 2022) a démontré qu’un CNN « modernisé » (convolutions plus larges, activation GELU, normalisation par couche, design inspiré des Transformers) peut atteindre des performances comparables aux Vision Transformers, tout en conservant la simplicité et l’efficacité des convolutions. C’est l’argument le plus fort pour dire que les CNN ne sont pas obsolètes.

Implémentation avec PyTorch

Voici un CNN simple pour la classification d’images, illustrant les composants fondamentaux :

import torch
import torch.nn as nn

class SimpleCNN(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        
        # Bloc 1 : Conv -> ReLU -> MaxPool
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        
        # Bloc 2 : Conv -> ReLU -> MaxPool
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
        self.conv4 = nn.Conv2d(128, 128, kernel_size=3, padding=1)
        
        # Classification
        self.gap = nn.AdaptiveAvgPool2d(1)  # Global Average Pooling
        self.fc = nn.Linear(128, num_classes)
        self.relu = nn.ReLU()
        self.dropout = nn.Dropout(0.5)
    
    def forward(self, x):
        # x shape: (batch, 3, H, W)
        x = self.relu(self.conv1(x))
        x = self.pool(self.relu(self.conv2(x)))
        
        x = self.relu(self.conv3(x))
        x = self.pool(self.relu(self.conv4(x)))
        
        x = self.gap(x)           # (batch, 128, 1, 1)
        x = x.view(x.size(0), -1) # (batch, 128)
        x = self.dropout(x)
        x = self.fc(x)            # (batch, num_classes)
        return x

model = SimpleCNN(num_classes=10)
print(f"Paramètres : {sum(p.numel() for p in model.parameters()):,}")

En pratique, on utilise rarement un CNN entraîné from scratch. Le transfer learning (fine-tuning d’un modèle pré-entraîné sur ImageNet) est la méthode standard :

import torchvision.models as models

# Charger ResNet-50 pré-entraîné
model = models.resnet50(weights='IMAGENET1K_V2')

# Remplacer la dernière couche pour votre tâche
num_classes = 5  # ex: 5 types de défauts industriels
model.fc = nn.Linear(model.fc.in_features, num_classes)

# Geler les premières couches (optionnel)
for param in list(model.parameters())[:-10]:
    param.requires_grad = False

Types de convolutions avancées

La convolution 2D standard n’est qu’un point de départ. Les architectures modernes utilisent des variantes spécialisées.

Applications des CNN

Classification d’images : la tâche historique. Identifier ce que contient une image (chat, chien, voiture). Les CNN atteignent une performance surhumaine sur ImageNet depuis 2015.

Détection d’objets : localiser et identifier plusieurs objets dans une image avec des bounding boxes. Architectures clés : YOLO (temps réel), Faster R-CNN (précision), DETR (approche Transformer).

Segmentation sémantique : classer chaque pixel de l’image. U-Net (imagerie médicale), DeepLab (scènes naturelles), SAM (segmentation universelle).

Imagerie médicale : détection de tumeurs, classification de radiographies, analyse de coupes histologiques. Les CNN rivalisent avec les radiologues sur certaines tâches.

Conduite autonome : détection de piétons, de véhicules, de panneaux et de lignes de voie en temps réel.

OCR : reconnaissance de texte dans les images. Les CNN extraient les features visuelles que le décodeur transforme en texte.

Au-delà des images : les convolutions 1D sont utilisées pour l’analyse de signaux temporels (ECG, vibrations, audio), et les convolutions 3D pour la vidéo et l’imagerie médicale volumétrique.

CNN vs Vision Transformer : le débat

Depuis 2020, les Vision Transformers (ViT) défient la suprématie des CNN. Le mécanisme d’attention des Transformers capture les dépendances à longue distance qu’un CNN ne voit pas (un filtre 3×3 a un champ récepteur local).

La tendance actuelle est aux architectures hybrides : un backbone CNN pour l’extraction efficace des features locales dans les premières couches, puis des blocs Transformer pour capturer les dépendances globales dans les couches profondes. Des architectures comme CoAtNet, BoTNet et Swin Transformer exploitent cette complémentarité.

ConvNeXt a également montré qu’en modernisant le design d’un CNN pur (convolutions 7×7, GELU, Layer Normalization), on peut rivaliser avec les ViT sans aucun mécanisme d’attention. Le débat n’est donc pas tranché : les CNN ne sont pas morts, ils évoluent.

Bonnes pratiques

Utilisez le transfer learning. Entraîner un CNN from scratch ne se justifie presque jamais (sauf si vos données sont radicalement différentes d’ImageNet). Fine-tuner un modèle pré-entraîné est plus rapide, plus performant et nécessite moins de données.

Appliquez la data augmentation. Rotations, flips, crops aléatoires, changements de luminosité, MixUp, CutMix. L’augmentation de données est la régularisation la plus efficace pour les CNN.

Choisissez l’architecture adaptée à votre contrainte. EfficientNet-B0 ou MobileNet pour le mobile/edge. ResNet-50 ou ConvNeXt-Base pour les serveurs. Ne prenez pas le plus gros modèle par défaut.

Utilisez le Batch Normalization. C’est inclus par défaut dans les architectures modernes, mais si vous construisez un CNN custom, ajoutez une couche BatchNorm après chaque convolution. Elle accélère la convergence et stabilise l’entraînement.

Préférez le Global Average Pooling aux couches fully connected massives en fin de réseau. Le GAP réduit l’overfitting et le nombre de paramètres.

Surveillez l’overfitting. Les CNN avec des millions de paramètres peuvent mémoriser le dataset d’entraînement. Utilisez Dropout, early stopping, et un jeu de validation séparé.