YOLOv8 改进 | 注意力机制 | 处理原始SE通道信息丢失问题的ESE【含分割，检测，OBByaml文件】

秋招面试专栏推荐 ：深度学习算法工程师面试问题总结【百面算法工程师】——点击即可跳转

💡💡💡本专栏所有程序均经过测试，可成功执行💡💡💡

专栏目录：《YOLOv8改进有效涨点》专栏介绍 & 专栏目录 | 目前已有70+篇内容，内含各种Head检测头、损失函数Loss、Backbone、Neck、NMS等创新点改进——点击即可跳转

我们提出了一种简单而高效的无需锚点的实例分割方法，称为CenterMask，它在一个阶段的目标检测器中增加了一个新颖的空间注意力引导的掩码（SAG-Mask）分支，这与Mask R-CNN的思路相同。嵌入到FCOS目标检测器中，SAG-Mask分支在每个检测到的框上预测一个分割掩码，并使用空间注意力图来帮助聚焦于信息丰富的像素并抑制噪声。我们还提出了一个改进的骨干网络，VoVNetV2，并采用了两种有效策略：（1）残差连接，用于减轻较大VoVNet的优化问题；（2）有效的压缩-激励（eSE），处理原始SE的通道信息丢失问题。文章在介绍主要的原理后，将手把手教学如何进行模块的代码添加和修改，并将修改后的完整代码放在文章的最后，方便大家一键运行，小白也可轻松上手实践。以帮助您更好地学习深度学习目标检测YOLO系列的挑战。

专栏地址：YOLOv8改进——更新各种有效涨点方法——点击即可跳转 订阅学习不迷路

1. 原理

2. 将ESE添加到yolov8网络中

2.1 ESE代码实现

2.2 更改init.py文件

2.3 添加yaml文件

2.4 注册模块

2.5 执行程序

3. 完整代码分享

4. GFLOPs

5. 进阶

6. 总结

1. 原理

论文地址：CenterMask : Real-Time Anchor-Free Instance Segmentation——点击即可跳转

官方代码：官方代码仓库——点击即可跳转

ESE（有效挤压和激励）机制是一种通道注意模块，旨在增强卷积神经网络（CNN）中的特征表示。ESE 机制的关键原理如下：

通道注意：ESE 专注于通道依赖性，旨在通过对通道之间的相互依赖性进行建模来重新校准通道特征响应。这样做是为了提高网络的表示能力。
挤压和激励（SE）模块：原始 SE 模块的工作原理是：

挤压：执行全局平均池化以生成通道统计数据。
激励：使用两个全连接（FC）层来捕获通道依赖性并重新校准特征。

有效 SE（eSE）改进：

单个 FC 层：ESE 通过使用一个全连接层而不是两个全连接层来改进 SE 模块。这有助于在不降低通道维度的情况下保留通道信息，从而避免信息丢失。
简化计算：ESE 模块保持通道维度完整，简化计算过程并降低复杂度。

ESE 流程：

全局平均池化：首先，对输入特征图进行全局平均池化以获得通道描述符。
全连接层：然后，将单个全连接层应用于此描述符。
Sigmoid 激活：FC 层的输出通过 Sigmoid 激活函数获得通道注意力图。
重新校准：通道注意力图用于通过元素乘法重新校准原始特征图。

正式流程可以总结如下：

$\text{AeSE}(X{\text{div}}) = \sigma(W_C(F{\text{gap}}(X{\text{div}})))$

$X{\text{refine}} = \text{AeSE}(X{\text{div}}) \otimes X{\text{div}}$

其中 $F{\text{gap}}$ 为全局平均池化函数， $W_C$ 为全连接层的权重， $\sigma$ 为 S 型函数， $X{\text{div}}$ 为多样化特征图， $\otimes$ 表示元素乘法。

2. 将ESE添加到yolov8网络中

2.1 ESE代码实现

关键步骤一: 将下面代码粘贴到在/ultralytics/ultralytics/nn/modules/block.py中，并在该文件的__all__中添加“EffectiveSELayer”

