Retour à la bibliothèque
arXiv 2020ICLR 2021Détection d’objetsNotes de lecture

Deformable DETR

Une attention déformable

Article original

Deformable DETR: Deformable Transformers for End-to-End Object Detection

Auteurs de l’article

Xizhou Zhu · Weijie Su · Lewei Lu · Bin Li · Xiaogang Wang · Jifeng Dai

Publication
ICLR 2021Conférence
Premier dépôt sur arXiv
arXiv:2010.04159
Citer cet article · BibTeX

La référence correspond à la version liée et cite les auteurs de l’article original.

@misc{objectdetectiondeformabledetr2020,
  title = {{Deformable DETR: Deformable Transformers for End-to-End Object Detection}},
  author = {Xizhou Zhu and Weijie Su and Lewei Lu and Bin Li and Xiaogang Wang and Jifeng Dai},
  year = {2020},
  eprint = {2010.04159},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2010.04159}
}
Sur cette page

DETR a laissé aux chercheurs une belle marge de manœuvre.

Il se contente d'une architecture Transformer élémentaire pour détecter les objets. Pas de foule d'astuces pour gagner quelques points : on lui donne une image, et il renvoie les positions et les classes des objets.

Quel bel article !

Les chercheurs qui suivront n'auront qu'à améliorer ce principe. Les articles vont pleuvoir, non ?

Définition du problème

Face aux détecteurs courants, certaines variantes de DETR sont vraiment lentes.

Si l'on compare DETR-DC5 à Faster R-CNN + FPN dans le tableau 1, sa vitesse d'inférence est environ deux fois moindre : 12 contre 26 images par seconde.

Et alors ? Cela ne semble pas forcément dramatique.

En effet, le gros problème est la convergence pendant l'entraînement. Avec cette même variante, le tableau indique 7 000 contre 380 heures GPU : près de vingt fois plus !

Ce qui prendrait un jour pourrait donc approcher vingt jours de calcul comparable. Quel cauchemar.

Le temps file et nous vieillissons. À attendre que le modèle converge, nous aurons les cheveux blancs.

Il faut faire quelque chose.

Résolution du problème

Pour les auteurs, le problème vient de l'attention du Transformer.

Dans l'encodeur de DETR, l'attention porte sur toutes les positions spatiales des cartes de caractéristiques convolutives. À mesure que leur résolution augmente, le coût en calcul et en mémoire grimpe rapidement. En outre, l'attention initiale, presque uniforme, met longtemps à se concentrer.

Ils s'inspirent donc de la convolution déformable pour remplacer cette attention Transformer classique par une attention déformable.

Attention déformable

Pour chaque élément de requête dans la carte de caractéristiques, les auteurs partent d'un point de référence. Les caractéristiques de la requête servent à prédire un petit nombre de décalages d'échantillonnage et leurs poids ; les caractéristiques prélevées sont ensuite additionnées de façon pondérée. Ces décalages ne sont pas limités à un voisinage local fixe.

Soit une carte de caractéristiques d'entrée :

x∈RC×H×Wx \in \mathbb{R}^{C \times H \times W}

Ici, CC désigne le nombre de canaux, et HH et WW la hauteur et la largeur de la carte.

L'élément de requête qq comprend un vecteur de contenu zqz_q et un point de référence 2D pqp_q. L'attention déformable est calculée ainsi :

DeformAttn(zq,pq,x)=∑m=1MWm∑k=1KAmqk⋅Wm′x(pq+Δpmqk)\text{DeformAttn}(z_q, p_q, x) = \sum_{m=1}^{M} W_m \sum_{k=1}^{K} A_{mqk} \cdot W_m^{\prime} x(p_q + \Delta p_{mqk})

Avec :

  • MM, le nombre de têtes d'attention.
  • KK, le nombre de points prélevés par tête et par requête, bien inférieur au nombre de positions de la carte entière.
  • AmqkA_{mqk}, le poids du kk-ième point de la tête mm, compris entre [0,1][0, 1] ; les KK poids d'une tête totalisent 1.
  • Δpmqk\Delta p_{mqk}, le décalage du kk-ième point de la tête mm, qui peut prendre une valeur réelle arbitraire.
  • WmW_m et Wm′W_m^{\prime}, des matrices de poids apprenables qui transforment linéairement les caractéristiques.
  • x(pq+Δpmqk)x(p_q + \Delta p_{mqk}), la valeur au point échantillonné situé en pq+Δpmqkp_q + \Delta p_{mqk} ; ses coordonnées peuvent être fractionnaires, d'où l'interpolation bilinéaire.

