【deeplearning】Pytorch实战1：卷积神经网络（LeNet-5）手写数字识别 (MNIST数据集)

最新推荐文章于 2024-08-14 17:40:03 发布

infinite_with

最新推荐文章于 2024-08-14 17:40:03 发布

阅读量3.4k

点赞数 6

分类专栏：计算机视觉文章标签： pytorch cnn 深度学习

本文链接：https://blog.csdn.net/weixin_45591044/article/details/104275157

版权

计算机视觉专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、实验环境:

Pytorch 1.3.1
torchvision 0.4.2
Python 3.7
ubuntu+Pycharm

LeNet-5出自论文Gradient-Based Learning Applied to Document
Recognition，是一种用于手写体字符识别的非常高效的卷积神经网络。

二、卷积神经网络（Convolutional Neural Network, CNN）

在讲解LeNet-5之前，让我们先看下CNN。卷积神经网络能够很好的利用图像的结构信息。LeNet-5是一个较简单的卷积神经网络。下图显示了其结构：输入的二维图像，先经过两次卷积层到池化层，再经过全连接层，最后使用softmax分类作为输出层。下面我们主要介绍卷积层和池化层。

在这里插入图片描述
1、卷积层
卷积层是卷积神经网络的核心基石。在图像识别里我们提到的卷积是二维卷积，即离散二维滤波器（也称作卷积核）与二维图像做卷积操作，简单的讲是二维滤波器滑动到二维图像上所有位置，并在每个位置上与该像素点及其领域像素点做内积。卷积操作被广泛应用与图像处理领域，不同卷积核可以提取不同的特征，例如边沿、线性、角等特征。在深层卷积神经网络中，通过卷积操作可以提取出图像低级到复杂的特征。
在这里插入图片描述

2、池化层

池化是非线性下采样的一种形式，主要作用是通过减少网络的参数来减小计算量，并且能够在一定程度上控制过拟合。通常在卷积层的后面会加上一个池化层。池化包括最大池化、平均池化等。其中最大池化是用不重叠的矩形框将输入层分成不同的区域，对于每个矩形框的数取最大值作为输出层，如上图所示。

三、Lenet-5

LeNet5 这个网络虽然很小，但是它包含了深度学习的基本模块：卷积层，池化层，全链接层。是其他深度学习模型的基础，这里我们对LeNet5进行深入分析。同时，通过实例分析，加深对与卷积层和池化层的理解。在这里插入图片描述
网络结构和参数：

输入层

图片大小为 32×32×1，其中 1 表示为黑白图像，只有一个 channel。

卷积层

filter 大小 5×5，filter 深度（个数）为 6，padding 为 0，卷积步长 s=1，输出矩阵大小为 28×28×6，其中 6 表示 filter 的个数。

池化层

average pooling，filter 大小 2×2（即 f=2），步长 s=2，no padding，输出矩阵大小为 14×14×6。

卷积层

filter 大小 5×5，filter 个数为 16，padding 为 0，卷积步长 s=1，输出矩阵大小为 10×10×16，其中 16 表示 filter 的个数。

池化层

average pooling，filter 大小 2×2（即 f=2），步长 s=2，no padding，输出矩阵大小为 5×5×16。注意，在该层结束，需要将 5×5×16 的矩阵flatten 成一个 400 维的向量。

全连接层（Fully Connected layer，FC）

neuron 数量为 120。

全连接层（Fully Connected layer，FC）

neuron 数量为 84。

全连接层，输出层

现在版本的 LeNet-5 输出层一般会采用 softmax 激活函数，在 LeNet-5 提出的论文中使用的激活函数不是 softmax，但其现在不常用。该层神经元数量为 10，代表 0～9 十个数字类别。（图 1 其实少画了一个表示全连接层的方框，而直接用 y^ 表示输出层。）

3.1、LeNet-5 的性质：

如果输入层不算神经网络的层数，那么 LeNet-5 是一个 7 层的网络。（有些地方也可能把卷积和池化当作一个 layer）（LeNet-5 名字中的“5”也可以理解为整个网络中含可训练参数的层数为 5。）

