Convolution

La convolution consiste à faire glisser une petite grille de poids, appelée noyau ou filtre, sur une entrée et à calculer une somme pondérée à chaque position. En vision par ordinateur (CV), l'entrée est une image ou une pile de cartes de caractéristiques, et chaque noyau produit une carte de sortie dont les valeurs sont élevées là où son motif apparaît : un bord vertical, une zone texturée ou, plus profondément dans un réseau, une partie de roue ou de visage. Les noyaux conçus à la main sont utilisés depuis longtemps en traitement d'images pour le flou, l'accentuation et la détection de contours. Dans un réseau neuronal convolutif (CNN), les valeurs du noyau sont des poids du modèle appris pendant l'entraînement ; le réseau découvre ainsi ses propres détecteurs de caractéristiques.

Fonctionnement de la convolution#

À chaque position, le noyau est appliqué à une zone de l'entrée ; chaque poids du noyau est multiplié par la valeur d'entrée située en dessous, puis les produits sont additionnés, avec un biais, pour obtenir une valeur de sortie. Le déplacement du noyau sur toute la hauteur et toute la largeur produit une carte de sortie bidimensionnelle. Les entrées réelles comportent plusieurs canaux, comme les canaux rouge, vert et bleu d'une image ; chaque noyau s'étend donc sur tous les canaux d'entrée : un noyau 3×3 appliqué à une entrée de 64 canaux contient 3 × 3 × 64 = 576 poids et produit toujours un seul canal de sortie. Une couche convolutive applique plusieurs noyaux de ce type, et leur nombre détermine celui des canaux de sortie ; une couche passant de 64 à 128 canaux avec des noyaux 3×3 contient donc 3 × 3 × 64 × 128 = 73 728 poids.

Le même noyau est réutilisé à chaque position ; les couches convolutives ont donc beaucoup moins de paramètres que les couches entièrement connectées, et un motif appris dans un coin de l'image est reconnu partout ailleurs. Le décalage de l'entrée entraîne le même décalage de la sortie : cette propriété s'appelle l'équivariance par translation. Chaque valeur de sortie dépend uniquement d'un petit voisinage de l'entrée, et l'empilement des couches élargit le champ réceptif résumé par une valeur de sortie profonde, de quelques pixels à presque toute l'image.

Les bibliothèques d'apprentissage profond calculent en réalité une corrélation croisée : la convolution mathématique inverse le noyau avant de le faire glisser, contrairement à Conv2d de PyTorch. Comme le noyau est appris, le réseau apprend simplement les poids inversés ; en pratique, les deux opérations sont donc interchangeables. Les bibliothèques GPU, comme cuDNN, reformulent généralement la convolution sous forme de multiplication de grandes matrices ou utilisent des algorithmes de Winograd ou fondés sur la FFT, qui calculent le même résultat plus rapidement que le déplacement littéral du noyau.

Pas, remplissage, dilatation et groupes#

Quatre hyperparamètres déterminent la forme de la sortie d'une convolution et le coût de son calcul :

• Pas : Distance entre les positions successives du noyau. Un pas de 2 saute une position sur deux et réduit de moitié la hauteur et la largeur de la sortie ; c'est ainsi que de nombreux CNN modernes effectuent le sous-échantillonnage.
• Remplissage : Valeurs supplémentaires, généralement des zéros, ajoutées autour du bord de l'entrée. Un remplissage de 1 conserve la même taille pour la sortie d'une convolution 3×3 que pour son entrée, avec un pas de 1.
• Dilatation : Espace les points d'application du noyau ; un noyau 3×3 avec une dilatation de 2 couvre ainsi une zone de 5×5 avec les mêmes neuf poids, ce qui élargit le champ réceptif sans coût supplémentaire.
• Groupes : Divise les canaux en groupes indépendants. Avec un groupe par canal, une convolution en profondeur filtre chaque canal séparément ; une convolution ponctuelle 1×1 qui suit mélange les canaux. Cette paire, appelée convolution séparable en profondeur, a été popularisée par MobileNets pour le matériel mobile.

