Detection Head

Une tête de détection est l'ensemble final de couches d'un réseau de détection d'objets. Elle lit les cartes de caractéristiques produites par les couches précédentes et génère, à chaque position candidate, une boîte englobante et un score pour chaque classe. Sa conception détermine la manière d'encoder les boîtes — sous forme de décalages par rapport aux boîtes d'ancrage ou de distances à partir d'un point —, le nombre de boîtes candidates produites par le modèle et la nécessité d'une étape de post-traitement comme la suppression des non-maxima (NMS) pour éliminer les doublons.

Emplacement de la tête#

Les détecteurs modernes se composent de trois étapes. Un backbone, généralement un réseau convolutif ou un transformer de vision, convertit les pixels en cartes de caractéristiques dont la résolution diminue et le contenu sémantique augmente avec la profondeur. Un neck, comme un réseau pyramidal de caractéristiques (FPN), fusionne les cartes profondes et superficielles afin que chaque échelle de sortie contienne à la fois des détails fins et du contexte. La tête applique ensuite de petites branches convolutives à chaque niveau de la pyramide, généralement avec des pas de 8, 16 et 32, de sorte que les cartes fines repèrent les petits objets et les cartes grossières les objets volumineux.

Les détecteurs à une étape ont une seule tête dense qui effectue des prédictions sur chaque cellule de la grille. Les détecteurs à deux étapes, comme Faster R-CNN, en ont deux : un réseau de proposition de régions qui attribue un score aux ancres à chaque position, puis une tête de région d'intérêt qui classe et affine les quelques centaines de régions proposées.

Comment une tête prédit les boîtes et les classes#

À chaque cellule de la grille, une tête dense prédit trois types de valeurs :

• Scores de classe : Un score par classe, chacun passant par une sigmoïde afin qu'une position puisse obtenir un score indépendant pour chaque classe.
• Régression des boîtes : Quatre nombres qui positionnent une boîte, soit des décalages qui déplacent et redimensionnent une boîte d'ancrage, soit les distances entre le centre de la cellule et les quatre bords de la boîte.
• Qualité et sorties propres à la tâche : Un score d'objectivité (YOLOv1 à YOLOv5) ou de centralité (FCOS) qui classe les boîtes, ainsi que des valeurs propres à la tâche, comme les coefficients de masque pour la segmentation d'instances ou les points clés pour l'estimation de pose.

L'encodage des boîtes distingue les détecteurs avec ancres des détecteurs sans ancres. Chaque branche comprend quelques convolutions qui se terminent par une convolution 1 × 1 avec un canal de sortie par valeur prédite. RetinaNet et FCOS utilisaient déjà des branches distinctes pour la classification et la régression ; en 2021, YOLOX a introduit cette tête découplée dans YOLO et annoncé une convergence d'entraînement bien plus rapide que celle de la couche de sortie partagée de YOLOv3. Le schéma ci-dessous construit ces couches finales 1 × 1 pour les trois niveaux de pyramide d'une image de 640 × 640 et aplatit leurs sorties en une seule liste de candidats :

import torch
from torch import nn

# Neck outputs for a 640x640 image at strides 8, 16, and 32 (80x80, 40x40, and 20x20 grids)
channels = (64, 128, 256)
features = [torch.randn(1, c, 640 // s, 640 // s) for c, s in zip(channels, (8, 16, 32))]

# Decoupled head: a box branch (4 values) and a class branch (80 scores) for every pyramid level
box_branches = nn.ModuleList(nn.Conv2d(c, 4, 1) for c in channels)
cls_branches = nn.ModuleList(nn.Conv2d(c, 80, 1) for c in channels)

# Flatten each level's grid and concatenate, giving one candidate per grid cell
boxes = torch.cat([branch(f).flatten(2) for branch, f in zip(box_branches, features)], dim=2)
scores = torch.cat([branch(f).flatten(2) for branch, f in zip(cls_branches, features)], dim=2).sigmoid()
print(f"boxes {tuple(boxes.shape)}, class scores {tuple(scores.shape)}")

Il affiche boxes (1, 4, 8400), class scores (1, 80, 8400) : les 6 400 + 1 600 + 400 cellules de la grille proposent chacune une boîte avec 80 scores de classe.

Des sorties brutes aux détections#

L'entraînement détermine le nombre de prédictions attribuées à chaque objet. L'affectation plusieurs-à-un marque comme positives plusieurs cellules proches de chaque objet ; la tête reçoit ainsi davantage de signaux d'entraînement et laisse plusieurs boîtes superposées par objet à l'inférence, de sorte que NMS conserve la meilleure. L'affectation un-à-un, utilisée par DETR et par la tête d'inférence de YOLOv10, entraîne exactement une prédiction par objet ; les sorties n'ont donc pas besoin de NMS.

La tête de YOLO26 prédit directement les distances aux quatre bords et supprime la sortie Distribution Focal Loss à 16 bins par bord utilisée par YOLOv8 et YOLO11 ; elle entraîne une copie un-à-plusieurs et une copie un-à-un de ses branches de boîte et de classe. Par défaut, YOLO26 applique NMS aux sorties un-à-plusieurs ; le paramètre nms=False permet de passer aux branches un-à-un, qui renvoient au plus 300 boîtes par image sans étape NMS.

Conception de tête en pratique#

• Ajustement fin sur de nouvelles classes : La branche de classification se termine par un canal de sortie par classe ; un entraînement sur un jeu de données comportant un nombre différent de classes nécessite donc une nouvelle couche de classification finale, tandis que les poids préentraînés du backbone et du neck sont conservés.
• Déploiement : Chaque opération de la tête s'exécute sur l'appareil cible ; un décodage simple des boîtes et des sorties sans NMS facilitent donc l'exportation et réduisent le temps de post-traitement.
• Petits objets : L'ajout d'un niveau de pyramide de pas 4 donne à la tête une grille plus fine pour les très petits objets, au prix d'un calcul supplémentaire : pour une entrée de 640 × 640, il ajoute 160 × 160 = 25 600 cellules, soit quatre fois plus que le niveau de pas 8.