卷积神经网络_手写数字识别[Pytorch]

Hello！欢迎来到六个核桃Lu！

运用卷积神经网络 实现手写数字识别

1 算法分析及设计

卷积神经网络：

图1-2

        如图1-2，卷积神经网络由若干个方块盒子构成，盒子从左到右仿佛越来越小，但却越来越厚；最左边是一张图像，最右边则变成了两排园圈。其实，每—个方块都是由大量神经元细胞构成的，只不过它们排成了立方体的形状。左边图像上的每个元素相当于一个神经元细胞，构成了这个卷积神经网络的输入单元。最右侧的圆圈也是神经元细胞，它们排列成了两条直线，构成了该网络的输出，这与普通神经网络中的细胞没有区别。
        卷积神经网络其实也是一个前馈神经网络，承载了深层的信息处理过程。信息从左侧输人一层一层加工处理，最后到右侧输出。对图像分类任务而言，输人的是一张图像，历经一系列卷积层、池化层和完全连接层的运算，最终得到输出，输出；是一组分类的概率，要分成多少类别就有多少个输出层神经元。相邻两层的神经元连按用图中的小立体锥形近似表示，实际上这种锥形遍布更高一层（右侧）立方体中的所有神经元。低层（左侧）到高层（右侧）的运算主要分为两大类：卷积和池化。一层卷积，一层池化，这两种运算交替进行，直到最后一层，我们又把立方体中的神经元拉平成了线性排列的神经元，与最后的输出层进行全连接。

2 程序设计
2.1 手写数字识别任务的卷积神经网络及运算过程

        灰度图是计算机中最简单的一种图像，如图2-1，数字8栅格图像和图像的二维矩 阵数据。数字8的灰度图图像只有明暗的区别，图像的二维矩阵数据都在0~255之间，只用一个数字表示出不同的灰度，0表示最明亮的白色，255表示最暗的黑色，介于0~255之间的整数则表示不同明暗程序的灰色。

图2-1

        在计算机中，这张输人的图像被表示成了一个尺寸为(28,28)的张量（一个28行28列的矩阵），其中张量的任意一个元素都是一个0~255的数宇，表示这一个像素点的灰度值，越接近255，这个点就会越白。这些输人像素点就自然构成了卷积神经网络的输人层神经元细胞，因此，输人层神经元排布成了一个正方形。
为了完成这个手写数字识别任务，我们设计了如图2-2所示架构的卷积神经网络（在具体设计网络架构的时候，网络有名少层，每一层有多少神经元，这些都可以作为超参数而重新选择）。

图2-2

        整个架构可以分为两大部分，第一部分是由输人图像和4个立方体构成的图像处理部分，在这部分中，图像被不断加工成尺寸更小、数量更多的图像；第二部分则是由一系列线性排布的神经元构成的普通前馈多层神经网络。
