YOLOv8改进 | Neck篇 | Slim-Neck替换特征融合层实现超级涨点 (又轻量又超级涨点)

一、本文介绍

本文给大家带来的改进机制是Slim-neck提出的Neck部分，Slim-neck是一种设计用于优化卷积神经网络中neck部分的结构。在我们YOLOv8中，neck是连接主干网络（backbone）和头部网络（head）的部分，负责特征融合和处理，以便提高检测的准确性和效率。亲测在小目标检测和大尺度目标检测的数据集上都有大幅度的涨点效果(mAP直接涨了大概有0.4左右。同时本文对Slim-Neck的框架原理进行了详细的分析，不光让大家会添加到自己的模型在写论文的时候也能够有一定的参照，最后本文会手把手教你添加Slim-Neck模块到网络结构中(值得一提的是这个Slim-neck还可以减少GFLOPs大概2修改完大概是8.0GFLOP所以非常适合轻量化的读者)。

(这里分析一下打分原因，推荐指数和涨点效果都是4克星，首先推荐指数是因为这是2022年的结构所以减少一分，但是大家可以根据这个结构进行一定的改进，毕竟其中的模块还是可以直接使用的，涨点效果0.4map还可以打4星)

推荐指数：⭐⭐⭐⭐

涨点效果：⭐⭐⭐⭐⭐

专栏回顾：YOLOv8改进系列专栏——本专栏持续复习各种顶会内容——科研必备

训练结果对比图->

这次试验我用的数据集大概有七八百张照片训练了150个epochs，虽然没有完全拟合但是效果有很高的涨点幅度，所以大家可以进行尝试毕竟不同的数据集上效果也可能差很多，同时我在后面给了多种yaml文件大家可以分别进行实验来检验效果。

可以看到这个涨点幅度mAP直接涨了大概有0.4左右，这个涨幅还可以，毕竟属于小的改进，重要的是大家能够从其中总结出来思想，能否提出一个新的Neck部分，没准下一个顶会文章就是你了，哈哈。

一、本文介绍

二、Slim-neck原理

2.1 Slim-neck的基本原理

2.2 GSConv的引入

2.3 模块元素

2.4 灵活性

三、 Slim-neck的完整代码

四、手把手教你添加Slim-neck模块

4.1 修改一

4.2 步骤二

4.3 步骤三

五、 Slim-neck的yaml文件

六、训练截图

五、本文总结

二、Slim-neck原理

论文地址：官方论文地址

代码地址：官方代码地址

2.1 Slim-neck的基本原理

Slim-neck是一种设计用于优化卷积神经网络（CNN）中“neck”部分的结构。在目标检测器中，"neck"是连接CNN的主干网络（backbone）和头部网络（head）的部分，负责特征融合和处理，以便提高检测的准确性和效率。

我们可以将Slim-neck的基本原理分为以下几点：

1. GSConv的引入：GSConv是为了在卷积神经网络（CNN）中加快图像的预测计算。在传统的CNN中，空间信息逐渐转换成通道信息，而这一过程在每一次特征图空间压缩和通道扩张时都会导致语义信息的部分丢失。GSConv旨在在保持较低时间复杂度的同时，尽可能地保留通道之间的隐藏连接。

2. 模块元素：GSConv之后，研究者继续引入GS瓶颈（GS bottleneck）和跨阶段部分网络（GSCSP）模块VoV-GSCSP，这些模块设计用于进一步提升性能。在实际应用中，更简单的结构模块由于更易于硬件实现，更有可能被采用。

3. 灵活性：论文提出了需要灵活使用GSConv、GS瓶颈和VoV-GSCSP这四个模块。可以像搭乐高一样构建Slim-neck层。

下面我为大家展示应用于YOLOv5模型的Slim-neck架构。这种架构使用了GSConv和VoV-GSCSP模块，以构建一个高效的神经网络“颈部”。在这个架构中，不同尺度的特征图（P3, P4, P5）首先通过GSConv模块处理，然后通过上采样（upsample）和拼接（Concat）操作与其他尺度的特征图结合。这样处理后的特征图再次通过GSConv模块，最后使用VoV-GSCSP模块来进一步提取和融合特征，以准备最终的检测头（head-1, head-2, head-3）进行目标检测。

通过这种模块化和分层的方法，Slim-neck架构能够在保持高准确度的同时减少计算复杂性和推理时间，这对于在自动驾驶车辆等计算资源受限的环境中的应用尤其重要。

2.2 GSConv的引入

GSConv的引入是为了解决在卷积神经网络（CNN）中预测计算的速度问题。在CNN的骨干网络（backbone）中，输入图像几乎总是经历一个类似的转换过程：空间信息逐步向通道传递。每一次特征图的空间（宽度和高度）压缩和通道扩张都会导致语义信息的部分丢失。通道密集型的卷积计算（SC）最大限度地保留了每个通道之间的隐含连接，而通道稀疏的卷积（DSC）则完全切断了这些连接。GSConv尽可能地保持这些连接，并且具有更低的时间复杂度。

上面提到的时间复杂度通常由浮点运算（FLOPs）来定义。因此，SC、DSC和GSConv的时间复杂度分别为：

- SC： $O(W \cdot H \cdot K_1 \cdot K_2 \cdot C_1 \cdot C_2)$
- DSC： $O(W \cdot H \cdot K_1 \cdot K_2 \cdot C_1)$
- GSConv： $O([W \cdot H \cdot K_1 \cdot K_2 \cdot C_2] / 2 \cdot (C_1 + 1))$

其中W是输出特征图的宽度，H是高度， $K_1 \cdot K_2$ 是卷积核的大小， $C_{1}$ 是每个卷积核的通道数，也是输入特征图的通道数， $C_{2}$ 是输出特征图的通道数。

下图为大家展示了GSConv模块的结构。

1. 卷积层（Conv）：输入特征图首先通过一个卷积层，该层的输出通道数为C2/2。

2. 深度可分离卷积层（DWConv）：该层标记为蓝色，表示深度可分离卷积（DSC）操作。它对输入特征图的每个通道独立进行卷积。

3. 拼接（Concat）：将Conv层和DWConv层的输出进行拼接。

4. 随机排列（Shuffle）：拼接后的特征图经过一个shuffle操作，以重新排列特征通道，提高特征间的信息流动。

5. 输出：最终输出的特征图有C2个通道。

我将通过下图为大家清晰展示标准卷积（SC）和深度可分离卷积（DSC）的计算过程。标准卷积是通道密集型的计算，而深度可分离卷积是通道稀疏的计算。

上图强调了在传统的标准卷积和现代轻量级深度可分离卷积之间的差异，其中后者在保持足够精确度的同时，减少了计算的复杂性，这对于计算资源受限的环境尤其有益。这种方法通常用于移动和边缘设备的神经网络架构中，以提高运行效率。

2.3 模块元素

模块元素是构成Slim-neck架构的基础部分，设计它们的目的是为了减少计算成本，同时保持或提高模型的学习能力。模块元素可以灵活使用，像搭积木一样组合成Slim-neck层，提供了构建高效深度学习模型的灵活性和效率

1. GSConv：是一种减少计算复杂性的轻量级卷积，它的计算成本约为标准卷积（SC）的一半，但在模型的学习能力方面与SC相当。

2. GS bottleneck：基于GSConv，这是一种增强模块，用于提高特征的非线性表达和信息的复用。

3. VoV-GSCSP：利用一次性聚合方法设计的跨阶段部分网络模块，用于在不同阶段的特征图之间进行有效的信息融合。

下图显示了GS bottleneck模块和VoV-GSCSP模块的结构：

(a) GS bottleneck模块，其中包含GSConv模块的一个或多个实例。 (b), (c), (d) 分别展示了不同设计方案的VoV-GSCSP模块。

GS bottleneck模块是为了进一步增强网络处理特征的能力，通过GSConv模块的堆叠来提高模型的学习能力。而VoV-GSCSP模块是利用不同的结构设计方案，以提高特征利用效率和网络性能。这些模块设计是Slim-neck理念的体现，旨在减少计算复杂性和推理时间，同时保持准确性。通过这样的模块化设计，可以根据需要灵活地构建出适合特定任务的网络架构。

2.4 灵活性

灵活性是指使用四种模块：GSConv、GS bottleneck和VoV-GSCSP，以及能够根据需要构建Slim-neck层的能力，类似于搭建乐高积木一样。这种灵活性允许研究者和工程师根据不同的需求和应用场景，调整和优化网络结构，从而实现特定目标的高效性和准确性。

三、 Slim-neck的完整代码

复制下面的代码在'ultralytics/nn/modules'目录下新建一个py文件粘贴进去，我这里的名字是Slimneck(大家注意不要带-否则会找不到文件的！！！)其它的具体使用方式看章节四。

import torch
import torch.nn as nn
import math


def autopad(k, p=None):  # kernel, padding
    # Pad to 'same'
    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
    def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True):  # ch_in, ch_out, kernel, stride, padding, groups
        super().__init__()
        self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g, bias=False)
        self.bn = nn.BatchNorm2d(c2)
        self.act = nn.Mish() if act else nn.Identity()

    def forward(self, x):
        return self.act(self.bn(self.conv(x)))

    def forward_fuse(self, x):
        return self.act(self.conv(x))


