Accueil › Glossaire › Feature Map

Feature Map : la représentation interne qui donne la « vue » aux réseaux de neurones

Une feature map (carte de caractéristiques, ou activation map) est une matrice 2D produite par l’application d’un filtre de convolution sur une entrée (image ou feature map précédente). Chaque valeur de cette matrice indique l’intensité avec laquelle un motif spécifique (contour, texture, forme) est détecté à un emplacement donné. L’ensemble des feature maps d’une couche constitue la représentation interne que le réseau utilise pour « comprendre » l’entrée.

Comment une feature map est-elle créée ?

La création d’une feature map suit un processus en trois étapes que chaque couche de convolution répète :

Étape 1 : Convolution. Un filtre (kernel), par exemple une matrice 3×3 de poids appris, glisse sur l’entrée. À chaque position, il effectue un produit scalaire entre ses poids et la zone correspondante de l’entrée. Le résultat est un scalaire qui reflète la « correspondance » entre le motif du filtre et le contenu local de l’entrée.

Étape 2 : Biais et activation. Un biais est ajouté au résultat, puis une fonction d’activation non linéaire (typiquement ReLU) est appliquée. ReLU met à zéro toutes les valeurs négatives et conserve les positives, ce qui introduit la non-linéarité nécessaire à l’apprentissage de patterns complexes.

Étape 3 : Assemblage. En glissant le filtre sur toutes les positions de l’entrée, on obtient une matrice 2D complète : la feature map. Si la couche utilise 64 filtres, elle produit 64 feature maps, empilées pour former un tenseur 3D (hauteur × largeur × 64).

Entrée : image 224×224 RGB (3 canaux)
Couche Conv2D : 64 filtres de taille 3×3, stride 1, padding "same"
→ 64 feature maps de 224×224
→ Tenseur de sortie : 224 × 224 × 64

Après pooling 2×2 :
→ 64 feature maps de 112×112
→ Tenseur de sortie : 112 × 112 × 64

Chacune de ces 64 feature maps répond à un motif différent : l’une détecte les contours verticaux, une autre les textures de fourrure, une troisième les transitions de couleur, etc. Le réseau apprend ces filtres automatiquement pendant l’entraînement via la rétropropagation.

La hiérarchie des feature maps : du pixel à l’objet

L’aspect le plus puissant des CNN est la hiérarchie de features qui émerge naturellement de l’empilement des couches. Les feature maps des différentes profondeurs du réseau ne capturent pas les mêmes informations :

Couches peu profondes : features de bas niveau

Les premières couches (proches de l’entrée) détectent des patterns simples et locaux. Leurs feature maps ressemblent à des détecteurs de :

Contours (horizontaux, verticaux, diagonaux), gradients de couleur, changements de luminosité, textures simples (rayures, points).

Ces features sont universelles : un détecteur de contour vertical est utile que l’on classifie des chats, des voitures ou des cellules biologiques. C’est pourquoi le transfer learning fonctionne si bien : les premières couches d’un réseau pré-entraîné sur ImageNet sont réutilisables pour presque n’importe quelle tâche de vision.

Couches intermédiaires : features de niveau moyen

Les couches du milieu combinent les features de bas niveau pour détecter des structures plus complexes. Leurs feature maps peuvent répondre à des yeux, des roues, des fenêtres, des textures de pelage, des motifs géométriques réguliers. Ces features commencent à être spécifiques à la tâche et au domaine d’application.

Couches profondes : features de haut niveau

Les dernières couches produisent des feature maps très abstraites. Les dimensions spatiales sont réduites (souvent 7×7 ou 14×14) mais le nombre de canaux est élevé (512, 1024, 2048). Chaque feature map de cette profondeur peut répondre à un concept complet : un visage, une voiture vue de profil, un chien de race spécifique. Ce sont ces features qui alimentent directement la couche de classification.

Comprendre les dimensions d’une feature map

Les dimensions d’une feature map dépendent de quatre facteurs :

La formule exacte :

