手把手带你YOLOv5/v7 添加注意力机制(并附上30多种顶会Attention原理图)2023/5/17更新

请添加图片描述


🌟想了解YOLO系列算法更多进阶教程欢迎订阅我的专栏🌟

基础不好的同学可以试试看一下我的《目标检测蓝皮书》🚀,里面包含超多目标检测实用知识,想速通目标检测,看这本就对了!

想了解 YOLOv5 YOLOv7 系列算法改进教程的同学可以关注这个专栏YOLOv5/v7 进阶实战 | 安卓部署 | PyQt5页面 | 剪枝✂️ | 蒸馏⚗️ | Flask Web部署 | 改进教程,里面包含多种手把手的部署压缩教程,除此之外还有大量的改进~

想了解 YOLOv8 系列算法进阶教程的同学可以关注这个专栏YOLOv8改进实战,里面包含超多YOLOv8算法改进教程,想快人一步发表YOLOv8改进论文,请抓紧订阅学习!目前折扣中


番外篇 | 20+ 种注意力机制及代码 适用于YOLOv5/v7/v8


文章目录


注意力机制介绍

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

在这里插入图片描述

可视化图表显示了顶级会议中与注意力相关的论文数量的增加量,
包括CVPR,ICCV,ECCV,NeurIPS,ICML和ICLR。

注意力机制的分类

在这里插入图片描述

注意力机制分类图

1. SE 注意力模块🌟

论文名称:《Squeeze-and-Excitation Networks》

论文地址:https://arxiv.org/pdf/1709.01507.pdf

代码地址: https://github.com/hujie-frank/SENet

1.1 原理

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

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

在这里插入图片描述

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

1.2 代码

# SE
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 9 9 层的位置;粉红色线条代表添加了SE注意力机制。

在这里插入图片描述


2. CBAM 注意力模块🌟

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

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

2.1 原理

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

在这里插入图片描述

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

在这里插入图片描述

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

在这里插入图片描述

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

2.2 代码

# CBAM
class 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):
    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


3. ECA 注意力模块🌟

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

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

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

3.1 原理

先前的方法大多致力于开发更复杂的注意力模块,以实现更好的性能,这不可避免地增加了模型的复杂性。为了克服性能和复杂性之间的矛盾,作者提出了一种有效的通道关注(ECA)模块,该模块只增加了少量的参数,却能获得明显的性能增益。

在这里插入图片描述

3.2 代码

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

4. CA 注意力模块🌟

论文名称:《Coordinate Attention for Efficient Mobile Network Design》

论文地址:https://arxiv.org/abs/2103.02907

4.1 原理

先前的轻量级网络的注意力机制大都采用SE模块,仅考虑了通道间的信息,忽略了位置信息。尽管后来的BAMCBAM尝试在降低通道数后通过卷积来提取位置注意力信息,但卷积只能提取局部关系,缺乏长距离关系提取的能力。为此,论文提出了新的高效注意力机制coordinate attention(CA),能够将横向和纵向的位置信息编码到channel attention中,使得移动网络能够关注大范围的位置信息又不会带来过多的计算量。

coordinate attention的优势主要有以下几点:

  • 不仅获取了通道间信息,还考虑了方向相关的位置信息,有助于模型更好地定位和识别目标;
  • 足够灵活和轻量,能够简单地插入移动网络的核心结构中;
  • 可以作为预训练模型用于多种任务中,如检测和分割,均有不错的性能提升。

在这里插入图片描述

4.2 代码

# CA
class 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) / 6
class 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

5. 添加方式💡

大致的修改方式如下

Y O L O v 5 YOLOv5 YOLOv5 Y O L O v 7 YOLOv7 YOLOv7 中添加注意力机制可分为如下 5 5 5 步,以在 yolov5s 中添加 SE 注意力机制为例子:

  1. yolov5/models文件夹下新建一个 yolov5s_SE.yaml
  2. 将本文上面提供的 SE 注意力代码添加到 common.py 文件末尾;
  3. SE 这个类的名字加入到 yolov5/models/yolo.py 中;
  4. 修改 yolov5s_SE.yaml ,将 SE 注意力加到你想添加的位置;
  5. 修改 train.py 文件的 '--cfg' 默认参数,随后就可以开始训练了。

详细的修改方式如下

  • 1 1 1 步:在yolov5/models文件夹下新建一个 yolov5_SE.yaml ,将 yolov5s.yaml 文件内容拷贝粘贴到我们新建的 yolov5s_SE.yaml 文件中等待第 4 4 4 步使用;
  • 2 2 2 步:将本文上面提供的 SE 注意力代码添加到 yolov5/models/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)
  • 3 3 3 步:将 SE 这个类的名字加入到 yolov5/models/yolo.py 如下位置;

在这里插入图片描述

你的可能和我有点区别,不用在意
  • 4 4 4 步:修改 yolov5s_SE.yaml ,将 SE 注意力加到你想添加的位置;常见的位置有 C 3 C3 C3 模块后面, N e c k Neck Neck 中,也可以在主干的 S P P F SPPF SPPF 前添加一层;我这里演示添加到 S P P F SPPF SPPF 上一层:
    [-1, 1, SE,[1024]], 添加到 SPPF 的上一层,即下图中所示位置:

在这里插入图片描述

加到这里还没完,还有两个细节需要注意!🌟

当在网络中添加了新的层之后,那么该层网络后续的层的编号都会发生改变,看下图,原本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]

在这里插入图片描述

左侧是原始的 yolov5s.yaml ,右侧为修改后的 yolov5s_SE.yaml

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

在这里插入图片描述

左侧是原始的 yolov5s.yaml ,右侧为修改后的 yolov5s_SE.yaml

如果这一步的原理大家没看懂的话,可以看看我的哔哩哔哩视频,我讲解了yaml文件的原理:点击跳转

  • 5 5 5 步:修改 train.py 文件的 '--cfg' 默认参数,在'--cfg' 后的 default= 后面加上 yolov5s_SE.yaml 的路径,随后就可以开始训练了。
    在这里插入图片描述
    在训练时会打印模型的结构,当出现下面的结构时,就代表我们添加成功了:
    在这里插入图片描述

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

