手把手带你Yolov5 (v6.1)添加注意力机制(一)（并附上30多种顶会Attention原理图）

Yolov5 (v6.1)如何添加注意力机制？

如果感觉有帮助的话请点赞支持下???
前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站。

文章目录

Yolov5 (v6.1)如何添加注意力机制？1.1 添加方式?1.2 主流注意力机制介绍1.2.1 SE?1.2.2 CBAM?1.2.3 ECA?1.2.4 CA?1.2.5 SOCA1.2.6 A2-Net1.2.7 DANPositional1.2.8 DANChannel1.2.9 RESNest1.2.10 Harmonious1.2.11 SpatialAttention1.2.12 RANet1.2.13 Co-excite1.2.14 EfﬁcientAttention1.2.15 X-Linear1.2.16 SlotAttention1.2.17 Axial1.2.18 RFA1.2.19 Attention-BasedDropout1.2.20 ReverseAttention1.2.21 CrossAttention1.2.22 Perceiver1.2.23 Criss-CrossAttention1.2.24 BoostedAttention1.2.25 Prophet1.2.26 S3TA1.2.27 Self-CriticAttention1.2.28 BayesianAttentionBeliefNetworks1.2.29 Expectation-MaximizationAttention1.2.30 GaussianAttention 1.3内容导航

注意力机制（Attention Mechanism）源于对人类视觉的研究。在认知科学中，由于信息处理的瓶颈，人类会选择性地关注所有信息的一部分，同时忽略其他可见的信息。为了合理利用有限的视觉信息处理资源，人类需要选择视觉区域中的特定部分，然后集中关注它。例如，人们在阅读时，通常只有少量要被读取的词会被关注和处理。综上，注意力机制主要有两个方面：决定需要关注输入的哪部分；分配有限的信息处理资源给重要的部分。这几年有关attention的论文与日俱增，下图就显示了在包括CVPR、ICCV、ECCV、NeurIPS、ICML和ICLR在内的顶级会议中，与attention相关的论文数量的增加量。下面我将会分享Yolov5 v6.1如何添加注意力机制；并分享到2022年4月为止，30个顶会上提出的优秀的attention.

在这里插入图片描述

1.1 添加方式?

第一步；要把注意力结构代码放到common.py文件中，以SE举例，将这段代码粘贴到common.py文件中

class SE(nn.Module):    def __init__(self, c1, c2, ratio=16):        super(SE, self).__init__()        #c*1*1        self.avgpool = nn.AdaptiveAvgPool2d(1)        self.l1 = nn.Linear(c1, c1 // ratio, bias=False)        self.relu = nn.ReLU(inplace=True)        self.l2 = nn.Linear(c1 // ratio, c1, bias=False)        self.sig = nn.Sigmoid()    def forward(self, x):        b, c, _, _ = x.size()        y = self.avgpool(x).view(b, c)        y = self.l1(y)        y = self.relu(y)        y = self.l2(y)        y = self.sig(y)        y = y.view(b, c, 1, 1)        return x * y.expand_as(x)

第二步；找到yolo.py文件里的parse_model函数，将类名加入进去

在这里插入图片描述

第三步；修改配置文件（我这里拿yolov5s.yaml举例子），将注意力层加到你想加入的位置；常用的一般是添加到backbone的最后一层，或者C3里面，这里是加在了最后一层

在这里插入图片描述

?加到这里还没完，还有两个细节需要注意！

当在网络中添加了新的层之后，那么该层网络后续的层的编号都会发生改变，看下图，原本Detect指定的是 [ 17 , 20 , 23 ] [17,20,23] [17,20,23]层，所以在我们添加了SE注意力层之后也要Detect对这里进行修改，即原来的 17 17 17层变成了 18 18 18层；原来的 20 20 20层变成了 21 21 21层；原来的 23 23 23层变成了 24 24 24层；所以Detecet的from系数要改为 [ 18 , 21 , 24 ] [18,21,24] [18,21,24]

在这里插入图片描述

