【3.1】卷积神经网络

tensorflow 阅读量：次

本节目标:学会使用 CNN 实现对手写数字的识别

一、概念

全连接 NN:

每个神经元与前后相邻层的每一个神经元都有连接关系，输入是 特征，输出为预测的结果。

参数个数:∑ (前层 × 后层 + 后层)

一张分辨率仅仅是 28x28 的黑白图像，就有近 40 万个待优化的参数。现实 生活中高分辨率的彩色图像，像素点更多，且为红绿蓝三通道信息。

待优化的参数过多，容易导致模型过拟合。为避免这种现象，实际应用中一 般不会将原始图片直接喂入全连接网络。

在实际应用中，会先对原始图像进行特征提取，把提取到的特征喂给全连接 网络，再让全连接网络计算出分类评估值。

例:先将此图进行多次特征提取，再把提取后的计算机可读特征喂给全连接 网络。

卷积 Convolutional

卷积是一种有效提取图片特征的方法。一般用一个正方形卷积核，遍历图片 上的每一个像素点。图片与卷积核重合区域内相对应的每一个像素值乘卷积核 内相对应点的权重，然后求和，再加上偏置后，最后得到输出图片中的一个像 素值。

例:上面是 5x5x1 的灰度图片，1 表示单通道，5x5 表示分辨率，共有 5 行 5 列个灰度值。若用一个 3x3x1 的卷积核对此 5x5x1 的灰度图片进行卷积，偏置项b=1，则求卷积的计算是:(-1)x1+0x0+1x2+(-1)x5+0x4+1x2+(-1)x3+0x4+1x5+1=1(注 意不要忘记加偏置 1)。

输出图片边长=(输入图片边长–卷积核长+1)/步长，此图为:(5 – 3 + 1)/ 1 = 3，输出图片是 3x3 的分辨率，用了 1 个卷积核，输出深度是 1，最后输出的是 3x3x1 的图片。

全零填充 Padding

有时会在输入图片周围进行全零填充，这样可以保证输出图片的尺寸和输入 图片一致。

例:在前面 5x5x1 的图片周围进行全零填充，可使输出图片仍保持 5x5x1 的 维度。这个全零填充的过程叫做 padding

输出数据体的尺寸=(W−F+2P)/S+1

W:输入数据体尺寸，F:卷积层中神经元感知域，S:步长，P:零填充的数 量。

例:输入是 7×7，滤波器是 3×3，步长为 1，填充为 0，那么就能得到一个 5×5 的输出。如果步长为 2，输出就是 3×3。

如果输入量是 32x32x3，核是 5x5x3，不用全零填充，输出是(32-5+1)/1=28，如果要让输出量保持在 32x32x3，可以对该层加一个大小为 2 的零填充。可以根 据需求计算出需要填充几层零。32=(32-5+2P)/1 +1，计算出 P=2，即需填充 2层零。

使用 padding 和不使用 padding 的输出维度

上一行公式是使用 padding 的输出图片边长，下一行公式是不使用 padding 的输出图片边长。公式如果不能整除，需要向上取整数。如果用全零填充，也就 是 padding=SAME。如果不用全零填充，也就是 padding=VALID。

Tensorflow 给出的计算卷积的函数

函数中要给出四个信息:对输入图片的描述、对卷积核的描述、对卷积核滑动步长的描述以及是否使用 padding。

1)对输入图片的描述:用 batch 给出一次喂入多少张图片，每张图片的分 辨率大小，比如 5 行 5 列，以及这些图片包含几个通道的信息，如果是灰度图 则为单通道，参数写 1，如果是彩色图则为红绿蓝三通道，参数写 3。

2)对卷积核的描述:要给出卷积核的行分辨率和列分辨率、通道数以及用 了几个卷积核。比如上图描述，表示卷积核行列分辨率分别为 3 行和 3 列，且是 1 通道的，一共有 16 个这样的卷积核，卷积核的通道数是由输入图片的通道数 决定的，卷积核的通道数等于输入图片的通道数，所以卷积核的通道数也是 1。 一共有 16 个这样的卷积核，说明卷积操作后输出图片的深度是 16，也就是输出 为 16 通道。

3)对卷积核滑动步长的描述:上图第二个参数表示横向滑动步长，第三个 参数表示纵向滑动步长。第一个 1 和最后一个 1 这里固定的。这句表示横向纵向 都以 1 为步长。

4)是否使用 padding:用的是 VALID。注意这里是以字符串的形式给出 VALID。

对多通道的图片求卷积

多数情况下，输入的图片是 RGB 三个颜色组成的彩色图，输入的图片包含了 红、绿、蓝三层数据，卷积核的深度应该等于输入图片的通道数，所以使用 3x3x3 的卷积核，最后一个 3 表示匹配输入图像的 3 个通道，这样这个卷积核有三层， 每层会随机生成 9 个待优化的参数，一共有 27 个待优化参数 w 和一个偏置 b。