class GSConv(nn.Module):
    # GSConv https://github.com/AlanLi1997/slim-neck-by-gsconv
    def __init__(self, c1, c2, k=1, s=1, g=1, act=True):
        super().__init__()
        c_ = c2 // 2
        self.cv1 = Conv(c1, c_, k, s, None, g, act)
        self.cv2 = Conv(c_, c_, 5, 1, None, c_, act)

    def forward(self, x):
        x1 = self.cv1(x)
        x2 = torch.cat((x1, self.cv2(x1)), 1)
        b, n, h, w = x2.data.size()
        b_n = b * n // 2
        y = x2.reshape(b_n, 2, h * w)
        y = y.permute(1, 0, 2)
        y = y.reshape(2, -1, n // 2, h, w)

        return torch.cat((y[0], y[1]), 1)


class GSConvns(GSConv):
    # GSConv with a normative-shuffle https://github.com/AlanLi1997/slim-neck-by-gsconv
    def __init__(self, c1, c2, k=1, s=1, g=1, act=True):
        super().__init__(c1, c2, k=1, s=1, g=1, act=True)
        c_ = c2 // 2
        self.shuf = nn.Conv2d(c_ * 2, c2, 1, 1, 0, bias=False)

    def forward(self, x):
        x1 = self.cv1(x)
        x2 = torch.cat((x1, self.cv2(x1)), 1)
        # normative-shuffle, TRT supported
        return nn.ReLU(self.shuf(x2))


class GSBottleneck(nn.Module):
    # GS Bottleneck https://github.com/AlanLi1997/slim-neck-by-gsconv
    def __init__(self, c1, c2, k=3, s=1, e=0.5):
        super().__init__()
        c_ = int(c2*e)
        # for lighting
        self.conv_lighting = nn.Sequential(
            GSConv(c1, c_, 1, 1),
            GSConv(c_, c2, 3, 1, act=False))
        self.shortcut = Conv(c1, c2, 1, 1, act=False)

    def forward(self, x):
        return self.conv_lighting(x) + self.shortcut(x)


class DWConv(Conv):
    # Depth-wise convolution class
    def __init__(self, c1, c2, k=1, s=1, act=True):  # ch_in, ch_out, kernel, stride, padding, groups
        super().__init__(c1, c2, k, s, g=math.gcd(c1, c2), act=act)


class GSBottleneckC(GSBottleneck):
    # cheap GS Bottleneck https://github.com/AlanLi1997/slim-neck-by-gsconv
    def __init__(self, c1, c2, k=3, s=1):
        super().__init__(c1, c2, k, s)
        self.shortcut = DWConv(c1, c2, k, s, act=False)


class VoVGSCSP(nn.Module):
    # VoVGSCSP module with GSBottleneck
    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):
        super().__init__()
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c1, c_, 1, 1)
        self.gsb = nn.Sequential(*(GSBottleneck(c_, c_, e=1.0) for _ in range(n)))
        self.res = Conv(c_, c_, 3, 1, act=False)
        self.cv3 = Conv(2 * c_, c2, 1)  #

    def forward(self, x):
        x1 = self.gsb(self.cv1(x))
        y = self.cv2(x)
        return self.cv3(torch.cat((y, x1), dim=1))


