经典卷积神经网络模型

本文回顾了经典的CNN结构，并附上相应的pytorch代码。融合了部分Ng、沐神讲解的内容(主要是ResNet)，主要是写一下反思，帮助理解CNN的一些核心思想。

PPT来自：计算机视觉与深度学习 北京邮电大学 鲁鹏

代码来自沐神《动手学深度学习》。

卷积概述

ReLU接在卷积层后面，对卷积的结果进行处理（卷积得到的结果不都是正数）！

卷积层堆叠：后面的conv可以在前面conv的基础上继续提取特征。

Pooling: 不改变深度信息，只减小空间尺寸，之后卷积需要计算的空间位置就减少了。【一般每pooling一次，下降一倍】

虽然卷积核的大小不变，但是越靠后，感受野“相对越大”，相当于从一个更大的尺度上观察图像【前面细粒度，后面粗粒度】。

卷积特征图

卷积核的个数决定了这一层输出的特征图的个数，也是下一层卷积核的深度。

池化层

AlexNet(2012)

贡献

动量：使得震荡方向减小，运动比较慢的方向加强，更快的通过平坦的区域。

结构

注：

1、这个Norm现在已经不用了，并不是BN。

2、说“网络层数”，我们只算Conv层和FC层。

3、算参数的时候“+1”是bias.

4、输入227 * 227 * 3的图像之前，进行了去均值处理【统计所有训练样本每个位置像素的均值，也是一个227 * 227 * 3的。然后对于每一个图像，减去这个均值向量】。

作用？——

在进行分类的时候，”绝对值“是无意义的，我们只需要比较”相对值“。去均值之后，保留了相对值，还可以使得数据减小。

这里使用的池化是重叠池化（但是在之后的网络中，一般还是使用不重叠的池化）。

池化不学习参数！

Norm的作用：将差距拉大，“助纣为虐，落井下石”。从VGG开始就去掉了。

呆码

以28 * 28 * 1的图片为例，pytorch代码：

# 这里由于是MINST数据集，所以输入的通道是1； 如果是ImageNet数据集，就应该是3了
net = nn.Sequential(
    nn.Conv2d(1, 96, kernel_size=11, stride=4, padding=1), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2),
    nn.Conv2d(96, 256, kernel_size=5, padding=2), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2),
    nn.Conv2d(256, 384, kernel_size=3, padding=1), nn.ReLU(),
    nn.Conv2d(384, 384, kernel_size=3, padding=1), nn.ReLU(),
    nn.Conv2d(384, 256, kernel_size=3, padding=1), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2), nn.Flatten(),
    nn.Linear(256 * 5 * 5, 4096), nn.ReLU(), nn.Dropout(p=0.5),
    nn.Linear(4096, 4096), nn.ReLU(), nn.Dropout(p=0.5),
    nn.Linear(4096, 10)
)

*重要规律

验证集损失不下降时，可以手动降低10倍学习率。

反思：卷积层到底在做什么？

256是256种特征响应模板，亮代表此处切合度高。

ZFNet(2013)

1、将第一个卷积改成7 * 7，这样方便感受更细粒度的内容；

2、步长设置成2，不让分辨率降低的太快，而是一点点降低；

3、之所以只增加后面层卷积核的个数：认为 “基元” 的内容是很少的（图像的底层特征），我们不需要很多的卷积核；但是他们之间组合出来的特征却很多，越到后面，卷积核包含的语义信息就越多，增加卷积核的个数，可以理解更多的语义信息。

VGG(2014)

串联小卷积核可以获得更大的感受野，而不非用大卷积核。串联小卷积核经过了多次变换，非线性性更强。

VGG处理归一化和AlexNet不同。VGG统计所有图片R, G, B的均值，然后将【R, G, B】作为均值。

之前是，若干图片同一位置的像素的R、G、B求均值，现在是若干图片所有像素的R、G、B求均值。

前层卷积核的个数少，后层卷积核的个数多。前层学习的是 “基元”信息，后期学习的 “语义”信息多。【与ZFNet类似】

但是并不越多越好。因为后面要接一个FC，如果太大，展开成向量输入FC的话，会非常大。

VGG-11的呆码

与VGG-16相比，每一个卷积块都少一个卷积层。