H_out = ⌊(H_in + 2×padding - kernel_size) / stride⌋ + 1
W_out = ⌊(W_in + 2×padding - kernel_size) / stride⌋ + 1
C_out = nombre de filtres

Exemple concret (ResNet, premier bloc) :
Entrée : 224×224×3
Conv 7×7, stride 2, padding 3, 64 filtres
→ Feature map : 112×112×64

Après max pooling 3×3, stride 2, padding 1 :
→ Feature map : 56×56×64

Feature maps au-delà des CNN

Le concept de feature map n’est pas limité aux CNN. Dans les architectures modernes, des représentations équivalentes existent sous d’autres formes :

Vision Transformers (ViT)

Un ViT découpe l’image en patches (par exemple 16×16 pixels) et les traite comme une séquence de tokens. Les représentations intermédiaires ne sont plus des grilles 2D mais des séquences de vecteurs. Cependant, on peut reformater ces vecteurs en grilles 2D pour obtenir l’équivalent de feature maps. Les architectures comme Swin Transformer produisent explicitement des feature maps hiérarchiques, compatibles avec les pipelines de détection d’objets conçus pour les CNN.

Feature Pyramid Networks (FPN)

En détection d’objets, les feature maps de différentes profondeurs sont combinées dans un Feature Pyramid Network. L’idée : les objets petits sont mieux détectés dans les feature maps de haute résolution (couches peu profondes), tandis que les objets grands bénéficient des feature maps profondes. Le FPN fusionne ces informations multi-échelles dans une pyramide unifiée. Des architectures comme YOLO, Faster R-CNN et RetinaNet utilisent cette approche.

Feature maps en NLP

Quand des convolutions 1D sont appliquées à des séquences de texte (comme dans TextCNN), les feature maps résultantes sont des vecteurs 1D où chaque valeur indique la présence d’un n-gramme spécifique à une position donnée dans la phrase. En NLP, on parle plus souvent de « représentations cachées » ou « hidden states », mais le principe est le même : des activations intermédiaires qui capturent des patterns à différents niveaux d’abstraction.

Visualiser les feature maps : comprendre ce que « voit » votre réseau

La visualisation des feature maps est un outil fondamental pour le débogage, l’interprétabilité et la compréhension des CNN.

Visualisation directe

La méthode la plus simple : extraire les feature maps d’une couche et les afficher comme des images en niveaux de gris. Les zones claires indiquent une forte activation (le filtre a détecté son motif), les zones sombres indiquent une faible activation.

import torch
import torchvision.models as models
import matplotlib.pyplot as plt

# Charger un modèle pré-entraîné
model = models.resnet18(pretrained=True)
model.eval()

# Hook pour capturer les feature maps
feature_maps = {}
def hook_fn(module, input, output):
    feature_maps['conv1'] = output.detach()

model.conv1.register_forward_hook(hook_fn)

# Passer une image dans le modèle
# (supposons que 'img_tensor' est un tenseur 1×3×224×224)
with torch.no_grad():
    model(img_tensor)

# Visualiser les 16 premières feature maps de conv1
fmaps = feature_maps['conv1'][0]  # shape: (64, 112, 112)
fig, axes = plt.subplots(4, 4, figsize=(12, 12))
for i, ax in enumerate(axes.flat):
    ax.imshow(fmaps[i].cpu().numpy(), cmap='viridis')
    ax.set_title(f'Filtre {i}')
    ax.axis('off')
plt.tight_layout()
plt.show()

Grad-CAM : des feature maps à l’explicabilité

Grad-CAM (Gradient-weighted Class Activation Mapping) utilise les gradients qui affluent vers la dernière couche de convolution pour produire une carte de chaleur montrant quelles régions de l’image ont le plus contribué à la prédiction. Le processus combine les feature maps de la dernière couche avec leurs gradients par rapport à la classe prédite pour obtenir une visualisation interprétable.

Cette technique est directement dérivée du Global Average Pooling : puisque le GAP agrège chaque feature map en une seule valeur, les poids de la couche fully connected finale indiquent l’importance relative de chaque feature map pour chaque classe. En pondérant les feature maps par ces poids, on obtient une carte qui localise les régions discriminantes.