class EffectiveSELayer(nn.Module):
    def __init__(self, channels, act='hardsigmoid'):
        super(EffectiveSELayer, self).__init__()
        self.fc = nn.Conv2d(channels, channels, kernel_size=1, padding=0)
        self.act = nn.Hardsigmoid(inplace=True)

    def forward(self, x):
        x_se = x.mean((2, 3), keepdim=True)
        x_se = self.fc(x_se)
        return x * self.act(x_se)

ESE（有效压缩和激励）机制通过关注通道依赖性来增强卷积神经网络（CNN）中的特征表示。以下是其处理图像的主要工作流程：

ESE 机制的工作流程

输入特征图提取：

该过程从输入图像开始，该图像经过多个卷积层以提取特征图X。此特征图的尺寸为 C×H×W（通道、高度、宽度）。

全局平均池化：

在特征图上执行全局平均池化以生成通道描述符 z。这会将空间维度 H×W减小到 1，从而得到大小为C的向量。
全局平均池化计算如下： $z_c = \frac{1}{H \times W} \sum{i=1}^H \sum{j=1}^W X_{c, i, j}$ 其中 $z_c$ 是通道 c 的池化值。

全连接层：

将通道描述符 z 传递到全连接 FC 层以捕获通道依赖关系。
在 ESE 机制中，仅使用一个 FC 层，以保持原始通道维度。这有助于避免由于原始 SE 模块中的维度减少而发生的信息丢失。

Sigmoid 激活：

将 Sigmoid 激活函数应用于 FC 层的输出以生成通道注意力图 ( s )。该图的大小与通道数 ( C ) 相同。
S 型函数确保注意力值介于 0 和 1 之间： $s = \sigma(W_C z)$ 其中 $W_C$ 表示全连接层的权重， $\sigma$ 是 S 型函数。

通道重新校准：

将原始特征图 ( X ) 乘以通道注意力图 ( s ) 以重新校准特征。这是针对每个通道逐个元素完成的： $X'{c, i, j} = s_c \cdot X{c, i, j}$ 其中 ( X' ) 是重新校准的特征图。

输出：

重新校准的特征图 ( X' ) 随后被传递到网络的后续层进行进一步处理，例如额外的卷积、池化或全连接层，具体取决于神经网络的架构。

步骤摘要

特征图提取：卷积层生成特征图 ( X )。
全局平均池化：降低空间维度，得到通道描述符 ( z )。
全连接层：变换 ( z )，同时保持通道维度。
S 型激活：生成通道注意力图 ( s )。
通道重新校准：使用 ( s ) 调整原始特征图 ( X )。
输出：使用重新校准的特征图X进行进一步处理。

该机制有效地突出了重要通道并抑制了信息量较小的通道，从而增强了网络的表征能力并提高了图像分类和物体检测等任务的性能。

2.2 更改init.py文件

关键步骤二：修改modules文件夹下的__init__.py文件，先导入函数

然后在下面的__all__中声明函数

2.3 添加yaml文件

关键步骤三：在/ultralytics/ultralytics/cfg/models/v8下面新建文件yolov8_ESE.yaml文件，粘贴下面的内容

OD【目标检测】

# Ultralytics YOLO 🚀, AGPL-3.0 license
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect

# Parameters
nc: 80 # number of classes
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
  # [depth, width, max_channels]
  n: [0.33, 0.25, 1024] # YOLOv8n summary: 225 layers,  3157200 parameters,  3157184 gradients,   8.9 GFLOPs
  s: [0.33, 0.50, 1024] # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients,  28.8 GFLOPs
  m: [0.67, 0.75, 768] # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients,  79.3 GFLOPs
  l: [1.00, 1.00, 512] # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
  x: [1.00, 1.25, 512] # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs

# YOLOv8.0n backbone
backbone:
  # [from, repeats, module, args]
  - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
  - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
  - [-1, 3, C2f, [128, True]]
  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  - [-1, 6, C2f, [256, True]]
  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  - [-1, 6, C2f, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  - [-1, 3, C2f, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]] # 9

# YOLOv8.0n head
head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  - [-1, 3, C2f, [512]] # 12

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  - [-1, 3, C2f, [256]] # 15 (P3/8-small)

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 12], 1, Concat, [1]] # cat head P4
  - [-1, 3, C2f, [512]] # 18 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 9], 1, Concat, [1]] # cat head P5
  - [-1, 3, C2f, [1024]] # 21 (P5/32-large)
  - [-1, 1, EffectiveSELayer, [1024]]

  - [[15, 18, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)

Seg【语义分割】

# Ultralytics YOLO 🚀, AGPL-3.0 license
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect

# Parameters
nc: 80 # number of classes
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
  # [depth, width, max_channels]
  n: [0.33, 0.25, 1024] # YOLOv8n summary: 225 layers,  3157200 parameters,  3157184 gradients,   8.9 GFLOPs
  s: [0.33, 0.50, 1024] # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients,  28.8 GFLOPs
  m: [0.67, 0.75, 768] # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients,  79.3 GFLOPs
  l: [1.00, 1.00, 512] # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
  x: [1.00, 1.25, 512] # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs

# YOLOv8.0n backbone
backbone:
  # [from, repeats, module, args]
  - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
  - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
  - [-1, 3, C2f, [128, True]]
  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  - [-1, 6, C2f, [256, True]]
  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  - [-1, 6, C2f, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  - [-1, 3, C2f, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]] # 9

# YOLOv8.0n head
head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  - [-1, 3, C2f, [512]] # 12

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  - [-1, 3, C2f, [256]] # 15 (P3/8-small)

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 12], 1, Concat, [1]] # cat head P4
  - [-1, 3, C2f, [512]] # 18 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 9], 1, Concat, [1]] # cat head P5
  - [-1, 3, C2f, [1024]] # 21 (P5/32-large)
  - [-1, 1, EffectiveSELayer, [1024]]

  - [[15, 18, 22], 1, Segment, [nc, 32, 256]] # Segment(P3, P4, P5)

