深度学习模型——经典卷积神经网络（从概念到实现）【下】

参考来源：

动手深度学习（第二版）

前文链接：

https://mp.csdn.net/mp_blog/creation/editor/130668945

一、卷积神经网络（LeNet）介绍

LeNet是深度学习中的一个经典卷积神经网络模型，它由加州大学Yann LeCun教授及其团队在20世纪90年代初期开发出来。主要用于手写数字识别等计算机视觉领域任务。

LeNet最早应用于美国银行自动支票处理系统，通过对输入图像进行卷积运算和池化操作，可以提取出图像的特征，并建立一系列全连接层对这些特征进行分类。

LeNet一般包含以下几个层次：

1. 输入层：接收原始图像数据

2. 卷积层：使用一组卷积核对输入图像进行卷积运算，提取出图像的特征。LeNet中使用了两个卷积层（C1和C3），每个卷积层后接一个非线性激活函数层（例如tanh或Sigmoid）。

3. 池化层：对卷积层的输出进行下采样或降维，减少数据计算量并保留重要的特征信息。LeNet中使用了两个池化层（S2和S4），通过最大值池化(max-pooling)来实现。

4. 全连接层：对卷积池化得到的特征进行分类。LeNet中使用了三个全连接层（F5、F6和输出层），其中输出层的节点数等于分类数目，使用Softmax函数对各类别得分进行归一化处理。

几个层次可以整合为两个主体：

• 卷积编码器：由两个卷积层组成;

• 全连接层密集块：由三个全连接层组成。

模型的示意图如下：

 流程概述：

        原输入图片大小为28×28的像素矩阵，我们首先对原图像进行填充，扩充到32×32的矩阵大小。之后放到一个5×5，具有6通道的卷积层里面。得到一个6通道28×28的特征图放进2×2的池化层中，使得宽高缩小一倍。之后再放入一个16通道5×5的卷积层中，得到最后16通道10×10的特征图，再放入二维池化层中缩小一倍宽高，拉成一个向量送到全连接层，通过三层SoftMAX判断类别概率。

       LeNet模型在20世纪90年代就已经取得了非常出色的手写数字识别效果，在后来被广泛应用于其他计算机视觉领域任务。同时，它也是现代深度学习中卷积神经网络的雏形，为后续的卷积神经网络模型发展奠定了基础。

二、卷积神经网络（LeNet）的优缺点

优点：

1. 参数共享：LeNet使用了卷积和池化操作将图像数据进行特征提取，其中卷积操作可以对图像中不同位置的信息进行识别，而参数共享使得网络中参数量减少，训练速度更快效率更高。

2. 局部连接性：LeNet使用了局部连接性的设计，这样每个神经元仅与前一层的局部神经元相连，避免了全连接带来的过拟合问题，并有效地降低了计算复杂度。

3. 池化操作：LeNet在卷积层之后使用池化操作来进行下采样，通过保留主要的特征信息，减少了参数量和计算量，同时还能够增强模型的鲁棒性。

缺点：

1. 难以处理大尺寸图像：LeNet适用于小尺寸图像的特征提取，但无法有效处理高分辨率或大尺寸的图像，因为具有较多卷积核和神经元等大量的待训练参数，需要更大规模的计算资源。

2. 容易过拟合：由于LeNet模型容易受限于固定的网络架构和参数初始化方式，当模型复杂度较高时，训练数据不足会导致过拟合的情况发生。

3. 依赖于提前手动特征工程：LeNet需要先对原始图像进行处理以提取出相关特征，如果网络架构和输入特征处理不够精确，将极大地影响模型的准确性。而对于复杂的计算机视觉任务，则需要更加智能、自适应的深度学习模型。

三、卷积神经网络（LeNet）代码实现：

首先实例化一个Sequential块并将需要的层连接在一起。需要注意的是，要在卷积层和池化层中加入一层激活函数，用于模型的非线性映射，增加模型的复杂度和表达能力。

import torch
from torch import nn
from d2l import torch as d2l

