返回論文筆記資料庫
arXiv 2020ICLR 2021物件偵測論文筆記

Deformable DETR

可變形的注意力機制

原始論文

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

論文作者

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

發表版本
ICLR 2021會議
arXiv 首次提交
arXiv:2010.04159
引用此論文 · BibTeX

引用資料對應所連結的論文版本,作者為原論文作者。

@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}
}
本頁內容

DETR 留給研究者們一個很好發揮的空間。

它只用了最基本的 Transformer 架構,做最樸素的物件偵測。裡面也沒有用到什麼提升分數的技巧,只是單純的把圖片丟進去,然後就可以得到物件的位置和類別。

多麽美好的論文!

往後的研究者們只要基於這個思路改進模型,論文還不是刷刷刷一大把?

定義問題

和目前的物件偵測器相比,DETR 實在是太慢了。

如果我們把它和時下最流行的 Faster-RCNN 比起來,推論速度慢了 2 倍!

那又怎樣?感覺好像也不是什麼大問題?

沒錯,問題不在推論速度,而是訓練收斂速度,慢了 20 倍!

原本只需要 1 天的訓練時間,現在變成需要 20 天,這是多麽可怕的事情?

韶光易逝,年華易老。等模型收斂,等到頭髮都白了。

這不行,肯定要改。

解決問題

作者認為問題出在 Transformer 的注意力機制上。

DETR 編碼器在卷積特徵圖的所有空間位置之間計算注意力,特徵圖解析度提高時,運算與記憶體成本會快速增加;初始注意力接近均勻,也需要較長訓練才會聚焦。

所以這裡不能再使用原本的 Transformer 注意力機制,而是借鑒了「可變形卷積」的思路,將原本的注意力機制改成一種「可變形的注意力機制」。

可變形注意力

在圖像特徵圖中,給定每個查詢元素(Query Element),作者以參考點為基準,從查詢特徵預測少量採樣偏移與權重,再對採樣點的特徵做加權求和;偏移量沒有固定的局部範圍限制。

假設輸入的特徵圖為:

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

其中 CC 表示通道數,HH 和 WW 分別是特徵圖的高度和寬度。

查詢元素 qq 包含一個內容特徵 zqz_q 和一個 2D 參考點 pqp_q,可變形注意力特徵的計算公式如下:

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})

其中:

  • MM 表示注意力頭的數量。
  • KK 表示每個注意力頭對每個查詢所採樣的點數,遠少於整張特徵圖的位置數。
  • AmqkA_{mqk} 是第 mm 個注意力頭中第 kk 個採樣點的注意力權重,範圍在 [0,1][0, 1] 之間;同一頭的 KK 個權重總和為 1。
  • Δpmqk\Delta p_{mqk} 是第 mm 個注意力頭中第 kk 個採樣點的偏移量,這些偏移量可以是任意的實數。
  • WmW_m 和 Wm′W_m^{\prime} 是可學習的權重矩陣,負責將輸入特徵進行線性變換。
  • x(pq+Δpmqk)x(p_q + \Delta p_{mqk}) 表示在位置 pq+Δpmqkp_q + \Delta p_{mqk} 處的特徵值,因為該位置是分數值(即非整數點),因此使用雙線性插值來計算。

查詢特徵 zqz_q 經過一個線性投影操作,該操作會輸出一個 3MK3MK 通道的張量:

  • 前 2MK2MK 個通道用來編碼每個採樣點的偏移量 Δpmqk\Delta p_{mqk}。
  • 剩餘的 MKMK 個通道會經過 softmax 操作,計算出對應的注意力權重 AmqkA_{mqk}。

這種設計方式,可以保證「偏移量」與「注意力權重」都是從查詢元素的特徵中學習得到的,而不是基於固定的規則。

多尺度計算

現代物件偵測框架通常會使用多尺度特徵圖來進行物件偵測。

可變形注意力模組當然也得支援多尺度版本,允許同時在多個特徵圖層上進行採樣和操作。

假設輸入的多尺度特徵圖為 {xl}l=1L\{x_l\}_{l=1}^L,每個特徵圖 xl∈RC×Hl×Wlx_l \in \mathbb{R}^{C \times H_l \times W_l}。

查詢元素的參考點用正規化坐標 p^q∈[0,1]2\hat{p}_q \in [0, 1]^2 表示,則多尺度的計算公式為:

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 表示輸入的特徵圖層數量。
  • ϕl(p^q)\phi_l(\hat{p}_q) 是一個縮放函數,用來將正規化坐標轉換到第 ll 層特徵圖上的實際坐標。
  • 其他符號的意義與單尺度的情況類似;此時每個注意力頭的權重在所有 L×KL\times K 個採樣點上一起正規化。

模型架構

如上圖,編碼器中處理多尺度特徵圖的自注意力、以及解碼器讀取特徵圖的交叉注意力改用可變形注意力;解碼器內物件查詢彼此互動的自注意力仍保留。編碼器輸入使用 ResNet 的 C3–C5 特徵與從 C5 下採樣得到的 C6,不經 FPN 的自上而下融合。

程式碼拆解

我們單獨把作者的實作拿出來看一下,到底 MSDeformAttn 和一般的 Attn 有什麼差異:

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

