深入浅出之CSPNet网络

一、提出背景

CSPNet（Cross Stage Partial Network）的提出背景主要源于对现有计算机视觉模型的分析和挑战。在计算资源受限的情况下，轻量级神经网络模型越来越受到关注，但这类模型在轻量化的同时往往会牺牲模型的准确性。此外，现有的模型在推断过程中存在计算瓶颈和内存开销较大的问题，这限制了模型在嵌入式设备和边缘计算平台上的应用。CSPNet旨在解决这些问题，通过优化网络结构和计算流程，提高轻量级模型的学习能力，以在保持较高准确性的同时实现轻量化。

在本文中，作者提出了跨阶段局部网络(CSPNet)，用来缓解以往工作需要从网络架构角度进行大量推理计算的问题，作者把这个问题归结为网络优化中的「重复梯度信息」。

CSPNet通过整合网络阶段开始和结束的特征图来尊重梯度的可变性，在我们的实验中，该方法减少了20%的计算量，在ImageNet数据集上具有相当、甚至更高的精度，并且在MS COCO目标检测数据集上的AP50方面显著优于最先进的方法。

除此之外，CSPNet易于实现，并且足够通用，可以处理基于「ResNet」、「ResNeXt」和「DenseNet」的体系结构。
 

二、时间与作者

CSPNet由Chien-Yao Wang等人在2019年提出，并发表在论文《CSPNET: A NEW BACKBONE THAT CAN ENHANCE LEARNING CAPABILITY OF CNN》中。

三、主要贡献

 设计CSPNet的主要目的是使该体系结构能够实现「更丰富的梯度组合，同时减少计算量」。通过将基础层的特征图划分为两个部分，然后通过提出的跨阶段层次结构将它们合并，可以实现此目标。

「作者的主要想法」是通过分割梯度流，使梯度流通过不同的网络路径传播。通过切换串联和过渡步骤，传播的梯度信息可以具有较大的相关性差异。此外，CSPNet可以大大减少计算量，并提高推理速度和准确性，如图1所示。

CSPNet的主要贡献包括：

1. 「增强了CNN的学习能力」。现有的CNN经过轻量化后，其准确性大大降低，所以作者希望加强CNN的学习能力，使其在轻量化的同时保持足够的准确性。所提出的CSPNet可以很容易地应用于ResNet、ResNeXt和DenseNet。将CSPNet应用于上述网络后，计算量从10%减少到20%，但在精度方面，在ImageNet上进行图像分类任务时，其表现优于ResNet、ResNeXt、DenseNet、HarDNet等一流的算法。
2. 「消除计算瓶颈」。过高的计算瓶颈将导致更多的周期来完成推理过程，否则一些算术单元将经常空闲。因此，作者希望在CNN中能够将每一层的计算量平均分配，从而有效的提高每一个计算单元的利用率，减少不必要的能源消耗。注意到所提出的CSPNet使PeleeNet的计算瓶颈减半。此外，在基于MS COCO数据集的目标检测实验中，该模型在基于YOLOv3的模型上测试时，可以有效地减少80%的计算瓶颈。
3. 「减少内存成本」。动态随机存取存储器(DRAM)的晶圆制造成本非常高，同时也占用大量的空间。如果能有效降低存储成本，将大大降低ASIC的成本。此外，小面积晶圆可以用于各种边缘计算设备。为了减少内存使用，在特征金字塔生成过程中，作者采用了跨通道的[6]pooling 来压缩特征映射。这样，在生成特征金字塔时，使用目标检测器的CSPNet可以减少PeleeNet 75%的内存使用。

四、网络结构

CSPNet的网络结构主要包括跨阶段部分连接（CSPBlock）模块。CSPBlock将基础层的特征图划分成两部分，一部分经过密集连接（Dense Connection）处理，另一部分则直接进行卷积操作。然后将这两部分的输出进行合并，形成最终的特征图。这种设计既保留了DenseNet重用特征特性的优点，又通过截断梯度流防止了过多的重复梯度信息。

4.1 CSP结构

