当前位置：首页 > article >正文

YOLO11改进 | 卷积模块 | 添加选择性内核SKConv【附完整代码一键运行】

article 2024/10/3 14:29:19

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

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

在标准卷积神经网络 (CNN) 中，每层人工神经元的感受野被设计为具有相同的大小。在神经科学界众所周知，视觉皮层神经元的感受野大小受刺激调节，但在构建 CNN 时很少考虑这一点。然而动态的选择机制，允许每个神经元基于多种输入信息尺度自适应地调整其感受野大小。在本文中，给大家带来的教程是将原来的网络中C3k2块替换为SKConv，或者单纯的添加SKconv。文章在介绍主要的原理后，将手把手教学如何进行模块的代码添加和修改，并将修改后的完整代码放在文章的最后，方便大家一键运行，小白也可轻松上手实践。

专栏地址：YOLO11入门 + 改进涨点——点击即可跳转欢迎订阅

1.原理

2. SKConv代码实现

2.1 将SKConv代码添加到YOLO11中

2.2 更改init.py文件

2.3 在task.py中进行注册

2.4 添加yaml文件

2.5 执行程序

3.修改后的网络结构图

4. 完整代码分享

5. GFLOPs

6. 进阶

7.总结

1.原理

官方论文：Selective Kernel Networks——点击即可跳转

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

SKconv是一种用于图像处理中的卷积神经网络（CNN）的卷积层变体。SKconv的全称是Selective Kernel Convolution，它引入了一种选择性内核机制，可以动态地选择不同尺寸的卷积核来捕捉不同尺度的特征。

SKconv的核心思想是引入一个注意力机制，允许网络在每个位置上选择性地聚焦于局部和全局特征之间的权衡。为了实现这一点，SKconv引入了三个部分：SK模块（Selective Kernel Module）、SK卷积操作和SK融合。

SK模块：SK模块包括一个全局池化操作，用于捕捉全局信息，并通过一系列操作将全局信息与局部信息进行融合，以便在每个位置上动态选择适当的卷积核尺寸。
SK卷积操作：在SKconv中，卷积核的选择不再是固定的，而是基于SK模块的输出动态确定的。这意味着在每个位置上，网络可以选择不同大小的卷积核来捕获局部和全局特征。
SK融合：SKconv使用一种有效的方式将选择的不同尺寸的卷积核的输出进行融合，以产生最终的特征图。

SKconv的引入旨在提高CNN模型对不同尺度特征的表达能力，从而增强模型对于图像的感知能力和识别性能。通过动态地选择卷积核尺寸，SKconv可以更好地适应不同尺度的目标，提高了模型的泛化能力和鲁棒性。因此，SKconv已经被广泛应用于图像分类、目标检测和语义分割等任务中，并取得了较好的效果。

2. SKConv代码实现

2.1 将SKConv代码添加到YOLO11中

关键步骤一：将下面代码粘贴到在/ultralytics/ultralytics/nn/modules/conv.py中，并在该文件的_all_中添加“SKConv”

class SKConv(nn.Module):
    def __init__(self, features, WH, M=2, G=1, r=2, stride=1, L=32):
        """ Constructor
        Args:
            features: input channel dimensionality.
            WH: input spatial dimensionality, used for GAP kernel size.
            M: the number of branchs.
            G: num of convolution groups.
            r: the radio for compute d, the length of z.
            stride: stride, default 1.
            L: the minimum dim of the vector z in paper, default 32.
        """
        super(SKConv, self).__init__()
        d = max(int(features / r), L)
        self.M = M
        self.features = features
        self.convs = nn.ModuleList([])
        for i in range(M):
            self.convs.append(
                nn.Sequential(
                    nn.Conv2d(features,
                              features,
                              kernel_size=3 + i * 2,
                              stride=stride,
                              padding=1 + i,
                              groups=G), nn.BatchNorm2d(features),
                    nn.ReLU(inplace=False)))
        # self.gap = nn.AvgPool2d(int(WH/stride))
        # print("D:", d)
        self.fc = nn.Linear(features, d)
        self.fcs = nn.ModuleList([])
        for i in range(M):
            self.fcs.append(nn.Linear(d, features))
        self.softmax = nn.Softmax(dim=1)

    def forward(self, x):
        for i, conv in enumerate(self.convs):
            fea = conv(x).unsqueeze_(dim=1)
            if i == 0:
                feas = fea
            else:
                feas = torch.cat([feas, fea], dim=1)
        fea_U = torch.sum(feas, dim=1)
        # fea_s = self.gap(fea_U).squeeze_()
        fea_s = fea_U.mean(-1).mean(-1)
        fea_z = self.fc(fea_s)
        for i, fc in enumerate(self.fcs):
            # print(i, fea_z.shape)
            vector = fc(fea_z).unsqueeze_(dim=1)
            # print(i, vector.shape)
            if i == 0:
                attention_vectors = vector
            else:
                attention_vectors = torch.cat([attention_vectors, vector],
                                              dim=1)
        attention_vectors = self.softmax(attention_vectors)
        attention_vectors = attention_vectors.unsqueeze(-1).unsqueeze(-1)
        fea_v = (feas * attention_vectors).sum(dim=1)
        return fea_v