对于彩色图，按层分解开，可以直观表示为上面这张图，三个颜色分量:红色分量、绿色分量和蓝色分量。

卷积计算方法和单层卷积核相似，卷积核为了匹配红绿蓝三个颜色，把三层 的卷积核套在三层的彩色图片上，重合的 27 个像素进行对应点的乘加运算，最 后的结果再加上偏置项 b，求得输出图片中的一个值。

这个 5x5x3 的输入图片加了全零填充，使用 3x3x3 的卷积核，所有 27 个点与 对应的待优化参数相乘，乘积求和再加上偏置 b 得到输出图片中的一个值 6。

针对上面这幅彩色图片，用 conv2d 函数实现可以表示为:

一次输入 batch 张图片，输入图片的分辨率是 5x5，是 3 通道的，卷积核是 3x3x3，一共有 16 个卷积核，这样输出的深度就是 16，核滑动横向步长是 1，纵 向步长也是 1，padding 选择 same，保证输出是 5x5 分辨率。由于一共用了 16 个卷积核，所以输出图片是 5x5x16。

池化 Pooling

池化用于减少特征向量

最大池化（提取池子里最大的值）可提取图片纹理，均值池化（提取池子的均值）可保留背景特征。

Tensorflow 给出了计算池化的函数。最大池化用 tf.nn.max_pool 函数，平均池化用 tf.nn.avg_pool 函数。 函数中要给出四个信息，对输入的描述、对池化核的描述、对池化核滑动步 长的描述和是否使用 padding。

  1. 对输入的描述:给出一次输入 batch 张图片、行列分辨率、输入通道的个 数。
  2. 对池化核的描述:只描述行分辨率和列分辨率，第一个和最后一个参数 固定是 1。
  3. 对池化核滑动步长的描述:只描述横向滑动步长和纵向滑动步长，第一 个和最后一个参数固定是 1。
  4. 是否使用 padding:padding 可以是使用零填充 SAME 或者不使用零填充 VALID。

舍弃 Dropout

在神经网络训练过程中，为了减少过多参数常使用 dropout 的方法，将一部 分神经元按照一定概率从神经网络中舍弃。这种舍弃是临时性的，仅在训练时舍 弃一些神经元;在使用神经网络时，会把所有的神经元恢复到神经网络中。比如 上面这张图，在训练时一些神经元不参加神经网络计算了。Dropout 可以有效减 少过拟合。

Tensorflow 提供的 dropout 的函数:用 tf.nn.dropout 函数。第一个参数链接 上一层的输出，第二个参数给出神经元舍弃的概率。

在实际应用中，常常在前向传播构建神经网络时使用 dropout 来减小过拟合 加快模型的训练速度。

dropout 一般会放到全连接网络中。如果在训练参数的过程中，输出 =tf.nn.dropout(上层输出，暂时舍弃神经元的概率)，这样就有指定概率的神经 元被随机置零，置零的神经元不参加当前轮的参数优化。

卷积 NN:借助卷积核(kernel)提取特征后，送入全连接网络。

卷积神经网络可以认为由两部分组成，一部分是对输入图片进行特征提取， 另一部分就是全连接网络，只不过喂入全连接网络的不再是原始图片，而是经过 若干次卷积、激活和池化后的特征信息。

卷积神经网络从诞生到现在，已经出现了许多经典网络结构，比如 Lenet-5、 Alenet、VGGNet、GoogleNet 和 ResNet 等。每一种网络结构都是以卷积、激活、 池化、全连接这四种操作为基础进行扩展。

Lenet-5 是最早出现的卷积神经网络，由 Lecun 团队首先提出，Lenet-5 有效 解决了手写数字的识别问题。

二、Lenet 神经网络

Lenet 神经网络是 Yann LeCun 等人在 1998 年提出的，该神经网络充分考虑图像 的相关性。

Lenet 神经网络结构为:

  1. 输入为 32321 的图片大小，为单通道的输入;
  2. 进行卷积，卷积核大小为 551，个数为 6，步长为 1，非全零填充模式;
  3. 将卷积结果通过非线性激活函数;
  4. 进行池化，池化大小为 2*2，步长为 1，全零填充模式;
  5. 进行卷积，卷积核大小为 556，个数为 16，步长为 1，非全零填充模式;
  6. 将卷积结果通过非线性激活函数;
  7. 进行池化，池化大小为 2*2，步长为 1，全零填充模式;
  8. 全连接层进行 10 分类。

Lenet 神经网络的结构图及特征提取过程如下所示:

