DilateFormer: Multi-Scale Dilated Transformer for Visual Recognition 中的空洞自注意力机制

空洞自注意力机制

摘要

    本文针对DilateFormer中的空洞自注意力机制原理和代码进行详细介绍，最后通过流程图梳理其实现原理。

1. 模型解释

1.1. 滑动窗口扩张注意力

    根据在普通视觉变换器（ViTs）中浅层全局注意力中观察到的局部性和稀疏性特性，我们提出了一种滑动窗口扩张注意力（SWDA） 操作，其中，keys和values被以query patch为中心的滑动窗口稀疏地选择。然后对这些代表性patches进行自注意力。我们的 SWDA 正式描述如下：

$$\begin{array}{rlrlrlrlrlrlrlrlrlrlrlrlrlrlrl}& & & & & & & & & & & & & X=SWDA(Q,K,V,r)& & & & & & & & & & & & & & & & (1)\end{array}$$

其中，$Q,K,V$分别代表query、key和value矩阵，三个矩阵的每一行表示一个query/key/value特征向量。对于原始特征图上$(i,j)$位置的query，SWDA以尺寸为$w\times w$大小的滑动窗口，稀疏地选择key和value去指导自注意力。

    而且，我们定义一个扩张率$rϵN^{+}$去控制稀疏程度。特别地，对于位置$(i,j)$，SWDA计算的输出$X$中的相应分量$x_{ij}$定义如下：

$$\begin{array}{rlrlrlrlrlrlrlrlrlrlrlrlrlrlrl}& & & & & & & & & & & & x_{ij}& =Attention(q_{ij},K_r,V_r),& & & & & & & & & & & & & & & & (2)\\ & & & & & & & & & & & & & =Softmax(\frac{q_{ij}{K}_r^T}{\sqrt{d_k}})V_r,& 1\le i\le W,1\le i\le H& & & & & & & & & & & & & & & \end{array}$$

其中，$H$ 和 $W$ 是特征图的高和宽。$K_r$和$V_r$表示从特征图 $K$ 和 $V$ 中选择的keys和values。

    给定位于$(i,j)$的query，位于坐标 $(i^{\prime },j^{\prime })$ 下keys和values将被选择去指导自注意力（self-attetion）：

$$\begin{array}{rlrlrlrlrlrlrlrlrlrlrlrlrlrlrl}& & & & & & & & & & & & & \{(i^{\prime },j^{\prime })|i^{\prime }=i+p\times r,j^{\prime }=j+q\times r\},\frac{-w}{2}\le p,q\le \frac{w}{2}.& & & & & & & & & & & & & & & & (3)\end{array}$$

    我们的 SWDA 以滑动窗口的方式对所有query patches进行自注意力操作。对于特征图边缘的query，我们简单地使用卷积运算中常用的 补零策略 来保持特征图的大小。通过稀疏地选择以queries为中心的keys和values，所提出的 SWDA 明确满足局部性和稀疏性属性，并且可以有效地对远程依赖关系进行建模

1.2. 多尺度扩张注意力

图4. 多尺度空洞注意力。

    首先，特征图的通道被划分不同的heads。然后，自注意力操作是在红色查询块周围的窗口中的彩色块之间执行的，在不同的头中使用不同的膨胀率。此外，不同heads中的特征被连接在一起，然后输入到线性层中。默认情况下，我们使用 3 × 3 的内核大小，膨胀率 r = 1、2 和 3，不同头中参与感受野的大小为 3 × 3、5 × 5 和 7 × 7。

 

    为了利用块级自注意力机制在不同尺度上的稀疏性，我们进一步提出了多尺度扩张注意力（MSDA） 块来提取多尺度语义信息。如图4所示，给定特征图$X$，我们通过 线性投影(linear projection) 获得相应的query、kay和value。之后，我们将特征图的通道划分到 $n$ 个不同的$heads$，并在不同的$heads$中以不同的膨胀率(dilation rates)执行多尺度SWDA。具体来说，我们的MSDA计算如下：

$$\begin{array}{rlrlrlrlrlrlrlrlrlrlrlrlrlrlrlr}& & & & & & & & & & & & & h_i=SWDA(Q_i,K_i,V_i,r_i),& 1\le i\le n,& & & & & & & & & & & & & & & & (4)\\ & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & \\ & & & & & & & & & & & & & X=Linear(Concat[h_1,...,h_n]),& & & & & & & & & & & & & & & & & (5)\end{array}$$

其中，$r_i$是第 $i$ 个$head$的扩张率，$Q_i,K_i$ 和 $V_i$ 代表馈入第 $i$ 个$head$的特征图切片。输出 { h i } i = 1 n \{h_i\}_{i=1}^n {hi​}i=1n​被concat到一起，然后送到线性层进行特征聚合。

    通过为不同的 $heads$ 设置不同的扩张率，我们的 MSDA 有效地聚合了参与感受野内不同尺度的语义信息，并有效地减少了自注意力机制的冗余，而无需复杂的操作和额外的计算成本。

2. 代码