LeNet-5 大约有 60,000 个参数。

随着网络越来越深，图像的高度和宽度在缩小，与此同时，图像的 channel 数量一直在增加。

现在常用的 LeNet-5 结构和 Yann LeCun 教授在 1998 年论文中提出的结构在某些地方有区别，比如激活函数的使用，现在一般使用 ReLU 作为激活函数，输出层一般选择 softmax。

3.2、各层参数详解：

在这里插入图片描述
1、INPUT层-输入层
首先是数据 INPUT 层，输入图像的尺寸统一归一化为32×32。

注意：本层不算LeNet-5的网络结构，传统上，不将输入层视为网络层次结构之一。

2、C1层-卷积层

输入图片：32×32

卷积核大小：5×5

卷积核种类：6

输出featuremap大小：28×28 （32-5+1）=28

神经元数量：28×28×6

可训练参数：（5×5+1) × 6（每个滤波器5*5=25个unit参数和一个bias参数，一共6个滤波器）

连接数：（5×5+1）×6×28×28=122304

详细说明：对输入图像进行第一次卷积运算（使用 6 个大小为 5×5 的卷积核），得到6个C1特征图（6个大小为28×28的 feature maps, 32-5+1=28）。我们再来看看需要多少个参数，卷积核的大小为5×5，总共就有6*（5×5+1）=156个参数，其中+1是表示一个核有一个bias。对于卷积层C1，C1内的每个像素都与输入图像中的5×5个像素和1个bias有连接，所以总共有156×28×28=122304个连接（connection）。有122304个连接，但是我们只需要学习156个参数，主要是通过权值共享实现的。

3、S2层-池化层（下采样层）
输入：28×28

采样区域：2×2

采样方式：4个输入相加，乘以一个可训练参数，再加上一个可训练偏置。结果通过sigmoid

采样种类：6

输出featureMap大小：14×14（28/2）

神经元数量：14×14×6

连接数：（2×2+1）×6×14×14

S2中每个特征图的大小是C1中特征图大小的1/4。

详细说明：第一次卷积之后紧接着就是池化运算，使用 2×2核进行池化，于是得到了S2，6个14×14的特征图（28/2=14）。S2这个pooling层是对C1中的2×2区域内的像素求和乘以一个权值系数再加上一个偏置，然后将这个结果再做一次映射。同时有5×14×14×6=5880个连接。

4、C3层-卷积层
输入：S2中所有6个或者几个特征map组合

卷积核大小：5×5

卷积核种类：16

输出featureMap大小：10×10 (14-5+1)=10

C3中的每个特征map是连接到S2中的所有6个或者几个特征map的，表示本层的特征map是上一层提取到的特征map的不同组合

存在的一个方式是：C3的前6个特征图以S2中3个相邻的特征图子集为输入。接下来6个特征图以S2中4个相邻特征图子集为输入。然后的3个以不相邻的4个特征图子集为输入。最后一个将S2中所有特征图为输入。

则：可训练参数：6×(3×5×5+1)+6×(4×5×5+1)+3×(4×5×5+1)+1×(6×5×5+1)=1516

连接数：10×10×1516=151600

详细说明：第一次池化之后是第二次卷积，第二次卷积的输出是C3，16个10×10的特征图，卷积核大小是 5×5. 我们知道S2 有6个 14×14 的特征图，怎么从6 个特征图得到 16个特征图了？这里是通过对S2 的特征图特殊组合计算得到的16个特征图。具体如下：
在这里插入图片描述
C3的前6个feature map（对应上图第一个红框的6列）与S2层相连的3个feature map相连接（上图第一个红框），后面6个feature map与S2层相连的4个feature map相连接（上图第二个红框），后面3个feature map与S2层部分不相连的4个feature map相连接，最后一个与S2层的所有feature map相连。卷积核大小依然为5×5，所以总共有6×(3×5×5+1)+6×(4×5×5+1)+3×(4×5×5+1)+1×(6×5×5+1)=1516个参数。而图像大小为10×10，所以共有151600个连接。
在这里插入图片描述
C3与S2中前3个图相连的卷积结构如下图所示：

