YOLO11改进|SPPF篇|引入SPPFCSPC金字塔结构

最新推荐文章于 2024-10-12 00:00:00 发布

如果能为勤奋颁奖

最新推荐文章于 2024-10-12 00:00:00 发布

阅读量585

点赞数 6

分类专栏： YOLO11改进专栏文章标签：深度学习人工智能 YOLO

本文链接：https://blog.csdn.net/A1983Z/article/details/142852555

版权

YOLO11改进专栏专栏收录该内容

34 篇文章 24 订阅

订阅专栏

在这里插入图片描述

一、【SPPFCSPC】金字塔结构

1.1【SPPFCSPC】金字塔结构介绍

在这里插入图片描述

下图是【SPPFCSPC】的结构图，让我们简单分析一下运行过程和优势

处理过程：

多尺度卷积处理：
输入首先经过一系列的卷积操作，其中包括 1×1和 3×3的卷积核。这些卷积操作的主要作用是对输入图像进行初步的特征提取，确保模型能够捕获不同层次的细节信息。
多尺度池化操作：
在右侧并行处理路径中，输入经过不同尺度的池化操作。图中展示了三种不同的池化核大小：5×5、9×9和 13×13，每个池化操作后得到的感受野分别为 7×7、11×11和 15×15。这种多尺度池化允许模型在不同的空间范围内聚合信息，有助于捕捉不同尺寸的目标。
特征拼接（Concat）：
每个池化操作的结果与卷积操作的输出进行特征拼接（Concat）。这种操作将不同尺度的特征融合在一起，使得模型能够同时从全局和局部的特征中学习，提高了模型对复杂场景的理解能力。
进一步卷积处理：
拼接后的特征进一步通过卷积层处理，包括一个 1×1和一个 3×3卷积层。这些卷积操作进一步整合并精炼不同来源的特征，提升特征表达的鲁棒性。
最终输出：
最终的特征经过卷积层后输出，准备送入下一个网络层或进行分类、检测等任务。
优势：
多尺度特征提取：
该结构通过并行的多尺度池化操作，捕捉到了不同感受野下的特征。多尺度特征提取使得网络能够同时处理大小不一的目标，提升了对复杂场景的适应能力。
特征融合：
通过特征的拼接操作，将不同层次、不同感受野的特征整合在一起，增强了模型的特征表示能力。这样的融合策略确保了模型能够从多个角度学习到更加全面的特征信息。
灵活性高：
该模块能够根据任务需求调整卷积核和池化核的大小，使得其在图像分类、目标检测等任务中具备较高的灵活性。
有效扩大感受野：
通过多种不同尺度的池化操作，模型能够在不增加卷积层深度的情况下扩大感受野，从而增强了对远距离特征的捕捉能力，同时保持较高的计算效率。

1.2【SPPFCSPC】核心代码

from torch import nn
import torch
def autopad(k, p=None, d=1):  # kernel, padding, dilation
    """Pad to 'same' shape outputs."""
    if d > 1:
        k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k]  # actual kernel-size
    if p is None:
        p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
    return p

class Conv(nn.Module):
    """Standard convolution with args(ch_in, ch_out, kernel, stride, padding, groups, dilation, activation)."""
    default_act = nn.SiLU()  # default activation

    def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
        """Initialize Conv layer with given arguments including activation."""
        super().__init__()
        self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), groups=g, dilation=d, bias=False)
        self.bn = nn.BatchNorm2d(c2)
        self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()

    def forward(self, x):
        """Apply convolution, batch normalization and activation to input tensor."""
        return self.act(self.bn(self.conv(x)))

    def forward_fuse(self, x):
        """Perform transposed convolution of 2D data."""
        return self.act(self.conv(x))



class SPPFCSPC(nn.Module):

    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5, k=5):
        super(SPPFCSPC, self).__init__()
        c_ = int(2 * c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c1, c_, 1, 1)
        self.cv3 = Conv(c_, c_, 3, 1)
        self.cv4 = Conv(c_, c_, 1, 1)
        self.m = nn.MaxPool2d(kernel_size=k, stride=1, padding=k // 2)
        self.cv5 = Conv(4 * c_, c_, 1, 1)
        self.cv6 = Conv(c_, c_, 3, 1)
        self.cv7 = Conv(2 * c_, c2, 1, 1)

    def forward(self, x):
        x1 = self.cv4(self.cv3(self.cv1(x)))
        x2 = self.m(x1)
        x3 = self.m(x2)
        y1 = self.cv6(self.cv5(torch.cat((x1, x2, x3, self.m(x3)), 1)))
        y2 = self.cv2(x)
        return self.cv7(torch.cat((y1, y2), dim=1))

二、添加【SPPFCSPC】金字塔结构

2.1STEP1

首先找到ultralytics/nn文件路径下新建一个Add-module的python文件包【这里注意一定是python文件包，新建后会自动生成_init_.py】，如果已经跟着我的教程建立过一次了可以省略此步骤，随后新建一个SPPFCSPC.py文件并将上文中提到的注意力机制的代码全部粘贴到此文件中，如下图所示在这里插入图片描述

2.2STEP2

在STEP1中新建的_init_.py文件中导入增加改进模块的代码包如下图所示在这里插入图片描述

2.3STEP3

找到ultralytics/nn文件夹中的task.py文件，在其中按照下图添加在这里插入图片描述

2.4STEP4

定位到ultralytics/nn文件夹中的task.py文件中的def parse_model(d, ch, verbose=True): # model_dict, input_channels(3)函数添加如图代码,【如果不好定位可以直接ctrl+f搜索定位】

在这里插入图片描述

三、yaml文件与运行

3.1yaml文件

以下是添加【SPPFCSPC】替换原始结构中的SPPF模块的yaml文件，大家可以注释自行调节，效果以自己的数据集结果为准

# Ultralytics YOLO 🚀, AGPL-3.0 license
# YOLO11 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=yolo11n.yaml' will call yolo11.yaml with scale 'n'
  # [depth, width, max_channels]
  n: [0.50, 0.25, 1024] # summary: 319 layers, 2624080 parameters, 2624064 gradients, 6.6 GFLOPs
  s: [0.50, 0.50, 1024] # summary: 319 layers, 9458752 parameters, 9458736 gradients, 21.7 GFLOPs
  m: [0.50, 1.00, 512] # summary: 409 layers, 20114688 parameters, 20114672 gradients, 68.5 GFLOPs
  l: [1.00, 1.00, 512] # summary: 631 layers, 25372160 parameters, 25372144 gradients, 87.6 GFLOPs
  x: [1.00, 1.50, 512] # summary: 631 layers, 56966176 parameters, 56966160 gradients, 196.0 GFLOPs

# YOLO11n backbone
backbone:
  # [from, repeats, module, args]
  - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
  - [-1, 1, SAConv2d, [128,3,2]] # 1-P2/4
  - [-1, 2, C3k2, [256, False, 0.25]]
  - [-1, 1, SAConv2d, [256,3,2]] # 3-P3/8
  - [-1, 2, C3k2, [512, False, 0.25]]
  - [-1, 1, SAConv2d, [512,3,2]] # 5-P4/16
  - [-1, 2, C3k2, [512, True]]
  - [-1, 1, SAConv2d, [1024,3,2]] # 7-P5/32
  - [-1, 2, C3k2, [1024, True]]
  - [-1, 1, SPPFCSPC, [1024]] # 9
  - [-1, 2, C2PSA, [1024]] # 10

# YOLO11n head
head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  - [-1, 2, C3k2, [512, False]] # 13

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

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 13], 1, Concat, [1]] # cat head P4
  - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 10], 1, Concat, [1]] # cat head P5
  - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)

  - [[16, 19, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)