论文提出Cross Stage Partial（CSP）结构，其初衷是减少计算量并且增强梯度的表现。主要思想是：在输入block之前，将输入分为两个部分，其中一部分通过block进行计算，另一部分直接通过一个shortbut进行concatenate。

作者基于Dense block（对DenseNet结构不了解的同学可以查看我以前的文章）讲述了CSP的结构，如下图：

图片来自于论文

上图中，上者为原始的Dense Block，下者为Partial Dense Block。假设将输入按照part_ratio=0.5的比例分成两部分，并且假设一个Dense Block的输入为w *h* c，growth rate为 d，Dense block的layer数量为m，则：对于原始的DenseBlock，其CIO为（Convolutional input/Output）为cm + [(mm+m)d]/2；而对于使用了CSP结构的结构来说，其CIO下降为[cm + (mm+m)d]/2。

作者在论文阐述了CSP结构的优点:

（1）加强CNN的学习能力；

（2）减少计算瓶颈，现在的网络大多计算代价昂贵，不利于工业的落地；

（3）减少内存消耗。

4.2 关于Partial Transition Layer

关于Patial Transition Layer，论文提出了三种不同的结构，如下图：

图片来自论文

Transition layer的含义同DenseNet，是一组1x1的卷积层。上图中，不同类型的transition layer决定了梯度的结构方式，并且各有其优势：

（c）图Fusion First的先将两个部分进行concatenate，然后再进行输入到Transion layer中，采用这种做法会是的大量特梯度信息被重用，有利于网络学习；

（d）图中Fusion Last先将部分特征输入Transition layer，然后再进行concatenate，这样做损失了部分的梯度重用，但是由于Transition的输入维度比（c）图少，大大减少计算复杂度。论文中CSPNet采用的是图（b）中的结构，其结合了（c）（d）的结合，进一步提升了学习能力，但是也进一步提高了一些计算复杂度。 作者在论文中给出其使用不同Partial Transition Layer的实验结果，如下图。具体使用哪种结构可以根据条件和使用场景进行调整。

图片来自论文

 

五、特点

CSPNet的特点可以归纳为以下几点：

1. 跨阶段部分连接：通过CSPBlock模块实现跨阶段的特征融合，提高了模型的学习能力。
2. 轻量化与高效性：在保证模型准确性的同时，实现了模型的轻量化，并提高了推断速度。
3. 灵活性：CSPNet可以轻松地整合到现有的深度学习架构中，适应不同的任务需求。
4. 减少梯度重用：通过截断梯度流，减少了不同层之间梯度信息的重复利用，提高了模型的训练效率。

六、优缺点

优点：

• 提高了轻量级模型的准确性。
• 降低了计算复杂度和内存占用。
• 通用性强，适用于多种计算机视觉任务。

缺点：

• 相对于一些更复杂的模型，CSPNet在极端复杂场景下的性能可能略有不足。
• 在某些特定任务上，可能需要结合其他技术或方法进行优化。

七、  pytorch实现CSP-DenseNet，CSP-ResNeXt

7.1 CSP-DenseNet

CSPNet沿用网络的Architecture，只是对于基础block进行改造，根据之前博客介绍的DenseNet结构修改相应代码即可实现。

7.1.1 Partial Dense block

沿用之前介绍DenseNet写的Dense Block代码：

class DenseBlock(nn.Module):

    def __init__(self, input_channels, num_layers, growth_rate):
        super(DenseBlock, self).__init__()
        self.num_layers = num_layers
        self.k0 = input_channels
        self.k = growth_rate
        self.layers = self.__make_layers()

    def __make_layers(self):
        layer_list = []
        for i in range(self.num_layers):
            layer_list.append(nn.Sequential(
                BN_Conv2d(self.k0 + i * self.k, 4 * self.k, 1, 1, 0),
                BN_Conv2d(4 * self.k, self.k, 3, 1, 1)
            ))
        return layer_list

    def forward(self, x):
        feature = self.layers[0](x)
        out = torch.cat((x, feature), 1)
        for i in range(1, len(self.layers)):
            feature = self.layers[i](out)
            out = torch.cat((feature, out), 1)
        return out