在这里插入图片描述
上图对应的参数为 3×5×5+1，一共进行6次卷积得到6个特征图，所以有6×（3×5×5+1）参数。为什么采用上述这样的组合了？论文中说有两个原因：1）减少参数，2）这种不对称的组合连接的方式有利于提取多种组合特征

5、S4层-池化层（下采样层）
输入：10×10

采样区域：2×2

采样方式：4个输入相加，乘以一个可训练参数，再加上一个可训练偏置。结果通过sigmoid

采样种类：16

输出featureMap大小：5×5（10/2）

神经元数量：5×5×16=400

连接数：16×（2×2+1）×5×5=2000

S4中每个特征图的大小是C3中特征图大小的1/4

详细说明：S4是pooling层，窗口大小仍然是2*2，共计16个feature map，C3层的16个10x10的图分别进行以2x2为单位的池化得到16个5x5的特征图。有5x5x5x16=2000个连接。连接的方式与S2层类似。

6、C5层-卷积层
输入：S4层的全部16个单元特征map（与s4全相连）

卷积核大小：5×5

卷积核种类：120

输出featureMap大小：1×1（5-5+1）

可训练参数/连接：120×（16×5×5+1）=48120

详细说明：C5层是一个卷积层。由于S4层的16个图的大小为5x5，与卷积核的大小相同，所以卷积后形成的图的大小为1x1。这里形成120个卷积结果。每个都与上一层的16个图相连。所以共有(5x5x16+1)x120 = 48120个参数，同样有48120个连接。C5层的网络结构如下：在这里插入图片描述
7、F6层-全连接层
输入：c5 120维向量

计算方式：计算输入向量和权重向量之间的点积，再加上一个偏置，结果通过sigmoid函数输出。

可训练参数:84×(120+1)=10164

详细说明：6层是全连接层。F6层有84个节点，对应于一个7x12的比特图，-1表示白色，1表示黑色，这样每个符号的比特图的黑白色就对应于一个编码。该层的训练参数和连接数是(120 + 1)x84=10164。ASCII编码图如下：在这里插入图片描述
F6层的连接方式如下：

8、Output层-全连接层
Output层也是全连接层，共有10个节点，分别代表数字0到9，且如果节点i的值为0，则网络识别的结果是数字i。采用的是径向基函数（RBF）的网络连接方式。假设x是上一层的输入，y是RBF的输出，则RBF输出的计算方式是：

上式w_ij 的值由i的比特图编码确定，i从0到9，j取值从0到7*12-1。RBF输出的值越接近于0，则越接近于i，即越接近于i的ASCII编码图，表示当前网络输入的识别结果是字符i。该层有84x10=840个参数和连接。

四、Pytorch训练代码：

使用的数据集是MNIST，其中包括6万张28x28的训练样本，1万张测试样本。

import torch
import torchvision as tv
import torchvision.transforms as transforms
import torch.nn as nn
import torch.optim as optim
import argparse

# 定义是否使用GPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

'''步骤一：定义超参数'''
BATCH_SIZE = 64  # 批处理尺寸(batch_size)
LR = 0.001  # 学习率
EPOCH = 5  # 遍历数据集次数

'''步骤二：下载手写数字数据集'''
# 定义数据预处理方式Z
transform = transforms.ToTensor()
# 训练数据集
trainset = tv.datasets.MNIST(root='./data/', train=True, download=True, transform=transform)
# 测试数据集
testset = tv.datasets.MNIST(root='./data/', train=False, download=True, transform=transform)

'''步骤三：数据预处理'''
trainloader = torch.utils.data.DataLoader(trainset, batch_size=BATCH_SIZE, shuffle=True)  # 训练批处理数据，打乱训练数据
testloader = torch.utils.data.DataLoader(testset, batch_size=BATCH_SIZE, shuffle=False)  # 测试批处理数据

