正文 

当前位置： 首页 > 代码 > java教程

yolov5-6.1添加注意力机制（secbamecaca）(代码片段)

Junevinvin Junevinvin     2023-04-08     355

关键词：

目录

0. 添加方法

主要步骤：
（1）在models/common.py中注册注意力模块
（2）在models/yolo.py中的parse_model函数中添加注意力模块
（3）修改配置文件yolov5s.yaml
（4）运行yolo.py进行验证
各个注意力机制模块的添加方法类似，各注意力模块的修改参照SE。
本文添加注意力完整代码：https://github.com/double-vin/yolov5_attention

1. SE

Squeeze-and-Excitation Networks
https://github.com/hujie-frank/SENet

1.1 SE

  1. 在models/common.py中注册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)
  1. 在models/yolo.py中的parse_model函数中添加SE模块
  2. 修改配置文件yolov5s.yaml。
    添加注意力的两种方法：一是在backbone的最后一层添加注意力；二是将backbone中的C3全部替换。
    这里使用第一种，第二种见下文中的C3SE

    注意：SE添加至第9层，第9层之后所有的编号都要+1，则：
    1>两个Concat的from系数分别由[-1, 14]，[-1, 10]改为[-1, 15]，[-1, 11]
    2>Detect的from系数由[17, 20, 23]改为[18,21,24]
  3. 验证：运行yolo.py

1.2 C3-SE

  1. 在models/common.py中注册C3SE模块：
class SEBottleneck(nn.Module):
    # Standard bottleneck
    def __init__(self, c1, c2, shortcut=True, g=1, e=0.5, ratio=16):  # ch_in, ch_out, shortcut, groups, expansion
        super().__init__()
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c_, c2, 3, 1, g=g)
        self.add = shortcut and c1 == c2
        # self.se=SE(c1,c2,ratio)
        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):
        x1 = self.cv2(self.cv1(x))
        b, c, _, _ = x.size()
        y = self.avgpool(x1).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)
        out = x1 * y.expand_as(x1)

        # out=self.se(x1)*x1
        return x + out if self.add else out


class C3SE(C3):
    # C3 module with SEBottleneck()
    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):
        super().__init__(c1, c2, n, shortcut, g, e)
        c_ = int(c2 * e)  # hidden channels
        self.m = nn.Sequential(*(SEBottleneck(c_, c_, shortcut) for _ in range(n)))
  1. 在models/yolo.py中的parse_model函数中添加C3SE模块
  2. 修改配置文件yolov5s.yaml。
  3. 验证：运行yolo.py

2. CBAM

《CBAM: Convolutional Block Attention Module》

2.1 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):
    # 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

2.2 C3-CBAM

class CBAMBottleneck(nn.Module):
    # Standard bottleneck
    def __init__(self, c1, c2, shortcut=True, g=1, e=0.5,ratio=16,kernel_size=7):  # ch_in, ch_out, shortcut, groups, expansion
        super(CBAMBottleneck,self).__init__()
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c_, c2, 3, 1, g=g)
        self.add = shortcut and c1 == c2
        self.channel_attention = ChannelAttention(c2, ratio)
        self.spatial_attention = SpatialAttention(kernel_size)
        #self.cbam=CBAM(c1,c2,ratio,kernel_size)

    def forward(self, x):
        x1 = self.cv2(self.cv1(x))
        out = self.channel_attention(x1) * x1
        # print('outchannels:'.format(out.shape))
        out = self.spatial_attention(out) * out
        return x + out if self.add else out


class C3CBAM(C3):
    # C3 module with CBAMBottleneck()
    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):
        super().__init__(c1, c2, n, shortcut, g, e)
        c_ = int(c2 * e)  # hidden channels
        self.m = nn.Sequential(*(CBAMBottleneck(c_, c_, shortcut) for _ in range(n)))

3. ECA

《ECA-Net: Efficient Channel Attention for Deep Convolutional Neural Networks》
https://github.com/BangguWu/ECANet

