dede网站地图,做医疗竞价网站,什么网站可以做简历,编程线上课程哪个机构好一些空洞自注意力机制 文章目录 摘要1. 模型解释1.1. 滑动窗口扩张注意力1.2. 多尺度扩张注意力 2. 代码3. 流程图3.1. MultiDilatelocalAttention3.2. DilateAttention3.3. MLP 摘要 本文针对DilateFormer中的空洞自注意力机制原理和代码进行详细介绍#xff0c;最后通过流程图梳…空洞自注意力机制 文章目录 摘要1. 模型解释1.1. 滑动窗口扩张注意力1.2. 多尺度扩张注意力 2. 代码3. 流程图3.1. MultiDilatelocalAttention3.2. DilateAttention3.3. MLP 摘要 本文针对DilateFormer中的空洞自注意力机制原理和代码进行详细介绍最后通过流程图梳理其实现原理。
1. 模型解释
1.1. 滑动窗口扩张注意力 根据在普通视觉变换器ViTs中浅层全局注意力中观察到的局部性和稀疏性特性我们提出了一种滑动窗口扩张注意力SWDA 操作其中keys和values被以query patch为中心的滑动窗口稀疏地选择。然后对这些代表性patches进行自注意力。我们的 SWDA 正式描述如下 X S W D A ( Q , K , V , r ) ( 1 ) \begin{aligned} X SWDA(Q,K,V,r) (1) \end{aligned} XSWDA(Q,K,V,r)(1)
其中 Q , K , V Q,K,V Q,K,V分别代表query、key和value矩阵三个矩阵的每一行表示一个query/key/value特征向量。对于原始特征图上 ( i , j ) (i,j) (i,j)位置的querySWDA以尺寸为 w × w w×w w×w大小的滑动窗口稀疏地选择key和value去指导自注意力。 而且我们定义一个扩张率 r ϵ N r \epsilon N^ rϵN去控制稀疏程度。特别地对于位置 ( i , j ) (i,j) (i,j)SWDA计算的输出 X X X中的相应分量 x i j x_{ij} xij定义如下 x i j A t t e n t i o n ( q i j , K r , V r ) , ( 2 ) S o f t m a x ( q i j K r T d k ) V r , 1 ≤ i ≤ W , 1 ≤ i ≤ H \begin{aligned} x_{ij} Attention(q_{ij},K_r,V_r), (2)\\ Softmax(\frac{q_{ij}K^T_r}{\sqrt{d_k}})V_r, 1≤i≤W, 1≤i≤H \\ \end{aligned} xijAttention(qij,Kr,Vr),Softmax(dk qijKrT)Vr,1≤i≤W,1≤i≤H(2)
其中 H H H 和 W W W 是特征图的高和宽。 K r K_r Kr和 V r V_r Vr表示从特征图 K K K 和 V V V 中选择的keys和values。 给定位于 ( i , j ) (i,j) (i,j)的query位于坐标 ( i ′ , j ′ ) (i, j) (i′,j′) 下keys和values将被选择去指导自注意力self-attetion { ( i ′ , j ′ ) ∣ i ′ i p × r , j ′ j q × r } , − w 2 ≤ p , q ≤ w 2 . ( 3 ) \begin{aligned} \{(i,j)|iip×r, jjq×r \}, \frac{-w}{2}≤p, q≤\frac{w}{2}. (3) \end{aligned} {(i′,j′)∣i′ip×r,j′jq×r},2−w≤p,q≤2w.(3) 我们的 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 X X我们通过 线性投影(linear projection) 获得相应的query、kay和value。之后我们将特征图的通道划分到 n n n 个不同的 h e a d s heads heads并在不同的 h e a d s heads heads中以不同的膨胀率(dilation rates)执行多尺度SWDA。具体来说我们的MSDA计算如下 h i S W D A ( Q i , K i , V i , r i ) , 1 ≤ i ≤ n , ( 4 ) X L i n e a r ( C o n c a t [ h 1 , . . . , h n ] ) , ( 5 ) \begin{aligned} h_iSWDA(Q_i,K_i,V_i,r_i), 1≤i≤n, (4)\\ \\ XLinear(Concat[h_1,...,h_n]), (5) \end{aligned} hiSWDA(Qi,Ki,Vi,ri),XLinear(Concat[h1,...,hn]),1≤i≤n,(4)(5)
其中 r i r_i ri是第 i i i 个 h e a d head head的扩张率 Q i , K i Q_i,K_i Qi,Ki 和 V i V_i Vi 代表馈入第 i i i 个 h e a d head head的特征图切片。输出 { h i } i 1 n \{h_i\}_{i1}^n {hi}i1n被concat到一起然后送到线性层进行特征聚合。 通过为不同的 h e a d s heads 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_featuresNone, out_featuresNone, act_layernn.GELU, drop0.):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-attentiondef __init__(self, head_dim, qk_scaleNone, attn_drop0, kernel_size3, dilation1):super().__init__()self.head_dim head_dimself.scale qk_scale or head_dim ** -0.5self.kernel_sizekernel_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-attentiondef __init__(self, dim, num_heads8, qkv_biasFalse, qk_scaleNone,attn_drop0.,proj_drop0., kernel_size3, 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, fnum_heads{num_heads} must be the times of num_dilation{self.num_dilation}!!self.qkv nn.Conv2d(dim, dim * 3, 1, biasqkv_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 blockdef __init__(self, dim, num_heads, mlp_ratio4., qkv_biasFalse,qk_scaleNone, drop0., attn_drop0.,drop_path0.,act_layernn.GELU, norm_layernn.LayerNorm, kernel_size3, dilation[1, 2, 3],cpe_per_blockFalse):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, padding1, groupsdim)self.norm1 norm_layer(dim)self.attn MultiDilatelocalAttention(dim, num_headsnum_heads, qkv_biasqkv_bias, qk_scaleqk_scale,attn_dropattn_drop, kernel_sizekernel_size, dilationdilation)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_featuresdim, hidden_featuresmlp_hidden_dim,act_layeract_layer, dropdrop)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_path0.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(dimC,num_headsnum_heads,kernel_size3,dilation[1,2,3],mlp_ratio4.,qkv_biasTrue,qk_scalehead_dim ** -0.5,drop0.,attn_drop0.,drop_pathdrop_paths[1] if isinstance(drop_paths, list) else drop_paths,norm_layernn.LayerNorm, act_layernn.GELU, cpe_per_blockTrue)y m(x)print(y.shape)3. 流程图 3.1. MultiDilatelocalAttention 3.2. DilateAttention 3.3. MLP 完整流程图如下:
