【YOLOv8改进-论文笔记】SCConv ：即插即用的空间和通道重建卷积

YOLO目标检测创新改进与实战案例专栏

专栏目录： YOLO有效改进系列及项目实战目录 包含卷积，主干 注意力，检测头等创新机制 以及 各种目标检测分割项目实战案例

专栏链接: YOLO目标检测创新改进与实战案例

摘要

卷积神经网络（CNNs）在各种计算机视觉任务中取得了显著的性能，但这是以巨大的计算资源为代价的，部分原因是卷积层提取了冗余特征。近期的研究要么压缩训练有素的大规模模型，要么探索设计精良的轻量级模型。在本文中，我们尝试利用特征之间的空间和通道冗余性来进行CNN压缩，并提出了一种高效的卷积模块，称为SCConv（空间和通道重构卷积），以减少冗余计算并促进代表性特征学习。所提出的SCConv由两个单元组成：空间重构单元（SRU）和通道重构单元（CRU）。SRU使用分离-重构方法来抑制空间冗余，而CRU使用分割-变换-融合策略来减少通道冗余。此外，SCConv是一个即插即用的架构单元，可以直接用于替换各种卷积神经网络中的标准卷积。实验结果表明，嵌入SCConv的模型能够通过减少冗余特征，在显著降低复杂性和计算成本的同时，达到更好的性能。

创新点

1. 空间重构单元（SRU）

2. 通道重构单元（CRU）

如下图，SCConv 由两个单元组成，即空间重构单元 (SRU) 和信道重构单元 (CRU) ，两个单元按顺序排列。输入的特征 X 先经过 空间重构单元 ，得到空间细化的特征Xw 。再经过 通道重构单元 ，得到通道提炼的特征 Y 作为输出。SCConv 模块利用了特征之间的空间冗余和信道冗余，模块可以无缝集成到任何 CNN 框架中，减少特征之间的冗余，提高 CNN 特征的代表性。

yoloV8引入SCConv

新建ultralytics/nn/modules/conv/ScConv.py

import torch
import torch.nn.functional as F
import torch.nn as nn
 
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):
        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):
        return self.act(self.bn(self.conv(x)))
 
    def forward_fuse(self, x):
        return self.act(self.conv(x))
 
 
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.gamma      = nn.Parameter( torch.randn(c_num, 1, 1)    )
        self.beta       = 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.gamma + self.beta
 
 
class SRU(nn.Module):
    def __init__(self,
                 oup_channels:int, 
                 group_num:int = 16,
                 gate_treshold:float = 0.5 
                 ):
        super().__init__()
        
        self.gn             = GroupBatchnorm2d( 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     = F.softmax(self.gn.gamma,dim=0)
        reweigts    = self.sigomid( gn_x * w_gamma )
        # Gate
        info_mask   = w_gamma>self.gate_treshold
        noninfo_mask= w_gamma<=self.gate_treshold
        x_1         = info_mask*reweigts * x
        x_2         = noninfo_mask*reweigts * x
        x           = self.reconstruct(x_1,x_2)
        return x
    
    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)
 

task.py 注册scconv

详见：https://blog.csdn.net/shangyanaf/article/details/135742727