Accueil › Glossaire › Convolution

Convolution : l’opération qui a révolutionné la vision par ordinateur

En deep learning, la convolution est une opération mathématique qui applique un filtre (kernel) sur des données d’entrée pour en extraire des caractéristiques locales, comme des contours, des textures ou des motifs. C’est la brique fondamentale des réseaux de neurones convolutifs (CNN), l’architecture qui a dominé la classification d’images pendant plus d’une décennie.

Comment fonctionne la convolution ?

Imaginez une loupe que vous faites glisser sur une image, pixel par pixel. À chaque position, la loupe examine une petite zone (le champ récepteur), effectue un calcul, et produit un seul nombre en sortie. En faisant glisser cette loupe sur toute l’image, vous obtenez une nouvelle image (la feature map) qui met en évidence les zones où un certain motif a été détecté.

Plus formellement, l’opération de convolution 2D se décompose en trois étapes :

1. Positionnement du kernel : un petit filtre (matrice de poids, par exemple 3×3) est placé sur un patch de l’image d’entrée.

2. Multiplication et somme : chaque valeur du kernel est multipliée par la valeur correspondante du patch d’image. Tous ces produits sont additionnés pour donner un scalaire.

3. Déplacement : le kernel se déplace d’un certain nombre de pixels (le stride) et l’opération se répète, jusqu’à couvrir toute l’image.

Le résultat est une feature map qui indique où et avec quelle intensité le motif encodé dans le kernel apparaît dans l’image.

Exemple numérique concret

Prenons une image 5×5 en niveaux de gris et un kernel 3×3 conçu pour détecter les contours verticaux :

Image (5×5):              Kernel (3×3):
1  0  1  0  1             -1  0  1
1  0  1  0  1             -1  0  1
1  0  1  0  1             -1  0  1
1  0  1  0  1
1  0  1  0  1

Position (0,0) : (-1×1)+(0×0)+(1×1)+(-1×1)+(0×0)+(1×1)+(-1×1)+(0×0)+(1×1) = 0
Position (0,1) : (-1×0)+(0×1)+(1×0)+(-1×0)+(0×1)+(1×0)+(-1×0)+(0×1)+(1×0) = 0
Position (0,2) : (-1×1)+(0×0)+(1×1)+(-1×1)+(0×0)+(1×1)+(-1×1)+(0×0)+(1×1) = 0

Feature map résultante (3×3) : que des zéros
→ Pas de contour vertical détecté (les colonnes alternent régulièrement)

Si l’image contenait une transition nette entre une zone sombre et une zone claire, les valeurs de la feature map seraient élevées à cet endroit, signalant la présence d’un contour.

Les hyperparamètres de la convolution

Taille du kernel (filtre)

Le kernel est la matrice de poids qui définit quel motif la convolution cherche. Les tailles courantes sont 1×1, 3×3, 5×5 et 7×7. Les kernels impairs sont privilégiés car ils permettent un padding symétrique.

Les kernels petits (3×3) sont devenus le standard depuis VGGNet (2014). L’intuition : empiler deux couches de convolution 3×3 couvre un champ récepteur de 5×5, mais avec moins de paramètres et plus de non-linéarité (deux activations au lieu d’une). C’est un principe fondamental de l’architecture des CNN modernes.

La convolution 1×1, introduite dans GoogLeNet (2014), est un cas spécial. Elle ne regarde qu’un seul pixel spatialement, mais agit sur tous les canaux simultanément. Elle sert à réduire ou augmenter le nombre de canaux (dimensionnalité), ajoutant une non-linéarité sans changer les dimensions spatiales.

Stride (pas de déplacement)

Le stride définit de combien de pixels le kernel se déplace à chaque étape. Un stride de 1 signifie que le kernel glisse pixel par pixel. Un stride de 2 signifie qu’il saute un pixel à chaque pas, divisant les dimensions spatiales de la sortie par deux.

La formule de la dimension de sortie est :

Sortie = ⌊(Entrée + 2×Padding - Kernel) / Stride⌋ + 1

Par exemple, une image 32×32 avec un kernel 3×3, stride 1 et padding 0 donne une sortie de 30×30. Avec un stride de 2 et padding 1, la sortie serait de 16×16. Le stride est un outil puissant pour contrôler la résolution spatiale sans recourir au pooling.

Padding (remplissage)

Sans padding, chaque couche de convolution réduit les dimensions spatiales de l’entrée. Après 10 couches de convolution 5×5 sans padding, une image de 240×240 serait réduite à 200×200, perdant 30 % de sa surface et toute l’information des bords.

Le padding résout ce problème en ajoutant des pixels (généralement des zéros) autour de l’entrée :

Padding « valid » (pas de padding) : la sortie est plus petite que l’entrée. Simple mais perd l’information aux bords.

