YOLOv8目标检测算法改进之融合SCconv的特征提取方法

引言

YOLO目标检测算法历经发展，目前已经成为了目标检测领域的经典算法。当前，YOLO目标检测算法已经更新到YOLOv10，但从大家的反映来看,YOLOv10的效果并不理想（该算法的创新点是提升检测速度，并不提升精度，去除了NMS的后处理过程），YOLOv9则针对反向传播中距离远的模块学习效果差的问题，提出使用可编程梯度。那么博主今天为何要介绍YOLOv8呢，因为它实在是太好用了。

为什么要学习YOLOv8？

前面博主说YOLOv8好用，那么体现在哪里呢？
首先，相较于其他的YOLO目标检测算法，YOLOv8更像一个算法框架，他里面集成了从v3到v10的YOLO算法（毕竟他是要做一个YOLO的框架）以及RT-DETR，因此环境是通用的，方便我们做对比实验
其次，该框架没有拘泥于目标检测领域，他还包含了分类、分割、姿态估计、追踪等一系列计算机视觉任务。
最后，该算法框架其实都是在调包，改进起来十分简单，方便水创新点。（当然还是希望大家能够知其然知其所以然）
综上所述，无论是从发论文还是项目学习角度来看，YOLOv8真的非常适合大家去学习。

那么我们便开始YOLOv8的学习吧！

YOLOv8模型结构

下面是YOLOv8的模型结构，可以看到，YOLO目标检测模型的整体架构基本已经确定了，其包含骨干特征提取层（Backbone)，特征融合模块（Neck），检测头（Head）。

当然，今天博主并不是要讲这些模块的实现和原理，而是从源码的角度告诉大家该如何去改进算法。

从水论文的角度来看，改进较为简单的便是模块的增改，或是损失函数的替换（这里博主说的是直接用别人的成果，如果你自己提出了新的模块或损失函数的话那是非常厉害的），这种改进就是缝缝补补，没有什么创新的，但事实上，为了应对学业要求，很大部分人不得不采用这种方式去来水一篇论文。

那么，话不多说，我们开整！

添加SCConv模块

本章创新为融合SCconv的特征提取方法，顾名思义就是将SCconv模块融合到YOLOv8的骨干特征提取网络部分（backbone)，首先我们了解一些SCconv。

SCConv是CVPR2023收录的一个即插即用的空间和通道重建卷积模块，其结构如下：

SCconv论文下载地址

同时，在论文中也提供了实现代码：

'''
Description: 
Date: 2023-07-21 14:36:27
LastEditTime: 2023-07-27 18:41:47
FilePath: /chengdongzhou/ScConv.py
'''
import torch
import torch.nn.functional as F
import torch.nn as nn 


class GroupBatchnorm2d(nn.Module):
    def __init__(self, c_num:int, 
                 group_num:int = 16, 
                 eps:float = 1e-10
                 ):
        super(GroupBatchnorm2d,self).__init__()
        assert c_num    >= group_num
        self.group_num  = group_num
        self.weight     = nn.Parameter( torch.randn(c_num, 1, 1)    )
        self.bias       = nn.Parameter( torch.zeros(c_num, 1, 1)    )
        self.eps        = eps
    def forward(self, x):
        N, C, H, W  = x.size()
        x           = x.view(   N, self.group_num, -1   )
        mean        = x.mean(   dim = 2, keepdim = True )
        std         = x.std (   dim = 2, keepdim = True )
        x           = (x - mean) / (std+self.eps)
        x           = x.view(N, C, H, W)
        return x * self.weight + self.bias