3.1 ECA

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)

3.2 C3-ECA

class ECABottleneck(nn.Module):
    # Standard bottleneck
    def __init__(self, c1, c2, shortcut=True, g=1, e=0.5, ratio=16, k_size=3):  # ch_in, ch_out, shortcut, groups, expansion
        super().__init__()
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c_, c2, 3, 1, g=g)
        self.add = shortcut and c1 == c2
        # self.eca=ECA(c1,c2)
        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):
        x1 = self.cv2(self.cv1(x))
        # out=self.eca(x1)*x1
        y = self.avg_pool(x1)
        y = self.conv(y.squeeze(-1).transpose(-1, -2)).transpose(-1, -2).unsqueeze(-1)
        y = self.sigmoid(y)
        out = x1 * y.expand_as(x1)

        return x + out if self.add else out


class C3ECA(C3):
    # C3 module with ECABottleneck()
    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):
        super().__init__(c1, c2, n, shortcut, g, e)
        c_ = int(c2 * e)  # hidden channels
        self.m = nn.Sequential(*(ECABottleneck(c_, c_, shortcut) for _ in range(n)))

4. CA

Coordinate Attention for Efficient Mobile Network Design
https://github.com/Andrew-Qibin/CoordAttention

4.1 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(yyolov5添加注意力机制的具体步骤(代码片段)

本文以CBAM和SE注意力机制的添加过程为例，主要介绍了向YOLOv5中添加注意力机制的具体步骤本文在此篇博客的基础上向YOLOv5-5.0版本代码中添加注意力机制yolov5模型训练———使用yolov5训练自己的数据集本文主要包括以下内容...  查看详情  

                

yolov7改进--添加cbam注意力机制(代码片段)


YOLOV7改进--添加CBAM注意力机制CBAM注意力机制代码在commen.py中添加CBAM模块在yolo.py中添加CBAM模块名在cfg文件中添加CBAM信息因为项目需要，尝试在yolov7上加入CBAM注意力机制，看看能不能提升点性能。之前有在yolov5上添加CBAM...  查看详情  

                

yolov7改进--添加cbam注意力机制(代码片段)


YOLOV7改进--添加CBAM注意力机制CBAM注意力机制代码在commen.py中添加CBAM模块在yolo.py中添加CBAM模块名在cfg文件中添加CBAM信息因为项目需要，尝试在yolov7上加入CBAM注意力机制，看看能不能提升点性能。之前有在yolov5上添加CBAM...  查看详情  

                

手把手带你yolov5(v6.1)添加注意力机制（二)（在c3模块中加入注意力机制）(代码片段)


之前在《手把手带你Yolov5(v6.1)添加注意力机制（并附上30多种顶会Attention原理图）》文章中已经介绍过了如何在主干网络里添加单独的注意力层，今天这篇将会介绍如何在C3模块里面加入注意力层。文章目录1.添加方式...  查看详情  

                

Keras - 向 LSTM 模型添加注意机制 [重复]