Une projection linéaire des caractéristiques de requête zqz_q produit un tenseur de 3MK3MK canaux :

  • Les 2MK2MK premiers codent les décalages Δpmqk\Delta p_{mqk}.
  • Les MKMK autres passent par un softmax pour donner les poids d'attention AmqkA_{mqk}.

Les positions et les poids d'attention sont ainsi appris à partir de la requête, plutôt que fixés par une règle préalable.

Calcul multi-échelle

Les détecteurs modernes exploitent habituellement des cartes de caractéristiques à plusieurs échelles.

Le module d'attention déformable doit donc lui aussi prélever et combiner des caractéristiques de plusieurs niveaux.

Notons les cartes d'entrée {xl}l=1L\{x_l\}_{l=1}^L, avec xl∈RC×Hl×Wlx_l \in \mathbb{R}^{C \times H_l \times W_l} pour chaque niveau.

Le point de référence d'une requête s'exprime en coordonnées normalisées p^q∈[0,1]2\hat{p}_q \in [0, 1]^2. Le calcul multi-échelle devient :

MSDeformAttn(zq,p^q,{xl}l=1L)=\text{MSDeformAttn}(z_q, \hat{p}_q, \{x_l\}_{l=1}^L) = ∑m=1MWm∑l=1L∑k=1KAmlqk⋅Wm′xl(ϕl(p^q)+Δpmlqk)\sum_{m=1}^{M} W_m \sum_{l=1}^{L} \sum_{k=1}^{K} A_{mlqk} \cdot W_m^{\prime} x_l(\phi_l(\hat{p}_q) + \Delta p_{mlqk})
  • LL est le nombre de niveaux de caractéristiques.
  • ϕl(p^q)\phi_l(\hat{p}_q) remet les coordonnées normalisées à l'échelle de la carte du niveau ll.
  • Les autres symboles gardent le même sens qu'à une seule échelle ; les poids de chaque tête sont ici normalisés conjointement sur les L×KL\times K points.

Architecture du modèle

Comme l'illustre le schéma, l'autoattention de l'encodeur entre cartes multi-échelles et l'attention croisée par laquelle le décodeur lit ces cartes deviennent déformables. L'autoattention entre les requêtes d'objets dans le décodeur est conservée. L'encodeur reçoit les cartes C3 à C5 de ResNet, plus une carte C6 obtenue par sous-échantillonnage de C5, sans fusion descendante par FPN.

Lecture du code

Regardons de plus près l'implémentation des auteurs. En quoi MSDeformAttn diffère-t-il d'une attention classique ?