從架構上來看,這個模組支援多層特徵(不同解析度)。論文使用 ResNet 的 C3–C6,經投影後展平為 input_flatten,再用 input_spatial_shapes 和 input_level_start_index 標記各層大小與起點;這些特徵不是 FPN 融合後的輸出。

  • 每個 Query 自行學習偏移量

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

    這行的意思是,對於每一個 Query,模型會輸出多個 offset (dx, dy),表示從 reference point 偏移的方向與距離,也就是「往哪看」。這些偏移點是學出來的,而非預先定義的固定格點。


  • Reference Points 決定「基準位置」

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

    注意力不再讓 Query 對整張特徵圖逐點計算,而是以指定的 reference_points 為基準,在學得的偏移點取樣並加權;偏移不限定在固定視窗內。Encoder 以各特徵位置自身為參考點,Decoder 的參考點則由物件查詢預測。


關鍵差異是採樣位置與權重都由 Query 決定;上方程式也在多尺度間共同正規化權重。Decoder 的查詢間自注意力仍使用原本的形式。

訓練策略

作者在 COCO 2017 資料集上進行實驗。

首先 Backbone 使用 ResNet-50,並且在 ImageNet 上進行預訓練。Neck 的部分直接從多尺度特徵圖中提取特徵,並且沒有使用 FPN。

可變形注意力設定:

  • 注意力頭的數量:M = 8
  • 每個注意力頭、每個特徵層對每個查詢的採樣點數量:K = 4

可變形變換器編碼器中的參數在不同的特徵層之間共享。

超參數和訓練策略主要遵循 DETR 的設置,除了以下幾點:

  • 邊界框分類採用 Focal Loss,損失權重設為 2。
  • 將物件查詢數量從 100 增加至 300。

模型預設訓練 50 個 epoch,第 40 個 epoch 時學習率會降低為原來的 0.1 倍。使用 Adam 優化器來進行訓練,基本學習率為 2×10−42 \times 10^{-4},且 β1=0.9\beta_1 = 0.9,β2=0.999\beta_2 = 0.999,權重衰減為 10−410^{-4}。

預測物件查詢參考點與採樣偏移量的線性投影的學習率會額外乘以 0.1 的縮放因子。

討論

與 DETR 的比較

根據上表,Faster R-CNN + FPN 在 109 epoch/380 GPU 小時時為 42.0 AP、26.6 AP_S;DETR 在 500 epoch/2000 GPU 小時時同為 42.0 AP,但 AP_S 為 20.5。Deformable DETR 用 50 epoch/325 GPU 小時達 43.8 AP、26.4 AP_S;「少 10 倍」指相對 DETR 的訓練 epoch,不能直接當成 GPU 時數的倍率。

詳細的收斂曲線見下圖:

表中同樣訓練 50 epoch 的迭代框修正使 AP 從 43.8 升至 45.4;再加兩階段機制升至 46.2。上圖的不同收斂曲線也包含改變學習率下降時點的實驗,並非全是同一個 50-epoch 設定。

在論文的 Tesla V100 測試下,Deformable DETR 為 173G FLOPs/19 FPS,與 Faster R-CNN + FPN 的 180G/26 FPS、DETR-DC5 的 187G/12 FPS 計算量接近;其 FPS 約為 DETR-DC5 的 1.6 倍,比 Faster R-CNN + FPN 低約 27%。

DETR-DC5 速度較慢的原因主要在於 Transformer 注意力機制中大量的記憶體存取,而 Deformable Attention 可以緩解此問題,但代價是無序的記憶體存取,仍稍慢於傳統卷積。

消融實驗

上表展示了變形注意力模組中不同設計選項的消融研究。

在未使用跨尺度注意力且 K=1K=1 的對照下,加入多尺度輸入使 AP 從 39.7 升至 41.4、AP_S 從 21.2 升至 24.1(各高 1.7/2.9 個百分點);再將 KK 增至 4,AP 由 41.4 升至 42.3(高 0.9 個百分點)。

在多尺度輸入、K=4K=4 下加入跨尺度注意力,AP 從 42.3 升至 43.8(高 1.5 個百分點)。同樣配置再加 FPN 仍為 43.8 AP;BiFPN 為 43.9 AP,增益很小。當未使用跨尺度注意力且 K=1K=1 時,模組接近可變形卷積的單點取樣形式,表列 AP 為 41.4,低於完整多尺度注意力的 43.8。

SOTA 比較

在上表中,Deformable DETR 均使用了迭代邊界框優化與兩階段機制。

在已使用迭代框修正與兩階段機制、不使用 TTA 的設定下,ResNet-101 和 ResNeXt-101 分別達到 48.7/49.0 AP;帶 DCN 的 ResNeXt-101 達 50.1 AP。不同骨幹與 TTA 條件不能視為單獨的注意力模組增益。

在加入測試時增強(test-time augmentations)後,該方法達到 52.3 AP。

結論

Deformable DETR 相較於傳統的 DETR,大幅縮短了訓練所需的時間。在小物體檢測的表現上,比 DETR 展現更明顯的優勢。

雖然 Deformable DETR 引入了可變形注意力以提升運行速度,但由於無序記憶體存取的特性,仍略微慢於傳統的卷積神經網路架構(如 Faster R-CNN)。因此,對於某些即時性要求高的應用,速度仍是需要考量的問題。

Deformable DETR 的設計為探索更高效、更實用的端對端物體偵測器變體開闢了新的方向,並具有廣泛的研究與應用潛力。