Lenet 神经网络的输入是 32321，经过 551 的卷积核，卷积核个数为 6 个， 采用非全零填充方式，步长为 1，根据非全零填充计算公式:输出尺寸=(输入 尺寸-卷积核尺寸+1)/步长=(32-5+1)/1=28.故经过卷积后输出为 28286。 经过第一层池化层，池化大小为 22，全零填充，步长为 2，由全零填充计算公 式:输出尺寸=输入尺寸/步长=28/2=14，池化层不改变深度，深度仍为 6。用同样计算方法，得到第二层池化后的输出为 55*16。将第二池化层后的输出拉直 送入全连接层。

根据 Lenet 神经网络的结构可得，Lenet 神经网络具有如下特点:

  1. 卷积(Conv)、池化(ave-pooling)、非线性激活函数(sigmoid)相互交替;
  2. 层与层之间稀疏连接，减少计算复杂度。

对 Lenet 神经网络进行微调，使其适应 Mnist 数据集:

由于 Mnist 数据集中图片大小为 28281 的灰度图片，而 Lenet 神经网络的输入 为 32321，故需要对 Lenet 神经网络进行微调。

  1. 输入为 28281 的图片大小，为单通道的输入;
  2. 进行卷积，卷积核大小为 551，个数为32，步长为1，全零填充模式;
  3. 将卷积结果通过非线性激活函数;
  4. 进行池化，池化大小为 22，步长为 2，全零填充模式; 5. 进行卷积，卷积核大小为 55*32，个数为 64，步长为 1，全零填充模式;
  5. 将卷积结果通过非线性激活函数;
  6. 进行池化，池化大小为 2*2，步长为 2，全零填充模式;
  7. 全连接层，进行 10 分类。

Lenet 进行微调后的结构如下所示:

Lenet 神经网络在 Mnist 数据集上的实现，主要分为三个部分:前向传播过程 (mnist_lenet5_forward.py)、反向传播过程(mnist_lenet5_backword.py)、 测试过程(mnist_lenet5_test.py)。

第一，前向传播过程(mnist_lenet5_forward.py)实现对网络中参数和偏置的 初始化、定义卷积结构和池化结构、定义前向传播过程。具体代码如下所示:

注释:

1)定义前向传播过程中常用到的参数。 图片大小即每张图片分辨率为 28*28，故 IMAGE_SIZE 取值为 28;Mnist 数据集 为灰度图，故输入图片通道数 NUM_CHANNELS 取值为 1;第一层卷积核大小为 5， 卷积核个数为 32，故 CONV1_SIZE 取值为 5，CONV1_KERNEL_NUM 取值为 32;第二 层卷积核大小为 5，卷积核个数为 64，故 CONV2_SIZE 取值为 5，CONV2_KERNEL_NUM为 64;全连接层第一层为 512 个神经元，全连接层第二层为 10 个神经元，故 FC_SIZE 取值为 512，OUTPUT_NODE 取值为 10，实现 10 分类输出。

2)把前向传播过程中，常用到的方法定义为函数，方便调用。 在 mnist_lenet5_forward.py 文件中，定义四个常用函数:权重 w 生成函数、偏 置 b 生成函数、卷积层计算函数、最大池化层计算函数，其中，权重 w 生成函数 和偏置 b 生成函数与之前的定义相同。

卷积层计算函数描述如下:

tf.nn.conv2d(输入描述[batch,行分辨率,列分辨率,通道数]，
卷积核描述[行分辨率,列分辨率,通道数,卷积核个数]， 核滑动步长[1,行步长,列步长,1]，
填充模式 padding)

例如:

tf.nn.conv2d(x=[100,28,28,1], w=[5,5,1,6], strides=[1,1,1,1],padding='SAME')

本例表示卷积输入 x 为 28281，一个 batch_size 为 100，卷积核大小为 5*5， 卷积核个数为 6，垂直方向步长为 1，水平方向步长为 1，填充方式为全零填充。

最大池化层计算函数描述如下:

tf.nn.max_pool(输入描述[batch,行分辨率，列分辨率，通道数]，
池化核描述[1,行分辨率,列分辨率,1]， 池化核滑动步长[1,行步长,列步长,1]， 填充模式 padding)

例如:

tf.nn.max_pool(x=[100,28,28,1],ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1],
padding='SAME')

本例表示卷积输入 x 为 28281，一个 batch_size 为 100，池化核大小用 ksize， 第一维和第四维都为 1，池化核大小为 2*2，垂直方向步长为 1，水平方向步长 为 1，填充方式为全零填充

3)定义前向传播过程

3.1)实现第一层卷积

conv1_w =get_weight([CONV1_SIZE,CONV1_SIZE,NUM_CHANNELS,CONV1_KERNEL_NUM],regularizer)
conv1_b = get_bias([CONV1_KERNEL_NUM])

根据先前定义的参数大小，初始化第一层卷积核和偏置项。

conv1 = conv2d(x, conv1_w)

实现卷积运算，输入参数为 x 和第一层卷积核参数。