SKconv的关键流程步骤主要包括SK模块的构建、SK卷积操作和SK融合。

SK模块的构建：
- 首先，对于输入特征图，通过一个全局池化操作（通常是全局平均池化），得到一个全局特征向量。
- 接着，通过几个全连接层或者卷积层，将全局特征向量映射到一个较低维度的表示，通常使用非线性激活函数来引入非线性。
- 在SK模块中，通常还会引入一些规范化操作，如归一化或者正则化，以便更好地控制特征的范围和稳定性。
- 最后，使用softmax函数或者sigmoid函数来生成一组权重，这些权重代表了每个位置上不同尺度卷积核的选择概率。
SK卷积操作：
- 在SK卷积操作中，根据SK模块生成的权重，动态地选择不同尺寸的卷积核来对输入特征图进行卷积操作。
- 对于每个位置，根据SK模块生成的权重，选择相应尺寸的卷积核，并在该位置上进行卷积操作。
- 通常，SK卷积操作可以在单个卷积层中实现，但也可以通过串联多个卷积层来实现。
SK融合：
- 在SK融合阶段，将不同尺寸卷积核的输出进行融合，以产生最终的特征图。
- 通常，可以采用加权求和或者拼接的方式来融合不同尺寸卷积核的输出。
- 在加权求和的情况下，使用SK模块生成的权重来对不同尺寸卷积核的输出进行加权求和。
- 在拼接的情况下，将不同尺寸卷积核的输出在通道维度上拼接起来，形成最终的特征图。

这些步骤的关键是引入了一个选择性的机制，使得网络可以动态地选择不同尺寸的卷积核，从而更好地捕获局部和全局特征。这样的设计使得SKconv在处理不同尺度的目标时更加灵活和有效。

2.2 更改init.py文件

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

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

2.3 在task.py中进行注册

关键步骤三：在parse_model函数中进行注册，添加SKConv,

2.4 添加yaml文件

关键步骤四：在/ultralytics/ultralytics/cfg/models/11下面新建文件yolo11_skconv.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, Conv, [128, 3, 2]] # 1-P2/4
  - [-1, 2, C3k2, [256, False, 0.25]]
  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  - [-1, 2, C3k2, [512, False, 0.25]]
  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  - [-1, 1, SKConv, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]] # 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)

# 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, Conv, [128, 3, 2]] # 1-P2/4
  - [-1, 2, C3k2, [256, False, 0.25]]
  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  - [-1, 2, C3k2, [512, False, 0.25]]
  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  - [-1, 1, SKConv, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]] # 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, OBB, [nc, 1]] # Detect(P3, P4, P5)

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

# YOLO11n
depth_multiple: 0.50  # model depth multiple
width_multiple: 0.25  # layer channel multiple
max_channel：1024
 
# YOLO11s
depth_multiple: 0.50  # model depth multiple
width_multiple: 0.50  # layer channel multiple
max_channel：1024
 
# YOLO11m
depth_multiple: 0.50  # model depth multiple
width_multiple: 1.00  # layer channel multiple
max_channel：512
 