Feature maps en pratique : ce qu’il faut retenir

Nombre de feature maps dans les architectures courantes

Le nombre de feature maps (canaux) par couche est un hyperparamètre crucial qui varie selon les architectures. Voici les configurations des modèles les plus utilisés :

La tendance générale est de doubler le nombre de canaux à chaque réduction spatiale. ResNet a introduit l’expansion via les blocs bottleneck (64 → 256 canaux dans un seul bloc), ce qui crée des feature maps plus riches avec un nombre de paramètres maîtrisé grâce aux convolutions 1×1.

Impact sur la mémoire

Les feature maps sont le principal consommateur de mémoire GPU pendant l’entraînement. Une seule couche avec 256 feature maps de 56×56 en float32 consomme 256 × 56 × 56 × 4 octets ≈ 3,2 Mo. Multipliez par le nombre de couches et la taille du batch, et vous comprenez pourquoi les modèles de vision requièrent des GPU avec beaucoup de VRAM.

Les techniques de gradient checkpointing permettent de ne conserver qu’un sous-ensemble de feature maps en mémoire pendant l’entraînement, en recalculant les autres lors de la rétropropagation. C’est un compromis calcul-mémoire essentiel pour entraîner de grands modèles.

Layout mémoire (NCHW vs NHWC)

Les feature maps sont stockées en mémoire selon un « layout » qui définit l’ordre des dimensions. Les deux formats principaux sont :

NCHW (batch, canaux, hauteur, largeur) : format par défaut de PyTorch. Optimisé pour les GPU NVIDIA (cuDNN).

NHWC (batch, hauteur, largeur, canaux) : format par défaut de TensorFlow. Meilleur pour certains accélérateurs (TPU, certaines opérations CPU).

Le choix du layout n’affecte pas les résultats mais peut impacter significativement les performances de calcul (jusqu’à 2× selon les benchmarks).

Signes d’alerte dans les feature maps

Lors du débogage d’un CNN, la visualisation des feature maps peut révéler des problèmes :

Feature maps entièrement noires : signe que les neurones sont « morts » (problème de dying ReLU). Envisagez Leaky ReLU ou une meilleure initialisation des poids.

Feature maps identiques entre filtres : les filtres n’apprennent pas des features diversifiées. Vérifiez le learning rate et la normalisation.

Feature maps bruitées dans les couches profondes : le réseau ne converge pas correctement. Possible problème de gradients explosifs ou de données d’entraînement insuffisantes.

Activations très élevées dans les couches profondes : risque d’instabilité numérique. Ajoutez de la batch normalization ou de la layer normalization.

Sparsité des feature maps

Un phénomène important : après l’application de ReLU, une grande proportion des valeurs dans les feature maps est exactement zéro. Dans un réseau entraîné typique, 50 à 80 % des activations sont nulles. Cette sparsité naturelle est bénéfique : elle simplifie la représentation (seuls les features pertinents sont actifs), réduit le coût de calcul (les multiplications par zéro sont gratuites), et améliore la capacité de généralisation.

Certaines architectures exploitent cette sparsité intentionnellement. Les convolutions depthwise separable (MobileNet), le dropout spatial, et les techniques de pruning cherchent à augmenter la sparsité des feature maps pour des gains d’efficacité sur les plateformes embarquées et mobiles.

Feature maps et augmentation de données

Les techniques d’augmentation de données (rotation, retournement, recadrage) modifient les feature maps de manière prévisible grâce à l’équivariance de la convolution. Un retournement horizontal de l’image produit un retournement horizontal de toutes les feature maps. Cette propriété garantit que l’augmentation de données enrichit réellement la diversité des patterns vus par le réseau, sans altérer la cohérence des représentations apprises.

Des techniques plus avancées comme Cutout, CutMix ou Mixup agissent au niveau des feature maps elles-mêmes (et pas seulement des images d’entrée) pour forcer le réseau à ne pas dépendre d’une seule région de l’image pour sa prédiction.