Partial Dense Block的实现：

class CSP_DenseBlock(nn.Module):

    def __init__(self, in_channels, num_layers, k, part_ratio=0.5):
        super(CSP_DenseBlock, self).__init__()
        self.part1_chnls = int(in_channels * part_ratio)
        self.part2_chnls = in_channels - self.part1_chnls
        self.dense = DenseBlock(self.part2_chnls, num_layers, k)
        # trans_chnls = self.part2_chnls + k * num_layers
        # self.transtion = BN_Conv2d(trans_chnls, trans_chnls, 1, 1, 0)

    def forward(self, x):
        part1 = x[:, :self.part1_chnls, :, :]
        part2 = x[:, self.part1_chnls:, :, :]
        part2 = self.dense(part2)
        # part2 = self.transtion(part2)
        out = torch.cat((part1, part2), 1)
        return out

上面的代码采用的是Fusion Last的Partial transition layer，取消其中的三行注释就是论文中采用的Partial transition layer。由于，我之前的Transition layer是写在整体网络结构中，没有放在block中，所以就不实现Fusion first的形式了。

7.1.2 网络整体结构

在之前原始的DenseNet结构的基础上进行修改，增加一个partion-ratio参数来控制使用的block结构和通道划分的比例就可以了，代码：

class DenseNet(nn.Module):

    def __init__(self, layers: object, k, theta, num_classes, part_ratio=0) -> object:
        super(DenseNet, self).__init__()
        # params
        self.layers = layers
        self.k = k
        self.theta = theta
        self.Block = DenseBlock if part_ratio == 0 else CSP_DenseBlock   # 通过part_tatio参数控制block type
        # layers
        self.conv = BN_Conv2d(3, 2 * k, 7, 2, 3)
        self.blocks, patches = self.__make_blocks(2 * k)
        self.fc = nn.Linear(patches, num_classes)

    def __make_transition(self, in_chls):
        out_chls = int(self.theta * in_chls)
        return nn.Sequential(
            BN_Conv2d(in_chls, out_chls, 1, 1, 0),
            nn.AvgPool2d(2)
        ), out_chls

    def __make_blocks(self, k0):
        """
        make block-transition structures
        :param k0:
        :return:
        """
        layers_list = []
        patches = 0
        for i in range(len(self.layers)):
            layers_list.append(self.Block(k0, self.layers[i], self.k))
            patches = k0 + self.layers[i] * self.k  # output feature patches from Dense Block
            if i != len(self.layers) - 1:
                transition, k0 = self.__make_transition(patches)
                layers_list.append(transition)
        return nn.Sequential(*layers_list), patches

    def forward(self, x):
        out = self.conv(x)
        out = F.max_pool2d(out, 3, 2, 1)
        # print(out.shape)
        out = self.blocks(out)
        # print(out.shape)
        out = F.avg_pool2d(out, 7)
        # print(out.shape)
        out = out.view(out.size(0), -1)
        out = F.softmax(self.fc(out))
        return out


def csp_densenet_121(num_classes=1000):
    return DenseNet([6, 12, 24, 16], k=32, theta=0.5, num_classes=num_classes, part_ratio=0.5)


def csp_densenet_169(num_classes=1000):
    return DenseNet([6, 12, 32, 32], k=32, theta=0.5, num_classes=num_classes, part_ratio=0.5)


def csp_densenet_201(num_classes=1000):
    return DenseNet([6, 12, 48, 32], k=32, theta=0.5, num_classes=num_classes, part_ratio=0.5)


def csp_densenet_264(num_classes=1000):
    return DenseNet([6, 12, 64, 48], k=32, theta=0.5, num_classes=num_classes, part_ratio=0.5)

7.2 CSP-ResNeXt

论文也给出了CSP-ResNet结构。我们知道在ResNeXt的实现中，若groups设置为1，就和ResNet结构相似，这里仅搭建CSP-ResNeXt。