Padding « same » : suffisamment de zéros sont ajoutés pour que la sortie ait les mêmes dimensions que l’entrée (avec stride 1). C’est le choix le plus courant.

Pour un kernel 3×3, un padding de 1 pixel de chaque côté suffit à maintenir les dimensions. Pour un kernel 5×5, il faut un padding de 2.

Canaux et nombre de filtres

Une image couleur a 3 canaux (RGB). Le kernel de convolution s’étend sur toute la profondeur de l’entrée : pour une entrée à 3 canaux et un kernel 3×3, le filtre est en réalité un tenseur 3×3×3. Le résultat de cette convolution est une feature map 2D unique.

En appliquant plusieurs filtres (chacun avec ses propres poids), on obtient autant de feature maps que de filtres. Le nombre de filtres est un hyperparamètre qui contrôle la « largeur » de la couche. Les architectures typiques commencent avec 64 filtres et doublent à chaque réduction spatiale (64 → 128 → 256 → 512), suivant le modèle établi par VGGNet.

Propriétés fondamentales de la convolution

Partage de poids (parameter sharing)

C’est la propriété la plus importante. Un même filtre (mêmes poids) est utilisé à toutes les positions de l’image. Si un filtre apprend à détecter un contour horizontal, il le détectera partout dans l’image, pas seulement dans un coin. C’est le partage de poids qui rend les CNN si efficaces par rapport aux réseaux entièrement connectés (feed-forward denses).

Un réseau fully connected pour une image 100×100 nécessiterait 10 000 poids par neurone de la première couche cachée. Un kernel de convolution 5×5 n’a besoin que de 25 poids, quel que soit la taille de l’image. Cette réduction massive du nombre de paramètres prévient le surapprentissage et rend l’entraînement tractable.

Équivariance à la translation

Grâce au partage de poids, si un objet se déplace dans l’image, sa représentation dans la feature map se déplace de manière correspondante. Un chat détecté en haut à gauche produira les mêmes activations s’il est déplacé en bas à droite, simplement à une position différente dans la feature map.

Extraction hiérarchique de caractéristiques

L’empilement de couches de convolution crée une hiérarchie de caractéristiques : les premières couches détectent des patterns simples (contours, textures), les couches intermédiaires combinent ces patterns en formes (yeux, roues), et les couches profondes reconnaissent des objets complets (visages, voitures). Cette hiérarchie émerge naturellement de l’entraînement, sans programmation explicite.

Variantes de la convolution

Convolution 1D

Le kernel glisse le long d’une seule dimension. Applications principales :

Traitement du texte (NLP) : les filtres 1D agissent comme des détecteurs de n-grammes sur des séquences d’embeddings de mots.

Traitement audio : extraction de caractéristiques à partir de formes d’onde brutes pour la reconnaissance vocale ou la classification musicale.

Séries temporelles : détection de motifs dans les données financières, capteurs IoT, signaux biomédicaux.

Convolution 3D

Le kernel se déplace dans trois dimensions spatiales (largeur, hauteur, profondeur/temps). Utilisée pour le traitement vidéo (la troisième dimension étant le temps) et l’imagerie médicale volumétrique (IRM, scanners CT).

Convolution depthwise separable

Introduite dans MobileNet (2017), cette variante décompose la convolution standard en deux étapes : une convolution depthwise (un filtre par canal) suivie d’une convolution pointwise (1×1). Le résultat est mathématiquement similaire mais avec une réduction drastique du nombre de paramètres et de calculs. Pour un kernel 3×3 avec 256 canaux d’entrée et 256 de sortie, la version depthwise separable nécessite environ 9× moins de calculs. C’est la base des architectures mobiles et embarquées.

Convolution dilatée (atrous)

Le kernel est « écarté » en insérant des espaces entre ses éléments. Un kernel 3×3 avec un taux de dilatation de 2 couvre un champ récepteur effectif de 5×5 sans augmenter le nombre de paramètres. Cette technique permet de capturer des dépendances à longue portée sans réduire la résolution spatiale, très utile en segmentation sémantique.

Convolution transposée (déconvolution)

Opération inverse de la convolution standard : elle augmente les dimensions spatiales au lieu de les réduire. Utilisée dans les décodeurs d’autoencodeurs, les réseaux de segmentation (U-Net), et les GAN pour générer des images à partir de vecteurs latents.

Architectures historiques basées sur la convolution

L’évolution des architectures CNN montre comment des innovations dans l’utilisation de la convolution ont progressivement repoussé les limites de la vision par ordinateur :

LeNet-5 (1998, Yann LeCun) : première architecture CNN fonctionnelle, conçue pour la reconnaissance de chiffres manuscrits. Deux couches de convolution suivies de pooling et de couches fully connected. Elle a posé les fondations de toutes les architectures CNN suivantes.