首先，输入图像经过一层卷积操作，变成了图中第一个立方体，尺寸为(28,28,4)。实际上这是4张28×28像素的图像；之后，这些图像经过池化的操作，尺寸缩小了一半，变成了4张14×14像素的小图，排布成了厚度为4、长宽为14的立方体；之后，这些图像又经历了一次卷积运算，变成了8张图像，尺寸仍然为14×14像素；最后，这8张图像又经历了一次池化操作，尺寸又变小一半，成为8张7×7像素的小图片。
        至此，第一部分的图像操作完成，下面就要进入第二部分。首先，我们将392(8×7×7)像素的神经元拉伸为一个长度为392的向量，这些神经元构成了前馈网络部分的输入单元，之后经过一层隐含层，再映射到输出层单元，输出10个(0,1)区间中的小数，表示隶属于0~9这10个数字的概率，且这些数字加起来等于1。最后，我们再选取最大的数值所对应的数字，作为最后的分类输出所有的卷积、池化运算都是依靠两层之问的神经元连按完成的（在图2-2中，这些连接表示为小立方锥体），这些连接与普通的前馈神经网络的连接并无本质区别，也对应了一组权重值。用这组权重值乘以相应的输入神经元就得到了计算结果。同理，第二部分网络的一层层运算也是由层与层之问的神经元连接完成的，它们也有相应的权重。
        整个卷积神经网络的运作分成了两个阶段：前馈运算阶段和反馈学习阶段。在网络的前馈阶段（从输人图像到输出数字），所有连接的权重值都不改变，系统会根据输人图像计算输出分类，并根据网络的分类与数据中的标签（标准答案）进行比较计算出交叉熵作为损失函数。接下来，在反馈阶段，根据前馈阶段的损失两数调整所有连接上的权重值，从而完成神经网络的学习过程。

  

 4 总结

        首先，卷积运算可以实现各种各样的图像操作。我们知道，绝大部分的图像处理操作，诸如锐化图像（强调细节）、模糊图像（减少细节）都可以看作某种特定权重的卷积核在原始图像上的卷积操作。换向话说，这些操作都是可被卷积神经网络学习到的。于是，学好的卷积核就能对图像进行去噪、提炼等信息过滤和提取的工作。
        其次，卷积神经网络中的池化操作可以提取大尺度特征。池化操作就是忽略掉图像中的细节信息，从而保留、提炼出;图像中的大尺度信息。这些信息可以帮助卷积神经网络从鉴体把握图像的分类。
        卷积操作虽然与普通的神经网络运算非常相似，只不过卷积核会沿着输人图像平移；池化操作则将图像压缩。因此，看起来普通神经网络的反向传播BP算法并不能直接用在卷积和化操作上，而需要给出适合它们的特殊BP算法。
        所幸，卷积与池化以及构建卷积神经网络过程中的所有计算都是可微分的，可以利用PyTorch的动态计算图调用backward两数自动计算出每个参数的梯度，并最终完成BP算法。
        所谓的卷积操作，其实可以看作一种模板匹配的过程。卷积核就是模板，特征图则是这个模板匹配的结果显示。池化操作则是一种对原始图像进行更大尺度的特征提取过程，它可以提炼出数据中的高尺度信息。将卷积和池化交替组装成多层的卷积神经网络模型，便有了强大的多尺度特征提取能力。

 参考资料:

1. 集智俱乐部. 《深度学习原理与PyTorch》. 人民邮电出版社
2. https://www.bilibili.com/video/BV1T64y167fK?p=13
3. https://blog.csdn.net/Bokman/article/details/109549191
4. https://blog.csdn.net/qq_41503660/article/details/103833961
5. https://zhuanlan.zhihu.com/p/139052035
6. Ian Goodfellow,Yoshua Bengio. 《深度学习》. 人民邮电出版社

——代码——

import torch
import torch.nn as nn
from torch. autograd import Variable
import torch.optim as optim
import torch.nn. functional as F
import torchvision.datasets as dsets
import torchvision.transforms as transforms
import matplotlib.pyplot as plt     # %matplotlib inline 可以让Jupyter Notebook直接输出图像
import pylab                        # 但我写上%matplotlib inline就报错 所以我就用了pylab.show()函数显示图像

# 接着定义一些训练用的超参数：
image_size = 28      # 图像的总尺寸为 28x28
num_classes = 10     # 标签的种类数
num_epochs = 20      # 训练的总猜环周期
batch_size = 64      # 一个批次的大小，64张图片

'''______________________________开始获取数据的过程______________________________'''
# 加载MNIST数据 MNIST数据属于 torchvision 包自带的数据,可以直接接调用
# 当用户想调用自己的图俱数据时，可以用torchvision.datasets.ImageFolder或torch.utils.data. TensorDataset来加载
train_dataset = dsets.MNIST(root='./data',    # 文件存放路径
                            train=True,        # 提取训练集
                            # 将图像转化为 Tensor，在加载數据时，就可以对图像做预处理
                            transform=transforms.ToTensor(),
                            download=True)      # 当找不到文件的时候，自动下載
# 加载测试数据集
test_dataset = dsets.MNIST(root='./data',
                           train=False,
                           transform=transforms.ToTensor())
# 训练数据集的加载器，自动将数据切分成批，顺序随机打乱
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                           batch_size=batch_size,
                                           shuffle=True)