图片来自论文
讨论：论文中提到由于输入的通道减半了，CSPNet不需要使用bottleneck结构了。但是我查看DarkNet框架下的网络参数，发现还是1x1,3x3,1x1的组合结构。有点纳闷，不知道我是不是对bottleneck结构有误解。可能作者指的是bottleneck指的是输出通道比输入通道数量要少的卷积层。
作者给的code链接是darknet框架下的cfg参数，由于我不熟悉这个框架，有点看不清楚。 这里，我是按照论文的思想和自己理解搭建CSP-ResNeXt，网络输入尺寸和整体结构仍沿用ResNeXt的,不是论文实验确实采用的确切网络结构，谨供参考和了解思路。

我们再回顾一下ResNeXt的整体结构，之前博客的传送门：

图片来自ResNeXt论文

ResNeXt的主题是一些不同尺寸的block组成的，共4组，以ResNeXt-53为例，每组blocks的数量分别为[3, 4, 6, 3]。根据CSPNet的思想去除bottleneck结构，采用Fusion First和Fusion Last的模式。针对每一组，可以设计如下的结构：

图片来源：自己画的~

由上图，之前ResNeXt中Residual block中的最后一层1x1滤波器数量进行了2倍的expansion，这里改成三层均是一样的数量，那么我们根据这个结构进行编码。

再次提醒，这个复现不是SoAT算法所用的确切CSPResNet。但是其block结构符合上图中CSPNet的基本思想，整体架构沿用ResNet架构——虽然目前不准备实验验证，但我想它应该具有一定精度。

7.2.0 BN_CONV_LeakyReLU

参考作者，激活函数采用了LeakyReLU，但在一些目标检测框架中会用Mish作为激活函数，以更高的计算代价获取网络更好的收敛性。

class BN_Conv2d_Leaky(nn.Module):
    """
    BN_CONV_LeakyRELU
    """

    def __init__(self, in_channels: object, out_channels: object, kernel_size: object, stride: object, padding: object,
                 dilation=1, groups=1, bias=False) -> object:
        super(BN_Conv2d_Leaky, self).__init__()
        self.seq = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride,
                      padding=padding, dilation=dilation, groups=groups, bias=bias),
            nn.BatchNorm2d(out_channels)
        )

    def forward(self, x):
        return F.leaky_relu(self.seq(x))

2.2.1 Residual block

在这里，将最后一层1x1的数量改为和之前两层一致。在shortcut的实现上，我用均值池化来应对stride不为1的情况，因为感觉我之前在ResNeXt写的在1x1卷积的时候设置stride处理方式会损失一定的输入信息。 代码如下：

class ResidualBlock(nn.Module):
    """
    Residual block for CSP-ResNeXt
    """
    def __init__(self, in_channels, cardinality, group_width, stride=1):
        super(ResidualBlock, self).__init__()
        self.out_channels = cardinality * group_width
        self.conv1 = BN_Conv2d_Leaky(in_channels, self.out_channels, 1, 1, 0)
        self.conv2 = BN_Conv2d_Leaky(self.out_channels, self.out_channels, 3, stride, 1, groups=cardinality)
        self.conv3 = nn.Conv2d(self.out_channels, self.out_channels, 1, 1, 0)
        self.bn = nn.BatchNorm2d(self.out_channels)

        # make shortcut
        layers = []
        if in_channels != self.out_channels:
            layers.append(nn.Conv2d(in_channels, self.out_channels, 1, 1, 0))
            layers.append(nn.BatchNorm2d(self.out_channels))
        if stride != 1:
            layers.append(nn.AvgPool2d(stride))
        self.shortcut = nn.Sequential(*layers)

    def forward(self, x):
        out = self.conv3(self.conv2(self.conv1(x)))
        out = self.bn(out)
        out += self.shortcut(x)
        return F.leaky_relu(out)

7.2.3 网络Architecture

1、把上图中设计的结构作为一个整体来实现，称之为Stem，代码如下：