AlexNet (2012) : le déclencheur de la révolution deep learning. Cinq couches de convolution, activation ReLU (au lieu de sigmoid), dropout, et entraînement sur GPU. Victoire écrasante au challenge ImageNet avec un taux d’erreur de 16,4 %, loin devant les méthodes classiques.

VGGNet (2014) : a montré que la profondeur compte. Architecture uniforme avec uniquement des convolutions 3×3 empilées. 16 à 19 couches. A établi le principe « petits kernels, réseau profond ».

GoogLeNet/Inception (2014) : a introduit le module Inception, qui applique en parallèle des convolutions de tailles différentes (1×1, 3×3, 5×5) et concatène les résultats. Innovation majeure : la convolution 1×1 comme réducteur de dimensionnalité.

ResNet (2015) : les connexions résiduelles (skip connections) ont permis d’entraîner des réseaux de 50, 101, voire 152 couches sans dégradation. Le concept de « résidu » (apprendre la différence plutôt que la transformation complète) a changé la donne pour toutes les architectures profondes.

ConvNeXt (2022, Meta AI) : a modernisé le CNN en adoptant les choix de design des Vision Transformers (ViT). Utilise des convolutions depthwise 7×7, layer normalization, activation GELU, et un « bottleneck inversé ». Résultat : des performances compétitives avec les Transformers tout en gardant la simplicité et l’efficacité des CNN.

Convolution vs Transformers : le débat actuel

Depuis l’introduction du Vision Transformer (ViT) en 2020, le paysage de la vision par ordinateur a changé. Les Transformers remplacent la convolution par le mécanisme de self-attention pour capturer les relations globales dans l’image dès la première couche.

Voici le résumé du débat :

La convolution dans les Transformers NLP

Fait souvent oublié : le Transformer original décrit son FFN comme « deux convolutions avec des kernels de taille 1 ». En effet, une convolution 1×1 appliquée position par position est mathématiquement identique à une couche linéaire. Certaines architectures récentes réintroduisent explicitement des convolutions dans les Transformers :

Conformer : combine convolution et attention pour la reconnaissance vocale, avec des résultats supérieurs aux architectures purement attentionnelles.

ConvBERT : remplace une partie des têtes d’attention par des convolutions, réduisant le coût computationnel tout en maintenant les performances.

Hyena : utilise des convolutions longues comme alternative à l’attention quadratique pour traiter des séquences très longues.

Implémentation en PyTorch

Voici comment utiliser les couches de convolution en pratique :

import torch
import torch.nn as nn

# Convolution 2D standard
conv2d = nn.Conv2d(
    in_channels=3,       # 3 canaux RGB
    out_channels=64,     # 64 filtres
    kernel_size=3,       # kernel 3x3
    stride=1,            # pas de 1
    padding=1            # padding "same"
)

# Entrée : batch de 8 images 224x224 RGB
x = torch.randn(8, 3, 224, 224)
out = conv2d(x)
print(out.shape)  # torch.Size([8, 64, 224, 224])

# Convolution 1D pour texte/audio
conv1d = nn.Conv1d(
    in_channels=300,     # dimension d'embedding
    out_channels=128,    # 128 filtres
    kernel_size=5,       # fenêtre de 5 tokens
    padding=2            # padding "same"
)

# Entrée : batch de 16 séquences de 100 tokens, embedding dim 300
x_text = torch.randn(16, 300, 100)
out_text = conv1d(x_text)
print(out_text.shape)  # torch.Size([16, 128, 100])

# Convolution depthwise separable
depthwise = nn.Conv2d(64, 64, kernel_size=3, padding=1, groups=64)
pointwise = nn.Conv2d(64, 128, kernel_size=1)
# Équivalent à une conv standard 3x3 64->128
# mais avec ~9x moins de calculs

Pièges courants et bonnes pratiques

Oublier le padding : sans padding, les dimensions diminuent à chaque couche. Avec 20 couches de convolution 3×3 sans padding, une image 256×256 devient 216×216, perdant 29 % de sa surface. Utilisez padding='same' par défaut.

Trop de paramètres en couche fully connected : la transition entre les couches convolutives et la couche de classification est souvent le goulot d’étranglement. Utilisez le global average pooling au lieu de flatten + dense pour réduire drastiquement le nombre de paramètres.

Kernels trop grands : sauf cas spécifique (ConvNeXt avec ses 7×7 depthwise), préférez empiler des convolutions 3×3 plutôt qu’utiliser un seul grand kernel. Vous gagnez en non-linéarité et en efficacité.

Ignorer la batch normalization : dans un CNN, la norme est d’appliquer une normalisation après chaque convolution (batch norm ou layer norm) et avant l’activation. Omettre cette étape déstabilise l’entraînement des réseaux profonds.