Pour une entrée de taille n, une taille de noyau k, un remplissage p, un pas s et une dilatation d, la taille de sortie est ⌊(n + 2p − d(k − 1) − 1) / s⌋ + 1. L'extrait ci-dessous applique quatre couches qui transforment chacune une carte de caractéristiques de 64 canaux et de 80×80 en 128 canaux :

import torch
from torch import nn

x = torch.randn(1, 64, 80, 80)  # a 64-channel, 80x80 feature map

# Four ways to map 64 input channels to 128 output channels
layers = {
    "standard 3x3": nn.Conv2d(64, 128, kernel_size=3, padding=1, bias=False),
    "stride 2": nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1, bias=False),
    "dilation 2": nn.Conv2d(64, 128, kernel_size=3, padding=2, dilation=2, bias=False),
    "depthwise separable": nn.Sequential(
        nn.Conv2d(64, 64, kernel_size=3, padding=1, groups=64, bias=False),  # one 3x3 filter per channel
        nn.Conv2d(64, 128, kernel_size=1, bias=False),  # 1x1 convolution mixes channels
    ),
}
for name, layer in layers.items():
    params = sum(p.numel() for p in layer.parameters())
    print(f"{name}: output {tuple(layer(x).shape)}, {params:,} weights")

La couche standard produit (1, 128, 80, 80) avec 73 728 poids. Un pas de 2 réduit la sortie de moitié, à (1, 128, 40, 40), avec le même nombre de poids ; une dilatation de 2 conserve les dimensions 80×80 et les 73 728 poids, tandis que chaque sortie couvre une zone de 5×5. La paire séparable en profondeur produit la même sortie (1, 128, 80, 80) avec seulement 8 768 poids, soit environ 8,4 fois moins. YOLO26 utilise les deux approches : cinq convolutions 3×3 de pas 2 réduisent une image 640×640 à la grille 20×20 de la carte de caractéristiques la plus profonde de son backbone, et la branche de classification de sa tête de détection associe des convolutions 3×3 en profondeur et 1×1 ponctuelles pour réduire le calcul.

Convolution dans d'autres dimensions#

• Convolution 1D : Se déplace le long d'un seul axe pour traiter les formes d'onde audio, les signaux de capteurs et les séries temporelles.
• Convolution 3D : Ajoute un axe de profondeur ou de temps pour traiter des séquences vidéo et des examens volumiques, comme les scanners CT et IRM en analyse d'images médicales.
• Convolution transposée : Répartit chaque valeur d'entrée sur une sortie plus grande et suréchantillonne les cartes de caractéristiques dans les modèles de segmentation comme U-Net. Elle rétablit la taille spatiale réduite par une convolution à pas, à l'aide de ses propres poids appris.

Convolution et opérations associées#

• Couche entièrement connectée : Relie chaque entrée à chaque sortie avec un poids qui lui est propre. Une convolution est une couche entièrement connectée restreinte à des voisinages locaux, avec des poids partagés entre les positions.
• Mise en commun : Fait glisser une fenêtre comme une convolution, mais applique une règle fixe, par exemple prendre la valeur maximale, sans poids appris.
• Auto-attention : Calcule des poids dépendant des données entre chaque paire de positions, ce qui lui permet de relier des parties éloignées d'une image en une seule couche. Une convolution applique le même noyau fixe partout et ne voit qu'une fenêtre locale, ce qui maintient son coût linéaire par rapport au nombre de pixels.
• Filtrage d'images : Les filtres classiques comme le flou gaussien et le détecteur de contours de Sobel sont des convolutions à noyaux fixes conçus à la main. filter2D d'OpenCV calcule aussi une corrélation, comme les bibliothèques d'apprentissage profond ; l'inversion du noyau permet d'obtenir une véritable convolution.