class Stem(nn.Module):
    def __init__(self, in_channels, num_blocks, cardinality, group_with, stride=2):
        super(Stem, self).__init__()
        self.c0 = in_channels // 2
        self.c1 = in_channels - in_channels // 2
        self.hidden_channels = cardinality * group_with
        self.out_channels = self.hidden_channels * 2
        self.transition = BN_Conv2d_Leaky(self.hidden_channels, in_channels, 1, 1, 0) # to match channel size
        self.trans_part0 = nn.Sequential(BN_Conv2d_Leaky(self.c0, self.hidden_channels, 1, 1, 0), nn.AvgPool2d(stride))
        self.block = self.__make_block(num_blocks, self.c1, cardinality, group_with, stride)
        self.trans_part1 = BN_Conv2d_Leaky(self.hidden_channels, self.hidden_channels, 1, 1, 0)
        self.trans = BN_Conv2d_Leaky(self.out_channels, self.out_channels, 1, 1, 0)

    def __make_block(self, num_blocks, in_channels, cardinality, group_with, stride):
        strides = [stride] + [1] * (num_blocks-1)
        channels = [in_channels] + [self.hidden_channels] * (num_blocks-1)
        return nn.Sequential(*[ResidualBlock(c, cardinality, group_with, s)
                               for c, s in zip(channels, strides)])

    def forward(self, x):
        x = self.transition(x)   # to match channels
        x0 = x[:, :self.c0, :, :]
        x1 = x[:, self.c0:, :, :]
        out0 = self.trans_part0(x0)
        out1 = self.trans_part1(self.block(x1))
        out = torch.cat((out0, out1), 1)
        return self.trans(out)

2、以下代码提供了CSP-ResNeXt的架构以及CSP-ResNeXt-53(32x4d)的接口：

class CSP_ResNeXt(nn.Module):
    def __init__(self, num_blocks, cadinality, group_width, num_classes):
        super(CSP_ResNeXt, self).__init__()
        self.conv0 = BN_Conv2d_Leaky(3, 64, 7, 2, 3)
        self.pool1 = nn.MaxPool2d(3, 2, 1)
        self.conv1 = BN_Conv2d_Leaky(64, 128, 1, 1, 0)
        self.stem0 = Stem(cadinality*group_width*2, num_blocks[0], cadinality, group_width, stride=1)
        self.stem1 = Stem(cadinality*group_width*4, num_blocks[1], cadinality, group_width*2)
        self.stem2 = Stem(cadinality*group_width*8, num_blocks[2], cadinality, group_width*4)
        self.stem3 = Stem(cadinality*group_width*16, num_blocks[3], cadinality, group_width*8)
        self.global_pool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(cadinality*group_width*16, num_classes)

    def forward(self, x):
        out = self.conv0(x)
        out = self.pool1(out)
        out = self.conv1(out)
        out = self.stem0(out)
        out = self.stem1(out)
        out = self.stem2(out)
        out = self.stem3(out)
        out = self.global_pool(out)
        out = out.view(out.size(0), -1)
        out = self.fc(out)
        return F.softmax(out)


def csp_resnext_50_32x4d(num_classes=1000):
    return CSP_ResNeXt([3, 4, 6, 3], 32, 4, num_classes)

3、搭建完毕，测试网络：

net = csp_resnext_50_32x4d()
summary(net, (3, 256, 256))

测试结果如下：

八、应用场景

CSPNet的设计使其适用于各种计算机视觉任务，包括但不限于：

• 图像分类：提升常规图像分类任务的准确性。
• 目标检测：在对象检测框架如YOLO或SSD中，CSPNet可作为基础网络以提高检测性能。
• 语义分割：对于需要理解像素级别的图像任务，CSPNet也能提供强大的支持。
• 视频分析：由于其高效特性，CSPNet也可以应用于实时视频理解等任务。

总的来说，CSPNet作为一种新型的深度学习架构，在保持精度的同时降低了计算复杂度和内存占用，为计算机视觉领域的研究和应用提供了新的思路和方法。

参考：

• CSPNet——PyTorch实现CSPDenseNet和CSPResNeXt
• 【CSPNet】一种增强学习能力的跨阶段局部网络