net = nn.Sequential(
    nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Conv2d(6, 16, kernel_size=5), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Flatten(),
    nn.Linear(16 * 5 * 5, 120), nn.Sigmoid(),
    nn.Linear(120, 84), nn.Sigmoid(),
    nn.Linear(84, 10))

 模型框架也可以用下图来表示：

                                    

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

这里为了方便大家理解，输出了每一层梳理后数组X的形状

这里是将每一小批量数据移动到我们指定的设备（例如GPU）上。同时用正确预测的数量除以总预测的数量来计算精度。

batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)
def evaluate_accuracy_gpu(net, data_iter, device=None): #@save
    """使用GPU计算模型在数据集上的精度"""
    if isinstance(net, nn.Module):
        net.eval()  # 设置为评估模式
        if not device:
            device = next(iter(net.parameters())).device
    # 正确预测的数量，总预测的数量
    metric = d2l.Accumulator(2)
    with torch.no_grad():
        for X, y in data_iter:
            if isinstance(X, list):
                # BERT微调所需的（之后将介绍）
                X = [x.to(device) for x in X]
            else:
                X = X.to(device)
            y = y.to(device)
            metric.add(d2l.accuracy(net(X), y), y.numel())
    return metric[0] / metric[1]

这里为利用GPU的模型训练方法：

nn.init.xavier_uniform_表示使用Xavier均匀分布方法进行权重初始化操作，其实现方式等价于nn.init.uniform(tensor, a=-sqrt(6)/sqrt(fan_in), b=sqrt(6)/sqrt(fan_in))，其中fan_in表示权重矩阵输入线性单元的数量。

Xavier权重初始化方法旨在使每个神经元的输出方差尽量相等，且避免饱和情况和梯度消失/爆炸现象导致的训练困难。由于PyTorch默认的权重初始化是采用均值为0、方差为1的高斯分布或均匀分布，因此使用Xavier方法进行初始化可以提升模型收敛速度和准确性。

d2l.Timer()是Deep Learning框架中定义的计时器类，用于测量代码运行时间。一般情况下，我们可以使用Python内置模块time来实现代码运行的时间测量，不过d2l.Timer()提供了更加直观、简洁和可读性强的计时接口。

#@save
def train_ch6(net, train_iter, test_iter, num_epochs, lr, device):
    """用GPU训练模型(在第六章定义)"""
    def init_weights(m):
        if type(m) == nn.Linear or type(m) == nn.Conv2d:
            nn.init.xavier_uniform_(m.weight)
    net.apply(init_weights)
    print('training on', device)
    net.to(device)
    optimizer = torch.optim.SGD(net.parameters(), lr=lr)
    loss = nn.CrossEntropyLoss()
    animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs],
                            legend=['train loss', 'train acc', 'test acc'])
    timer, num_batches = d2l.Timer(), len(train_iter)
    for epoch in range(num_epochs):
        # 训练损失之和，训练准确率之和，样本数
        metric = d2l.Accumulator(3)
        net.train()
        for i, (X, y) in enumerate(train_iter):
            timer.start()
            optimizer.zero_grad()
            X, y = X.to(device), y.to(device)
            y_hat = net(X)
            l = loss(y_hat, y)
            l.backward()
            optimizer.step()
            with torch.no_grad():
                metric.add(l * X.shape[0], d2l.accuracy(y_hat, y), X.shape[0])
            timer.stop()
            train_l = metric[0] / metric[2]
            train_acc = metric[1] / metric[2]
            if (i + 1) % (num_batches // 5) == 0 or i == num_batches - 1:
                animator.add(epoch + (i + 1) / num_batches,
                             (train_l, train_acc, None))
        test_acc = evaluate_accuracy_gpu(net, test_iter)
        animator.add(epoch + 1, (None, None, test_acc))
    print(f'loss {train_l:.3f}, train acc {train_acc:.3f}, '
          f'test acc {test_acc:.3f}')
    print(f'{metric[2] * num_epochs / timer.sum():.1f} examples/sec '
          f'on {str(device)}')

定义超参数来训练模型：

lr, num_epochs = 0.9, 10
train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())