OBB【旋转检测】

# Ultralytics YOLO 🚀, AGPL-3.0 license
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect

# Parameters
nc: 80 # number of classes
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
  # [depth, width, max_channels]
  n: [0.33, 0.25, 1024] # YOLOv8n summary: 225 layers,  3157200 parameters,  3157184 gradients,   8.9 GFLOPs
  s: [0.33, 0.50, 1024] # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients,  28.8 GFLOPs
  m: [0.67, 0.75, 768] # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients,  79.3 GFLOPs
  l: [1.00, 1.00, 512] # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
  x: [1.00, 1.25, 512] # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs

# YOLOv8.0n backbone
backbone:
  # [from, repeats, module, args]
  - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
  - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
  - [-1, 3, C2f, [128, True]]
  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  - [-1, 6, C2f, [256, True]]
  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  - [-1, 6, C2f, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  - [-1, 3, C2f, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]] # 9

# YOLOv8.0n head
head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  - [-1, 3, C2f, [512]] # 12

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  - [-1, 3, C2f, [256]] # 15 (P3/8-small)

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 12], 1, Concat, [1]] # cat head P4
  - [-1, 3, C2f, [512]] # 18 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 9], 1, Concat, [1]] # cat head P5
  - [-1, 3, C2f, [1024]] # 21 (P5/32-large)
  - [-1, 1, EffectiveSELayer, [1024]]

  - [[15, 18, 22], 1, OBB, [nc, 1]] # OBB(P3, P4, P5)

温馨提示：因为本文只是对yolov8基础上添加模块，如果要对yolov8n/l/m/x进行添加则只需要指定对应的depth_multiple 和 width_multiple。

# YOLOv8n
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.25  # layer channel multiple
max_channels: 1024 # max_channels
 
# YOLOv8s
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.50  # layer channel multiple
max_channels: 1024 # max_channels
 
# YOLOv8l 
depth_multiple: 1.0  # model depth multiple
width_multiple: 1.0  # layer channel multiple
max_channels: 512 # max_channels
 
# YOLOv8m
depth_multiple: 0.67  # model depth multiple
width_multiple: 0.75  # layer channel multiple
max_channels: 768 # max_channels
 
# YOLOv8x
depth_multiple: 1.33  # model depth multiple
width_multiple: 1.25  # layer channel multiple
max_channels: 512 # max_channels