# 超参数：需要的卷积层的个数、输入输出的channel数
def vgg_block(num_convs, in_channels, out_channels): 
    layers = []
    for i in range(num_convs):
        layers.append(nn.Conv2d(
            in_channels, out_channels, kernel_size=3, padding=1))
        layers.append(nn.ReLU())
        in_channels = out_channels
    layers.append(nn.MaxPool2d(kernel_size=2, stride=2))   
    return nn.Sequential(*layers)
    
conv_arch = ((1, 64), (1, 128), (2, 256), (2, 512), (2, 512))
def vgg(conv_arch):
    conv_blks = []
    in_channels = 1
    for (num_convs, out_channels) in conv_arch:
        conv_blks.append(vgg_block(
            num_convs, in_channels, out_channels))
        in_channels = out_channels
    
    return nn.Sequential(
        *conv_blks, nn.Flatten(),
        nn.Linear(out_channels * 7 * 7, 4096), nn.ReLU(), nn.Dropout(0.5),
        nn.Linear(4096, 4096), nn.ReLU(), nn.Dropout(0.5),
        nn.Linear(4096, 10)
    )

反思：小卷积核有什么优势？

两个3 * 3的小卷积核串联，其实就等效于一个5 * 5的卷积核，他们的感受野是一样的。

但是，串联多经过了一次变换，非线性能力更强【感性理解：组合出来之后，会更复杂，得到更复杂的信息】。

此外，参数也更少。

反思：为什么经过一次Pooling, 卷积核个数要增加一倍？

“动态平衡”的思想。如果不Pooling,那显存占用太大。

GoogLeNet(2014)

核心改进：网络结构发生本质改变，引入Inception块。

为什么不采用串联结构了呢？

举一个栗子。如果图中有一条很宽的线，但是用小卷积核，只能把他提取成四条边，这样一个重要信息就丢失了。

所以，这个错误是“叠加”的，前面丢失了信息，后面无法挽回。

【注：沐神在《动手学深度学习》中提供另外一种说法：“小学生才做选择题，我全都要！”

既然不知道什么时候用3 * 3， 5 * 5，那我不如全都留下来，一起算。】

解决方案：保留前面层更多的信息。

兵分四路。1 * 1的卷积对于通道做融合（相当于全连接）；3 * 3的卷积感受细粒度的信息，提取3 * 3局部信息； 5 * 5的卷积感受相对粗粒度的信息，提取5 * 5局部信息；MaxPooling对强信息做扩张【理解：如果有一个极大值像素，那么所有卷积操作包含它的部分都会变成这个值】。最后将所有的层concat(在深度方向拼接)起来。这四个层都不改变H * W的大小。

但是问题在于，如果直接这样做，会很慢。所以在前面先用NiN(Network in Netwok),不改变宽高，但是改变通道数(深度).所以第2,3路的1 * 1块与1,4路的1 * 1块功能不同，1,4路的是融合信息，对深度进行压缩，2,3路是主要减少计算量(当然也会融合信息)。

最后也砍掉了2个FC，大大减少了参数个数。取而代之的是一个AvgPooling,每个特征图用一个最大值代替。【之前是每一个特征图展开成一个长向量，现在是每个特征图只保留一个值】

此外，GoogLeNet中还有两个辅助分类器，因为网络太深，所以使用辅助分类器让前面也能有梯度回传（PPT中的两条红线）从而解决梯度消失问题。

ReLU虽然也可以一定程度解决梯度消失，但是并不能完全解决深层网络难以训练的问题。加上辅助分类器之后，前面的层更好训练，前面层学到的特征也能让网络更快的收敛。

Inception块呆码

class Inception(nn.Module):
    # c1--c4是每条路径的输出通道数
    def __init__(self, in_channels, c1, c2, c3, c4, **kwargs):
        super(Inception, self).__init__(**kwargs)
        # 线路1，单1x1卷积层
        self.p1_1 = nn.Conv2d(in_channels, c1, kernel_size=1)
        # 线路2，1x1卷积层后接3x3卷积层
        self.p2_1 = nn.Conv2d(in_channels, c2[0], kernel_size=1)
        self.p2_2 = nn.Conv2d(c2[0], c2[1], kernel_size=3, padding=1)
        # 线路3，1x1卷积层后接5x5卷积层
        self.p3_1 = nn.Conv2d(in_channels, c3[0], kernel_size=1)
        self.p3_2 = nn.Conv2d(c3[0], c3[1], kernel_size=5, padding=2)
        # 线路4，3x3最大汇聚层后接1x1卷积层
        self.p4_1 = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)
        self.p4_2 = nn.Conv2d(in_channels, c4, kernel_size=1)

    def forward(self, x):
        p1 = F.relu(self.p1_1(x))
        p2 = F.relu(self.p2_2(F.relu(self.p2_1(x))))
        p3 = F.relu(self.p3_2(F.relu(self.p3_1(x))))
        p4 = F.relu(self.p4_2(self.p4_1(x)))
        # 在通道维度上连结输出
        return torch.cat((p1, p2, p3, p4), dim=1)

