学习资源站

YOLOv11改进-添加注意力机制篇-添加YOLO-Face提出的SEAM注意力机制优化物体遮挡检测（附二次创新C2PSA机制）

一、本文介绍

本文给大家带来的改进机制是由YOLO-Face提出能够改善物体遮挡检测的 注意力机制 SEAM， SEAM（Spatially Enhanced Attention Module） 注意力 网络模块旨在补偿被遮挡面部的响应损失，通过增强未遮挡面部的响应来实现这一目标，其希望通过学习遮挡面和未遮挡面之间的关系来改善遮挡情况下的损失从而达到改善物体遮挡检测的效果，同时本文附二次创新PSA机制。 本文将通过介绍其主要原理后，提供该机制的代码和修改教程，并附上运行的yaml文件和运行代码，小白也可轻松上手 (本文附二次创新C2PSASEAM机制) 。

欢迎大家订阅我的专栏一起学习YOLO！

二、原理介绍

2.1 遮挡改进

本文重点介绍 遮挡改进 ，其主要体现在两个方面： 注意力网络模块（SEAM） 和 排斥损失（Repulsion Loss） 。

1. SEAM模块：SEAM（Spatially Enhanced Attention Module） 注意力 网络模块 旨在补偿被遮挡面部的响应损失，通过增强未遮挡面部的响应来实现这一目标。SEAM模块通过深度可分离卷积和残差连接的组合来实现，其中深度可分离卷积按通道进行操作，虽然可以学习不同通道的重要性并减少参数量，但忽略了通道间的信息关系。为了弥补这一损失，不同深度卷积的输出通过点对点（1x1）卷积组合。然后使用两层全连接网络融合每个通道的信息，以增强所有通道之间的联系。这种 模型 希望通过学习遮挡面和未遮挡面之间的关系，来弥补遮挡情况下的损失。

2. 排斥损失（Repulsion Loss） ：一种设计来处理面部遮挡问题的 损失函数 。具体来说，排斥损失被分为两部分：RepGT和RepBox。RepGT的功能是使当前的边界框尽可能远离周围的真实边界框，而RepBox的目的是使预测框尽可能远离周围的预测框，从而减少它们之间的IOU，以避免某个预测框被NMS抑制，从而属于两个面部。

2.2 SEAM模块

下图展示了 SEAM（Separated and Enhancement Attention Module）的架构 以及 CSMM（Channel and Spatial Mixing Module）的结构 。

左侧 是SEAM的整体架构，包括三个不同尺寸（patch-6、patch-7、patch-8）的CSMM模块。这些模块的输出进行平均池化，然后通过通道扩展（Channel exp）操作，最后相乘以提供增强的特征表示。 右侧 是CSMM模块的详细结构，它通过不同尺寸的patch来利用多尺度特征，并使用深度可分离卷积来学习空间维度和通道之间的相关性。模块包括了以下元素：

（a）Patch Embedding：对输入的patch进行嵌入。
（b）GELU：Gaussian Error Linear Unit，一种激活函数。
（c）BatchNorm：批量归一化，用于加速训练过程并提高 性能 。
（d）Depthwise Convolution：深度可分离卷积，对每个输入通道分别进行卷积操作。
（f）Pointwise Convolution：逐点卷积，其使用1x1的卷积核来融合深度可分离卷积的特征。

这种模块设计旨在 通过对空间维度和通道的细致处理 ，从而增强网络对遮挡面部特征的注意力和捕捉能力。通过综合利用多尺度特征和深度可分离卷积，CSMM在保持计算效率的同时，提高了特征提取的精确度。这对于面部检测尤其重要，因为面部特征的大小、形状和遮挡程度可以在不同情况下大相径庭。通过SEAM和CSMM，YOLO-FaceV2提高了模型对复杂场景中各种面部特征的识别能力。

2.3 排斥损失

排斥损失（Repulsion Loss） 是一种用于处理面部检测中遮挡问题的损失函数。在面部检测中，类内遮挡可能会导致一个面部包含另一个面部的特征，从而增加错误检测率。排斥损失能够有效地通过排斥效应来缓解这一问题。排斥损失被分为两个部分： RepGT 和 RepBox 。

（a）RepGT损失： 其功能是使当前边界框尽可能远离周围的真实边界框。这里的“周围真实边界框”指的是与除了要预测的边界框外的面部标签具有最大IoU的那个边界框。RepGT损失的计算方法如下：

L_{\text{RepGT}} = \sum_{P \in P^+} \text{SmoothLn}(\text{IoG}(P, G_{\text{Rep}}))

