一、提出背景
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的主要贡献包括:
- 「增强了CNN的学习能力」。现有的CNN经过轻量化后,其准确性大大降低,所以作者希望加强CNN的学习能力,使其在轻量化的同时保持足够的准确性。所提出的CSPNet可以很容易地应用于ResNet、ResNeXt和DenseNet。将CSPNet应用于上述网络后,计算量从10%减少到20%,但在精度方面,在ImageNet上进行图像分类任务时,其表现优于ResNet、ResNeXt、DenseNet、HarDNet等一流的算法。
- 「消除计算瓶颈」。过高的计算瓶颈将导致更多的周期来完成推理过程,否则一些算术单元将经常空闲。因此,作者希望在CNN中能够将每一层的计算量平均分配,从而有效的提高每一个计算单元的利用率,减少不必要的能源消耗。注意到所提出的CSPNet使PeleeNet的计算瓶颈减半。此外,在基于MS COCO数据集的目标检测实验中,该模型在基于YOLOv3的模型上测试时,可以有效地减少80%的计算瓶颈。
- 「减少内存成本」。动态随机存取存储器(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的特点可以归纳为以下几点:
- 跨阶段部分连接:通过CSPBlock模块实现跨阶段的特征融合,提高了模型的学习能力。
- 轻量化与高效性:在保证模型准确性的同时,实现了模型的轻量化,并提高了推断速度。
- 灵活性:CSPNet可以轻松地整合到现有的深度学习架构中,适应不同的任务需求。
- 减少梯度重用:通过截断梯度流,减少了不同层之间梯度信息的重复利用,提高了模型的训练效率。
六、优缺点
优点:
- 提高了轻量级模型的准确性。
- 降低了计算复杂度和内存占用。
- 通用性强,适用于多种计算机视觉任务。
缺点:
- 相对于一些更复杂的模型,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】一种增强学习能力的跨阶段局部网络
版权归原作者 浩瀚之水_csdn 所有, 如有侵权,请联系我们删除。