'''                                         
将测试数据分成两部分，一部分作为校验数据，一部分作为测试数据。
校验数据用于检测模型是否过拟合并调整参数，测试数据检验整个模型的工作
'''
# 首先，定义下标数组 indices，它相当于对所有test_dataset 中数据的编码
# 然后，定义下标 indices_val 表示校验集数据的下标，indices_test 表示测试集的下标
indices = range(len(test_dataset))
indices_val = indices[: 5000]
indices_test = indices[5000:]
# 根据下标构造两个数据集的SubsetRandomSampler 来样器，它会对下标进行来样
sampler_val = torch.utils.data.sampler.SubsetRandomSampler(indices_val)
sampler_test = torch.utils.data.sampler. SubsetRandomSampler(indices_test)
# 根据两个采样器定义加载器
# 注意将sampler_val 和sampler_test 分别賦值给了 validation_loader 和 test_loader
validation_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                                                batch_size=batch_size,
                                                shuffle=False,
                                                sampler=sampler_val)
test_loader = torch. utils.data.DataLoader(dataset=test_dataset,
                                           batch_size=batch_size,
                                           shuffle=False,
                                           sampler=sampler_test)
# 随便从数据集中读入一张图片，并绘制出来
idx = 70    # random.randint(1, 100)
# dataset支特下标索引，其中提取出来的元素为 features、target 格式，即属性和标签。[0]表示索引 features
muteimg = train_dataset[idx][0].numpy()
# 一般的图像包含RGB 这了个通道，而 MNIST 数据集的因像都是交度的，只有一个通道
# 因此，我们忽略通道，把图像看作一个灰度矩阵
# 用 imshow 画图，会将交度矩阵自动展现为彩色，不同灰度对应不同的颜色：从黄到紫
plt.imshow(muteimg[0, ...])
plt.title("{}: {}".format('image sample', train_dataset[idx][1]))   # 显示获取到的图片的标签
pylab.show()
'''______________________________获取数据的过程完成______________________________'''