其中， P 代表面部预测框， G_{\text{Rep}} 是周围具有最大IoU的真实边界框。这里的IoG（Intersection over Ground truth）定义为 \frac{\text{area}(P \cap G)}{\text{area}(G)} ，且其值范围在0到1之间。 SmoothLn 是一个连续可导的对数函数， \sigma 是一个在[0,1)范围内的平滑参数，用于调整排斥损失对 异常 值的敏感度。

（b）RepBox损失： 其目的是使预测框尽可能远离周围的预测框，从而减少它们之间的IOU，以避免一个预测框因NMS（非最大抑制）而被压制，并归属于两个面部。预测框被分成多个组，不同组之间的预测框对应不同的面部标签。对于不同组之间的预测框 p_i 和 p_j ，希望它们之间的重叠面积尽可能小。RepBox也使用SmoothLn作为优化函数。

L_{\text{RepBox}} = \sum_{i \neq j} \text{SmoothLn}(\text{IoU}(B_{p_i}, B_{p_j}))

排斥损失通过使边界框之间保持距离，减少预测框之间的重叠，从而提高面部检测在遮挡情况下的准确性。

三、核心代码

代码的使用方式看章节四！ 

  1. import torch
  2. import torch.nn as nn
  4. __all__ = ['SEAM', 'C2PSA_SEAM']
  6. class Residual(nn.Module):
  7.     def __init__(self, fn):
  8.         super(Residual, self).__init__()
  9.         self.fn = fn
  11.     def forward(self, x):
  12.         return self.fn(x) + x
  14. class SEAM(nn.Module):
  15.     def __init__(self, c1,  n=1, reduction=16):
  16.         super(SEAM, self).__init__()
  17.         c2 = c1
  18.         self.DCovN = nn.Sequential(
  19.             # nn.Conv2d(c1, c2, kernel_size=3, stride=1, padding=1, groups=c1),
  20.             # nn.GELU(),
  21.             # nn.BatchNorm2d(c2),
  22.             *[nn.Sequential(
  23.                 Residual(nn.Sequential(
  24.                     nn.Conv2d(in_channels=c2, out_channels=c2, kernel_size=3, stride=1, padding=1, groups=c2),
  25.                     nn.GELU(),
  26.                     nn.BatchNorm2d(c2)
  27.                 )),
  28.                 nn.Conv2d(in_channels=c2, out_channels=c2, kernel_size=1, stride=1, padding=0, groups=1),
  29.                 nn.GELU(),
  30.                 nn.BatchNorm2d(c2)
  31.             ) for i in range(n)]
  32.         )
  33.         self.avg_pool = torch.nn.AdaptiveAvgPool2d(1)
  34.         self.fc = nn.Sequential(
  35.             nn.Linear(c2, c2 // reduction, bias=False),
  36.             nn.ReLU(inplace=True),
  37.             nn.Linear(c2 // reduction, c2, bias=False),
  38.             nn.Sigmoid()
  39.         )
  41.         self._initialize_weights()
  42.         # self.initialize_layer(self.avg_pool)
  43.         self.initialize_layer(self.fc)
  46.     def forward(self, x):
  47.         b, c, _, _ = x.size()
  48.         y = self.DCovN(x)
  49.         y = self.avg_pool(y).view(b, c)
  50.         y = self.fc(y).view(b, c, 1, 1)
  51.         y = torch.exp(y)
  52.         return x * y.expand_as(x)
  54.     def _initialize_weights(self):
  55.         for m in self.modules():
  56.             if isinstance(m, nn.Conv2d):
  57.                 nn.init.xavier_uniform_(m.weight, gain=1)
  58.             elif isinstance(m, nn.BatchNorm2d):
  59.                 nn.init.constant_(m.weight, 1)
  60.                 nn.init.constant_(m.bias, 0)
  62.     def initialize_layer(self, layer):
  63.         if isinstance(layer, (nn.Conv2d, nn.Linear)):
  64.             torch.nn.init.normal_(layer.weight, mean=0., std=0.001)
  65.             if layer.bias is not None:
  66.                 torch.nn.init.constant_(layer.bias, 0)
  69. def DcovN(c1, c2, depth, kernel_size=3, patch_size=3):
  70.     dcovn = nn.Sequential(
  71.         nn.Conv2d(c1, c2, kernel_size=patch_size, stride=patch_size),
  72.         nn.SiLU(),
  73.         nn.BatchNorm2d(c2),
  74.         *[nn.Sequential(
  75.             Residual(nn.Sequential(
  76.                 nn.Conv2d(in_channels=c2, out_channels=c2, kernel_size=kernel_size, stride=1, padding=1, groups=c2),
  77.                 nn.SiLU(),
  78.                 nn.BatchNorm2d(c2)
  79.             )),
  80.             nn.Conv2d(in_channels=c2, out_channels=c2, kernel_size=1, stride=1, padding=0, groups=1),
  81.             nn.SiLU(),
  82.             nn.BatchNorm2d(c2)
  83.         ) for i in range(depth)]
  84.     )
  85.     return dcovn
  87. def autopad(k, p=None, d=1):  # kernel, padding, dilation
  88.     """Pad to 'same' shape outputs."""
  89.     if d > 1:
  90.         k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k]  # actual kernel-size
  91.     if p is None:
  92.         p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
  93.     return p
  96. class Conv(nn.Module):
  97.     """Standard convolution with args(ch_in, ch_out, kernel, stride, padding, groups, dilation, activation)."""
  99.     default_act = nn.SiLU()  # default activation
  101.     def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
  102.         """Initialize Conv layer with given arguments including activation."""
  103.         super().__init__()
  104.         self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), groups=g, dilation=d, bias=False)
  105.         self.bn = nn.BatchNorm2d(c2)
  106.         self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()
  108.     def forward(self, x):
  109.         """Apply convolution, batch normalization and activation to input tensor."""
  110.         return self.act(self.bn(self.conv(x)))
  112.     def forward_fuse(self, x):
  113.         """Perform transposed convolution of 2D data."""
  114.         return self.act(self.conv(x))
  116. class PSABlock(nn.Module):
  117.     """
  118.     PSABlock class implementing a Position-Sensitive Attention block for neural networks.
  120.     This class encapsulates the functionality for applying multi-head attention and feed-forward neural network layers
  121.     with optional shortcut connections.
  123.     Attributes:
  124.         attn (Attention): Multi-head attention module.
  125.         ffn (nn.Sequential): Feed-forward neural network module.
  126.         add (bool): Flag indicating whether to add shortcut connections.
  128.     Methods:
  129.         forward: Performs a forward pass through the PSABlock, applying attention and feed-forward layers.
  131.     Examples:
  132.         Create a PSABlock and perform a forward pass
  133.         >>> psablock = PSABlock(c=128, attn_ratio=0.5, num_heads=4, shortcut=True)
  134.         >>> input_tensor = torch.randn(1, 128, 32, 32)
  135.         >>> output_tensor = psablock(input_tensor)
  136.     """
  138.     def __init__(self, c, attn_ratio=0.5, num_heads=4, shortcut=True) -> None:
  139.         """Initializes the PSABlock with attention and feed-forward layers for enhanced feature extraction."""
  140.         super().__init__()
  142.         self.attn = SEAM(c)
  143.         self.ffn = nn.Sequential(Conv(c, c * 2, 1), Conv(c * 2, c, 1, act=False))
  144.         self.add = shortcut
  146.     def forward(self, x):
  147.         """Executes a forward pass through PSABlock, applying attention and feed-forward layers to the input tensor."""
  148.         x = x + self.attn(x) if self.add else self.attn(x)
  149.         x = x + self.ffn(x) if self.add else self.ffn(x)
  150.         return x
  153. class C2PSA_SEAM(nn.Module):
  154.     """
  155.     C2PSA module with attention mechanism for enhanced feature extraction and processing.
  157.     This module implements a convolutional block with attention mechanisms to enhance feature extraction and processing
  158.     capabilities. It includes a series of PSABlock modules for self-attention and feed-forward operations.
  160.     Attributes:
  161.         c (int): Number of hidden channels.
  162.         cv1 (Conv): 1x1 convolution layer to reduce the number of input channels to 2*c.
  163.         cv2 (Conv): 1x1 convolution layer to reduce the number of output channels to c.
  164.         m (nn.Sequential): Sequential container of PSABlock modules for attention and feed-forward operations.
  166.     Methods:
  167.         forward: Performs a forward pass through the C2PSA module, applying attention and feed-forward operations.
  169.     Notes:
  170.         This module essentially is the same as PSA module, but refactored to allow stacking more PSABlock modules.
  172.     Examples:
  173.         >>> c2psa = C2PSA(c1=256, c2=256, n=3, e=0.5)
  174.         >>> input_tensor = torch.randn(1, 256, 64, 64)
  175.         >>> output_tensor = c2psa(input_tensor)
  176.     """
  178.     def __init__(self, c1, c2, n=1, e=0.5):
  179.         """Initializes the C2PSA module with specified input/output channels, number of layers, and expansion ratio."""
  180.         super().__init__()
  181.         assert c1 == c2
  182.         self.c = int(c1 * e)
  183.         self.cv1 = Conv(c1, 2 * self.c, 1, 1)
  184.         self.cv2 = Conv(2 * self.c, c1, 1)
  186.         self.m = nn.Sequential(*(PSABlock(self.c, attn_ratio=0.5, num_heads=self.c // 64) for _ in range(n)))
  188.     def forward(self, x):
  189.         """Processes the input tensor 'x' through a series of PSA blocks and returns the transformed tensor."""
  190.         a, b = self.cv1(x).split((self.c, self.c), dim=1)
  191.         b = self.m(b)
  192.         return self.cv2(torch.cat((a, b), 1))
  195. if __name__ == "__main__":
  196.     # Generating Sample image
  197.     image_size = (1, 64, 240, 240)
  198.     image = torch.rand(*image_size)
  200.     # Model
  201.     mobilenet_v1 = C2PSA_SEAM(64, 64)
  203.     out = mobilenet_v1(image)
  204.     print(out.size())

四、添加教程

本文的改善遮挡的注意力机制我是建议用在Neck的输出部分来进行使用。

4.1 修改一

第一还是建立文件，我们找到如下 ultralytics /nn/modules文件夹下建立一个目录名字呢就是'Addmodules'文件夹( 用群内的文件的话已经有了无需新建) ！然后在其内部建立一个新的py文件将核心代码复制粘贴进去即可。

4.2 修改二

第二步我们在该目录下创建一个新的py文件名字为'__init__.py'( 用群内的文件的话已经有了无需新建) ，然后在其内部导入我们的检测头如下图所示。

4.3 修改三

第三步我门中到如下文件'ultralytics/nn/tasks.py'进行导入和注册我们的模块( 用群内的文件的话已经有了无需重新导入直接开始第四步即可) ！

从今天开始以后的教程就都统一成这个样子了，因为我默认大家用了我群内的文件来进行修改！！

​

4.4 修改四

按照我的添加在parse_model里添加即可。

到此就修改完成了，大家可以复制下面的yaml文件运行。

五、 SEAM 的yaml文件和运行记录

5.1 C2PSA SEAM 的yaml文件

此版本训练信息：YOLO11-C2PSA-SEAM summary: 324 layers, 2,563,739 parameters, 2,563,723 gradients, 6.4 GFLOPs 

  1. # Ultralytics YOLO 🚀, AGPL-3.0 license
  2. # YOLO11 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
  4. # Parameters
  5. nc: 80 # number of classes
  6. scales: # model compound scaling constants, i.e. 'model=yolo11n.yaml' will call yolo11.yaml with scale 'n'
  7.   # [depth, width, max_channels]
  8.   n: [0.50, 0.25, 1024] # summary: 319 layers, 2624080 parameters, 2624064 gradients, 6.6 GFLOPs
  9.   s: [0.50, 0.50, 1024] # summary: 319 layers, 9458752 parameters, 9458736 gradients, 21.7 GFLOPs
  10.   m: [0.50, 1.00, 512] # summary: 409 layers, 20114688 parameters, 20114672 gradients, 68.5 GFLOPs
  11.   l: [1.00, 1.00, 512] # summary: 631 layers, 25372160 parameters, 25372144 gradients, 87.6 GFLOPs
  12.   x: [1.00, 1.50, 512] # summary: 631 layers, 56966176 parameters, 56966160 gradients, 196.0 GFLOPs
  14. # YOLO11n backbone
  15. backbone:
  16.   # [from, repeats, module, args]
  17.   - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
  18.   - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
  19.   - [-1, 2, C3k2, [256, False, 0.25]]
  20.   - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  21.   - [-1, 2, C3k2, [512, False, 0.25]]
  22.   - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  23.   - [-1, 2, C3k2, [512, True]]
  24.   - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  25.   - [-1, 2, C3k2, [1024, True]]
  26.   - [-1, 1, SPPF, [1024, 5]] # 9
  27.   - [-1, 2, C2PSA_SEAM, [1024]] # 10
  29. # YOLO11n head
  30. head:
  31.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  32.   - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  33.   - [-1, 2, C3k2, [512, False]] # 13
  35.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  36.   - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  37.   - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
  39.   - [-1, 1, Conv, [256, 3, 2]]
  40.   - [[-1, 13], 1, Concat, [1]] # cat head P4
  41.   - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)
  43.   - [-1, 1, Conv, [512, 3, 2]]
  44.   - [[-1, 10], 1, Concat, [1]] # cat head P5
  45.   - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)
  47.   - [[16, 19, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)

5.2 SEAM训练Yaml文件

此版本训练信息：YO4LO11-SEAM summary: 370 layers, 2,698,203 parameters, 2,698,187 gradients, 6.7 GFLOPs 

  1. # Ultralytics YOLO 🚀, AGPL-3.0 license
  2. # YOLO11 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
  4. # Parameters
  5. nc: 80 # number of classes
  6. scales: # model compound scaling constants, i.e. 'model=yolo11n.yaml' will call yolo11.yaml with scale 'n'
  7.   # [depth, width, max_channels]
  8.   n: [0.50, 0.25, 1024] # summary: 319 layers, 2624080 parameters, 2624064 gradients, 6.6 GFLOPs
  9.   s: [0.50, 0.50, 1024] # summary: 319 layers, 9458752 parameters, 9458736 gradients, 21.7 GFLOPs
  10.   m: [0.50, 1.00, 512] # summary: 409 layers, 20114688 parameters, 20114672 gradients, 68.5 GFLOPs
  11.   l: [1.00, 1.00, 512] # summary: 631 layers, 25372160 parameters, 25372144 gradients, 87.6 GFLOPs
  12.   x: [1.00, 1.50, 512] # summary: 631 layers, 56966176 parameters, 56966160 gradients, 196.0 GFLOPs
  14. # YOLO11n backbone
  15. backbone:
  16.   # [from, repeats, module, args]
  17.   - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
  18.   - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
  19.   - [-1, 2, C3k2, [256, False, 0.25]]
  20.   - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  21.   - [-1, 2, C3k2, [512, False, 0.25]]
  22.   - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  23.   - [-1, 2, C3k2, [512, True]]
  24.   - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  25.   - [-1, 2, C3k2, [1024, True]]
  26.   - [-1, 1, SPPF, [1024, 5]] # 9
  27.   - [-1, 2, C2PSA, [1024]] # 10
  29. # YOLO11n head
  30. head:
  31.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  32.   - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  33.   - [-1, 2, C3k2, [512, False]] # 13
  35.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  36.   - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  37.   - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
  38.   - [-1, 1, SEAM, []] # 17 (P3/8-small)  小目标检测层输出位置增加注意力机制
  40.   - [-1, 1, Conv, [256, 3, 2]]
  41.   - [[-1, 13], 1, Concat, [1]] # cat head P4
  42.   - [-1, 2, C3k2, [512, False]] # 20 (P4/16-medium)
  43.   - [-1, 1, SEAM, []] # 21 (P4/16-medium) 中目标检测层输出位置增加注意力机制
  45.   - [-1, 1, Conv, [512, 3, 2]]
  46.   - [[-1, 10], 1, Concat, [1]] # cat head P5
  47.   - [-1, 2, C3k2, [1024, True]] # 24 (P5/32-large)
  48.   - [-1, 1, SEAM, []] # 25 (P5/32-large) 大目标检测层输出位置增加注意力机制
  50.   # 具体在那一层用注意力机制可以根据自己的数据集场景进行选择。
  51.   # 如果你自己配置注意力位置注意from[17, 21, 25]位置要对应上对应的检测层！
  52.   - [[17, 21, 25], 1, Detect, [nc]] # Detect(P3, P4, P5)

5.3 训练代码

大家可以创建一个py文件将我给的代码复制粘贴进去，配置好自己的文件路径即可运行。 

  1. import warnings
  2. warnings.filterwarnings('ignore')
  3. from ultralytics import YOLO
  5. if __name__ == '__main__':
  6.     model = YOLO('ultralytics/cfg/models/v8/yolov8-C2f-FasterBlock.yaml')
  7.     # model.load('yolov8n.pt') # loading pretrain weights
  8.     model.train(data=r'替换数据集yaml文件地址',
  9.                 # 如果大家任务是其它的'ultralytics/cfg/default.yaml'找到这里修改task可以改成detect, segment, classify, pose
  10.                 cache=False,
  11.                 imgsz=640,
  12.                 epochs=150,
  13.                 single_cls=False,  # 是否是单类别检测
  14.                 batch=4,
  15.                 close_mosaic=10,
  16.                 workers=0,
  17.                 device='0',
  18.                 optimizer='SGD', # using SGD
  19.                 # resume='', # 如过想续训就设置last.pt的地址
  20.                 amp=False,  # 如果出现训练损失为Nan可以关闭amp
  21.                 project='runs/train',
  22.                 name='exp',
  23.                 )

5.4 训练过程截图

五、本文总结

到此本文的正式分享内容就结束了，在这里给大家推荐我的YOLOv11改进有效涨点专栏，本专栏目前为新开的平均质量分98分，后期我会根据各种最新的前沿顶会进行论文复现，也会对一些老的改进机制进行补充，如果大家觉得本文帮助到你了，订阅本专栏，关注后续更多的更新~