概述

前几节我们尝试使用与房价预测相同的简单神经网络解决手写数字识别问题，但是效果并不理想。原因是手写数字识别的输入是28 × 28的像素值，输出是0-9的数字标签，而线性回归模型无法捕捉二维图像数据中蕴含的复杂信息，如 图1 所示。无论是牛顿第二定律任务，还是房价预测任务，输入特征和输出预测值之间的关系均可以使用“直线”刻画（使用线性方程来表达）。但手写数字识别任务的输入像素和输出数字标签之间的关系显然不是线性的，甚至这个关系复杂到我们靠人脑难以直观理解的程度。

图1：数字识别任务的输入和输入不是线性关系

因此，我们需要尝试使用其他更复杂、更强大的网络来构建手写数字识别任务，观察一下训练效果，即将“横纵式”教学法从横向展开，如 图2 所示。本节主要介绍两种常见的网络结构：经典的多层全连接神经网络和卷积神经网络。

【手写数字识别】之网络结构 - 图2

图2：“横纵式”教学法 — 网络结构优化

在介绍网络结构前，需要先进行数据处理，代码与上一节保持一致。

  1. 2020-03-26 15:24:28,868-INFO: font search path ['/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/mpl-data/fonts/ttf', '/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/mpl-data/fonts/afm', '/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/mpl-data/fonts/pdfcorefonts']
  2. 2020-03-26 15:24:29,250-INFO: generated new fontManager

经典的全连接神经网络

图3：手写数字识别任务的全连接神经网络结构

  • 输入层：将数据输入给神经网络。在该任务中，输入层的尺度为28×28的像素值。
  • 隐含层：增加网络深度和复杂度，隐含层的节点数是可以调整的，节点数越多，神经网络表示能力越强，参数量也会增加。在该任务中，中间的两个隐含层为10×10的结构，通常隐含层会比输入层的尺寸小，以便对关键信息做抽象，激活函数使用常见的sigmoid函数。
  • 输出层：输出网络计算结果，输出层的节点数是固定的。如果是回归问题，节点数量为需要回归的数字数量。如果是分类问题，则是分类标签的数量。在该任务中，模型的输出是回归一个数字，输出层的尺寸为1。

说明：

隐含层引入非线性激活函数sigmoid是为了增加神经网络的非线性能力。

举例来说，如果一个神经网络采用线性变换，有四个输入

【手写数字识别】之网络结构 - 图4 ~ ，一个输出 【手写数字识别】之网络结构 - 图6 。假设第一层的变换是 和 【手写数字识别】之网络结构 - 图8 ，第二层的变换是 ，则将两层的变换展开后得到 【手写数字识别】之网络结构 - 图10 。也就是说，无论中间累积了多少层线性变换，原始输入和最终输出之间依然是线性关系。

Sigmoid是早期神经网络模型中常见的非线性变换函数，通过如下代码，绘制出Sigmoid的函数曲线。

  2.     # 直接返回sigmoid函数
  3.     return 1. / (1. + np.exp(-x))
  5. # param:起点，终点，间距
  6. x = np.arange(-8, 8, 0.2)
  7. y = sigmoid(x)
  8. plt.plot(x, y)
  9. plt.show()

针对手写数字识别的任务，网络层的设计如下：

  • 输入层的尺度为28×28，但批次计算的时候会统一加1个维度（大小为bitchsize）。
  • 中间的两个隐含层为10×10的结构，激活函数使用常见的sigmoid函数。
  • 与房价预测模型一样，模型的输出是回归一个数字，输出层的尺寸设置成1。 
  1. # 多层全连接神经网络实现
  2. class MNIST(fluid.dygraph.Layer):
  3.     def __init__(self, name_scope):
  4.         super(MNIST, self).__init__(name_scope)
  5.         # 定义两层全连接隐含层，输出维度是10，激活函数为sigmoid
  6.         self.fc1 = Linear(input_dim=784, output_dim=10, act='sigmoid') # 隐含层节点为10，可根据任务调整
  7.         self.fc2 = Linear(input_dim=10, output_dim=10, act='sigmoid')
  8.         # 定义一层全连接输出层，输出维度是1，不使用激活函数
  9.         self.fc3 = Linear(input_dim=10, output_dim=1, act=None)
  11.     # 定义网络的前向计算
  12.     def forward(self, inputs, label=None):
  13.         inputs = fluid.layers.reshape(inputs, [inputs.shape[0], 784])
  14.         outputs1 = self.fc1(inputs)
  15.         outputs2 = self.fc2(outputs1)
  16.         outputs_final = self.fc3(outputs2)
  17.         return outputs_final
  1. #网络结构部分之后的代码，保持不变
  2. with fluid.dygraph.guard():
  3.     model = MNIST("mnist")
  4.     model.train()
  5.     #调用加载数据的函数，获得MNIST训练数据集
  6.     train_loader = load_data('train')
  7.     optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.01, parameter_list=model.parameters())
  8.     # 训练5轮
  9.     EPOCH_NUM = 5
  10.     for epoch_id in range(EPOCH_NUM):
  11.         for batch_id, data in enumerate(train_loader()):
  12.             #准备数据
  13.             image_data, label_data = data
  15.             label = fluid.dygraph.to_variable(label_data)
  17.             #前向计算的过程
  18.             predict = model(image)
  20.             #计算损失，取一个批次样本损失的平均值
  21.             loss = fluid.layers.square_error_cost(predict, label)
  22.             avg_loss = fluid.layers.mean(loss)
  24.             #每训练了200批次的数据，打印下当前Loss的情况
  25.             if batch_id % 200 == 0:
  26.                 print("epoch: {}, batch: {}, loss is: {}".format(epoch_id, batch_id, avg_loss.numpy()))
  28.             #后向传播，更新参数的过程
  29.             avg_loss.backward()
  30.             optimizer.minimize(avg_loss)
  31.             model.clear_gradients()
  33.     #保存模型参数
  34.     fluid.save_dygraph(model.state_dict(), 'mnist')