relu1 = tf.nn.relu(tf.nn.bias_add(conv1, conv1_b)

第一层卷积的输出值作为非线性激活函数的输入值，首先通过 tf.nn.bias_add() 对卷积后的输出添加偏置，并过 tf.nn.relu()完成非线性激活。

pool1 = max_pool_2x2(relu1)

根据先前定义的池化函数，将第一层激活后的输出值进行最大池化。

tf.nn.relu()用来实现非线性激活，相比 sigmoid 和 tanh 函数，relu 函数可 以实现快速的收敛。

3.2)实现第二层卷积

conv2_w =get_weight([CONV2_SIZE,CONV2_SIZE,CONV1_KERNEL_NUM, CONV2_KERNEL_NUM],regularizer)
conv2_b = get_bias([CONV2_KERNEL_NUM])

初始化第二层卷积层的变量和偏置项，该层每个卷积核的通道数要与上一层 卷积核的个数一致。

conv2 = conv2d(pool1, conv2_w)

实现卷积运算，输入参数为上一层的输出 pool1 和第二层卷积核参数。

relu2 = tf.nn.relu(tf.nn.bias_add(conv2, conv2_b))

实现第二层非线性激活函数。

pool2 = max_pool_2x2(relu2)

根据先前定义的池化函数，将第二层激活后的输出值进行最大池化。

3.3)将第二层池化层的输出 pool2 矩阵转化为全连接层的输入格式即向量形式:

pool_shape = pool2.get_shape().as_list()

根据.get_shape()函数得到 pool2 输出矩阵的维度，并存入 list 中。其中， pool_shape[0]为一个 batch 值。

nodes = pool_shape[1] * pool_shape[2] * pool_shape[3]

从list中依次取出矩阵的长宽及深度，并求三者的乘积，得到矩阵被拉长后的 长度。

reshaped = tf.reshape(pool2, [pool_shape[0], nodes])

将 pool2 转换为一个 batch 的向量再传入后续的全连接。

get_shape函数用于获取一个张量的维度，并且输出张量每个维度上面的值。 例如:

A = tf.random_normal(shape=[3,4])
print A.get_shape()

输出结果为:(3，4)

3.4)实现第三层全连接层:

fc1_w = get_weight([nodes, FC_SIZE], regularizer)

初始化全连接层的权重，并加入正则化。

fc1_b = get_bias([FC_SIZE])

初始化全连接层的偏置项。

fc1 = tf.nn.relu(tf.matmul(reshaped, fc1_w) + fc1_b)

将转换后的 reshaped 向量与权重 fc1_w 做矩阵乘法运算，然后再加上偏置，最 后再使用 relu 进行激活。

if train: fc1 = tf.nn.dropout(fc1, 0.5)

如果是训练阶段，则对该层输出使用 dropout，也就是随机的将该层输出中的一 半神经元置为无效，是为了避免过拟合而设置的，一般只在全连接层中使用。

3.5)实现第四层全连接层的前向传播过程:

fc2_w = get_weight([FC_SIZE, OUTPUT_NODE], regularizer)
fc2_b = get_bias([OUTPUT_NODE])

初始化全连接层对应的变量。

y = tf.matmul(fc1, fc2_w) + fc2_b

将转换后的 reshaped 向量与权重 fc2_w 做矩阵乘法运算，然后再加上偏置。 return y 返回输出值有，完成整个前向传播过程，从而实现对 Mnist 数据集的 10 分类。

第二，反向传播过程(mnist_lenet5_backward.py)，完成训练神经网络的参数。

具体代码如下所示:

注释:

1)定义训练过程中的超参数

规定一个 batch 的数量为 100，故 BATCH_SIZE 取值为 100;设定初始学习率为 0.005.学习率衰减率为 0.99;最大迭代次数为 50000，故 STEPS 取值为 50000; 滑动平均衰减率设置为 0.99，并规定模型保存路径以及保存的模型名称。

2)完成反向传播过程

2.1) 给 x, y_是占位

x = tf.placeholder(tf.float32,[
    BATCH_SIZE,
   mnist_lenet5_forward.IMAGE_SIZE,
   mnist_lenet5_forward.IMAGE_SIZE,
   mnist_lenet5_forward.NUM_CHANNELS])
y_ = tf.placeholder(tf.float32, [None,mnist_lenet5_forward.OUTPUT_NODE])

x,y_是定义的占位符，指定参数为浮点型。由于卷积层输入为四阶张量，故 x 的占位符表示为上述形式，第一阶表示每轮喂入的图片数量，第二阶和第三阶分 别表示图片的行分辨率和列分辨率，第四阶表示通道数。

x = tf.placeholder(dtype,shape,name=None) tf.placeholder()

函数有三个参数，dtype 表示数据类型，常用的类型为 tf,float32,tf.float64 等数值类型，shape 表示数据形状，namen 表示名称。