'''步骤四：模型搭建，定义LeNet网络模型'''


class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()
        self.conv1 = nn.Sequential(  # input_size=(28*28*1)
            nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, stride=1, padding=2),  # padding=2保证输入输出尺寸相同
            nn.BatchNorm2d(6),
            nn.ReLU(),  # input_size=(28*28*6)
            nn.MaxPool2d(kernel_size=2, stride=2),  # output_size=(14*14*6)
        )
        self.conv2 = nn.Sequential(
            nn.Conv2d(6, 16, 5),
            nn.BatchNorm2d(16),
            nn.ReLU(),  # input_size=(10*10*16)
            nn.MaxPool2d(2, 2)  # output_size=(5*5*16)
        )
        self.fc1 = nn.Sequential(
            nn.Linear(5 * 5 * 16, 120),
            nn.ReLU()
        )
        self.fc2 = nn.Sequential(
            nn.Linear(120, 84),
            nn.ReLU()
        )
        self.fc3 = nn.Linear(84, 10)

    # 定义前向传播过程，输入为x
    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        # nn.Linear()的输入输出都是维度为一的值，所以要把多维度的tensor展平成一维
        x = x.view(x.size()[0], -1)
        x = self.fc1(x)
        x = self.fc2(x)
        x = self.fc3(x)
        return x


'''步骤五：定义损失函数loss function 和优化方式（采用Adam）'''
net = LeNet().to(device)
criterion = nn.CrossEntropyLoss()  # 交叉熵损失函数，通常用于多分类问题上
# optimizer = optim.SGD(net.parameters(), lr=LR, momentum=0.9)
optimizer = optim.Adam(net.parameters(), lr=LR, betas=(0.9, 0.999), eps=1e-08, weight_decay=0)


def train():
    for epoch in range(EPOCH):
        '''步骤六：训练模型'''
        sum_loss = 0.0
        # 数据读取
        for i, data in enumerate(trainloader):
            inputs, labels = data
            inputs, labels = inputs.to(device), labels.to(device)
            # 梯度清零
            optimizer.zero_grad()
            # 前向传播 + 反向传播
            outputs = net(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()

            # 每训练200个batch打印一次平均loss
            sum_loss += loss.item()
            if i % 200 == 199:
                print('[%d, %d] loss: %.03f' % (epoch + 1, i + 1, sum_loss / 200))
                sum_loss = 0.0

        '''步骤七：评估模型'''  # 每跑完一次epoch测试一下准确率
        with torch.no_grad():  # 停止自动求导
            correct = 0
            total = 0
            for data in testloader:
                images, labels = data
                images, labels = images.to(device), labels.to(device)
                outputs = net(images)
                # 取得分最高的那个类
                _, predicted = torch.max(outputs.data, 1)
                total += labels.size(0)
                correct += (predicted == labels).sum()
            print('第%d个epoch的识别准确率为：%.2f%%' % (epoch + 1, (100.0 * correct / total)))


if __name__ == "__main__":
    train()

实验结果

在这里插入图片描述

上图是LeNet-5识别数字3的过程。

五、总结

LeNet-5是一种用于手写体字符识别的非常高效的卷积神经网络。
卷积神经网络能够很好的利用图像的结构信息。
卷积层的参数较少，这也是由卷积层的主要特性即局部连接和共享权重所决定。

infinite_with

关注

6
点赞
踩
46

收藏

觉得还不错? 一键收藏
6
评论
【deeplearning】Pytorch实战1：卷积神经网络（LeNet-5）手写数字识别 (MNIST数据集)

吴恩达机器学习课程笔记机器学习定义监督学习和无监督学习单变量线性回归模型表示（model representation）代价函数梯度下降线性回归中的梯度下降凸函数（convex function）多变量线性回归特征缩放（feature scaling）学习率（learning rate）特征和多项式回归正规方程（normal equation）逻辑回归（logistic...
复制链接

扫一扫

专栏目录