基于CNN的FashionMNIST数据集识别6—

基于CNN的FashionMNIST数据集识别6——ResNet模型

news2025/3/31 0:47:08

前言

之前我们在cnn已经搞过VGG和GoogleNet模型了，这两种较深的模型出现了一些问题：

梯度传播问题

在反向传播过程中，梯度通过链式法则逐层传递。对于包含 L 层的网络，第 l 层的梯度计算为：

其中 a(k) 表示第 k层的激活值。当多个雅可比矩阵 ∂a(k+1)/∂a(k) 的乘积中出现大量小于1的特征值时（例如使用Sigmoid激活函数），梯度会指数级衰减（‌梯度消失‌）；反之若特征值大于1，则梯度爆炸式增长（‌梯度爆炸‌）。

实验证明，VGG-19的训练损失曲线在后期趋于平缓，参数更新停滞。

网络退化问题

当网络深度超过某个阈值时（例如20层），VGG会出现以下矛盾现象：

训练误差不降反升（与过拟合无关）
测试集准确率显著低于更浅的网络

网络退化问题通常是过深的网络的表达力下降导致的，原始像素信息需经过所有层的非线性变换，关键特征可能在传递过程中被破坏。

计算代价问题

以VGG-16为例：

全连接层占总参数量的90%以上（约1.38亿参数中的1.22亿）
最后三个全连接层（4096→4096→1000）产生巨大计算开销（我在训练的时候不得不减少前两个全连接层的神经元数量来尽快完成训练）。

单张224×224图像前向传播的浮点运算量（FLOPs）：

其中l是神经网络层数， Kl 为卷积核尺寸，Cin、Cout 为输入/输出通道数。VGG-16的FLOPs高达15.5G 。训练起来太费劲了。

过拟合问题

模型复杂度应与训练数据规模匹配。VGG-16的1.38亿参数需要极大训练集（ImageNet的120万图像勉强足够），但在小数据集上，测试集准确率显著低于更紧凑的网络。

这些问题说明单纯叠深度不是万能的，甚至有副作用。这里我们使用ResNet来一定程度解决上面的问题。

源码

import torch
from torch import nn
from torchsummary import summary

class Residual(nn.Module):
    def __init__(self, in_channels, out_channels, use_1conv=False, strides = 1):
        super().__init__()
        self.Rulu = nn.ReLU()
        self.conv1 = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=3, padding=1, stride=strides)
        self.conv2 = nn.Conv2d(in_channels=out_channels, out_channels=out_channels, kernel_size=3, padding=1)
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.bn2 = nn.BatchNorm2d(out_channels)
        if use_1conv:
            self.conv3 = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=1, stride=strides)
        else:
            self.conv3 = None

    def forward(self, x):
        y = self.Rulu(self.bn1(self.conv1(x)))
        y = self.bn2(self.conv2(y))
        if self.conv3:
            x = self.conv3(x)
        y = self.Rulu(x + y)
        return y

class ResNet18(nn.Module):
    def __init__(self, Residual):
        super().__init__()
        self.block1 = nn.Sequential(
            nn.Conv2d(in_channels=1, out_channels=64, kernel_size=7, stride=3, padding=3),
            nn.ReLU(),
            nn.BatchNorm2d(64),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        )
        self.block2 = nn.Sequential(
            Residual(64, 64, use_1conv=False, strides=1),
            Residual(64, 64, use_1conv=False, strides=1)
        )
        self.block3 = nn.Sequential(
            Residual(64, 128, use_1conv=True, strides=2),
            Residual(128, 128, use_1conv=False, strides=1)
        )
        self.block4 = nn.Sequential(
            Residual(128, 256, use_1conv=True, strides=2),
            Residual(256, 256, use_1conv=False, strides=1)
        )
        self.block5 = nn.Sequential(
            Residual(256, 512, use_1conv=True, strides=2),
            Residual(512, 512, use_1conv=False, strides=1)
        )
        self.block6 = nn.Sequential(
            nn.AdaptiveAvgPool2d((1, 1)),
            nn.Flatten(),
            nn.Linear(512, 10)
        )

    def forward(self, x):
        x = self.block1(x)
        x = self.block2(x)
        x = self.block3(x)
        x = self.block4(x)
        x = self.block5(x)
        x = self.block6(x)
        return x

if __name__ == "__main__":
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model = ResNet18(Residual).to(device)
    print(summary(model, (1, 224, 224)))