2.2) 调用前向传播过程

y = mnist_lenet5_forward.forward(x,True, REGULARIZER)

调用前向传播网络得到维度为 10 的 tensor。

2.3) 求含有正则化的损失值

global_step = tf.Variable(0, trainable=False)

声明一个全局计数器，并输出化为 0

ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.argmax(y_, 1))

对网络最后一层的输出 y 做softmax，求取输出属于某一类的概率，结果为一个num_classes 大小的向量，再将此向量和实际标签值做交叉熵，返回一个向量值。

cem = tf.reduce_mean(ce)

通过 tf.reduce_mean()函数对得到的向量求均值，得到 loss。

loss = cem + tf.add_n(tf.get_collection('losses'))

添加正则化中的 losses 值到 loss 中。

sparse_softmax_cross_entropy_with_logits(_sentinel=None, labels=None,ogits=None,name=None)

此函数的参数 logits 为神经网络最后一层的输出，它的大小为[batch_size,num_classes]，参数 labels 表示实际标签值，大小为[batch_size,num_classes]。 第一步是先对网络最后一层的输出做一个 softmax，输出为属于某一属性的概率向量;再将概率向量与实际标签向量做交叉熵，返回向量。

tf.reduce_mean( input_tensor,reduction_indices=None, keep_dims=False,name=None)

此函数表示对得到的向量求取均值。参数 input_tensor 表示要减少的张量;

参数 reduction_indices 表示求取均值的维度;参数 keep_dims 含义为:如果 为 true，则保留长度为 1 的缩小尺寸。name 表示操作的名称。

例如:

x = tf.constant([[1., 1.], [2., 2.]])
tf.reduce_mean(x)  #表示对向量整体求均值 1.5
tf.reduce_mean(x, 0)  #表示对向量在列上求均值[1.5, 1.5]
tf.reduce_mean(x, 1)  #表示对向量在行上求均值[1., 2.]

2.4) 实现指数衰减学习率

learning_rate = tf.train.exponential_decay(LEARNING_RATE_BASE, global_step,mnist.train.num_examples / BATCH_SIZE, LEARNING_RATE_DECAY,staircase=True)

tf.train.exponential_decay 函数中参数 LEARNING_RATE_BASE 表示初始学习率， 参数 LEARNING_RATE_DECAY 表示学习率衰减速率。实现指数级的减小学习率，可 以让模型在训练的前期快速接近较优解，又可以保证模型在训练后期不会有太大 波动。其中，当 staircase=True 时，为阶梯形衰减，(global_step/ decay_steps)则被转化为整数;当 staircase=False 时，为曲线形衰减，以此 根据 staircase 来选择不同的衰减方式。

计算公式为:

decayed_learning_rate=learining_rate*decay_rate^(global_step/decay_steps) 
train_step=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss,global_step=global_step)

此函数的参数 learning_rate为传入的学习率，构造一个实现梯度下降算法的优化器，再通过使用 minimize 更新存储要训练的变量的列表来减小 loss。

2.5) 实现滑动平均模型

ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
ema_op = ema.apply(tf.trainable_variables())

tf.train.ExponentialMovingAverage 函数采用滑动平均的方法更新参数。此函 数的参数 MOVING_AVERAGE_DECAY 表示衰减速率，用于控制模型的更新速度;此 函数维护一个影子变量，影子变量初始值为变量初始值。影子变量值的更新方式

如下:

shadow_variable = decay * shadow_variable + (1-decay) * variable。

其中，shadow_variable 是影子变量，variable 表示待更新的变量，decay 为衰 减速率。decay 一般设为接近于 1 的数(0.99,0.999)，decay 越大模型越稳定。

2.6) 将 train_step 和 ema_op 两个训练操作绑定到 train_op 上

with tf.control_dependencies([train_step, ema_op]):
	train_op = tf.no_op(name='train')

2.7)实例化一个保存和恢复变量的 saver，并创建一个会话

saver = tf.train.Saver()
with tf.Session() as sess:
	init_op = tf.global_variables_initializer()
	sess.run(init_op)

	#创建一个会话，并通过python中的上下文管理器来管理这个会话，初始化 计算图中的变量，并用 sess.run 实现初始化。
	ckpt = tf.train.get_checkpoint_state(MODEL_SAVE_PATH)
	if ckpt and ckpt.model_checkpoint_path:
		saver.restore(sess, ckpt.model_checkpoint_path)
	#通过 checkpoint文件定位到最新保存的模型，若文件存在，则加载最新的 模型。
    for i in range(STEPS):
        xs, ys = mnist.train.next_batch(BATCH_SIZE)
        reshaped_xs = np.reshape(xs,(
                    BATCH_SIZE,
                    mnist_lenet5_forward.IMAGE_SIZE,
                    mnist_lenet5_forward.IMAGE_SIZE,
                    mnist_lenet5_forward.NUM_CHANNELS))