# Parameters
nc: 80  # number of classes
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.50  # layer channel multiple
anchors:
  - [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+SE
backbone:
  # [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 head
head:
  [[-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)
  ]

6. SOCA 注意力模块 (🤖部分同学有bug)

论文地址:https://openaccess.thecvf.com.pdf

在这里插入图片描述

代码

import numpy as np
import torch
from torch import nn
from torch.nn import init

from torch.autograd import Function

class Covpool(Function):
     @staticmethod
     def forward(ctx, input):
         x = input
         batchSize = x.data.shape[0]
         dim = x.data.shape[1]
         h = x.data.shape[2]
         w = x.data.shape[3]
         M = h*w
         x = x.reshape(batchSize,dim,M)
         I_hat = (-1./M/M)*torch.ones(M,M,device = x.device) + (1./M)*torch.eye(M,M,device = x.device)
         I_hat = I_hat.view(1,M,M).repeat(batchSize,1,1).type(x.dtype)
         y = x.bmm(I_hat).bmm(x.transpose(1,2))
         ctx.save_for_backward(input,I_hat)
         return y
     @staticmethod
     def backward(ctx, grad_output):
         input,I_hat = ctx.saved_tensors
         x = input
         batchSize = x.data.shape[0]
         dim = x.data.shape[1]
         h = x.data.shape[2]
         w = x.data.shape[3]
         M = h*w
         x = x.reshape(batchSize,dim,M)
         grad_input = grad_output + grad_output.transpose(1,2)
         grad_input = grad_input.bmm(x).bmm(I_hat)
         grad_input = grad_input.reshape(batchSize,dim,h,w)
         return grad_input

class Sqrtm(Function):
     @staticmethod
     def forward(ctx, input, iterN):
         x = input
         batchSize = x.data.shape[0]
         dim = x.data.shape[1]
         dtype = x.dtype
         I3 = 3.0*torch.eye(dim,dim,device = x.device).view(1, dim, dim).repeat(batchSize,1,1).type(dtype)
         normA = (1.0/3.0)*x.mul(I3).sum(dim=1).sum(dim=1)
         A = x.div(normA.view(batchSize,1,1).expand_as(x))
         Y = torch.zeros(batchSize, iterN, dim, dim, requires_grad = False, device = x.device)
         Z = torch.eye(dim,dim,device = x.device).view(1,dim,dim).repeat(batchSize,iterN,1,1)
         if iterN < 2:
            ZY = 0.5*(I3 - A)
            Y[:,0,:,:] = A.bmm(ZY)
         else:
            ZY = 0.5*(I3 - A)
            Y[:,0,:,:] = A.bmm(ZY)
            Z[:,0,:,:] = ZY
            for i in range(1, iterN-1):
               ZY = 0.5*(I3 - Z[:,i-1,:,:].bmm(Y[:,i-1,:,:]))
               Y[:,i,:,:] = Y[:,i-1,:,:].bmm(ZY)
               Z[:,i,:,:] = ZY.bmm(Z[:,i-1,:,:])
            ZY = 0.5*Y[:,iterN-2,:,:].bmm(I3 - Z[:,iterN-2,:,:].bmm(Y[:,iterN-2,:,:]))
         y = ZY*torch.sqrt(normA).view(batchSize, 1, 1).expand_as(x)
         ctx.save_for_backward(input, A, ZY, normA, Y, Z)
         ctx.iterN = iterN
         return y
     @staticmethod
     def backward(ctx, grad_output):
         input, A, ZY, normA, Y, Z = ctx.saved_tensors
         iterN = ctx.iterN
         x = input
         batchSize = x.data.shape[0]
         dim = x.data.shape[1]
         dtype = x.dtype
         der_postCom = grad_output*torch.sqrt(normA).view(batchSize, 1, 1).expand_as(x)
         der_postComAux = (grad_output*ZY).sum(dim=1).sum(dim=1).div(2*torch.sqrt(normA))
         I3 = 3.0*torch.eye(dim,dim,device = x.device).view(1, dim, dim).repeat(batchSize,1,1).type(dtype)
         if iterN < 2:
            der_NSiter = 0.5*(der_postCom.bmm(I3 - A) - A.bmm(der_sacleTrace))
         else:
            dldY = 0.5*(der_postCom.bmm(I3 - Y[:,iterN-2,:,:].bmm(Z[:,iterN-2,:,:])) -
                          Z[:,iterN-2,:,:].bmm(Y[:,iterN-2,:,:]).bmm(der_postCom))
            dldZ = -0.5*Y[:,iterN-2,:,:].bmm(der_postCom).bmm(Y[:,iterN-2,:,:])
            for i in range(iterN-3, -1, -1):
               YZ = I3 - Y[:,i,:,:].bmm(Z[:,i,:,:])
               ZY = Z[:,i,:,:].bmm(Y[:,i,:,:])
               dldY_ = 0.5*(dldY.bmm(YZ) - 
                         Z[:,i,:,:].bmm(dldZ).bmm(Z[:,i,:,:]) - 
                             ZY.bmm(dldY))
               dldZ_ = 0.5*(YZ.bmm(dldZ) - 
                         Y[:,i,:,:].bmm(dldY).bmm(Y[:,i,:,:]) -
                            dldZ.bmm(ZY))
               dldY = dldY_
               dldZ = dldZ_
            der_NSiter = 0.5*(dldY.bmm(I3 - A) - dldZ - A.bmm(dldY))
         grad_input = der_NSiter.div(normA.view(batchSize,1,1).expand_as(x))
         grad_aux = der_NSiter.mul(x).sum(dim=1).sum(dim=1)
         for i in range(batchSize):
             grad_input[i,:,:] += (der_postComAux[i] \
                                   - grad_aux[i] / (normA[i] * normA[i])) \
                                   *torch.ones(dim,device = x.device).diag()
         return grad_input, None

def CovpoolLayer(var):
    return Covpool.apply(var)

def SqrtmLayer(var, iterN):
    return Sqrtm.apply(var, iterN)

class SOCA(nn.Module):
    # second-order Channel attention
    def __init__(self, channel, reduction=8):
        super(SOCA, self).__init__()
        self.max_pool = nn.MaxPool2d(kernel_size=2)

        self.conv_du = nn.Sequential(
            nn.Conv2d(channel, channel // reduction, 1, padding=0, bias=True),
            nn.ReLU(inplace=True),
            nn.Conv2d(channel // reduction, channel, 1, padding=0, bias=True),
            nn.Sigmoid()
        )

    def forward(self, x):
        batch_size, C, h, w = x.shape  # x: NxCxHxW
        N = int(h * w)
        min_h = min(h, w)
        h1 = 1000
        w1 = 1000
        if h < h1 and w < w1:
            x_sub = x
        elif h < h1 and w > w1:
            W = (w - w1) // 2
            x_sub = x[:, :, :, W:(W + w1)]
        elif w < w1 and h > h1:
            H = (h - h1) // 2
            x_sub = x[:, :, H:H + h1, :]
        else:
            H = (h - h1) // 2
            W = (w - w1) // 2
            x_sub = x[:, :, H:(H + h1), W:(W + w1)]
        cov_mat = CovpoolLayer(x_sub) # Global Covariance pooling layer
        cov_mat_sqrt = SqrtmLayer(cov_mat,5) # Matrix square root layer( including pre-norm,Newton-Schulz iter. and post-com. with 5 iteration)
        cov_mat_sum = torch.mean(cov_mat_sqrt,1)
        cov_mat_sum = cov_mat_sum.view(batch_size,C,1,1)
        y_cov = self.conv_du(cov_mat_sum)
        return y_cov*x

yolov5/models/yolo.py 的如下位置添加下面的判断语句,虽然和上面介绍的添加方式不同,但是原理都是一样的。

elif m is SOCA:
    c1, c2 = ch[f], args[0]
    if c2 != no:
        c2 = make_divisible(c2 * gw, 8)
    args = [c1, *args[1:]]

在这里插入图片描述
yolov5s_SOCA.yaml


# Parameters
nc: 20  # number of classes
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.50  # layer channel multiple
anchors:
  - [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+SE
backbone:
  # [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, SOCA,[1024]],
   [-1, 1, SPPF, [1024, 5]],  # 10
  ]

# YOLOv5 v6.1 head
head:
  [[-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)
  ]


7. SimAM 注意力模块🌟

论文名称:《SimAM: A Simple, Parameter-Free Attention Module for Convolutional Neural Networks》

论文地址:http://proceedings.mlr.press/v139/yang21o/yang21o.pdf

代码地址:https://github.com/ZjjConan/SimAM

7.1 原理

在这篇论文中,我们提出了一个概念上简单但非常有效的注意力模块,用于卷积神经网络。与现有的基于通道和空间的注意力模块不同,我们的模块通过推断特征图中的三维注意力权重来工作,而无需向原始网络添加参数。具体而言,我们基于一些著名的神经科学理论,并提出了优化能量函数以找到每个神经元重要性的方法。我们进一步推导了能量函数的快速闭合形式解,并展示了该解可以用不到十行代码实现。该模块的另一个优点是,大多数运算符是基于定义的能量函数解的选择,避免了过多的结构调整的工作。对各种视觉任务的定量评估表明,所提出的模块具有灵活性和有效性,可以提高许多ConvNets的表征能力。

在这里插入图片描述


7.2 代码

import torch
import torch.nn as nn

class SimAM(torch.nn.Module):
    def __init__(self, channels = None,out_channels = None, e_lambda = 1e-4):
        super(SimAM, self).__init__()

        self.activaton = nn.Sigmoid()
        self.e_lambda = e_lambda

    def __repr__(self):
        s = self.__class__.__name__ + '('
        s += ('lambda=%f)' % self.e_lambda)
        return s

    @staticmethod
    def get_module_name():
        return "simam"

    def forward(self, x):

        b, c, h, w = x.size()
        
        n = w * h - 1

        x_minus_mu_square = (x - x.mean(dim=[2,3], keepdim=True)).pow(2)
        y = x_minus_mu_square / (4 * (x_minus_mu_square.sum(dim=[2,3], keepdim=True) / n + self.e_lambda)) + 0.5

        return x * self.activaton(y)  
elif m is SimAM:
    c1, c2 = ch[f], args[0]
    if c2 != no:
        c2 = make_divisible(c2 * gw, 8)
    args = [c1, c2]
[-1, 1, SimAM, [1024]],

8. S2-MLPv2 注意力模块🌟

论文名称:《S^2-MLPV2: IMPROVED SPATIAL-SHIFT MLP ARCHITECTURE FOR VISION》

论文地址:https://arxiv.org/pdf/2108.01072.pdf

4.1 原理

最近,基于多层感知机(MLP)的视觉骨干网络开始出现。相比于CNN和视觉Transformer,具有较少归纳偏差的基于MLP的视觉架构在图像识别中取得了有竞争力的性能。其中,采用直接的空间位移操作的空间位移MLP (S2-MLP)在性能上优于包括MLP-mixerResMLP在内的开创性工作。最近,使用具有金字塔结构的较小补丁,Vision Permutator (ViP)Global Filter Network (GFNet)在性能上优于S2-MLP。在本文中,我们改进了S2-MLP视觉骨干网络。我们沿通道维度扩展特征图,并将扩展后的特征图分成几个部分。我们对这些分割部分进行不同的空间位移操作。同时,我们利用分割注意力操作来融合这些分割部分。此外,与之前的方法类似,我们采用较小规模的补丁,并使用金字塔结构来提高图像识别准确性。我们将改进后的空间位移MLP视觉骨干网络称为S2-MLPv2。使用5500万个参数,我们的中等规模模型S2-MLPv2-MediumImageNet-1K基准测试中,使用224×224的图像,在没有自注意力和外部训练数据的情况下,实现了83.6%top-1准确率。

在这里插入图片描述
图:S2-MLP和提出的S2-MLPv2之间的空间位移操作的比较。在S2-MLP中,通道被平均分成四个部分,每个部分沿不同的方向进行位移。在位移后的通道上进行MLP操作。相比之下,在S2-MLPv2中, c c c 通道特征图被扩展为 3 c 3c 3c 通道特征图。然后,扩展的特征图沿通道维度被平均分成三个部分。对于每个部分,我们进行不同的空间位移操作。然后,通过分割注意力操作,将位移后的部分合并以生成 c c c 通道特征图。


8.2 代码

import numpy as np
import torch
from torch import nn
from torch.nn import init

# https://arxiv.org/abs/2108.01072
def spatial_shift1(x):
    b,w,h,c = x.size()
    x[:,1:,:,:c//4] = x[:,:w-1,:,:c//4]
    x[:,:w-1,:,c//4:c//2] = x[:,1:,:,c//4:c//2]
    x[:,:,1:,c//2:c*3//4] = x[:,:,:h-1,c//2:c*3//4]
    x[:,:,:h-1,3*c//4:] = x[:,:,1:,3*c//4:]
    return x


def spatial_shift2(x):
    b,w,h,c = x.size()
    x[:,:,1:,:c//4] = x[:,:,:h-1,:c//4]
    x[:,:,:h-1,c//4:c//2] = x[:,:,1:,c//4:c//2]
    x[:,1:,:,c//2:c*3//4] = x[:,:w-1,:,c//2:c*3//4]
    x[:,:w-1,:,3*c//4:] = x[:,1:,:,3*c//4:]
    return x


class SplitAttention(nn.Module):
    def __init__(self,channel=512,k=3):
        super().__init__()
        self.channel=channel
        self.k=k
        self.mlp1=nn.Linear(channel,channel,bias=False)
        self.gelu=nn.GELU()
        self.mlp2=nn.Linear(channel,channel*k,bias=False)
        self.softmax=nn.Softmax(1)
    
    def forward(self,x_all):
        b,k,h,w,c=x_all.shape
        x_all=x_all.reshape(b,k,-1,c) 
        a=torch.sum(torch.sum(x_all,1),1) 
        hat_a=self.mlp2(self.gelu(self.mlp1(a))) 
        hat_a=hat_a.reshape(b,self.k,c) 
        bar_a=self.softmax(hat_a) 
        attention=bar_a.unsqueeze(-2) 
        out=attention*x_all 
        out=torch.sum(out,1).reshape(b,h,w,c)
        return out


class S2Attention(nn.Module):

    def __init__(self, channels=512 ):
        super().__init__()
        self.mlp1 = nn.Linear(channels,channels*3)
        self.mlp2 = nn.Linear(channels,channels)
        self.split_attention = SplitAttention()

    def forward(self, x):
        b,c,w,h = x.size()
        x=x.permute(0,2,3,1)
        x = self.mlp1(x)
        x1 = spatial_shift1(x[:,:,:,:c])
        x2 = spatial_shift2(x[:,:,:,c:c*2])
        x3 = x[:,:,:,c*2:]
        x_all=torch.stack([x1,x2,x3],1)
        a = self.split_attention(x_all)
        x = self.mlp2(a)
        x=x.permute(0,3,1,2)
        return x
elif m is S2Attention:
    c1, c2 = ch[f], args[0]
    if c2 != no:
        c2 = make_divisible(c2 * gw, 8)
[-1, 1, S2Attention, [1024]],

9. NAMAttention 注意力模块🌟

论文名称:《NAM: Normalization-based Attention Module》

论文地址:https://arxiv.org/pdf/2111.12419.pdf

代码地址:https://github.com/Christian-lyc/NAM

9.1 原理

识别较不显著的特征对于模型压缩至关重要。然而,在革命性的注意力机制中,这一点尚未得到研究。在本研究中,我们提出了一种新颖的基于规范化的注意力模块(NAM),它抑制了较不显著的权重。它对注意力模块应用权重稀疏惩罚,从而使其在保持类似性能的同时更加计算高效。在ResnetMobilenet上与其他三种注意力机制进行比较表明,我们的方法具有更高的准确性。

在这里插入图片描述


9.2 代码

import torch.nn as nn
import torch
from torch.nn import functional as F


class Channel_Att(nn.Module):
    def __init__(self, channels, t=16):
        super(Channel_Att, self).__init__()
        self.channels = channels
      
        self.bn2 = nn.BatchNorm2d(self.channels, affine=True)


    def forward(self, x):
        residual = x

        x = self.bn2(x)
        weight_bn = self.bn2.weight.data.abs() / torch.sum(self.bn2.weight.data.abs())
        x = x.permute(0, 2, 3, 1).contiguous()
        x = torch.mul(weight_bn, x)
        x = x.permute(0, 3, 1, 2).contiguous()
        
        x = torch.sigmoid(x) * residual #
        
        return x


class NAMAttention(nn.Module):
    def __init__(self, channels, out_channels=None, no_spatial=True):
        super(NAMAttention, self).__init__()
        self.Channel_Att = Channel_Att(channels)
  
    def forward(self, x):
        x_out1=self.Channel_Att(x)
 
        return x_out1  
 
elif m is NAMAttention:
    c1, c2 = ch[f], args[0]
    if c2 != no:
        c2 = make_divisible(c2 * gw, 8)
    args = [c1, *args[1:]]
[-1, 1, NAMAttention, [1024]],

10. Criss-CrossAttention 注意力模块🌟

论文名称:《CCNet: Criss-Cross Attention for Semantic Segmentation》

论文地址:https://arxiv.org/pdf/1811.11721.pdf

代码地址:https://github.com/speedinghzl/CCNet

10.1 原理

在这里插入图片描述

在语义分割和物体检测等视觉理解问题中,上下文信息至关重要。我们提出了一种名为Criss-Cross Network (CCNet) 的方法,以非常有效和高效的方式获取完整的图像上下文信息。具体来说,对于每个像素,一个新颖的交叉注意力模块收集其交叉路径上所有像素的上下文信息。通过进一步的循环操作,每个像素最终可以捕获完整的图像依赖关系。此外,我们提出了一种类别一致的损失,用于强制交叉注意力模块产生更具辨别力的特征。总体而言,CCNet 具有以下优点:1) 对GPU内存友好。与非局部块相比,提出的循环交叉注意力模块使用的GPU内存减少了11倍。2) 高计算效率。循环交叉注意力显著减少了非局部块的FLOPs,约为其85%。3) 具备最先进的性能。我们在包括CityscapesADE20KLIP以及COCO等语义分割基准数据集上进行了大量实验。特别是,在Cityscapes测试集、ADE20K验证集和LIP验证集上,我们的CCNet分别实现了81.9%45.76%55.47%mIoU得分,这些是最新的最先进结果。

10.2 代码

'''
This code is borrowed from Serge-weihao/CCNet-Pure-Pytorch
'''

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import Softmax


def INF(B,H,W):
     return -torch.diag(torch.tensor(float("inf")).repeat(H),0).unsqueeze(0).repeat(B*W,1,1)


class CrissCrossAttention(nn.Module):
    """ Criss-Cross Attention Module"""
    def __init__(self, in_dim):
        super(CrissCrossAttention,self).__init__()
        self.query_conv = nn.Conv2d(in_channels=in_dim, out_channels=in_dim//8, kernel_size=1)
        self.key_conv = nn.Conv2d(in_channels=in_dim, out_channels=in_dim//8, kernel_size=1)
        self.value_conv = nn.Conv2d(in_channels=in_dim, out_channels=in_dim, kernel_size=1)
        self.softmax = Softmax(dim=3)
        self.INF = INF
        self.gamma = nn.Parameter(torch.zeros(1))


    def forward(self, x):
        m_batchsize, _, height, width = x.size()
        proj_query = self.query_conv(x)
        proj_query_H = proj_query.permute(0,3,1,2).contiguous().view(m_batchsize*width,-1,height).permute(0, 2, 1)
        proj_query_W = proj_query.permute(0,2,1,3).contiguous().view(m_batchsize*height,-1,width).permute(0, 2, 1)
        proj_key = self.key_conv(x)
        proj_key_H = proj_key.permute(0,3,1,2).contiguous().view(m_batchsize*width,-1,height)
        proj_key_W = proj_key.permute(0,2,1,3).contiguous().view(m_batchsize*height,-1,width)
        proj_value = self.value_conv(x)
        proj_value_H = proj_value.permute(0,3,1,2).contiguous().view(m_batchsize*width,-1,height)
        proj_value_W = proj_value.permute(0,2,1,3).contiguous().view(m_batchsize*height,-1,width)
        energy_H = (torch.bmm(proj_query_H, proj_key_H)+self.INF(m_batchsize, height, width)).view(m_batchsize,width,height,height).permute(0,2,1,3)
        energy_W = torch.bmm(proj_query_W, proj_key_W).view(m_batchsize,height,width,width)
        concate = self.softmax(torch.cat([energy_H, energy_W], 3))

        att_H = concate[:,:,:,0:height].permute(0,2,1,3).contiguous().view(m_batchsize*width,height,height)
        #print(concate)
        #print(att_H) 
        att_W = concate[:,:,:,height:height+width].contiguous().view(m_batchsize*height,width,width)
        out_H = torch.bmm(proj_value_H, att_H.permute(0, 2, 1)).view(m_batchsize,width,-1,height).permute(0,2,3,1)
        out_W = torch.bmm(proj_value_W, att_W.permute(0, 2, 1)).view(m_batchsize,height,-1,width).permute(0,2,1,3)
        #print(out_H.size(),out_W.size())
        return self.gamma*(out_H + out_W) + x
elif m is CrissCrossAttention:
    c1, c2 = ch[f], args[0]
    if c2 != no:
        c2 = make_divisible(c2 * gw, 8)
    args = [c1, *args[1:]]
[-1, 1, CrissCrossAttention, [1024]],

11. GAMAttention 注意力模块🌟

论文名称:《Global Attention Mechanism: Retain Information to Enhance Channel-Spatial Interactions》

论文地址:https://arxiv.org/pdf/2112.05561v1.pdf

11.1 原理

各种注意机制已经被研究用于改善各种计算机视觉任务的性能。然而,先前的方法忽视了在通道和空间方面保留信息以增强跨维度交互的重要性。因此,我们提出了一种全局注意机制,通过减少信息损失和放大全局交互表示来提升深度神经网络的性能。我们引入了3D排列和多层感知机用于通道注意,同时还引入了卷积空间注意的子模块。对于在CIFAR-100ImageNet-1K上进行的图像分类任务的评估表明,我们的方法在ResNet和轻量级MobileNet上稳定地优于几种最近的注意机制。

在这里插入图片描述
在这里插入图片描述
通道注意子模块使用3D排列来跨三个维度保留信息。然后,它使用两层MLP(多层感知机)放大跨维度的通道-空间依赖关系。(MLP是一个编码器-解码器结构,具有与BAM相同的减少比例r)。通道注意子模块如图2所示。

在空间注意子模块中,为了关注空间信息,我们使用两个卷积层进行空间信息融合。我们还使用与通道注意子模块相同的减少比例r,与BAM相同。同时,最大池化会减少信息并对结果产生负面影响。为了进一步保留特征图,我们去除了池化操作。结果是,空间注意模块有时会显著增加参数的数量。为了防止参数数量显著增加,我们在ResNet50中采用了具有通道随机洗牌的组卷积。不带组卷积的空间注意子模块如图3所示。


11.2 代码

import numpy as np
import torch
from torch import nn
from torch.nn import init

class GAMAttention(nn.Module):
       #https://paperswithcode.com/paper/global-attention-mechanism-retain-information
    def __init__(self, c1, c2, group=True,rate=4):
        super(GAMAttention, self).__init__()
        
        self.channel_attention = nn.Sequential(
            nn.Linear(c1, int(c1 / rate)),
            nn.ReLU(inplace=True),
            nn.Linear(int(c1 / rate), c1)
        )
        self.spatial_attention = nn.Sequential(
            nn.Conv2d(c1, c1//rate, kernel_size=7, padding=3,groups=rate)if group else nn.Conv2d(c1, int(c1 / rate), kernel_size=7, padding=3), 
            nn.BatchNorm2d(int(c1 /rate)),
            nn.ReLU(inplace=True),
            nn.Conv2d(c1//rate, c2, kernel_size=7, padding=3,groups=rate) if group else nn.Conv2d(int(c1 / rate), c2, kernel_size=7, padding=3), 
            nn.BatchNorm2d(c2)
        )

    def forward(self, x):
        b, c, h, w = x.shape
        x_permute = x.permute(0, 2, 3, 1).view(b, -1, c)
        x_att_permute = self.channel_attention(x_permute).view(b, h, w, c)
        x_channel_att = x_att_permute.permute(0, 3, 1, 2)
        x = x * x_channel_att
 
        x_spatial_att = self.spatial_attention(x).sigmoid()
        x_spatial_att=channel_shuffle(x_spatial_att,4) #last shuffle 
        out = x * x_spatial_att
        return out  

def channel_shuffle(x, groups=2):   ##shuffle channel 
        #RESHAPE----->transpose------->Flatten 
        B, C, H, W = x.size()
        out = x.view(B, groups, C // groups, H, W).permute(0, 2, 1, 3, 4).contiguous()
        out=out.view(B, C, H, W) 
        return out
elif m is GAMAttention:
    c1, c2 = ch[f], args[0]
    if c2 != no:
        c2 = make_divisible(c2 * gw, 8)
[-1, 1, GAMAttention, [1024,1024]],

12. Selective Kernel Attention 注意力模块🌟

论文名称:《Selective Kernel Networks》

论文地址:https://arxiv.org/pdf/1903.06586.pdf

代码地址:https://github.com/implus/SKNet

12.1 原理

在标准的卷积神经网络中,每层人工神经元的感受野被设计为具有相同的大小。神经科学界已经广泛认识到,视觉皮层神经元的感受野大小会受到刺激的调节,然而在构建CNN时很少考虑这一点。我们提出了一种动态选择机制,使得CNN中的每个神经元可以根据多个输入信息的尺度自适应地调整其感受野大小。我们设计了一个称为Selective Kernel (SK)单元的构建块,其中使用softmax注意力将具有不同核大小的多个分支进行融合,这种注意力受到这些分支中的信息的指导。对这些分支的不同注意力产生了融合层中神经元的有效感受野的不同大小。多个SK单元堆叠成一个深度网络,称为Selective Kernel Networks (SKNets)。在 ImageNetCIFAR 基准测试中,我们经验证明SKNet 在模型复杂度较低的情况下胜过了现有的最先进架构。详细分析表明,SKNet中的神经元能够捕捉具有不同尺度的目标对象,从而验证了神经元根据输入自适应调整感受野大小的能力。

在这里插入图片描述


12.2 代码

class SKAttention(nn.Module):

    def __init__(self, channel=512,kernels=[1,3,5,7],reduction=16,group=1,L=32):
        super().__init__()
        self.d=max(L,channel//reduction)
        self.convs=nn.ModuleList([])
        for k in kernels:
            self.convs.append(
                nn.Sequential(OrderedDict([
                    ('conv',nn.Conv2d(channel,channel,kernel_size=k,padding=k//2,groups=group)),
                    ('bn',nn.BatchNorm2d(channel)),
                    ('relu',nn.ReLU())
                ]))
            )
        self.fc=nn.Linear(channel,self.d)
        self.fcs=nn.ModuleList([])
        for i in range(len(kernels)):
            self.fcs.append(nn.Linear(self.d,channel))
        self.softmax=nn.Softmax(dim=0)

    def forward(self, x):
        bs, c, _, _ = x.size()
        conv_outs=[]
        ### split
        for conv in self.convs:
            conv_outs.append(conv(x))
        feats=torch.stack(conv_outs,0)#k,bs,channel,h,w

        ### fuse
        U=sum(conv_outs) #bs,c,h,w

        ### reduction channel
        S=U.mean(-1).mean(-1) #bs,c
        Z=self.fc(S) #bs,d

        ### calculate attention weight
        weights=[]
        for fc in self.fcs:
            weight=fc(Z)
            weights.append(weight.view(bs,c,1,1)) #bs,channel
        attention_weughts=torch.stack(weights,0)#k,bs,channel,1,1
        attention_weughts=self.softmax(attention_weughts)#k,bs,channel,1,1

        ### fuse
        V=(attention_weughts*feats).sum(0)
        return V
elif m is SKAttention:
    c1, c2 = ch[f], args[0]
    if c2 != no:
        c2 = make_divisible(c2 * gw, 8)
    args = [c1, *args[1:]]
[-1, 1, SKAttention, [1024]],

13. ShuffleAttention 注意力模块

论文地址:https://arxiv.org/pdf/2102.00240.pdf

13.1 原理

在这里插入图片描述

13.2 代码

import numpy as np
import torch
from torch import nn
from torch.nn import init
from torch.nn.parameter import Parameter

# https://arxiv.org/pdf/2102.00240.pdf
class ShuffleAttention(nn.Module):

    def __init__(self, channel=512,reduction=16,G=8):
        super().__init__()
        self.G=G
        self.channel=channel
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.gn = nn.GroupNorm(channel // (2 * G), channel // (2 * G))
        self.cweight = Parameter(torch.zeros(1, channel // (2 * G), 1, 1))
        self.cbias = Parameter(torch.ones(1, channel // (2 * G), 1, 1))
        self.sweight = Parameter(torch.zeros(1, channel // (2 * G), 1, 1))
        self.sbias = Parameter(torch.ones(1, channel // (2 * G), 1, 1))
        self.sigmoid=nn.Sigmoid()


    def init_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                init.kaiming_normal_(m.weight, mode='fan_out')
                if m.bias is not None:
                    init.constant_(m.bias, 0)
            elif isinstance(m, nn.BatchNorm2d):
                init.constant_(m.weight, 1)
                init.constant_(m.bias, 0)
            elif isinstance(m, nn.Linear):
                init.normal_(m.weight, std=0.001)
                if m.bias is not None:
                    init.constant_(m.bias, 0)


    @staticmethod
    def channel_shuffle(x, groups):
        b, c, h, w = x.shape
        x = x.reshape(b, groups, -1, h, w)
        x = x.permute(0, 2, 1, 3, 4)

        # flatten
        x = x.reshape(b, -1, h, w)

        return x

    def forward(self, x):
        b, c, h, w = x.size()
        #group into subfeatures
        x=x.view(b*self.G,-1,h,w) #bs*G,c//G,h,w

        #channel_split
        x_0,x_1=x.chunk(2,dim=1) #bs*G,c//(2*G),h,w

        #channel attention
        x_channel=self.avg_pool(x_0) #bs*G,c//(2*G),1,1
        x_channel=self.cweight*x_channel+self.cbias #bs*G,c//(2*G),1,1
        x_channel=x_0*self.sigmoid(x_channel)

        #spatial attention
        x_spatial=self.gn(x_1) #bs*G,c//(2*G),h,w
        x_spatial=self.sweight*x_spatial+self.sbias #bs*G,c//(2*G),h,w
        x_spatial=x_1*self.sigmoid(x_spatial) #bs*G,c//(2*G),h,w

        # concatenate along channel axis
        out=torch.cat([x_channel,x_spatial],dim=1)  #bs*G,c//G,h,w
        out=out.contiguous().view(b,-1,h,w)

        # channel shuffle
        out = self.channel_shuffle(out, 2)
        return out
elif m is ShuffleAttention:
    c1, c2 = ch[f], args[0]
    if c2 != no:
        c2 = make_divisible(c2 * gw, 8)
args = [c1, c2, *args[1:]]
[-1, 1, ShuffleAttention, [1024]],


14. A2-Net 注意力模块🌟

论文名称:《A2-Nets: Double Attention Networks》

论文地址:https://arxiv.org/pdf/1810.11579.pdf

14.1 原理

学习捕捉远距离关系对于图像/视频识别是基础性的。现有的CNN模型通常依靠增加深度来建模这些关系,这在很大程度上效率低下。在这项工作中,我们提出了“双重注意力块”,这是一种新颖的组件,它可以从输入图像/视频的整个时空空间聚合和传播有信息的全局特征,使得后续的卷积层可以高效地访问整个空间的特征。该组件设计了一个双重注意力机制的两个步骤,第一步通过二阶注意力池将整个空间的特征聚集到一个紧凑的集合中,第二步通过另一个注意力机制自适应地选择和分配特征到每个位置。所提出的双重注意力块易于采用,并可以方便地插入到现有的深度神经网络中。我们进行了大量的消融研究和实验证明其性能。在图像识别任务中,使用我们的双重注意力块装备的ResNet-50ImageNet-1k数据集上胜过了更大的ResNet-152架构,参数数量减少了40%以上,FLOPs也减少了。在动作识别任务中,我们提出的模型在KineticsUCF-101数据集上取得了最先进的结果,并具有比最近的研究工作更高的效率。
在这里插入图片描述


14.2 代码

from torch.nn import init


class DoubleAttention(nn.Module):
    """
        A2-Nets: Double Attention Networks. NIPS 2018
    """
    def __init__(self, in_channels, c_m, c_n, reconstruct=True):
        super().__init__()
        self.in_channels = in_channels
        self.reconstruct = reconstruct
        self.c_m = c_m
        self.c_n = c_n
        self.convA = nn.Conv2d(in_channels, c_m, 1)
        self.convB = nn.Conv2d(in_channels, c_n, 1)
        self.convV = nn.Conv2d(in_channels, c_n, 1)
        if self.reconstruct:
            self.conv_reconstruct = nn.Conv2d(c_m, in_channels, kernel_size=1)
        self.init_weights()

    def init_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                init.kaiming_normal_(m.weight, mode='fan_out')
                if m.bias is not None:
                    init.constant_(m.bias, 0)
            elif isinstance(m, nn.BatchNorm2d):
                init.constant_(m.weight, 1)
                init.constant_(m.bias, 0)
            elif isinstance(m, nn.Linear):
                init.normal_(m.weight, std=0.001)
                if m.bias is not None:
                    init.constant_(m.bias, 0)

    def forward(self, x):
        b, c, h, w = x.shape
        assert c == self.in_channels
        A = self.convA(x)  # b,c_m,h,w
        B = self.convB(x)  # b,c_n,h,w
        V = self.convV(x)  # b,c_n,h,w
        tmpA = A.view(b, self.c_m, -1)
        attention_maps = F.softmax(B.view(b, self.c_n, -1), dim=1)
        attention_vectors = F.softmax(V.view(b, self.c_n, -1), dim=1)
        # step 1: feature gating
        global_descriptors = torch.bmm(tmpA, attention_maps.permute(0, 2, 1))  # b.c_m,c_n
        # step 2: feature distribution
        tmpZ = global_descriptors.matmul(attention_vectors)  # b,c_m,h*w
        tmpZ = tmpZ.view(b, self.c_m, h, w)  # b,c_m,h,w
        if self.reconstruct:
            tmpZ = self.conv_reconstruct(tmpZ)

        return tmpZ
        elif m is DoubleAttention:
            c1, c2 = ch[f], args[0]
            if c2 != no:  # if not output
                c2 = make_divisible(c2 * gw, 8)
            args = [c1, c2, *args[1:]]
   [-1, 1, DoubleAttention,[1024,256,256]],

更多注意力代码欢迎关注我的《目标检测蓝皮书》💖
番外篇 | 20+ 种注意力机制及代码 适用于YOLOv5/v7/v8


15. DANPositional 注意力模块

在这里插入图片描述


16. DANChannel 注意力模块

在这里插入图片描述


17. RESNest 注意力模块

在这里插入图片描述


18. Harmonious 注意力模块

在这里插入图片描述


19. SpatialAttention 注意力模块

在这里插入图片描述


19. RANet 注意力模块

在这里插入图片描述


20. Co-excite 注意力模块

在这里插入图片描述


21. EfficientAttention 注意力模块

在这里插入图片描述


22. X-Linear 注意力模块

在这里插入图片描述


23. SlotAttention 注意力模块

在这里插入图片描述


24. Axial 注意力模块

在这里插入图片描述


25. RFA 注意力模块

在这里插入图片描述


26. Attention-BasedDropout 注意力模块

在这里插入图片描述


27. ReverseAttention 注意力模块

在这里插入图片描述


28. CrossAttention 注意力模块

在这里插入图片描述


29. Perceiver 注意力模块

在这里插入图片描述


30. Criss-CrossAttention 注意力模块

在这里插入图片描述
在这里插入图片描述


31. BoostedAttention 注意力模块

在这里插入图片描述


32. Prophet 注意力模块

在这里插入图片描述


33. S3TA 注意力模块

在这里插入图片描述


34. Self-CriticAttention 注意力模块

在这里插入图片描述


35. BayesianAttentionBeliefNetworks 注意力模块

在这里插入图片描述


36. Expectation-MaximizationAttention 注意力模块

在这里插入图片描述


37. GaussianAttention 注意力模块

在这里插入图片描述


代码持续更新中。。。


本人更多 YOLOv5/v7 实战内容导航🍀🌟🚀

  1. 手把手带你调参YOLOv5 (v5.0-v7.0)(推理)🌟强烈推荐

  2. 手把手带你调参YOLOv5 (v5.0-v7.0)(训练)🚀

  3. 手把手带你调参YOLOv5 (v5.0-v7.0)(验证)

  4. 简单三步 用YOLOv5快速训练自己的数据集

  5. 手把手带你YOLOv5/v7 (v5.0-v7.0)添加注意力机制(一)(并附上30多种顶会Attention原理图)🌟强烈推荐🍀新增8种

  6. 手把手带你YOLOv5/v7 (v5.0-v7.0)添加注意力机制(二)(在C3模块中加入注意力机制)

  7. YOLOv5/v7 如何更换激活函数?

  8. YOLOv5 如何更换BiFPN?

  9. YOLOv5 数据增强方式解析

  10. YOLOv5/v7 更换上采样方式( 最近邻 / 双线性 / 双立方 / 三线性 / 转置卷积)

  11. YOLOv5/v7 如何更换EIOU / alpha IOU / SIoU?

  12. YOLOv5/v7 应用轻量级通用上采样算子CARAFE

  13. 空间金字塔池化改进 SPP / SPPF / SimSPPF / ASPP / RFB / SPPCSPC / SPPFCSPC🚀

  14. 用于低分辨率图像和小物体的模块SPD-Conv

  15. GSConv+Slim-neck 减轻模型的复杂度同时提升精度

  16. 头部解耦 | 将YOLOX解耦头添加到YOLOv5 | 涨点杀器

  17. Stand-Alone Self-Attention | 搭建纯注意力FPN+PAN结构

  18. 改进YOLOv5/v7 | 引入密集连接卷积网络DenseNet思想 | 搭建密集连接模块

  19. YOLOv5/v7 更换骨干网络之 PP-LCNet

  20. YOLOv5/v7 更换骨干网络之 EfficientNet-B0

  21. YOLOv5/v7 更换骨干网络之 MobileNet V3

  22. YOLOv5/v7 更换骨干网络之 GhostNet

  23. YOLOv5/v7 更换骨干网络之 ShuffleNetv2

  24. YOLOv5/v7 引入 最新 BiFusion Neck🍀

  25. YOLOv5/v7 引入 YOLOv8 的 C2f 模块🍀

  26. YOLOv5/v7 引入 RepVGG 重参数化模块🍀

  27. YOLOv5 模型剪枝实战✂️

  28. YOLOv5 知识蒸馏实战⚗️

  29. YOLOv7 知识蒸馏实战⚗️

  30. YOLOv5/v7 Falsk Web 部署💻

  31. YOLOv5/v7添加PyQt5页面📟

  32. YOLOv5 安卓部署📱


2022/10/30更新日志:新增加8种注意力机制源码(6-13),完美适配YOLO系列算法,感谢CSDN芒果汁没有芒果为本文提供技术支持。
2023/01/07更新日志:修改了文章结构,对部分章节增加了更加详细的解释。
2023/02/011更新日志:增加了A2-Net注意力代码。
2023/5/17更新日志: 新增部分注意力理论及论文地址🍀


有问题欢迎大家指正,如果感觉有帮助的话请点赞支持下👍📖🌟

!!禁止转载!!
请添加图片描述

  • 471
    点赞
  • 3059
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 355
    评论
<h3>回答1:</h3><br/>首先,你需要安装好PyTorch和OpenCV。然后,你可以从GitHub上下载yolov5的代码。 接下来,你需要准备你的数据集。数据集应该包含你想要检测的物体的图像和标签。标签应该是一个XML文件,其中包含物体的类别和位置。 然后,你需要将数据集分成训练集和验证集。训练集用于训练模型,验证集用于评估模型的性能。 接下来,你需要创建一个配置文件,其中包含模型的参数和训练的超参数。你可以使用默认的配置文件,也可以根据你的需求进行修改。 然后,你可以开始训练模型。在训练过程中,你可以使用tensorboard来监视模型的性能。 最后,你可以使用训练好的模型来进行目标检测。你可以使用OpenCV来读取图像,并使用训练好的模型来检测物体。 总之,使用yolov5训练自己的目标检测模型需要一些准备工作和技能,但是一旦你掌握了这些技能,你就可以创建自己的目标检测模型了。 <h3>回答2:</h3><br/>Yolov5是一种便捷快速的目标检测框架,它在精度和速度上比之前的版本有所提高。如果你想要使用Yolov5训练自己的目标检测模型,以下是一些步骤和技巧。 1. 准备数据集:首先,必须准备一个数据集,该数据集包含你想要检测的物体的图像。数据集可以从其他公开数据集直接下载或从自己收集的数据集中获取。无论是哪种方式,数据集都必须以YOLOv5可读的格式组织,即每个图像必须有一个它的标签文件,标签文件中包含有关每个物体位置和类别的信息。 2. 安装必要的依赖项:安装YOLOv5需要具有Python,其次我们要安装所需的Python的库依赖,例如Pytorch、NumPy、Pandas,等等。 可以通过使用conda或pip来安装这些依赖项; 3. Clone YOLOv5 Github repostory:要下载Yolov5,可以克隆YOLOv5 Github网址。从命令行中运行以下命令: git clone https://github.com/ultralytics/yolov5.git cd yolov5 4. 这个项目结构: * ┣ data/ * ┃ ┣ image/ * ┃ ┃ ┣ train/ * ┃ ┃ ┃ ┣ image_1.jpg * ┃ ┃ ┃ ┣ image_1.txt * ┃ ┃ ┃ ...... * ┃ ┃ ┣ valid/ * ┃ ┣ train.py * ┃ ┣ utils/ * ┃ ┣ models/ * ┃ ┣ weights/ * ┣ name.names * ┣ yolov5s.yaml 5. 准备NGC预训练数据:在训练模型前,需要下载预训练权重。YOLOv5的权重文件可以从NGC上下载,也可以从 https://github.com/ultralytics/yolov5/releases/ 上下载发布的权重文件。 6. 配置自己的类别:可以通过YOLOv5的配置文件修改,Yolov5使用YAML(Yet Another Markup Language)格式来配置其超参数,如类别数量,学习率,训练epoch等。 7. 训练模型:准备好以上步骤后,就可以开始训练模型了。可以使用 train.py 脚本进行训练。比如: python train.py --img 640 --batch 16 --epochs 10 --data ./data/yolo.yaml --cfg models/yolov5s.yaml --weights "" 8. 验证、测试模型:尽管loss值很低,并不意味着模型一定很好。因此,为了更好的评估模型的性能,建议你对测试集进行评估,可以使用 detect.py 脚本来进行评估。比如: python detect.py --source data/images/test/ --weights runs/train/exp/weights/best.pt 9. 将模型导出为TensorRT引擎:为了在移动设备或嵌入式设备上使用Yolov5模型,可以将其导出为TensorRT引擎。可以使用Yolov5提供的 export.py 脚本导出为TensorRT引擎。 python export.py --weights runs/train/exp7/weights/best.pt --img 640 --batch 1 总的来说,使用Yolov5训练自己的目标检测模型需要一些前置工作去写,然后通过配置参数,运行训练、验证和测试脚本。在每个步骤中,需要十分清楚自己要做什么,处理好每一个细节问题,才能顺利地完成自己的目标检测模型训练并有一定的精度。 <h3>回答3:</h3><br/>Yolov5是一种深度学习模型,能够进行目标检测,它对于广泛的物体检测任务具有出色的性能。本文将手把手地介绍如何使用Yolov5进行目标检测模型的训练。 1. 下载和安装Yolov5 第一步是下载和安装Yolov5。我们可以在Github上得到最新的代码,并通过命令运行安装。安装完成后,建议按照提示安装必要的Python依赖项。 2. 准备数据集 第二步是准备好训练和测试数据集,可以使用现成的数据集,也可以从头开始创建自己的数据集。对于自制数据集,需要将图像和注释文件存储在相应目录中。注释文件描述了图像中所有目标的位置和类别。当完成这一步骤时,我们应该获得训练和测试集目录,每个目录应该包含图像文件和相应的注释文件。 3. 配置训练参数 第三步是为训练配置所需的超参数。这些参数包括网络结构,学习率,批量大小,迭代次数等等。可以通过修改配置文件来设置这些参数。我们需要基于网络结构来选择模型的版本。在配置文件中,我们需要设置图像的大小、目标分类的数量、训练和测试数据集的路径以及其他必要的参数。 4. 训练模型 当所有参数设置完成后,可以开始训练模型。通过在命令行中运行yolo.py脚本,可以启动训练过程。该脚本在训练期间使用指定的超参数和数据集对模型进行训练,并输出各个batch的训练状态信息。 5. 评估模型 训练完模型后,需要对模型进行评估。评估过程包括计算模型的准确度、精度和召回率等指标。我们可以使用测试集对模型进行测试,并输出相关的指标信息。在测试期间,我们可以使用训练期超参数的某些变体或者优化超参数,以改进模型的精度。 6. 应用模型 最后一步是将模型应用于新的数据集。这可以通过在模型的输出上提取目标的位置和类别来完成,从而进行物体检测。在将模型应用于新数据集时,最好考虑训练和验证数据之间的数据分布差异,确保模型在新的数据集上的表现仍然良好。 总之,使用Yolov5进行目标检测模型的训练需要准备好训练和测试数据集、配置模型的超参数以及选择网络结构和版本。训练和评估模型后,就可以将模型应用于新的数据集。需要注意的是,在整个过程中,超参数的选择和调整对模型的性能有着关键性的影响。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 355
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

迪菲赫尔曼

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值