可形变注意力机制的总结

综述

非常容易理解，这个机制的诞生。既然有可形变卷积，且表现出不错的效果，自然就会产生可形变注意力机制。可形变卷积更多是卷积每一个部分的偏移，可形变注意力是patch的大小和整体位置的改变。从整体上说可形变注意力在算力上影响并不大，因为位置的预测基本上是和整体任务分离的（不全是比如人脸位置定位），patch位置和大小一般是由一个线性连接层直接得到。
另外一件事，纯注意力机制+可形变注意力并没有出现。

文章

patch的位置和大小其实是可形变注意力机制的核心问题。
目前看到的带有“自定义patch位置和大小的论文”有（未完待续）：

• Stand-Alone Inter-Frame Attention in Video Models CVPR2022 动作识别中的一部分机制
• Vision Transformer with Deformable Attention CVPR2021 形变注意力机制
• DPT: Deformable Patch-based Transformer for Visual Recognition ACM MM 2021 形变注意力机制
• Deformable DETR: Deformable Transformers for End-to-End Object Detection ICLR2021 加速DETR训练
• Sparse Local Patch Transformer for Robust Face Alignment and Landmarks Inherent Relation Learning CVPR2022 定位人脸

代码

这一部分主要集中于可形变注意力机制的patch位置是怎么生成的：

DPT: Deformable Patch-based Transformer for Visual

内容部分

这篇文章的程序有几个特点：

• 可学习的位置和patch大小
• plug&play 在PVT结构上进行的逐层改变，计算量增加小
  “DePatch can adjust the position and scale of each patch based on the input image”

代码部分

主体结构没有改变主要是patch_embed的方式不同

        x, (H, W) = self.patch_embed2(x)
        if isinstance(x, tuple):
            aux_results.append(x[1])
            x = x[0]
        x = x + self.pos_embed2
        x = self.pos_drop2(x)
        for blk in self.block2:
            x = blk(x, H, W)
        x = x.reshape(B, H, W, -1).permute(0, 3, 1, 2).contiguous()

patch_embed方式，第一阶段不变形后三个阶段变形。box_coder是个函数，怎么裁剪patch指定的形状。
Simple_DePatch用来使用box_coder把每个patch裁剪成指定形状。