读取一个 batch 数据，将输入数据 xs 转成与网络输入相同形状的矩阵。

_, loss_value, step = sess.run([train_op, loss, global_step], feed_dict={x: reshaped_xs, y_: ys})

喂入训练图像和标签，开始训练。

if i % 100 == 0:
	print("After %d training step(s), loss on training batch is %g." % (step, loss_value))
	#每迭代 100 次打印 loss 信息，并保存最新的模型。

训练 Lenet 网络后，输出结果如下:

由运行结果可以看出，损失值在不断减小，且可以实现断点续训。

第三，测试过程(mnist_lenet5_test.py)，对 Mnist 数据集中的测试数据进行 预测，测试模型准确率。具体代码如下所示:

注释:

  1. 在测试程序中使用的是训练好的网络，故不使用 dropout，而是让所有神经 元都参与运算，从而输出识别准确率。

2)correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))

tf.equaf(x,y) 此函数用于判断函数的两个参数 x 与 y 是否相等，一般 x 表示预测值，y 表示实 际值。

  1. accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) 求平均得到预测准确率。

在测试集上，输出结果如下:

由输出结果表明，在测试集上的准确率可以达到 99%左右，Lenet 性能良好。

三、课程中 Lenet5 源码的全文注释

mnist_lenet5_forward.py

#coding:utf-8
import tensorflow as tf

# 设定神经网络的超参数

# 定义神经网络可以接收的图片的尺寸和通道数 
IMAGE_SIZE = 28
NUM_CHANNELS = 1

# 定义第一层卷积核的大小和个数 
CONV1_SIZE = 5 
CONV1_KERNEL_NUM = 32

# 定义第二层卷积核的大小和个数 
CONV2_SIZE = 5 
CONV2_KERNEL_NUM = 64

# 定义第三层全连接层的神经元个数 
FC_SIZE = 512
# 定义第四层全连接层的神经元个数 
OUTPUT_NODE = 10

# 定义初始化网络权重函数
def get_weight(shape, regularizer):
	''' args:
	shape:生成张量的维度
	regularizer: 正则化项的权重 
	'''
	# tf.truncated_normal 生成去掉过大偏离点的正态分布随机数的张量，stddev 是指定标准差
	w = tf.Variable(tf.truncated_normal(shape,stddev=0.1))
	# 为权重加入 L2 正则化，通过限制权重的大小，使模型不会随意拟合训练数据中的随机噪音
	if regularizer != None: tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w)) 
	return w

# 定义初始化偏置项函数 
def get_bias(shape):
	''' args:
	shape:生成张量的维度 
	'''
	b = tf.Variable(tf.zeros(shape)) # 统一将 bias 初始化为 0
	return b

# 定义卷积计算函数 
def conv2d(x,w):
	''' 
	args:
		x: 一个输入 batch
		w: 卷积层的权重 
	'''
	
	# strides 表示卷积核在不同维度上的移动步长为 1，第一维和第四维一定是 1，这是因为卷积层的步 长只对矩阵的长和宽有效;
	# padding='SAME'表示使用全 0 填充，而'VALID'表示不填充 
	return tf.nn.conv2d(x, w, strides=[1, 1, 1, 1], padding='SAME')

# 定义最大池化操作函数
def max_pool_2x2(x): 
	'''
	args:
		x: 一个输入 batch
	'''
	# ksize 表示池化过滤器的边长为 2，strides 表示过滤器移动步长是 2，'SAME'提供使用全 0 填充 
	return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