反思：关于1 * 1的卷积（NiN)：

对于卷积层，可以理解为每一个像素有多个通道，如果通道数是100，可以理解为一个像素有一个长为100的向量，可以认为这个向量是这个像素的特征。那么可以理解为，每一个像素就是一个样本，共有批量大小 * 高 * 宽个样本。故，可以把通道层当做卷积层的特征维度。【这也是1 * 1的卷积相当于全连接的解释】。

NiN会导致信息的损失吗？

理论上压缩会损失，但损失的是“不存在”的特征，所以实际上未太损失。

以上图为例，m * n * 64的特征图，每一个卷积核都是描述一种结构【这个向量描述的是某个点A被64个卷积核卷积的结果】。但是图像在同一个位置只会有1种结构（或再多一点点，2-3种，但是不会很多），不可能卷积核描述的特征在原图像同一个位置都有，所以描述图像上A位置的这个向量(64维)是一个很稀疏的向量。压缩之后，会把很多的0压缩掉，所以不会丢失信息。

ResNet(2015)

发现问题——网络并不是越深越好！

Residual

大名鼎鼎的残差块，几乎成为之后深层网络的必备了(如Transformer中的Add&Norm层)。

可以用下面的图理解残差块。【这主要是从正向传播的角度理解的】

原图 + 边缘图 = 锐化后的图，在保证了原图信息的同时，把细节进行了强化。那我们可以这样理解：输入的X就是原图，特征提取之后输出的F(X)就是这个边缘细节图，他们和在一起的H(X)就是最后的输出。【卷积在这里可以理解为那个边缘提取器。】当然，锐化的增强是“人的视觉效果”最关心的信息，在ResNet中增强的可不一定是人视觉上感兴趣的信息，有可能是对分类比较有兴趣的信息。这里只是拿锐化来对比理解下。

之前的网络，要学习的直接就是H(x)，但是现在要学习的是F(X) = H(x) - X, 这也就是“残差”的思想，即输出和输入的差异。

这里第一次使用1 * 1的卷积，依然是为了降低通道数【减少运算量】； 而第二次使用1 * 1的卷积，是为了增加通道数【不升回去没法相加】。所谓 “瓶颈”就是深度先减小再增大。

两种ResNet块

只看上图会发现一个问题：维度对不上！因为Residual结构的存在，所以输入输出的维度应该完全不变才对（和X一致）。

这里鲁鹏老师没有讲，其实是因为有两种ResNet结构：高宽减半的resnet块和高宽不变的resnet块。【注：这里李沐老师讲的和上面的resnet结构稍有不同，因为鲁鹏老师讲的是resnet152,沐神讲的是resnet18，但是原理一样】。具体细节可以看下面的代码。

反思：为什么ResNet可以训练到1000层？

从反向传播理解

之前网络一个很大的问题——深度太深之后，梯度会消失，前面的网络训练不好。

如何避免梯度消失？-> 乘法变加法

梯度消失： 新加的层如果拟合能力很强（例如AlexNet的全连接层)，那么高层的梯度会很快变得非常小【导数可以理解为：真实值和预测值之间的差别（可以去看softmax求导）】。如果梯度很小的话，只能增大学习率。但是增的太大，高层的学习率也大了，会使得训练很不稳定（这里假设的是全局统一的学习率）。

但是resnet:每一层都会把上一层的导数传过来，于是不会太小。贴近数据的W的梯度可以由上层直接经过高速公路传下来，一开始下面的层也可以拿到比较大的梯度，才可以对很深的网络做训练。

结合吴恩达老师的再理解下。如果我们在此基础上再使用L2正则化（权重衰退），会进一步压缩W的值。

如果W学到了0，那么a[l + 2]就会学习到a[l]（因为是relu函数，a[l]肯定是大于0的），这就实现了恒等式的传递。

也就是说，当网络足够深的时候，开始起反作用的时候，这个模块可以保证你网络性能不变（尽管加了两层）。这里是假设很深的时候梯度消失了，此时这个网络可以退回到梯度消失之前。但是plain NN 是做不到这样的，随着深度的加深，会学的更烂。