同样的，Concat的from系数也要修改，这样才能保持原网络结构不发生特别大的改变，我们刚才把SE层加到了第9层，所以第9层之后的编号都会加1，这里我们要把后面两个Concat的from系数分别由 [ − 1 , 14 ] , [ − 1 , 10 ] [-1,14],[-1,10] [−1,14],[−1,10]改为 [ − 1 , 15 ] , [ − 1 , 11 ] [-1,15],[-1,11] [−1,15],[−1,11]

在这里插入图片描述

这里放上我加入SE注意力层后完整的配置文件SE.yaml

# Parametersnc: 80  # number of classesdepth_multiple: 0.33  # model depth multiplewidth_multiple: 0.50  # layer channel multipleanchors:  - [10,13, 16,30, 33,23]  # P3/8  - [30,61, 62,45, 59,119]  # P4/16  - [116,90, 156,198, 373,326]  # P5/32# YOLOv5 v6.0 backbone+SEbackbone:  # [from, number, module, args]  [[-1, 1, Conv, [64, 6, 2, 2]],  # 0-P1/2   [-1, 1, Conv, [128, 3, 2]],  # 1-P2/4   [-1, 3, C3, [128]],   [-1, 1, Conv, [256, 3, 2]],  # 3-P3/8   [-1, 6, C3, [256]],   [-1, 1, Conv, [512, 3, 2]],  # 5-P4/16   [-1, 9, C3, [512]],   [-1, 1, Conv, [1024, 3, 2]],  # 7-P5/32   [-1, 3, C3, [1024]],   [-1,1,SE,[1024]], #SE   [-1, 1, SPPF, [1024, 5]],  # 10  ]# YOLOv5+SE v6.0 headhead:  [[-1, 1, Conv, [512, 1, 1]],   [-1, 1, nn.Upsample, [None, 2, 'nearest']],   [[-1, 6], 1, Concat, [1]],  # cat backbone P4   [-1, 3, C3, [512, False]],  # 14   [-1, 1, Conv, [256, 1, 1]],   [-1, 1, nn.Upsample, [None, 2, 'nearest']],   [[-1, 4], 1, Concat, [1]],  # cat backbone P3   [-1, 3, C3, [256, False]],  # 18 (P3/8-small)   [-1, 1, Conv, [256, 3, 2]],   [[-1, 15], 1, Concat, [1]],  # cat head P4   [-1, 3, C3, [512, False]],  # 21 (P4/16-medium)   [-1, 1, Conv, [512, 3, 2]],   [[-1, 11], 1, Concat, [1]],  # cat head P5   [-1, 3, C3, [1024, False]],  # 24 (P5/32-large)   [[18, 21, 24], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)  ]

加好了就可以训练了，在运行的时候会看到我们注意力层的位置：

在这里插入图片描述

这就代表加成功了，其他的注意力机制和这个原理是一样的，下面依次放上几种注意力的结构代码和原理图：

1.2 主流注意力机制介绍

在这里插入图片描述

注意力机制分类图

下面只介绍顶会主流的attention,根据主流attention的魔改版这里不做介绍

1.2.1 SE?

论文名称：Squeeze-and-Excitation Networks

论文链接：https://arxiv.org/pdf/1709.01507.pdf

论文代码： https://github.com/hujie-frank/SENet

SEnet（Squeeze-and-Excitation Network）考虑了特征通道之间的关系，在特征通道上加入了注意力机制。

SEnet通过学习的方式自动获取每个特征通道的重要程度，并且利用得到的重要程度来提升特征并抑制对当前任务不重要的特征。SEnet通过Squeeze模块和Exciation模块实现所述功能。

在这里插入图片描述