#定义前向传播的过程
def forward(x, train, regularizer):
	''' 
	args:
		x: 一个输入 batch
		train: 用于区分训练过程 True，测试过程 False regularizer:正则化项的权重
	'''
	# 实现第一层卷积层的前向传播过程
	conv1_w = get_weight([CONV1_SIZE, CONV1_SIZE,NUM_CHANNELS, CONV1_KERNEL_NUM], regularizer) # 初始化卷积核

	conv1_b = get_bias([CONV1_KERNEL_NUM]) # 初始化偏置项
	conv1 = conv2d(x, conv1_w) # 实现卷积运算
	relu1 = tf.nn.relu(tf.nn.bias_add(conv1, conv1_b)) # 对卷积后的输出添加偏置，并过 relu 非线性激活
	函数
	pool1 = max_pool_2x2(relu1) # 将激活后的输出进行最大池化
	
	# 实现第二层卷积层的前向传播过程，并初始化卷积层的对应变量
	conv2_w = get_weight([CONV2_SIZE, CONV2_SIZE,CONV1_KERNEL_NUM,CONV2_KERNEL_NUM],regularizer) # 该层每个卷积核的通道数要与上一层卷积核的个数一致

	conv2_b = get_bias([CONV2_KERNEL_NUM])
	conv2 = conv2d(pool1, conv2_w) # 该层的输入就是上一层的输出 pool1 
	relu2 = tf.nn.relu(tf.nn.bias_add(conv2, conv2_b))
	pool2 = max_pool_2x2(relu2)


	# 将上一池化层的输出 pool2(矩阵)转化为下一层全连接层的输入格式(向量)
	pool_shape = pool2.get_shape().as_list() # 得到 pool2 输出矩阵的维度，并存入 list 中，注意 pool_shape[0]是一个 batch 的值
	nodes = pool_shape[1] * pool_shape[2] * pool_shape[3] # 从list中依次取出矩阵的长宽及深度，并求三者的乘积就得到矩阵被拉长后的长度
	reshaped = tf.reshape(pool2, [pool_shape[0],nodes]) # 将 pool2 转换为一个 batch 的向量再传入后续的
	全连接

	# 实现第三层全连接层的前向传播过程
	fc1_w = get_weight([nodes, FC_SIZE], regularizer) # 初始化全连接层的权重，并加入正则化 
	fc1_b = get_bias([FC_SIZE]) # 初始化全连接层的偏置项
	
	# 将转换后的 reshaped 向量与权重 fc1_w 做矩阵乘法运算，然后再加上偏置，最后再使用 relu 进行 激活
	fc1 = tf.nn.relu(tf.matmul(reshaped, fc1_w) + fc1_b)
	# 如果是训练阶段，则对该层输出使用 dropout，也就是随机的将该层输出中的一半神经元置为无效，
	是为了避免过拟合而设置的，一般只在全连接层中使用
	if train: fc1 = tf.nn.dropout(fc1, 0.5)

	# 实现第四层全连接层的前向传播过程，并初始化全连接层对应的变量 
	fc2_w = get_weight([FC_SIZE, OUTPUT_NODE], regularizer)
	fc2_b = get_bias([OUTPUT_NODE])
	y = tf.matmul(fc1, fc2_w) + fc2_b
		return y

mnist_lenet5_backward.py

#coding:utf-8
import tensorflow as tf
from tensorflow.examples.tutorials.mnist 
import input_data 
import mnist_lenet5_forward
import os
import numpy as np

# 定义训练过程中的超参数
BATCH_SIZE = 100 # 一个 batch 的数量 
LEARNING_RATE_BASE = 0.005 # 初始学习率 LEARNING_RATE_DECAY = 0.99 # 学习率的衰减率 
REGULARIZER = 0.0001 # 正则化项的权重
STEPS = 50000 # 最大迭代次数 
MOVING_AVERAGE_DECAY = 0.99 # 滑动平均的衰减率 
MODEL_SAVE_PATH="./model/" # 保存模型的路径
MODEL_NAME="mnist_model" # 模型命名


# 训练过程
def backward(mnist):
	# x, y_是定义的占位符，需要指定参数的类型，维度(要和网络的输入与输出维度一致)，类似 于函数的形参，运行时必须传入值
	x = tf.placeholder(tf.float32,[ BATCH_SIZE,mnist_lenet5_forward.IMAGE_SIZE,mnist_lenet5_forward.IMAGE_SIZE, mnist_lenet5_forward.NUM_CHANNELS])


	y_ = tf.placeholder(tf.float32, [None, mnist_lenet5_forward.OUTPUT_NODE])
	y = mnist_lenet5_forward.forward(x,True, REGULARIZER) # 调用前向传播网络得到维度为 10 的 tensor
	global_step = tf.Variable(0, trainable=False) # 声明一个全局计数器，并输出化为 0
	
	# 先是对网络最后一层的输出 y 做 softmax，通常是求取输出属于某一类的概率，其实就是一个num_classes 大小的向量，
	# 再将此向量和实际标签值做交叉熵，需要说明的是该函数返回的是一个向量
	ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1)) 
	cem = tf.reduce_mean(ce) # 再对得到的向量求均值就得到loss
	loss = cem + tf.add_n(tf.get_collection('losses')) # 添加正则化中的 losses


	# 实现指数级的减小学习率，可以让模型在训练的前期快速接近较优解，又可以保证模型在训 练后期不会有太大波动
	# 计算公式:decayed_learning_rate=learining_rate*decay_rate^(global_step/decay_steps) 

	learning_rate = tf.train.exponential_decay(
	LEARNING_RATE_BASE,
	global_step,
	mnist.train.num_examples / BATCH_SIZE,
	LEARNING_RATE_DECAY,
	staircase=True) # 当 staircase=True 时，(global_step/decay_steps)则被转化为整数，以此来选择不同的衰减方式


	# 传入学习率，构造一个实现梯度下降算法的优化器，再通过使用 minimize 更新存储要训练的 变量的列表来减小 loss
	train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)

	# 实现滑动平均模型，参数 MOVING_AVERAGE_DECAY 用于控制模型更新的速度。训练过程中会对每一个变量维护一个影子变量，这个影子变量的初始值

	# 就是相应变量的初始值，每次变量更新时，影子变量就会随之更新
	ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step) 
	ema_op = ema.apply(tf.trainable_variables()) 
	withtf.control_dependencies([train_step,ema_op]):# 将train_step和ema_op两个训练操作绑定到 train_op 上
		train_op = tf.no_op(name='train')

	saver = tf.train.Saver() # 实例化一个保存和恢复变量的 saver


	with tf.Session() as sess: # 创建一个会话，并通过 python 中的上下文管理器来管理这个会话 
		init_op = tf.global_variables_initializer() # 初始化计算图中的变量
		sess.run(init_op)
		
		ckpt = tf.train.get_checkpoint_state(MODEL_SAVE_PATH) # 通过 checkpoint 文件定位 到最新保存的模型
		
		if ckpt and ckpt.model_checkpoint_path:
			saver.restore(sess, ckpt.model_checkpoint_path) # 加载最新的模型
		for i in range(STEPS):
			xs, ys = mnist.train.next_batch(BATCH_SIZE) # 读取一个 batch 的数据
			reshaped_xs = np.reshape(xs,( # 将输入数据 xs 转换成与网络输入相同形状的矩阵
			BATCH_SIZE,
			mnist_lenet5_forward.IMAGE_SIZE,
			mnist_lenet5_forward.IMAGE_SIZE,
			mnist_lenet5_forward.NUM_CHANNELS))
			# 喂入训练图像和标签，开始训练
			_, loss_value, step = sess.run([train_op, loss, global_step], feed_dict={x: reshaped_xs,y_: ys})
			if i % 100 == 0: # 每迭代 100 次打印 loss 信息，并保存最新的模型
				print("After %d training step(s), loss on training batch is %g." % (step,loss_value))
				saver.save(sess, os.path.join(MODEL_SAVE_PATH, MODEL_NAME),global_step=global_step)