卷积神经网络

虽然使用经典的神经网络可以提升一定的准确率，但对于计算机视觉问题，效果最好的模型仍然是卷积神经网络。卷积神经网络针对视觉问题的特点进行了网络结构优化，更适合处理视觉问题。

卷积神经网络由多个卷积层和池化层组成，如 图4 所示。卷积层负责对输入进行扫描以生成更抽象的特征表示，池化层对这些特征表示进行过滤，保留最关键的特征信息。

【手写数字识别】之网络结构 - 图12

图4：在处理计算机视觉任务中大放异彩的卷积神经网络

说明：

本节只介绍手写数字识别在卷积神经网络的实现以及它带来的效果提升。读者可以将卷积神经网络先简单的理解成是一种比经典的全连接神经网络更强大的模型即可，更详细的原理和实现在接下来的中讲述。

两层卷积和池化的神经网络实现如下代码所示。

  1. # 多层卷积神经网络实现
  2. class MNIST(fluid.dygraph.Layer):
  3.      def __init__(self, name_scope):
  4.          super(MNIST, self).__init__(name_scope)
  6.          # 定义卷积层，输出特征通道num_filters设置为20，卷积核的大小filter_size为5，卷积步长stride=1，padding=2
  7.          # 激活函数使用relu
  8.          self.conv1 = Conv2D(num_channels=1, num_filters=20, filter_size=5, stride=1, padding=2, act='relu')
  9.          # 定义池化层，池化核pool_size=2，池化步长为2，选择最大池化方式
  10.          self.pool1 = Pool2D(pool_size=2, pool_stride=2, pool_type='max')
  11.          # 定义卷积层，输出特征通道num_filters设置为20，卷积核的大小filter_size为5，卷积步长stride=1，padding=2
  12.          self.conv2 = Conv2D(num_channels=20, num_filters=20, filter_size=5, stride=1, padding=2, act='relu')
  13.          # 定义池化层，池化核pool_size=2，池化步长为2，选择最大池化方式
  14.          self.pool2 = Pool2D(pool_size=2, pool_stride=2, pool_type='max')
  15.          # 定义一层全连接层，输出维度是1，不使用激活函数
  17.     # 定义网络前向计算过程，卷积后紧接着使用池化层，最后使用全连接层计算最终输出
  18.      def forward(self, inputs):
  20.          x = self.pool1(x)
  21.          x = self.conv2(x)
  22.          x = self.pool2(x)
  23.          x = fluid.layers.reshape(x, [x.shape[0], -1])
  24.          x = self.fc(x)
  25.          return x

训练定义好的卷积神经网络，代码如下所示。

  1. #网络结构部分之后的代码，保持不变
  2. with fluid.dygraph.guard():
  3.     model = MNIST("mnist")
  4.     model.train()
  5.     #调用加载数据的函数
  6.     train_loader = load_data('train')
  7.     optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.01, parameter_list=model.parameters())
  8.     EPOCH_NUM = 5
  9.     for epoch_id in range(EPOCH_NUM):
  10.         for batch_id, data in enumerate(train_loader()):
  11.             #准备数据
  12.             image_data, label_data = data
  13.             image = fluid.dygraph.to_variable(image_data)
  14.             label = fluid.dygraph.to_variable(label_data)
  16.             #前向计算的过程
  17.             predict = model(image)
  19.             #计算损失，取一个批次样本损失的平均值
  20.             loss = fluid.layers.square_error_cost(predict, label)
  21.             avg_loss = fluid.layers.mean(loss)
  23.             #每训练了100批次的数据，打印下当前Loss的情况
  24.             if batch_id % 200 == 0:
  25.                 print("epoch: {}, batch: {}, loss is: {}".format(epoch_id, batch_id, avg_loss.numpy()))
  27.             #后向传播，更新参数的过程
  28.             avg_loss.backward()
  29.             optimizer.minimize(avg_loss)
  30.             model.clear_gradients()
  32.     #保存模型参数
  33.     fluid.save_dygraph(model.state_dict(), 'mnist')