吴恩达老师提出观点，residual有用的原因就是：他学习恒等函数很容易。

集成模型（核心理解）

残差可以看成很多子网络的求和。

Ensemble当然效果好鸭。

研究人员发现，随便盖住ResNet中的某几层，效果依然很好，但是如果对VGG这么干，就GG了。后面提出的DenseNet也是对ResNet的优化，他发现Ensemble的坏处在于，“投票“虽然好，但是有很多冗余信息，这里就不在深究了。

ResNet18呆码

注意resnet的“加法“是直接数值相加【见下面Y += X】，而不是像GoogLeNet那样做通道堆积合并。

class Residual(nn.Module): # use_1x1conv：要不要使用1x1的卷积
    def __init__(self, input_channels, num_channels, use_1x1conv=False, strides=1):
        super().__init__()
        self.conv1 = nn.Conv2d(input_channels, num_channels, kernel_size=3, padding=1, stride=strides)
        self.conv2 = nn.Conv2d(num_channels, num_channels, kernel_size=3, padding=1) # 这里输入通道数=输出通道数，这是左边的第二个3x3
        if use_1x1conv:
            self.conv3 = nn.Conv2d(input_channels, num_channels, kernel_size=1, stride=strides)
        else:
            self.conv3 = None
        self.bn1 = nn.BatchNorm2d(num_channels)
        self.bn2 = nn.BatchNorm2d(num_channels)
        self.relu = nn.ReLU(implace=True)
        
    def forward(self, X):
        Y = F.relu(self.bn1(self.conv1(X)))
        Y = self.bn2(self.conv2(Y))
        if self.conv3:
            X = self.conv3(X)
        Y += X #!!!!!
        return F.relu(Y)

使用两种不同的resnet块：

blk = Residual(3, 3)
X = torch.rand(4, 3, 6, 6)
Y = blk(X)
Y.shape
torch.Size([4, 3, 6, 6])

增加输出通道的同时，高宽减半。

blk = Residual(3, 6, use_1x1conv=True, strides=2)
Y = blk(X)
Y.shape
torch.Size([4, 6, 3, 3])

下面是RetNet18网络的实现：

b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
                   nn.BatchNorm2d(64), nn.ReLU(),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

ResNet则使用4个由残差块组成的模块，每个模块使用若干个同样输出通道数的残差块。 第一个模块的通道数同输入通道数一致。 由于之前已经使用了步幅为2的最大汇聚层，所以无须减小高和宽。 之后的每个模块在第一个残差块里将上一个模块的通道数翻倍，并将高和宽减半。

# 一个stage要多少个residual小块，是不是第一个stage
def residual_block(input_channels, num_channels, num_residuals, first_block=False):
    blk = []
    for i in range(num_residuals): # 只在第一个stage(b2)才减半，其余的都不减半
        if i == 0 and not first_block:
            blk.append(Residual(input_channels, num_channels, use_1x1conv=True, strides=2))
        else:
            blk.append(Residual(num_channels, num_channels))
    return blk
    
b2 = nn.Sequential(*residual_block(64, 64, 2, True))
b3 = nn.Sequential(*residual_block(64, 128, 2))
b4 = nn.Sequential(*residual_block(128, 256, 2))
b5 = nn.Sequential(*residual_block(256, 512, 2))

net = nn.Sequential(b1, b2, b3, b4, b5, nn.AdaptiveAvgPool2d((1, 1)),
                   nn.Flatten(), nn.Linear(512, 10))

X = torch.rand(size=(1, 1, 224, 224))
for layer in net:
    X = layer(X)
    print(layer.__class__.__name__,'output shape:\t', X.shape)

Sequential output shape:	 torch.Size([1, 64, 56, 56])
Sequential output shape:	 torch.Size([1, 64, 56, 56])
Sequential output shape:	 torch.Size([1, 128, 28, 28])
Sequential output shape:	 torch.Size([1, 256, 14, 14])
Sequential output shape:	 torch.Size([1, 512, 7, 7])
AdaptiveAvgPool2d output shape:	 torch.Size([1, 512, 1,  1]) # 用池化变成1 * 1
Flatten output shape:	 torch.Size([1, 512])
Linear output shape:	 torch.Size([1, 10])

ResNet18结构图

Summary

一般要自己做任务的时候，建议使用resnet或InceptionV4.

当然最新的研究表明，swin transformer好像吊锤CNN？不过我不会，长大后在学习。