python
class MSDeformAttn(nn.Module):

    def __init__(self, d_model=256, n_levels=4, n_heads=8, n_points=4):
        """
        Multi-Scale Deformable Attention Module
        :param d_model      hidden dimension
        :param n_levels     number of feature levels
        :param n_heads      number of attention heads
        :param n_points     number of sampling points per attention head per feature level
        """
        super().__init__()
        if d_model % n_heads != 0:
            raise ValueError('d_model must be divisible by n_heads, but got {} and {}'.format(d_model, n_heads))
        _d_per_head = d_model // n_heads
        # you'd better set _d_per_head to a power of 2 which is more efficient in our CUDA implementation
        if not _is_power_of_2(_d_per_head):
            warnings.warn("You'd better set d_model in MSDeformAttn to make the dimension of each attention head a power of 2 "
                          "which is more efficient in our CUDA implementation.")

        self.im2col_step = 64

        self.d_model = d_model
        self.n_levels = n_levels
        self.n_heads = n_heads
        self.n_points = n_points

        self.sampling_offsets = nn.Linear(d_model, n_heads * n_levels * n_points * 2)
        self.attention_weights = nn.Linear(d_model, n_heads * n_levels * n_points)
        self.value_proj = nn.Linear(d_model, d_model)
        self.output_proj = nn.Linear(d_model, d_model)

        self._reset_parameters()

    def _reset_parameters(self):
        constant_(self.sampling_offsets.weight.data, 0.)
        thetas = torch.arange(self.n_heads, dtype=torch.float32) * (2.0 * math.pi / self.n_heads)
        grid_init = torch.stack([thetas.cos(), thetas.sin()], -1)
        grid_init = (grid_init / grid_init.abs().max(-1, keepdim=True)[0]).view(self.n_heads, 1, 1, 2).repeat(1, self.n_levels, self.n_points, 1)
        for i in range(self.n_points):
            grid_init[:, :, i, :] *= i + 1
        with torch.no_grad():
            self.sampling_offsets.bias = nn.Parameter(grid_init.view(-1))
        constant_(self.attention_weights.weight.data, 0.)
        constant_(self.attention_weights.bias.data, 0.)
        xavier_uniform_(self.value_proj.weight.data)
        constant_(self.value_proj.bias.data, 0.)
        xavier_uniform_(self.output_proj.weight.data)
        constant_(self.output_proj.bias.data, 0.)

    def forward(self, query, reference_points, input_flatten, input_spatial_shapes, input_level_start_index, input_padding_mask=None):
        """
        :param query                       (N, Length_{query}, C)
        :param reference_points            (N, Length_{query}, n_levels, 2), range in [0, 1], top-left (0,0), bottom-right (1, 1), including padding area
                                        or (N, Length_{query}, n_levels, 4), add additional (w, h) to form reference boxes
        :param input_flatten               (N, \sum_{l=0}^{L-1} H_l \cdot W_l, C)
        :param input_spatial_shapes        (n_levels, 2), [(H_0, W_0), (H_1, W_1), ..., (H_{L-1}, W_{L-1})]
        :param input_level_start_index     (n_levels, ), [0, H_0*W_0, H_0*W_0+H_1*W_1, H_0*W_0+H_1*W_1+H_2*W_2, ..., H_0*W_0+H_1*W_1+...+H_{L-1}*W_{L-1}]
        :param input_padding_mask          (N, \sum_{l=0}^{L-1} H_l \cdot W_l), True for padding elements, False for non-padding elements

        :return output                     (N, Length_{query}, C)
        """
        N, Len_q, _ = query.shape
        N, Len_in, _ = input_flatten.shape
        assert (input_spatial_shapes[:, 0] * input_spatial_shapes[:, 1]).sum() == Len_in

        value = self.value_proj(input_flatten)
        if input_padding_mask is not None:
            value = value.masked_fill(input_padding_mask[..., None], float(0))
        value = value.view(N, Len_in, self.n_heads, self.d_model // self.n_heads)
        sampling_offsets = self.sampling_offsets(query).view(N, Len_q, self.n_heads, self.n_levels, self.n_points, 2)
        attention_weights = self.attention_weights(query).view(N, Len_q, self.n_heads, self.n_levels * self.n_points)
        attention_weights = F.softmax(attention_weights, -1).view(N, Len_q, self.n_heads, self.n_levels, self.n_points)
        # N, Len_q, n_heads, n_levels, n_points, 2
        if reference_points.shape[-1] == 2:
            offset_normalizer = torch.stack([input_spatial_shapes[..., 1], input_spatial_shapes[..., 0]], -1)
            sampling_locations = reference_points[:, :, None, :, None, :] \
                                 + sampling_offsets / offset_normalizer[None, None, None, :, None, :]
        elif reference_points.shape[-1] == 4:
            sampling_locations = reference_points[:, :, None, :, None, :2] \
                                 + sampling_offsets / self.n_points * reference_points[:, :, None, :, None, 2:] * 0.5
        else:
            raise ValueError(
                'Last dim of reference_points must be 2 or 4, but get {} instead.'.format(reference_points.shape[-1]))
        output = MSDeformAttnFunction.apply(
            value, input_spatial_shapes, input_level_start_index, sampling_locations, attention_weights, self.im2col_step)
        output = self.output_proj(output)
        return output

Par sa structure, ce module traite plusieurs niveaux de caractéristiques, donc plusieurs résolutions. L'article prend les cartes C3 à C6 de ResNet, les projette et les aplatit dans input_flatten ; input_spatial_shapes et input_level_start_index indiquent la taille et le point de départ de chaque niveau. Il ne s'agit pas de sorties déjà fusionnées par un FPN.

  • Chaque requête apprend ses décalages

    python
    self.sampling_offsets = nn.Linear(d_model, n_heads * n_levels * n_points * 2)
    

    Pour chaque requête, cette ligne produit des décalages (dx, dy) qui indiquent où regarder par rapport au point de référence. Ce sont des positions apprises, pas une grille fixe prédéfinie.


  • Les points de référence définissent la position de départ

    python
    if reference_points.shape[-1] == 2:
        ...
    elif reference_points.shape[-1] == 4:
        ...
    

    La requête ne calcule plus son attention point par point sur la carte entière. Elle échantillonne autour de reference_points aux décalages appris, puis pondère ces points. Les décalages ne sont pas confinés dans une fenêtre fixe. Dans l'encodeur, chaque position des caractéristiques sert de point de référence ; dans le décodeur, ce point est prédit à partir de la requête d'objet.


L'essentiel est que les positions d'échantillonnage et leurs poids dépendent tous deux de la requête. Le code normalise aussi les poids conjointement entre les échelles. L'autoattention entre les requêtes du décodeur, elle, conserve sa forme initiale.

Stratégie d'entraînement

Les auteurs évaluent le modèle sur COCO 2017.

Le backbone est un ResNet-50 préentraîné sur ImageNet. Les caractéristiques multi-échelles sont extraites directement, sans FPN pour les fusionner.

L'attention déformable utilise par défaut :

  • M = 8 têtes d'attention ;
  • K = 4 points d'échantillonnage par requête, par tête et par niveau de caractéristiques.

Les paramètres de l'encodeur Transformer déformable sont partagés entre les niveaux de caractéristiques.

Les hyperparamètres et l'entraînement suivent principalement DETR, avec deux différences :

  • La classification des boîtes emploie une Focal Loss de poids 2.
  • Le nombre de requêtes d'objets passe de 100 à 300.

Par défaut, le modèle s'entraîne pendant 50 époques ; à la 40e, le taux d'apprentissage est multiplié par 0,1. Il utilise Adam avec un taux initial de 2×10−42 \times 10^{-4}, β1=0.9\beta_1 = 0.9, β2=0.999\beta_2 = 0.999 et un weight decay de 10−410^{-4}.

Le taux d'apprentissage des projections linéaires qui prédisent les points de référence et les décalages est lui aussi multiplié par 0,1.

Discussion

Comparaison avec DETR

Dans ce tableau, Faster R-CNN + FPN atteint 42,0 AP et 26,6 AP_S après 109 époques / 380 heures GPU. DETR atteint également 42,0 AP après 500 époques / 2 000 heures GPU, mais seulement 20,5 AP_S. Deformable DETR obtient 43,8 AP et 26,4 AP_S en 50 époques / 325 heures GPU. Le facteur « dix fois moins » compare les époques d'entraînement avec DETR, et ne s'applique pas directement aux heures GPU.

Les courbes de convergence sont ci-dessous :

À durée égale de 50 époques, le raffinement itératif des boîtes fait passer l'AP de 43,8 à 45,4 ; l'ajout du mécanisme en deux étapes la porte à 46,2. Les courbes ci-dessus comprennent également des essais où l'époque de baisse du taux d'apprentissage varie : elles ne correspondent donc pas toutes au même calendrier de 50 époques.

Sur le Tesla V100 utilisé dans l'article, Deformable DETR demande 173G FLOPs et tourne à 19 FPS. Les chiffres sont 180G / 26 FPS pour Faster R-CNN + FPN et 187G / 12 FPS pour DETR-DC5. Les coûts de calcul sont proches ; Deformable DETR atteint environ 1,6 fois le débit de DETR-DC5, mais reste environ 27 % derrière Faster R-CNN + FPN.

DETR-DC5 pâtit surtout des nombreux accès mémoire de l'attention Transformer. L'attention déformable atténue ce problème, au prix d'accès mémoire désordonnés ; elle reste donc légèrement plus lente que la convolution classique.

Étude d'ablation

Ce tableau isole différents choix de conception du module d'attention déformable.

Sans attention entre échelles et avec K=1K=1, l'ajout de cartes multi-échelles fait passer l'AP de 39,7 à 41,4 et l'AP_S de 21,2 à 24,1 : +1,7 / +2,9 points. Passer ensuite à K=4K=4 porte l'AP de 41,4 à 42,3, soit +0,9 point.

Avec les cartes multi-échelles et K=4K=4, l'attention entre échelles fait passer l'AP de 42,3 à 43,8, soit +1,5 point. Ajouter ensuite un FPN laisse l'AP à 43,8 ; un BiFPN atteint 43,9 : le gain est minime. Sans cette attention entre échelles et avec K=1K=1, le module ressemble à un échantillonnage ponctuel de convolution déformable ; son AP de 41,4 reste sous les 43,8 du modèle multi-échelle complet.

Comparaison avec les meilleures méthodes

Tous les modèles Deformable DETR de ce tableau utilisent le raffinement itératif des boîtes et l'architecture en deux étapes.

Sans augmentation à l'inférence (TTA), ResNet-101 et ResNeXt-101 obtiennent respectivement 48,7 et 49,0 AP ; ResNeXt-101 avec DCN atteint 50,1 AP. Il faut tenir compte des différences de backbone et de TTA avant d'attribuer ces gains au seul module d'attention.

Avec des augmentations à l'inférence, la méthode atteint 52,3 AP.

Conclusion

Par rapport au DETR traditionnel, Deformable DETR réduit fortement la durée d'entraînement. Son avantage est particulièrement net pour les petits objets.

L'attention déformable accélère l'inférence par rapport à DETR-DC5, mais ses accès mémoire désordonnés la laissent légèrement derrière une architecture convolutive comme Faster R-CNN + FPN. Pour les usages qui exigent une réponse immédiate, la vitesse reste donc un critère à considérer.

Cette conception ouvre la voie à des variantes de détecteurs d'objets de bout en bout plus efficaces et plus faciles à employer. Elle offre aussi de nombreuses pistes de recherche et d'application.