class SRU(nn.Module):
    def __init__(self,
                 oup_channels:int, 
                 group_num:int = 16,
                 gate_treshold:float = 0.5,
                 torch_gn:bool = True
                 ):
        super().__init__()
        
        self.gn             = nn.GroupNorm( num_channels = oup_channels, num_groups = group_num ) if torch_gn else GroupBatchnorm2d(c_num = oup_channels, group_num = group_num)
        self.gate_treshold  = gate_treshold
        self.sigomid        = nn.Sigmoid()

    def forward(self,x):
        gn_x        = self.gn(x)
        w_gamma     = self.gn.weight/sum(self.gn.weight)
        w_gamma     = w_gamma.view(1,-1,1,1)
        reweigts    = self.sigomid( gn_x * w_gamma )
        # Gate
        w1          = torch.where(reweigts > self.gate_treshold, torch.ones_like(reweigts), reweigts) # 大于门限值的设为1，否则保留原值
        w2          = torch.where(reweigts > self.gate_treshold, torch.zeros_like(reweigts), reweigts) # 大于门限值的设为0，否则保留原值
        x_1         = w1 * x
        x_2         = w2 * x
        y           = self.reconstruct(x_1,x_2)
        return y
    
    def reconstruct(self,x_1,x_2):
        x_11,x_12 = torch.split(x_1, x_1.size(1)//2, dim=1)
        x_21,x_22 = torch.split(x_2, x_2.size(1)//2, dim=1)
        return torch.cat([ x_11+x_22, x_12+x_21 ],dim=1)


class CRU(nn.Module):
    '''
    alpha: 0<alpha<1
    '''
    def __init__(self, 
                 op_channel:int,
                 alpha:float = 1/2,
                 squeeze_radio:int = 2 ,
                 group_size:int = 2,
                 group_kernel_size:int = 3,
                 ):
        super().__init__()
        self.up_channel     = up_channel   =   int(alpha*op_channel)
        self.low_channel    = low_channel  =   op_channel-up_channel
        self.squeeze1       = nn.Conv2d(up_channel,up_channel//squeeze_radio,kernel_size=1,bias=False)
        self.squeeze2       = nn.Conv2d(low_channel,low_channel//squeeze_radio,kernel_size=1,bias=False)
        #up
        self.GWC            = nn.Conv2d(up_channel//squeeze_radio, op_channel,kernel_size=group_kernel_size, stride=1,padding=group_kernel_size//2, groups = group_size)
        self.PWC1           = nn.Conv2d(up_channel//squeeze_radio, op_channel,kernel_size=1, bias=False)
        #low
        self.PWC2           = nn.Conv2d(low_channel//squeeze_radio, op_channel-low_channel//squeeze_radio,kernel_size=1, bias=False)
        self.advavg         = nn.AdaptiveAvgPool2d(1)

    def forward(self,x):
        # Split
        up,low  = torch.split(x,[self.up_channel,self.low_channel],dim=1)
        up,low  = self.squeeze1(up),self.squeeze2(low)
        # Transform
        Y1      = self.GWC(up) + self.PWC1(up)
        Y2      = torch.cat( [self.PWC2(low), low], dim= 1 )
        # Fuse
        out     = torch.cat( [Y1,Y2], dim= 1 )
        out     = F.softmax( self.advavg(out), dim=1 ) * out
        out1,out2 = torch.split(out,out.size(1)//2,dim=1)
        return out1+out2


class ScConv(nn.Module):
    def __init__(self,
                op_channel:int,
                group_num:int = 4,
                gate_treshold:float = 0.5,
                alpha:float = 1/2,
                squeeze_radio:int = 2 ,
                group_size:int = 2,
                group_kernel_size:int = 3,
                 ):
        super().__init__()
        self.SRU = SRU( op_channel, 
                       group_num            = group_num,  
                       gate_treshold        = gate_treshold )
        self.CRU = CRU( op_channel, 
                       alpha                = alpha, 
                       squeeze_radio        = squeeze_radio ,
                       group_size           = group_size ,
                       group_kernel_size    = group_kernel_size )
    
    def forward(self,x):
        x = self.SRU(x)
        x = self.CRU(x)
        return x


if __name__ == '__main__':
    x       = torch.randn(1,32,16,16)
    model   = ScConv(32)
    print(model(x).shape)

当然，博主在这里并不是要对SCconv的结构抑或是背后的逻辑进行解读，博主只是想告诉大家如何将该模块应用到YOLOv8（当然也可以是任意一个YOLOv8里集成的模型），其实，要做到这一点并不难，大家按照这个步骤来即可：

确定添加位置

对于这样的模块，我们一般会将其添加到骨干特征提取模块（Backbone），当然这个位置任意，只要效果好了即可，这里博主选择Backbone中的Conv与 C2f 模块后面。
这里顺带对模型的配置文件进行讲解，其遵循如下定义规则：

[from, repeats, module, args]表示层的来源、重复次数、模块类型和参数。

backbone:
  # [from, repeats, module, args]
  - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2  -1代表将上层的输入作为本层的输入。第0层的输入是640*640*3的图像。Conv代表卷积层，相应的参数：64代表输出通道数，3代表卷积核大小k，2代表stride步长。 
  - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
  - [-1, 3, C2f, [128, True]]#C2f模块，3代表本层重复3次。128代表输出通道数，True表示Bottleneck有shortcut。
  - [-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

我们首先开启一次训练，看下其结构，我打算将SCconv模块加入到Conv与C2f之间

可以看到，模块的输入维度是由上一个模块的输出维度所确定的，以C2f模块为例，其输入维度即为Conv的输出维度64，那么我们要将SCConv模块加入到Conv与C2f之间的话，就需要让SCConv的输入维度为64（对应Conv的输出维度），让SCConv的输出维度为64（对应C2f的输入维度）

确定模块的输入输出

在确定了Conv与C2f模块的关联后，我们就需要让SCConv与其进行适配了，首先通过代码来模拟一下其结果：

if __name__ == '__main__':
    x       = torch.randn(1,256,80,80)
    model   = ScConv(256)
    print(model(x).shape)

输出结果为：torch.Size([1, 256, 80, 80])，即输入输出前后没有发生维度上的变化，符合要求。

创建SCConv类

接下来便是如何修改代码，从而让该模块与YOLOv8相融合了
我们在首先在如下文件夹下新建一个mine.py，这个名字随便起，随后将SCConv的代码粘贴到该文件中。

添加引用（可跳过）

当然如果你想要更规范的话，可以将代码粘贴到\ultralytics\nn\modules\block.py文件中，并
在ultralytics/nn/modules/init.py文件中加入引用，这看你个人要求。

from .block import (
    C1,
    C2,
    C3,
    C3TR,
    DFL,
    SPP,
    SPPELAN,
    SPPF,
    ADown,
    BNContrastiveHead,
    Bottleneck,
    BottleneckCSP,
    C2f,
    C2fAttn,
    C3Ghost,
    C3x,
    CBFuse,
    CBLinear,
    ContrastiveHead,
    GhostBottleneck,
    HGBlock,
    HGStem,
    ImagePoolingAttn,
    Proto,
    RepC3,
    RepNCSPELAN4,
    ResNetLayer,
    Silence,
    ScConv,
)
__all__ = (
    "Conv",
    "Conv2",
    "LightConv",
    "RepConv",
    "DWConv",
    "DWConvTranspose2d",
    "ConvTranspose",
    "Focus",
    "GhostConv",
    "ChannelAttention",
    "SpatialAttention",
    "CBAM",
    "Concat",
    "TransformerLayer",
    "TransformerBlock",
    "MLPBlock",
    "LayerNorm2d",
    "DFL",
    "HGBlock",
    "HGStem",
    "SPP",
    "SPPF",
    "C1",
    "C2",
    "C3",
    "C2f",
    "C2fAttn",
    "C3x",
    "C3TR",
    "C3Ghost",
    "GhostBottleneck",
    "Bottleneck",
    "BottleneckCSP",
    "Proto",
    "Detect",
    "Segment",
    "Pose",
    "Classify",
    "TransformerEncoderLayer",
    "RepC3",
    "RTDETRDecoder",
    "AIFI",
    "DeformableTransformerDecoder",
    "DeformableTransformerDecoderLayer",
    "MSDeformAttn",
    "MLP",
    "ResNetLayer",
    "OBB",
    "WorldDetect",
    "ImagePoolingAttn",
    "ContrastiveHead",
    "BNContrastiveHead",
    "RepNCSPELAN4",
    "ADown",
    "SPPELAN",
    "CBFuse",
    "CBLinear",
    "Silence",
    "ScConv",#all中加入引用
)

随后在tasks.py中引入SCConv模块，让配置文件知道该去哪里读取：

from ultralytics.nn.modules.mine import ScConv

修改模型结构

随后只需要修改对应的yaml配置文件即可：

    [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  - [-1, 1, ScConv, [64]]
  - [-1, 6, C2f, [256, True]]

至此，修改便完成了，是不是非常简单，然后我们训练一下看看是否能够跑通？
在加载模型时，发现只能加载一个，即我们修改了yaml文件，就不能只有YOLOv8的预训练模型，由于模型将重头开始训练，这是十分令人苦恼的。

随后开启训练，根据下面的网络层数，参数量以及GFLOPs来看，加入了SCconv模块后的计算复杂度提升了很多，这就需要更多的计算资源。

我们首先给出YOLOv8在不使用任何改进情况下的结果，可以看到仅仅是训练34个epoch，其mAP便达到了一个较好的结果。

由于没有使用预训练模型，因此刚开始的训练效果很差

随着训练轮次的增加，其效果开始提升：

Closing dataloader mosaic
最终的训练结果如下：

从结果来看，似乎并不太理想，当然这很大程度上是由于博主没有使用YOLOv8的预训练模型所导致的。

随后，博主让其加载了YOLOv8的预训练权重:

	from ultralytics import YOLO
    model = YOLO("/ultralytics\cfg\models/v8\yolov8.yaml")  # build a new model from YAML
    model.load("yolov8n.pt")
    results = model.train(data="/ultralytics\cfg\datasets\cocomine.yaml", epochs=100, imgsz=640,batch=8,workers=2)

由开始的训练效果可知，使用了预训练模型后，起点高了那么一点，至于最终的效果，敬请期待。

最终使用权重文件的结果如下，可以看到效果也并不好，这就说明融合SCconv的创新还有待考量，毕竟，创新提升效果并不容易。

总结

经过上述过程，我们便将SCconv模块插入到了YOLOv8模型中，当然这个改进是十分简单的，我们可以对SCconv模块再进行改进，让其更加的适配YOLOv8检测模型，同时我们需要记住的是，写一篇论文不但要求你的创新点要新颖，如何去描述你的创新更是重中之重，正所谓做的好不如说的好（博主还是希望能够既做的好，又说得好）。