class VoVGSCSPC(VoVGSCSP):
    # cheap VoVGSCSP module with GSBottleneck
    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):
        super().__init__(c1, c2)
        c_ = int(c2 * 0.5)  # hidden channels
        self.gsb = GSBottleneckC(c_, c_, 1, 1)

四、手把手教你添加Slim-neck模块

4.1 修改一

我们上面的代码复制粘贴到'ultralytics/nn/modules'目录下新建一个py文件粘贴进去，我这里的名字是Slimneck(大家注意不要带-否则会找不到文件的！！！)

4.2 步骤二

之后我们找到'ultralytics/nn/tasks.py'文件，在其中注册我们的slim-neck模块。

（这里需要注意的是我们用的是slim-neck中的VOVSCSP和GSConv模块）

首先我们需要在文件的开头导入我们的slim-neck中的VOVSCSP和GSConv模块，如下图所示->

4.3 步骤三

我们找到如下代码，按照我的进行添加即可。

到此就可以了，完成了注册然后只需要修改yaml文件就可以进行训练了~

五、 Slim-neck的yaml文件

我这里和官方的yaml文件给的一样，但是官方给的是yolov5的我进行了一定的转换，换成了YOLO

v8的。

# 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:
# slim-neck
  - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
  - [[-1, 6], 1, Concat, [1]]  # cat backbone P4
  - [-1, 3, VoVGSCSP, [512]]  # 12

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

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

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

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

六、训练截图

下面是训练成功的截图，证明这个模块的改进是没有毛病的~同时如果你用我的模块成功了，还是希望大家来给我的文章点赞和评论支持一下，这样我也好发更多的模块，而且我YOLOv8系列马上就停更了，我可能要去更v5了，之后文章如果大家有需要才会更新了，因为感觉v5看的人更多一些。

五、本文总结

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