】Keras-向LSTM模型添加注意机制[重复]【英文标题】：Keras-AddattentionmechanismtoanLSTMmodel[duplicate]【发布时间】：2019-04-0814:59:34【问题描述】：使用以下代码：model=Sequential()num_features=data.shape[2]num_samples=data.shape[1]model.add(LSTM(16,batch_input_  查看详情  

                

yolov5添加注意力机制pytorch(代码片段)


我的YOLOv5版本为6.0需要修改的两个文件如下：./models/yolo5s_SE-Net.yaml./models/commom.py1.yolo5s_SE-Net.yaml文件yolo5s_SE-Net.yaml修改自文件yolo5s.yamlyolo5s.yaml文件内容为：#YOLOv5  查看详情  

                

神经网络加上注意力机制，精度不升反降？(代码片段)


之前写过两篇YOLOv5+各种注意力机制的文章，收到了大家很多的反馈，这篇博文就简单针对这些问题讨论一下：为什么我添加了注意力模块以后精度反而下降了？在什么位置添加注意力模块比较好？同一种或...  查看详情  

                

yolov5改进之加入cbam,se,eca,ca,simam,shuffleattention,criss-crossattention,crisscrossattention多种注意力机制(代码片


...到的yolov5网络为6.1版本（6.0-6.2均适用）yolov5加入注意力机制模块的三个标准步骤（适用于本文中的任何注意力机制）1.common.py中加入注意力机制模块2.yolo.py中增加对应的注意力机制关键字3.yaml文件中添加相应模块...  查看详情  

                

yolov5--从模块解析到网络结构修改（添加注意力机制）(代码片段)


...块03.Bottleneck模块：04.C3模块05.SPP模块2.为yolov5添加CBAM注意力机制01.CBAM机制02.具体步骤①.以yolov5l结构为例（其实只是深度和宽度因子不同），修改yolov5l.yaml，将C3模块修改为添加注意力机制后的模块CBAMC3，...  查看详情  

                

yolox改进之一：添加cbamseeca注意力机制(代码片段)


...智能AI算法工程师 解决问题：本文以加入CBAM双通道注意力机制为例，可以让网络更加关注待检测目标，提高检测效果，解决复杂环境背景下容易错漏检的情况。添加方法：第一步：确定添加的位置，...  查看详情  

                

关于《注意力模型--attention注意力机制》的学习


关于《注意力模型--Attention注意力机制》的学习 此文大部分参考深度学习中的注意力机制(2017版) 张俊林的博客，不过添加了一些个人的思考与理解过程。在github上找到一份基于keras框架实现的可运行的注意模型代码：Atten...  查看详情  

                

目标检测yolov5改进系列：主干网络中添加se注意力机制网络


...并在通道维度上进行融合而得到。SEnet就是对通道维度的注意力机制，上面介绍了通道特征是对空间特征FeatueMap的融合。其实同一个通道维度的不同的FeatureMap是用着不同的重要程度的，也就是说对于同一个FeatureMap里面的信息权...  查看详情  

                

深度学习cnn中的混合域注意力机制（danet，cbam），附tensorflow完整代码(代码片段)


...天和大家分享一下如何使用Tensorflow构建DANet和CBAM混合域注意力机制模型。在之前的文章中我介绍了CNN中的通道注意力机制SENet和ECANet，感兴趣的可以看一下：https://blog.csdn.net/dgvv4/article/details/1235720651.注意力机制介绍注意...  查看详情  

                

手把手带你yolov5/v7添加注意力机制（并附上30多种顶会attention原理图）2023/2/11更新(代码片段)


...d6;🌟，您的点赞是对我最大的鼓励~神经网络加上注意力机制，精度不升反降？大家好，我是迪菲赫尔曼😁，我最近将本人硕士阶段所有学习的计算机视觉基础知识进行了一个系统性的整理，编写...  查看详情  

                

注意力机制详解系列：混合注意力机制


  查看详情  

                

空间注意力机制和通道注意力机制详解


Attention机制在近几年来在图像，自然语言处理等领域中都取得了重要的突破，被证明有益于提高模型的性能。Attention机制本身也是符合人脑和人眼的感知机制，这次我们主要以计算机视觉领域为例，讲述Attention机...  查看详情  

                

神经网络到底在关注哪里？注意力机制与transformer


目录一、注意力机制介绍1.浅谈注意力2.注意力机制类别二、计算机视觉中的注意力机制1.看图说话2.存在的问题3.加入注意力机制三、序列模型中的注意力机制1.Seq2Seq的一些问题 2.Seq2Seq加入注意力机制四、自注意力机制与Transform...  查看详情  

                

视觉注意力机制——通道注意力空间注意力自注意力


前言本文介绍注意力机制的概念和基本原理，并站在计算机视觉CV角度，进一步介绍通道注意力、空间注意力、混合注意力、自注意力等。目录前言一、注意力机制二、通道注意力机制三、空间注意力机制四、混合注意力...  查看详情