'''______________________________开始构建网络的过程______________________________'''
# 定义卷积神经网络：4和8为人为指定的两个卷积层的厚度(feature map的数量）
depth = [4, 8]
class ConvNet(nn.Module):
    def __init__(self):
        # 该函数在创建一个ConvNet对象即调用语句net=ConvNet()时就会被调用
        # 首先调用父类相应的构造函数
        super(ConvNet, self).__init__()

        # 其次构造ConvNet需要用到的各个神经模块
        # 注意，定义组件并不是卖正搭建组件，只是把基本建筑砖块先找好
        self.conv1 = nn. Conv2d(1, 4, 5, padding=2)     # 定义一个卷积层，输入通道为1，输出通道为4，窗口大小为5，padding为2
        self.pool = nn.MaxPool2d(2, 2)   # 定义一个池化层，一个窗口为2x2的池化运箅
        # 第二层卷积，输入通道为depth[o]，输出通道为depth[2]，窗口为 5，padding 为2
        self.conv2 = nn. Conv2d(depth[0], depth[1], 5, padding=2)    # 输出通道为depth[1]，窗口为5，padding为2
        # 一个线性连接层，输入尺寸为最后一层立方体的线性平铺，输出层 512个节点
        self.fc1 = nn. Linear(image_size // 4 * image_size // 4 * depth[1], 512)

        self. fc2 = nn. Linear(512, num_classes)    # 最后一层线性分类单元，输入为 512，输出为要做分类的类别数

    def forward(self, x):    # 该函数完成神经网络真正的前向运算，在这里把各个组件进行实际的拼装
        # x的尺寸：(batch_size, image_channels, image_width, image_height)
        x = self.conv1(x)   # 第一层卷积
        x = F.relu(x)       # 激活函数用ReLU，防止过拟合
        # x的尺寸：(batch_size, num_filters, image_width, image_height)

        x = self.pool(x)    # 第二层池化，将图片变小
        # x的尺寸：(batch_size, depth[0], image_width/ 2， image_height/2)

        x = self.conv2(x)   # 第三层又是卷积，窗口为5，输入输出通道分列为depth[o]=4,depth[1]=8
        x = F.relu(x)       # 非线性函数
        # x的尺寸：(batch_size, depth[1], image_width/2, image_height/2)

        x = self.pool(x)    # 第四层池化，将图片缩小到原来的 1/4
        # x的尺寸：(batch_size, depth[1], image_width/ 4, image_height/4)

        # 将立体的特征图 tensor 压成一个一维的向量
        # view 函数可以将一个tensor 按指定的方式重新排布
        # 下面这个命令就是要让x按照batch_size * (image_ size//4)^2*depth[1]的方式来排布向量
        x = x.view(-1, image_size // 4 * image_size // 4 * depth[1])
        # x的尺寸：(batch_ size， depth[1J*image width/4*image height/4)

        x = F.relu(self.fc1(x))     # 第五层为全连接，ReLU激活函数
        # x的尺才：(batch_size, 512)

        # 以默认0.5的概率对这一层进行dropout操作，防止过拟合
        x = F.dropout(x, training=self.training)
        x = self.fc2(x)         # 全连接
        # X的尺寸：(batch_size, num_classes)

        # 输出层为 log_Softmax，即概率对数值 log(p(×))。采用log_softmax可以使后面的交叉熵计算更快
        x = F.log_softmax(x, dim=1)
        return x

    def retrieve_features(self, x):
        # 该函数用于提取卷积神经网络的特征图，返回feature_map1,feature_map2为前两层卷积层的特征图
        feature_map1 = F.relu(self.conv1(x))    # 完成第一层卷积
        x = self.pool(feature_map1)             # 完成第一层池化
        # 第二层卷积，两层特征图都存储到了 feature_map1,feature map2 中
        feature_map2 = F.relu(self.conv2(x))
        return (feature_map1, feature_map2)
'''______________________________构造网络的过程完成______________________________'''


'''________________________________开始训练的过程________________________________'''
net = ConvNet()     # 新建一个卷积神经网络的实例。此时convNet的__init()__函数会被自动调用
criterion = nn.CrossEntropyLoss()   # Loss 函数的定义，交叉熵
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)    # 定义优化器，普通的随机梯度下降算法
record = []     # 记录准确率等数值的容器
weights = []     # 每若干步就记录一次卷积核

# 开始训练循环
def rightness(output, target):
    preds = output.data.max(dim=1, keepdim=True)[1]
    return preds.eq(target.data.view_as(preds)).cpu().sum(), len(target)

for epoch in range(num_epochs):
    train_rights = []   # 记录训练数据集准确率的容器
    '''
    下面的enumerate起到构道一个枚举器的作用。在对train_loader做循环选代时，enumerate会自动输出一个数宇指示循环了几次，
    并记录在batch_idx中，它就等于0，1，2，... 
    train_loader 每选代一次，就会输出一对数据data和target，分别对应一个批中的手写数宇图及对应的标签。
    '''
    for batch_idx, (data, target) in enumerate(train_loader):   # 针对容器中的每一个批进行循环
        # 将 Tensor 转化为 Variable, data 为一批图像，target 为一批标签
        data, target = Variable(data), Variable(target)
        # 给网络模型做标记，标志着模型在训练集上训练
        # 这种区分主要是为了打开关闭net的training标志，从而决定是否运行dropout
        net.train()

        output = net(data)  # 神经网络完成一次前馈的计算过程，得到预测输出output
        loss = criterion(output, target)  # 将output与标签target比较，计算误差
        optimizer.zero_grad()  # 清空梯度
        loss.backward()  # 反向传播
        optimizer.step()  # 一步随机梯度下降算法
        right = rightness(output, target)  # 计算准确率所需数值，返回数值为（正确样例数，总样本数）
        train_rights.append(right)  # 将计算结果装到列表容器train_rights中

        if batch_idx % 100 == 0:    # 每间隔100个batch 执行一次打印操作
            net.eval()  # 给网络楧型做标记，标志着模型在训练集上训练
            val_rights = []       # 记录校验数据集准确率的容器

            # 开始在校验集上做循环，计算校验集上的准确度
            for (data, target) in validation_loader:
                data, target = Variable(data), Variable(target)
                # 完成一次前馈计算过程，得到目前训练得到的模型net在校验集上的表现
                output = net(data)
                # 计算准确率所需数值，返回正确的数值为（正确样例数，总样本数）
                right = rightness(output, target)
                val_rights.append(right)
            # 分别计算目前已经计算过的测试集以及全部校验集上模型的表现：分类准确率
            # train_r为一个二元组，分别记录经历过的所有训练集中分类正确的数量和该集合中总的样本数
            # train_r[0]/train_r[1]是训练集的分类准殖度，val_[0]/val_r[1]是校验集的分类准确度
            train_r = (sum([tup[0] for tup in train_rights]), sum([tup[1] for tup in train_rights]))
            # val_r为一个二元组，分别记录校验集中分类正确的数量和该集合中总的样本数
            val_r = (sum([tup[0] for tup in val_rights]), sum([tup[1] for tup in val_rights]))

            # 打印准确率等数值，其中正确率为本训练周期epoch 开始后到目前批的正确率的平均值
            print(val_r)
            print('训练周期: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}\t训练正确率: {:.2f}%\t校验正确率: {:.2f}%'.format(
                epoch, batch_idx * batch_size, len(train_loader.dataset),
                       100. * batch_idx / len(train_loader),
                loss.data,
                       100. * train_r[0].numpy() / train_r[1],
                       100. * val_r[0].numpy() / val_r[1]))

            # 将准确率和权重等数值加载到容器中，方便后续处理
            record.append((100 -100.* train_r[0] / train_r[1], 100 - 100. * val_r[0] / val_r[1]))

            # weights 记录了训练周期中所有卷积核的演化过程，net.conv1.weight 提取出了第一层卷积核的权重
            # Clone 是将weight.data 中的数据做一个备份放到列表中
            # 否则当 weight.data 变化时，列表中的每一项数值也会联动
            # 这里使用clone这个函数很重要
            weights.append([net.conv1.weight.data.clone(), net.conv1.bias.data.clone(),
                            net.conv2.weight.data.clone(), net.conv2.bias.data.clone()])
'''______________________________训练的过程完成______________________________'''

# 绘制训练过程的误差曲线，校验集和测试集上的错误率。
plt.figure(figsize=(10, 7))
plt.title('Training loss curve')
plt.plot(record)  # record记载了每一个打印周期记录的训练和校验数据集上的准确度
plt.xlabel('Steps')
plt.ylabel('Error rate')
pylab.show()


''' 可视化第一层卷积核与特征图 '''
# 提取第一层卷积层的卷积核
plt.figure(figsize=(10, 7))
for i in range(4):
    plt.subplot(1, 4, i+1)
    # 提取第一层卷积核中的权重值，注意conv1是net的属性
    plt.imshow(net.conv1.weight.data.numpy()[i, 0, ...])
plt.title('Convolution kernel of the first convolution layer')
pylab.show()

# 调用net的retrieve_features方法可以抽取出输入当前数据后输出的所有特征图(第一个卷积层和第二个卷积层)
# 首先定义读入的图片，它是从test_dataset中提取第idx个批次的第0个图
# 其次unsqueeze的作用是在最前面添加一维
# 目的是让这个input_x的tensor是四维的，这样才能输给net。补充的那一维表示batch
input_x = test_dataset[idx][0].unsqueeze(0)
# feature maps是有两个元素的列表，分别表示第一层和第二层卷积的所有特征因
feature_maps = net. retrieve_features(Variable(input_x))
plt.figure(figsize=(10, 7))
# 打印出4个特征图
for i in range(4):
    plt.subplot(1, 4, i + 1)
    plt.imshow(feature_maps[0][0, i, ...].data.numpy())
plt.title('Characteristic diagram of the first layer of convolution')
pylab.show()

''' 可视化第二层卷积核与特征图 '''
# 绘制第二层的卷积核，每一列对应一个卷积核，一共有8个卷积核
plt.figure(figsize=(15, 10))
plt.title('Characteristic diagram of the second layer of convolution')
for i in range(4):
    for j in range(8):
        plt.subplot(4, 8, i * 8 + j + 1)
        plt.imshow(net.conv2.weight.data.numpy()[j, i, ...])
pylab.show()

# 绘制第二层的特征图，一共有8个
plt.figure(figsize=(10, 7))
plt.title('Characteristic diagram of the second layer of convolution')
for i in range(8):
    plt. subplot(2, 4, i + 1)
    plt. imshow(feature_maps[1][0, i, ...].data.numpy())
pylab.show()