如图所示，首先作者通过squeeze操作，对空间维度进行压缩，直白的说就是对每个特征图做全局池化，平均成一个实数值。该实数从某种程度上来说具有全局感受野。作者提到该操作能够使得靠近数据输入的特征也可以具有全局感受野，这一点在很多的任务中是非常有用的。紧接着就是excitaton操作，由于经过squeeze操作后，网络输出了11C大小的特征图，作者利用权重w来学习C个通道直接的相关性。在实际应用时有的框架使用全连接，有的框架使用11的卷积实现，从参数计算角度我更加推荐使用11卷积，也就是下面代码中的fc2操作。该过程中作者先对C个通道降维再扩展回C通道。好处就是一方面降低了网络计算量，一方面增加了网络的非线性能力。最后一个操作时将exciation的输出看作是经过特征选择后的每个通道的重要性，通过乘法加权的方式乘到先前的特征上，从事实现提升重要特征，抑制不重要特征这个功能。

class SE(nn.Module):    def __init__(self, c1, c2, ratio=16):        super(SE, self).__init__()        #c*1*1        self.avgpool = nn.AdaptiveAvgPool2d(1)        self.l1 = nn.Linear(c1, c1 // ratio, bias=False)        self.relu = nn.ReLU(inplace=True)        self.l2 = nn.Linear(c1 // ratio, c1, bias=False)        self.sig = nn.Sigmoid()    def forward(self, x):        b, c, _, _ = x.size()        y = self.avgpool(x).view(b, c)        y = self.l1(y)        y = self.relu(y)        y = self.l2(y)        y = self.sig(y)        y = y.view(b, c, 1, 1)        return x * y.expand_as(x)

这里放上我自己做实验的截图，我就是把SE层加到了第9层的位置；粉红色线条代表添加了SE注意力机制

在这里插入图片描述

1.2.2 CBAM?

论文题目：《CBAM: Convolutional Block Attention Module》

论文地址：https://arxiv.org/pdf/1807.06521.pdf

CBAM(Convolutional Block Attention Module)结合了特征通道和特征空间两个维度的注意力机制。

在这里插入图片描述

CBAM通过学习的方式自动获取每个特征通道的重要程度，和SEnet类似。此外还通过类似的学习方式自动获取每个特征空间的重要程度。并且利用得到的重要程度来提升特征并抑制对当前任务不重要的特征。

在这里插入图片描述

CBAM提取特征通道注意力的方式基本和SEnet类似，如下ChannelAttention中的代码所示，其在SEnet的基础上增加了max_pool的特征提取方式，其余步骤是一样的。将通道注意力提取厚的特征作为空间注意力模块的输入。

在这里插入图片描述

CBAM提取特征空间注意力的方式：经过ChannelAttention后，最终将经过通道重要性选择后的特征图送入特征空间注意力模块，和通道注意力模块类似，空间注意力是以通道为单位进行最大和平均迟化，并将两者的结果进行concat，之后再一个卷积降成1wh的特征图空间权重，再将该权重和输入特征进行点积，从而实现空间注意力机制。

# CBAMclass ChannelAttention(nn.Module):    def __init__(self, in_planes, ratio=16):        super(ChannelAttention, self).__init__()        self.avg_pool = nn.AdaptiveAvgPool2d(1)        self.max_pool = nn.AdaptiveMaxPool2d(1)        self.f1 = nn.Conv2d(in_planes, in_planes // ratio, 1, bias=False)        self.relu = nn.ReLU()        self.f2 = nn.Conv2d(in_planes // ratio, in_planes, 1, bias=False)        self.sigmoid = nn.Sigmoid()    def forward(self, x):        avg_out = self.f2(self.relu(self.f1(self.avg_pool(x))))        max_out = self.f2(self.relu(self.f1(self.max_pool(x))))        out = self.sigmoid(avg_out + max_out)        return out    class SpatialAttention(nn.Module):    def __init__(self, kernel_size=7):        super(SpatialAttention, self).__init__()        assert kernel_size in (3, 7), 'kernel size must be 3 or 7'        padding = 3 if kernel_size == 7 else 1        # (特征图的大小-算子的size+2*padding)/步长+1        self.conv = nn.Conv2d(2, 1, kernel_size, padding=padding, bias=False)        self.sigmoid = nn.Sigmoid()    def forward(self, x):        # 1*h*w        avg_out = torch.mean(x, dim=1, keepdim=True)        max_out, _ = torch.max(x, dim=1, keepdim=True)        x = torch.cat([avg_out, max_out], dim=1)        #2*h*w        x = self.conv(x)        #1*h*w        return self.sigmoid(x)    class CBAM(nn.Module):    # CSP Bottleneck with 3 convolutions    def __init__(self, c1, c2, ratio=16, kernel_size=7):  # ch_in, ch_out, number, shortcut, groups, expansion        super(CBAM, self).__init__()        self.channel_attention = ChannelAttention(c1, ratio)        self.spatial_attention = SpatialAttention(kernel_size)    def forward(self, x):        out = self.channel_attention(x) * x        # c*h*w        # c*h*w * 1*h*w        out = self.spatial_attention(out) * out        return out