def _build_patch_embeds(embed_dims, img_size, Depatch):
    patch_embeds=[]
    for i in range(4):
        inchans = embed_dims[i-1] if i>0 else 3
        in_size = img_size // 2**(i+1) if i>0 else img_size
        patch_size = 2 if i > 0 else 4
        if Depatch[i]:
            box_coder = pointwhCoder(input_size=in_size, patch_count=in_size//patch_size, weights=(1.,1.,1.,1.), pts=3, tanh=True, wh_bias=torch.tensor(5./3.).sqrt().log())
            patch_embeds.append(
                Simple_DePatch(box_coder, img_size=in_size, patch_size=patch_size, patch_pixel=3, patch_count=in_size//patch_size,
                 in_chans=inchans, embed_dim=embed_dims[i], another_linear=True, use_GE=True, with_norm=True))
        else:
            patch_embeds.append(
                PatchEmbed(img_size=in_size, patch_size=patch_size, in_chans=inchans,
                           embed_dim=embed_dims[i]))
    return patch_embeds

box_coder代码如下：根据送入坐标和长宽生成裁剪框返回裁剪的坐标位置

    def forward(self, pts, model_offset=None):
        assert model_offset is None
        if self.wh_bias is not None:
            print(pts.shape)
            pts[:, :, 2:] = pts[:, :, 2:] + self.wh_bias
        self.boxes = self.decode(pts)
        points = self.meshgrid(self.boxes)
        return points

Simple_DePatch代码如下：其中self.act是一个gelu层，offsetpredictor是一个线性层输入是输入为dim输出为4（位置+大小）。最后按照位置信息做一个自注意力。

    @torch.cuda.amp.autocast(enabled=False)
    def forward(self, x, model_offset=None):
        if x.dim() == 3:
            B, H, W = x.shape[0], self.img_size, self.img_size
            assert x.shape[1] == H * W
            x = x.view(B, H, W, -1).permute(0, 3, 1, 2).contiguous()
        B, C, H, W = x.shape
        img = x
        print('img:',img.shape)
        x = self.patch_embed(x)
        print('patch_embed:',x.shape)
        if self.another_linear:
            pred_offset = self.offset_predictor(self.act(x))
            print('pred_offset:',pred_offset.shape)
        else:
            pred_offset = x.contiguous()
        return self.get_output(img, pred_offset, model_offset), (self.patch_count, self.patch_count)

Sparse Local Patch Transformer for Robust Face Alignment and Landmarks Inherent Relation Learning

内容部分

这是一篇标注人脸landmark的文章，这篇的特点比较明显：

• 点的位置是注意力patch的位置
• 根据点所在patch得出landmark移动位置。

代码部分

三个迭代，从最初默认值开始。每一个迭代过程如下

• 第一步得到锚点、框的大小和初始点的位置
• 第二部根据锚点切割特征图 interpolation部分（自己写了一个双线性插值）
• 把7x7特征图用一个卷积卷成1x1然后做注意力机制得到新的初始点位置和旧位置的偏差值。

        # stage_1
        ROI_anchor_1, bbox_size_1, start_anchor_1 = self.ROI_1(initial_landmarks.detach())
        ROI_anchor_1 = ROI_anchor_1.view(bs, self.num_point * self.Sample_num * self.Sample_num, 2)
        ROI_feature_1 = self.interpolation(feature_map, ROI_anchor_1.detach()).view(bs, self.num_point, self.Sample_num,
                                                                            self.Sample_num, self.d_model)
        # torch.Size([1, 98, 7, 7, 256])
        
        ROI_feature_1 = ROI_feature_1.view(bs * self.num_point, self.Sample_num, self.Sample_num,
                                     self.d_model).permute(0, 3, 2, 1)
        #torch.Size([98, 256, 7, 7])
        transformer_feature_1 = self.feature_extractor(ROI_feature_1).view(bs, self.num_point, self.d_model)
        offset_1 = self.Transformer(transformer_feature_1)
        offset_1 = self.out_layer(offset_1)
        landmarks_1 = start_anchor_1.unsqueeze(1) + bbox_size_1.unsqueeze(1) * offset_1
        output_list.append(landmarks_1)

Vision Transformer with Deformable Attention

内容部分

和第一个DPT一样，移动范围有限制，结构比较简单，且没有大小信息。
将未经偏置的patches作为q，对q中每个patch做偏移预测，用这个偏移生成k和v，之后做注意力运算。

偏置网络网络实现为两个具有非线性激活的卷积模块，如图2(b)所示。首先对输入特征进行5,5深度卷积以捕获局部特征。然后采用GELU激活和1x1卷积得到二维偏移量。同样值得注意的是，为了减轻所有位置的强制移位，在1x1卷积中的偏差被降低了。得到这个偏置后用双线性插值来得到k和v。

代码部分

        q = self.proj_q(x)
        q_off = einops.rearrange(q, 'b (g c) h w -> (b g) c h w', g=self.n_groups, c=self.n_group_channels)
        offset = self.conv_offset(q_off) # B * g 2 Hg Wg
        Hk, Wk = offset.size(2), offset.size(3)
        n_sample = Hk * Wk

offset是相对位移（大家好像都用相对位移）。生成offset的和之前的transformer、linear不同用的是卷积。

        self.conv_offset = nn.Sequential(
            nn.Conv2d(self.n_group_channels, self.n_group_channels, kk, stride, kk//2, groups=self.n_group_channels),
            LayerNormProxy(self.n_group_channels),
            nn.GELU(),
            nn.Conv2d(self.n_group_channels, 2, 1, 1, 0, bias=False)
        )

Stand-Alone Inter-Frame Attention in Video Models

文章内容

这篇文章是一篇视频动作识别的论文，和之前的图像分类文章不同。从结构来说它做的是将当前帧的patch（作为Q）和下一帧的八邻域patches（作为K和V）之间做一个注意力。这个九个patches根据offset predictor 预测做的注意力和原位置做注意力的相加。
另外一个特点就是是以通用图像识别骨干网络（resnet）作为主干网络的。

代码部分

导入模型注册模型过程比较难看，可以直接看/model/c2d_sifa_resnet.py
这个帧间关系的模块用在了resnet的倒数三个layer。

        x_origin = self.layer4(x)
        x_dual = self.maxpool_dual(x) #两帧抽一帧
        x_dual = self.layer4_dual(x_dual) #抽一帧之后再来resnet_layer
        x_g_origin = self.pool(x_origin) 
        x_g_dual = self.pool_dual(x_dual)
        x_g_origin = self.drop(x_g_origin)
        x_g_dual = self.drop_dual(x_g_dual)
        x1_origin = self.fc(x_g_origin)
        x1_dual = self.fc_dual(x_g_dual)

        return [x1_origin, x1_dual]

（看的恶心死我了，清华是什么世界二流大学啊。）
out_tmp是运动图，通过运动图求偏置。这个偏置是2kk个位移。
corre_weight做一个带偏置的注意力

out_agg是融合，详细代码在下面：

        # insert the aggregate block
        out_tmp = out.clone()
        out_tmp[:,:,1:,:,:] = out_tmp[:,:,:-1,:,:]
        out_tmp = (torch.sigmoid(out - out_tmp) * out) + out # [sig(f_{t}-f_{t-1})*f_{t}]*f_{t}
        offset = self.conv_offset(out_tmp)        
        
        corre_weight = self.def_cor(out, offset)
        out_agg = self.def_agg(out, offset, corre_weight)
        
        mask = torch.ones(out.size()).cuda()
        mask[:,:,-1,:,:] = 0
        mask.requires_grad = False
        out_shift = out_agg.clone()
        out_shift[:,:,:-1,:,:] = out_shift[:,:,1:,:,:]
        out = out + out_shift * mask

代码写了一段cuda:核心代码如下：实现了下一帧的n个patch和本帧的patch相乘再乘一个通道权重。

    float val = static_cast<float>(0);
    const int c_in_start = group_id * c_in_per_defcor;
    const int c_in_end = (group_id + 1) * c_in_per_defcor;
    if (h_im > -1 && w_im > -1 && h_im < height && w_im < width){
      for (int c_in = c_in_start; c_in < c_in_end; ++c_in){
        const int former_ptr = (((n_out * channels + c_in) * times + t_former) * height + h_out) * width + w_out;
        const int weight_offset = ((c_in * times + t_out) * kernel_h + kh) * kernel_w + kw;
        const float* data_im_ptr = data_im + ((n_out * channels + c_in) * times + t_out) * height * width;
        float next_val = im2col_bilinear_cuda(data_im_ptr, width, height, width, h_im, w_im);
        val += (data_weight[weight_offset] * data_im[former_ptr] * next_val);
      }
    }
    data_out[index] = val;

DEFORMABLE DETR: DEFORMABLE TRANSFORMERS FOR END-TO-END OBJECT DETECTION

内容部分

这篇文章是一篇目标检测的文章，使用可形变注意力机制的目的是加速训练流程。“We propose the deformable attention module, which attends to a small set of sampling locations（位移） as a pre-filter for prominent key elements out of all the feature map pixels.”大体上就是每个patch做注意力太慢了，先来个位置上的移动，再做注意力。
换句话说就是用偏置把本来应该由注意力机制学到的东西，变成位置直接得到。

代码部分

把每一个分类的特征图取出来，取出来之后的q做一个偏移，把和这个分类有关的位置的patch放到学习到的位置。

        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)

偏置的生成。

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