# YOLO11l 
depth_multiple: 1.00  # model depth multiple
width_multiple: 1.00  # layer channel multiple
max_channel：512 
 
# YOLO11x
depth_multiple: 1.00  # model depth multiple
width_multiple: 1.50 # layer channel multiple
max_channel：512

2.5 执行程序

关键步骤五：在ultralytics文件中新建train.py，将model的参数路径设置为yolo11_skconv.yaml的路径即可

from ultralytics import YOLO
import warnings
warnings.filterwarnings('ignore')
from pathlib import Path
 
if __name__ == '__main__':
 
 
    # 加载模型
    model = YOLO("ultralytics/cfg/11/yolo11.yaml")  # 你要选择的模型yaml文件地址
    # Use the model
    results = model.train(data=r"你的数据集的yaml文件地址",
                          epochs=100, batch=16, imgsz=640, workers=4, name=Path(model.cfg).stem)  # 训练模型

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

                   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      6640  ultralytics.nn.modules.block.C3k2            [32, 64, 1, False, 0.25]
  3                  -1  1     36992  ultralytics.nn.modules.conv.Conv             [64, 64, 3, 2]
  4                  -1  1     26080  ultralytics.nn.modules.block.C3k2            [64, 128, 1, False, 0.25]
  5                  -1  1    147712  ultralytics.nn.modules.conv.Conv             [128, 128, 3, 2]
  6                  -1  1    164416  ultralytics.nn.modules.conv.SKConv           [128, 128, True]
  7                  -1  1    295424  ultralytics.nn.modules.conv.Conv             [128, 256, 3, 2]
  8                  -1  1    346112  ultralytics.nn.modules.block.C3k2            [256, 256, 1, True]
  9                  -1  1    164608  ultralytics.nn.modules.block.SPPF            [256, 256, 5]
 10                  -1  1    249728  ultralytics.nn.modules.block.C2PSA           [256, 256, 1]
 11                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']
 12             [-1, 6]  1         0  ultralytics.nn.modules.conv.Concat           [1]
 13                  -1  1    111296  ultralytics.nn.modules.block.C3k2            [384, 128, 1, False]
 14                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']
 15             [-1, 4]  1         0  ultralytics.nn.modules.conv.Concat           [1]
 16                  -1  1     32096  ultralytics.nn.modules.block.C3k2            [256, 64, 1, False]
 17                  -1  1     36992  ultralytics.nn.modules.conv.Conv             [64, 64, 3, 2]
 18            [-1, 13]  1         0  ultralytics.nn.modules.conv.Concat           [1]
 19                  -1  1     86720  ultralytics.nn.modules.block.C3k2            [192, 128, 1, False]
 20                  -1  1    147712  ultralytics.nn.modules.conv.Conv             [128, 128, 3, 2]
 21            [-1, 10]  1         0  ultralytics.nn.modules.conv.Concat           [1]
 22                  -1  1    378880  ultralytics.nn.modules.block.C3k2            [384, 256, 1, True]
 23        [16, 19, 22]  1    464912  ultralytics.nn.modules.head.Detect           [80, [64, 128, 256]]
YOLO11_SKConv summary: 296 layers, 2,701,456 parameters, 2,701,440 gradients, 6.8 GFLOPs

3.修改后的网络结构图

4. 完整代码分享

pan.bai【删】du.【删】com/s/1ybPkxdJje9PPahSmmZuTmA?pwd=seqs

提取码: seqs

5. GFLOPs

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

未改进的YOLO11n GFLOPs

改进后的GFLOPs

6. 进阶

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

7.总结

SKconv是一种图像处理中的卷积神经网络卷积层变体，其核心思想是引入选择性内核机制，允许网络动态地选择不同尺寸的卷积核，以捕获局部和全局特征之间的权衡。其关键流程包括构建SK模块、SK卷积操作和SK融合，通过全局池化、全连接层和softmax函数生成不同尺寸卷积核的选择权重，然后根据这些权重动态选择卷积核进行卷积操作，并最终通过加权求和或拼接融合不同尺寸卷积核的输出。SKconv提高了CNN模型对不同尺度特征的表达能力，增强了模型对图像的感知能力和识别性能，适用于图像分类、目标检测和语义分割等任务。