1.2.3 ECA?

论文名称：ECA-Net: Efficient Channel Attention for Deep Convolutional Neural Networks

论文地址：https://arxiv.org/abs/1910.03151

代码: https://github.com/BangguWu/ECANet

在这里插入图片描述

class ECA(nn.Module):    """Constructs a ECA module.    Args:        channel: Number of channels of the input feature map        k_size: Adaptive selection of kernel size    """    def __init__(self, c1,c2, k_size=3):        super(ECA, self).__init__()        self.avg_pool = nn.AdaptiveAvgPool2d(1)        self.conv = nn.Conv1d(1, 1, kernel_size=k_size, padding=(k_size - 1) // 2, bias=False)        self.sigmoid = nn.Sigmoid()    def forward(self, x):        # feature descriptor on the global spatial information        y = self.avg_pool(x)        # print(y.shape,y.squeeze(-1).shape,y.squeeze(-1).transpose(-1, -2).shape)        # Two different branches of ECA module        # 50*C*1*1        #50*C*1        #50*1*C        y = self.conv(y.squeeze(-1).transpose(-1, -2)).transpose(-1, -2).unsqueeze(-1)        # Multi-scale information fusion        y = self.sigmoid(y)        return x * y.expand_as(x)

1.2.4 CA?

在这里插入图片描述

#CAclass h_sigmoid(nn.Module):    def __init__(self, inplace=True):        super(h_sigmoid, self).__init__()        self.relu = nn.ReLU6(inplace=inplace)    def forward(self, x):        return self.relu(x + 3) / 6class h_swish(nn.Module):    def __init__(self, inplace=True):        super(h_swish, self).__init__()        self.sigmoid = h_sigmoid(inplace=inplace)    def forward(self, x):        return x * self.sigmoid(x)class CoordAtt(nn.Module):    def __init__(self, inp, oup, reduction=32):        super(CoordAtt, self).__init__()        self.pool_h = nn.AdaptiveAvgPool2d((None, 1))        self.pool_w = nn.AdaptiveAvgPool2d((1, None))        mip = max(8, inp // reduction)        self.conv1 = nn.Conv2d(inp, mip, kernel_size=1, stride=1, padding=0)        self.bn1 = nn.BatchNorm2d(mip)        self.act = h_swish()        self.conv_h = nn.Conv2d(mip, oup, kernel_size=1, stride=1, padding=0)        self.conv_w = nn.Conv2d(mip, oup, kernel_size=1, stride=1, padding=0)    def forward(self, x):        identity = x        n, c, h, w = x.size()        #c*1*W        x_h = self.pool_h(x)        #c*H*1        #C*1*h        x_w = self.pool_w(x).permute(0, 1, 3, 2)        y = torch.cat([x_h, x_w], dim=2)        #C*1*(h+w)        y = self.conv1(y)        y = self.bn1(y)        y = self.act(y)        x_h, x_w = torch.split(y, [h, w], dim=2)        x_w = x_w.permute(0, 1, 3, 2)        a_h = self.conv_h(x_h).sigmoid()        a_w = self.conv_w(x_w).sigmoid()        out = identity * a_w * a_h        return out