Deformable Attention

L’attention déformable est un mécanisme d’attention pour la vision par ordinateur où chaque requête se concentre sur un petit nombre fixe de points d’échantillonnage autour d’une position de référence, plutôt que sur chaque position d’une carte de caractéristiques. La requête prédit elle-même la position de ces points sous forme de décalages par rapport à la référence, ainsi que le poids de chacun ; le coût dépend donc du nombre de requêtes et de points, et non de la résolution de l’image. Xizhou Zhu, Jifeng Dai et leurs collègues de SenseTime, de l’University of Science and Technology of China et de la Chinese University of Hong Kong l’ont présentée dans Deformable DETR, un article sélectionné pour une présentation orale à ICLR 2021. Cette méthode a corrigé les deux faiblesses du Transformer de détection DETR original : l’attention complète le limitait aux caractéristiques de faible résolution et son entraînement nécessitait 500 époques. Deformable DETR nécessitait dix fois moins d’époques et détectait mieux les petits objets.

Fonctionnement de l’attention déformable#

Cette idée prolonge la convolution déformable, également développée par Dai et ses collègues, qui apprend les décalages des points d’échantillonnage d’un noyau de convolution. Pour chaque requête associée à un point de référence, chaque tête d’attention applique deux couches linéaires aux caractéristiques de la requête : l’une prédit K décalages d’échantillonnage, l’autre K poids d’attention normalisés par softmax. Les caractéristiques de valeur à chaque point déplacé sont lues par interpolation bilinéaire, car les décalages peuvent être fractionnaires, puis la tête renvoie leur somme pondérée. L’article utilise 8 têtes et K = 4 points ; chaque requête lit donc 32 positions par carte de caractéristiques, tandis que l’auto-attention classique évaluerait chaque pixel. Une version à une seule tête et une seule échelle tient en quelques lignes de code PyTorch :

import torch
import torch.nn.functional as F

torch.manual_seed(0)
dim, n_points, n_queries = 32, 4, 100
value = torch.randn(1, dim, 64, 64)  # a 64x64 feature map: 4,096 positions
query = torch.randn(n_queries, dim)
ref = torch.rand(n_queries, 2) * 2 - 1  # reference points in grid_sample's [-1, 1] coordinates

# Each query predicts where to look (offsets) and how much each sample counts (weights)
to_offsets, to_weights = torch.nn.Linear(dim, n_points * 2), torch.nn.Linear(dim, n_points)
offsets = 0.1 * to_offsets(query).view(n_queries, n_points, 2)
weights = to_weights(query).softmax(dim=-1)

# Bilinearly sample the value map at reference + offset, then take the weighted sum
grid = (ref[:, None] + offsets)[None]  # (1, n_queries, n_points, 2)
sampled = F.grid_sample(value, grid, align_corners=False)[0]  # (dim, n_queries, n_points)
out = (sampled * weights).sum(dim=-1).T  # (n_queries, dim)
print(f"Output {tuple(out.shape)} from {n_queries * n_points} samples, not {n_queries * 64 * 64:,} dense scores")

Le programme affiche Output (100, 32) from 400 samples, not 409,600 dense scores : chacune des 100 requêtes lit 4 positions parmi les 4 096. L’entraînement ajuste les couches de décalage et de poids ; les points se déplacent ainsi vers les parties de l’image utiles à la tâche.

Attention déformable mult-échelle#

Les objets apparaissent à des tailles très différentes ; Deformable DETR échantillonne donc simultanément des points sur plusieurs cartes de caractéristiques. Avec L niveaux, chaque tête prend K points à chaque niveau et normalise ensemble les poids sur les L × K points, ce qui combine en une seule étape des caractéristiques fines et grossières et remplace le réseau pyramidal de caractéristiques (FPN) dans son encodeur. L’encodeur l’applique comme une auto-attention, chaque pixel de chaque niveau servant de requête, et le décodeur l’applique comme une attention croisée entre les requêtes d’objets et les caractéristiques de l’image.

RT-DETR, le Transformer de détection en temps réel de Baidu disponible dans le package Ultralytics, utilise l’attention déformable mult-échelle comme attention croisée dans ses six couches de décodeur : chacune de ses 300 requêtes d’objets échantillonne 4 points par tête dans 8 têtes sur les cartes de caractéristiques aux strides 8, 16 et 32, soit 96 positions au total, alors qu’une attention croisée complète sur ces cartes d’une image de 640 pixels évaluerait 8 400 positions.

Applications#

• Détection d’objets : les successeurs de Deformable DETR, notamment DINO et RT-DETR, conservent l’attention croisée déformable dans leurs décodeurs, ce qui leur permet de consulter des caractéristiques à haute résolution pour détecter les petits objets.
• Véhicules autonomes : BEVFormer projette des images provenant de plusieurs caméras embarquées dans une grille en vue aérienne. Chaque cellule de la grille échantillonne alors des points déformables dans les vues des caméras qui la couvrent.
• Segmentation panoptique : Mask2Former construit ses caractéristiques de pixels mult-échelle avec l’attention déformable avant de prédire les masques.

Attention déformable et notions connexes#

• Attention à fenêtre glissante : se concentre sur un voisinage fixe défini par la position, identique pour toutes les entrées.
• Attention parcimonieuse : évalue un sous-ensemble fixe de paires de jetons choisi à l’avance.
• Attention Flash : calcule plus rapidement l’attention dense ordinaire en la répartissant dans la mémoire GPU intégrée à la puce, tout en donnant le même résultat que l’attention standard.
• Attention des Transformers de vision (ViT) : compare chaque patch d’image à tous les autres ; son coût augmente donc avec le carré du nombre de patches.