def main():
	mnist = input_data.read_data_sets("./data/", one_hot=True) # 读入 mnist 数据 backward(mnist)

if __name__ == '__main__': 
	main()

mnist_lenet5_test.py

#coding:utf-8
import time
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data import mnist_lenet5_forward
import mnist_lenet5_backward
import numpy as np

TEST_INTERVAL_SECS = 5
def test(mnist):
	# 创建一个默认图，在该图中执行以下操作(多数操作和 train 中一样，就不再重复解释，大家 对照学习即可)
	with tf.Graph().as_default() as g:
		x = tf.placeholder(tf.float32,[ mnist.test.num_examples, mnist_lenet5_forward.IMAGE_SIZE, mnist_lenet5_forward.IMAGE_SIZE, mnist_lenet5_forward.NUM_CHANNELS])
		
		y_ = tf.placeholder(tf.float32, [None, mnist_lenet5_forward.OUTPUT_NODE]) 
		y = mnist_lenet5_forward.forward(x,False,None)
		
		ema = tf.train.ExponentialMovingAverage(mnist_lenet5_backward.MOVING_AVERAGE_DECAY)
		
		ema_restore = ema.variables_to_restore() 
		saver = tf.train.Saver(ema_restore)
		
		correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1)) # 判断预测值和实际值是否相同
		accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) # 求平均得到准确率
		
		while True:
			with tf.Session() as sess:
				ckpt = tf.train.get_checkpoint_state(mnist_lenet5_backward.MODEL_SAVE_PATH)
				if ckpt and ckpt.model_checkpoint_path: 
					saver.restore(sess, ckpt.model_checkpoint_path)
					# 根据读入的模型名字切分出该模型是属于迭代了多少次保存的 
					global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1] 

					reshaped_x = np.reshape(mnist.test.images,( mnist.test.num_examples,
					mnist_lenet5_forward.IMAGE_SIZE, mnist_lenet5_forward.IMAGE_SIZE,
					mnist_lenet5_forward.NUM_CHANNELS))
					
					accuracy_score = sess.run(accuracy, feed_dict={x:reshaped_x,y_:mnist.test.labels}) # 计算出测试集上准确率
					
					print("After %s training step(s), test accuracy = %g" % (global_step,accuracy_score))
				else:
					print('No checkpoint file found') return
			time.sleep(TEST_INTERVAL_SECS) # 每隔 5 秒寻找一次是否有最新的模型

def main():
	mnist = input_data.read_data_sets("./data/", one_hot=True) test(mnist)

if __name__ == '__main__': 
	main()

参考资料

参考资料：

北京大学 曹建老师 《人工智能实践：Tensorflow学习笔记》

这里是一个广告位，，感兴趣的都可以发邮件聊聊：tiehan@sina.cn
个人公众号，比较懒，很少更新，可以在上面提问题，如果回复不及时，可发邮件给我： tiehan@sina.cn