2.4 注册模块

关键步骤四：在task.py的parse_model函数中注册“ EffectiveSELayer”

937行附近添加 EffectiveSELayer

        elif m is EffectiveSELayer:
            c2 = ch[f]
            args = [c2, *args]

2.5 执行程序

在train.py中，将model的参数路径设置为yolov8_ESE.yaml的路径

建议大家写绝对路径，确保一定能找到

from ultralytics import YOLO
 
# Load a model
# model = YOLO('yolov8n.yaml')  # build a new model from YAML
# model = YOLO('yolov8n.pt')  # load a pretrained model (recommended for training)
 
model = YOLO(r'/projects/ultralytics/ultralytics/cfg/models/v8/yolov8_ESE.yaml')  # build from YAML and transfer weights
 
# Train the model
model.train(batch=16)

🚀运行程序，如果出现下面的内容则说明添加成功🚀

                  from  n    params  module                                       arguments                     
  0                  -1  1       464  ultralytics.nn.modules.conv.Conv             [3, 16, 3, 2]                 
  1                  -1  1      4672  ultralytics.nn.modules.conv.Conv             [16, 32, 3, 2]                
  2                  -1  1      7360  ultralytics.nn.modules.block.C2f             [32, 32, 1, True]             
  3                  -1  1     18560  ultralytics.nn.modules.conv.Conv             [32, 64, 3, 2]                
  4                  -1  2     49664  ultralytics.nn.modules.block.C2f             [64, 64, 2, True]             
  5                  -1  1     73984  ultralytics.nn.modules.conv.Conv             [64, 128, 3, 2]               
  6                  -1  2    197632  ultralytics.nn.modules.block.C2f             [128, 128, 2, True]           
  7                  -1  1    295424  ultralytics.nn.modules.conv.Conv             [128, 256, 3, 2]              
  8                  -1  1    460288  ultralytics.nn.modules.block.C2f             [256, 256, 1, True]           
  9                  -1  1    164608  ultralytics.nn.modules.block.SPPF            [256, 256, 5]                 
 10                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 11             [-1, 6]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 12                  -1  1    148224  ultralytics.nn.modules.block.C2f             [384, 128, 1]                 
 13                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 14             [-1, 4]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 15                  -1  1     37248  ultralytics.nn.modules.block.C2f             [192, 64, 1]                  
 16                  -1  1     36992  ultralytics.nn.modules.conv.Conv             [64, 64, 3, 2]                
 17            [-1, 12]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 18                  -1  1    123648  ultralytics.nn.modules.block.C2f             [192, 128, 1]                 
 19                  -1  1    147712  ultralytics.nn.modules.conv.Conv             [128, 128, 3, 2]              
 20             [-1, 9]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 21                  -1  1    493056  ultralytics.nn.modules.block.C2f             [384, 256, 1]                 
 22                  -1  1     65792  ultralytics.nn.modules.block.EffectiveSELayer[256, 256]                    
 23        [15, 18, 21]  1    897664  ultralytics.nn.modules.head.Detect           [80, [64, 128, 256]]          
YOLOv8_ESE summary: 228 layers, 3222992 parameters, 3222976 gradients

3. 完整代码分享

https://pan.baidu.com/s/1NRXzmjK90vXUhc6KfqGueQ?pwd=3xhh

提取码: 3xhh

4. GFLOPs

关于GFLOPs的计算方式可以查看：百面算法工程师 | 卷积基础知识——Convolution

未改进的YOLOv8nGFLOPs

改进后的GFLOPs

~~现在手上没有卡了，等过段时候有卡了把这补上，需要的同学自己测一下~~

5. 进阶

可以与其他的注意力机制或者损失函数等结合，进一步提升检测效果

6. 总结

ESE（有效挤压和激励）机制通过关注通道依赖性来增强卷积神经网络。它通过在输入特征图上执行全局平均池化来创建通道描述符，然后将其通过单个全连接层，然后进行 S 形激活以生成通道注意图。该图用于通过元素乘法重新校准原始特征图，有效地突出重要通道并抑制信息量较少的通道，从而提高网络的表征能力和性能。