import torch
import torch.nn as nn
from functools import partial
from timm.models.layers import DropPath, to_2tuple, trunc_normal_
from timm.models.registry import register_model
from timm.models.vision_transformer import _cfgclass Mlp(nn.Module):def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):super().__init__()out_features = out_features or in_featureshidden_features = hidden_features or in_featuresself.fc1 = nn.Linear(in_features, hidden_features)self.act = act_layer()self.fc2 = nn.Linear(hidden_features, out_features)self.drop = nn.Dropout(drop)def forward(self, x):x = self.fc1(x)x = self.act(x)x = self.drop(x)x = self.fc2(x)x = self.drop(x)return xclass DilateAttention(nn.Module):"Implementation of Dilate-attention"def __init__(self, head_dim, qk_scale=None, attn_drop=0, kernel_size=3, dilation=1):super().__init__()self.head_dim = head_dimself.scale = qk_scale or head_dim ** -0.5self.kernel_size=kernel_sizeself.unfold = nn.Unfold(kernel_size, dilation, dilation*(kernel_size-1)//2, 1)self.attn_drop = nn.Dropout(attn_drop)def forward(self,q,k,v):#B, C//3, H, Wq, k, v = q.detach(), k.detach(), v.detach()  # todo:!!!B,d,H,W = q.shapeq = q.reshape([B, d//self.head_dim, self.head_dim, 1 ,H*W]).permute(0, 1, 4, 3, 2)  # B,h,N,1,dk = self.unfold(k).reshape([B, d//self.head_dim, self.head_dim, self.kernel_size*self.kernel_size, H*W]).permute(0, 1, 4, 2, 3)  #B,h,N,d,k*kattn = (q @ k) * self.scale  # B,h,N,1,k*kattn = attn.softmax(dim=-1)attn = self.attn_drop(attn)v = self.unfold(v).reshape([B, d//self.head_dim, self.head_dim, self.kernel_size*self.kernel_size, H*W]).permute(0, 1, 4, 3, 2)  # B,h,N,k*k,dx = (attn @ v).transpose(1, 2).reshape(B, H, W, d)return xclass MultiDilatelocalAttention(nn.Module):"Implementation of Dilate-attention"def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None,attn_drop=0.,proj_drop=0., kernel_size=3, dilation=[1, 2, 3]):super().__init__()self.dim = dimself.num_heads = num_headshead_dim = dim // num_headsself.dilation = dilationself.kernel_size = kernel_sizeself.scale = qk_scale or head_dim ** -0.5self.num_dilation = len(dilation)assert num_heads % self.num_dilation == 0, f"num_heads{num_heads} must be the times of num_dilation{self.num_dilation}!!"self.qkv = nn.Conv2d(dim, dim * 3, 1, bias=qkv_bias)self.dilate_attention = nn.ModuleList([DilateAttention(head_dim, qk_scale, attn_drop, kernel_size, dilation[i])for i in range(self.num_dilation)])self.proj = nn.Linear(dim, dim)self.proj_drop = nn.Dropout(proj_drop)def forward(self, x):B, H, W, C = x.shapex = x.permute(0, 3, 1, 2)# B, C, H, Wqkv = self.qkv(x).reshape(B, 3, self.num_dilation, C//self.num_dilation, H, W).permute(2, 1, 0, 3, 4, 5)#num_dilation,3,B,C//num_dilation,H,Wx = x.reshape(B, self.num_dilation, C//self.num_dilation, H, W).permute(1, 0, 3, 4, 2 )# num_dilation, B, H, W, C//num_dilationfor i in range(self.num_dilation):x[i] = self.dilate_attention[i](qkv[i][0], qkv[i][1], qkv[i][2])# B, H, W,C//num_dilationx = x.permute(1, 2, 3, 0, 4).reshape(B, H, W, C)x = self.proj(x)x = self.proj_drop(x)return xclass DilateBlock(nn.Module):"Implementation of Dilate-attention block"def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False,qk_scale=None, drop=0., attn_drop=0.,drop_path=0.,act_layer=nn.GELU, norm_layer=nn.LayerNorm, kernel_size=3, dilation=[1, 2, 3],cpe_per_block=False):super().__init__()self.dim = dimself.num_heads = num_headsself.mlp_ratio = mlp_ratioself.kernel_size = kernel_sizeself.dilation = dilationself.cpe_per_block = cpe_per_blockif self.cpe_per_block:self.pos_embed = nn.Conv2d(dim, dim, 3, padding=1, groups=dim)self.norm1 = norm_layer(dim)self.attn = MultiDilatelocalAttention(dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale,attn_drop=attn_drop, kernel_size=kernel_size, dilation=dilation)self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()self.norm2 = norm_layer(dim)mlp_hidden_dim = int(dim * mlp_ratio)self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim,act_layer=act_layer, drop=drop)def forward(self, x):if self.cpe_per_block:x = x + self.pos_embed(x)x = x.permute(0, 2, 3, 1)x = x + self.drop_path(self.attn(self.norm1(x)))x = x + self.drop_path(self.mlp(self.norm2(x)))x = x.permute(0, 3, 1, 2)#B, C, H, Wreturn xif __name__ == "__main__":x = torch.rand([2,72,56,56])B, C, H, W = x.shapedim = Cnum_heads = 3   # 必须是dilation的整数倍 且 被dim整除head_dim = dim // num_heads#######################drop_path=0.1depths = [2, 2, 6, 2]num_layers = len(depths)dpr = [x.item() for x in torch.linspace(0, drop_path, sum(depths))]for i_layer in range(num_layers):drop_paths = dpr[sum(depths[:i_layer]):sum(depths[:i_layer + 1])]#######################m = DilateBlock(dim=C,num_heads=num_heads,kernel_size=3,dilation=[1,2,3],mlp_ratio=4.,qkv_bias=True,qk_scale=head_dim ** -0.5,drop=0.,attn_drop=0.,drop_path=drop_paths[1] if isinstance(drop_paths, list) else drop_paths,norm_layer=nn.LayerNorm, act_layer=nn.GELU, cpe_per_block=True)y = m(x)print(y.shape)

3. 流程图

---

3.1. MultiDilatelocalAttention

3.2. DilateAttention

3.3. MLP

完整流程图如下: