YOLO11改进|卷积篇|引入SPDConv

如果能为勤奋颁奖

于 2024-10-06 16:14:01 发布

阅读量856

点赞数 19

分类专栏： YOLO11改进专栏文章标签： YOLO

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

版权

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

16 篇文章 1 订阅

订阅专栏

在这里插入图片描述

一、【SPD】卷积

1.1【SPD】卷积介绍

在这里插入图片描述

SPD-Conv卷积的结构图如下，下面我们简单分析一下其处理过程和优势

处理过程：
输入特征图 (a):输入特征图的尺寸为 𝑆×𝑆×𝐶1，其中 𝑆是特征图的空间分辨率，𝐶1是通道数。如图 (a) 所示，这个输入特征图会被送入 SPD-Conv 模块进行处理。
Space-to-Depth 操作 (b, c):图 (b) 进行的是 Space-to-Depth 操作，将原来的空间维度压缩，同时将多个像素点的值重新映射到深度维度（即通道维度）。通过这一操作，原本 𝑆×𝑆×𝐶1的特征图被拆分成多个较小的区域，每个区域的空间维度减少为 𝑆/2×𝑆/2，通道数则增加为 4𝐶1（如图 © 所示）。具体过程是，将特征图按像素间隔进行拆分，将这些拆分的结果按通道方向堆叠起来。
特征拼接与合并 (d):图 © 显示了经过 Space-to-Depth 操作后，特征图被拆分为四个分块。这些特征块通过通道维度进行拼接，合并成一个具有 4𝐶1通道的特征图，空间维度变成了 𝑆/2×𝑆/2
卷积操作 (e):合并后的特征图会通过卷积操作（图 (e)），在此过程中使用的卷积核步长为 1，确保空间维度保持不变。最终的输出特征图为 𝑆/2×𝑆/2×𝐶2，其中 𝐶2是经过卷积操作后的输出通道数。
优势：
多尺度特征提取:Space-to-Depth 操作通过压缩空间维度并增加通道数，使得特征图可以以较小的空间分辨率同时处理更多的特征。这种方式有助于捕捉更多局部的细节信息，并保留全局上下文。
减少计算成本:相较于直接在大分辨率下执行复杂的卷积操作，通过 Space-to-Depth 操作，SPD-Conv 将空间维度减少，可以有效减少计算量，同时通过增加通道数确保特征表达的丰富性。
提高特征表达能力:通过将原本分散在空间中的特征重新映射到深度维度，SPD-Conv 可以更好地聚合空间信息，从而提升网络对特征的表达能力。
更好的并行计算:由于空间维度被缩小，而通道数增大，这种结构更适合在现代硬件（如 GPU）上进行并行计算，有利于提升计算效率。

1.2【SPD】核心代码

import torch
import torch.nn as nn

__all__ = ['SPDConv']


def autopad(k, p=None, d=1):  # kernel, padding, dilation

    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 SPDConv(nn.Module):
    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__()
        c1 = c1 * 4
        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):
        x = torch.cat([x[..., ::2, ::2], x[..., 1::2, ::2], x[..., ::2, 1::2], x[..., 1::2, 1::2]], 1)
        """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."""
        x = torch.cat([x[..., ::2, ::2], x[..., 1::2, ::2], x[..., ::2, 1::2], x[..., 1::2, 1::2]], 1)
        return self.act(self.conv(x))

二、添加【SPD】卷积

2.1STEP1

首先找到ultralytics/nn文件路径下新建一个Add-module的python文件包【这里注意一定是python文件包，新建后会自动生成_init_.py】，如果已经跟着我的教程建立过一次了可以省略此步骤，随后新建一个SPD.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文件

以下是添加【SPD】卷积在Backbone中的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, SPDConv, [128]] # 1-P2/4
  - [-1, 2, C3k2, [256, False, 0.25]]
  - [-1, 1, SPDConv, [256]] # 3-P3/8
  - [-1, 2, C3k2, [512, False, 0.25]]
  - [-1, 1, SPDConv, [512]] # 5-P4/16
  - [-1, 2, C3k2, [512, True]]
  - [-1, 1, SPDConv, [1024]] # 7-P5/32
  - [-1, 2, C3k2, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]] # 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)