TensorFlow笔记（8） LeNet-5卷积神经网络

• 1. 卷积神经网络分类问题
• 2. 数据读取
• 3. 构建模型
• 4. 训练模型
• 5. 评估模型
• 6. 模型预测

1. 卷积神经网络分类问题

假如对单神经元的模型92.28%的准确率还不满意
根据 深度学习笔记 的 深度学习笔记（21） 边缘检测 至 深度学习笔记（27） 经典卷积网络 可以了解到
可以利用卷积神经网络来解决这个问题

那么，还是以MNIST手写数字识别问题为例，采用LeNet-5卷积神经网络模型来解决问题
以下有部分内容与 TensorFlow笔记（7） 多神经元分类 重复，如数据读取等可选择性跳过

2. 数据读取

利用网上的 MNIST 数据集 获取数据集压缩文件（切勿解压）：

• 载入数据集合查看数据集数量：

  import tensorflow as tf
  from tensorflow.examples.tutorials.mnist import input_data
  import matplotlib.pyplot as plt
  import numpy as np
  
  # 载入数据集
  mnist = input_data.read_data_sets("data/", one_hot=True)
  
  # 显示数据集数量
  print("训练集数量：", mnist.train.num_examples)
  print("验证集数量：", mnist.validation.num_examples)
  print("测试集数量：", mnist.test.num_examples)
  
  # 训练集数量： 55000
  # 验证集数量： 5000
  # 测试集数量： 10000

  其中，训练集 55000（78.6%），验证集 5000（7.1%），测试集 10000（14.3%）
  one_hot=True 是使用独热（one hot）编码：
  使用N位状态寄存器来对N个状态进行编码，一位为1，其余为0
  常用于表示拥有有限个可能值的字符串或标识符

  如果直接用0-9表示标签的话，那如果实际标签是5
  那能说预测的4比预测的9更接近5么？
  很明显不能，所以使用独热编码更合理

• 查看数据大小

  print("训练图像大小：", mnist.train.images.shape)
  print("训练标签大小：", mnist.train.labels.shape)
  
  # 训练图像大小： (55000, 784)
  # 训练标签大小： (55000, 10)

  55000个训练集
  784 = 28 x 28 像素
  10是10分类的独热编码

• 可视化图像：

  # 可视化图像
  def plot_image(image):
  plt.imshow(image.reshape(28, 28), cmap='binary')
  plt.show()
  
  # 可视化第二张训练图像
  plot_image(mnist.train.images[2])

  
  可以看出是数字4

  cmap='binary’ 是对显示颜色参数的定义
  
  具体取值参考matplotlib官网关于Choosing Colormaps的介绍

• 可视化第二张图像的标签

  print(mnist.train.labels[2])
  
  # [0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]

  由此可知，[0. 0. 0. 0. 0. 1. 0. 0. 0. 0.] 代表5，[0. 0. 0. 1. 0. 0. 0. 0. 0. 0.] 代表3，10个标签0 - 9以此类推

3. 构建模型

• 定义训练数据的占位符， x是784个像素点的特征值， y是10分类的标签值：

  x = tf.placeholder(tf.float32, [None, 784], name="X")
  y = tf.placeholder(tf.float32, [None, 10], name="Y")

  shape中 None 表示行的数量未知
  在实际训练时决定一次代入多少行样本

• 展开图片 x
  为了使用卷积层，需把x变成一个4d向量
  其第1维对应样本数， -1表示任意数量
  其第2、第3维对应图片的宽、高，最后一维代表图片的颜色通道数

  x_image = tf.reshape(x, [-1, 28, 28, 1])

• 定义权重初始化函数：

  定义权重W 初始化函数 ：从标准差0.1的截断正态分布中输出随机值
  标准正态分布生生成的数据在负无穷到正无穷
  但是截断式正态分布生成的数据在均值-2倍的标准差，均值+2倍的标准差这个范围内

  def weight_variable(shape):
  initial = tf.truncated_normal(shape, stddev=0.1)
  return tf.Variable(initial)

• 定义权重b 初始化函数 ：数值为0.1

  def bias_variable(shape):
  initial = tf.constant(0.1, shape=shape)
  return tf.Variable(initial)

• 定义 valid卷积 函数：步长为1

  def conv2d(x, W):
  return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='VALID')

  TensorFow的卷积函数：

  tf.nn.conv2d(input, filter, strides, padding, use_cudnn_on_gpu=None,name=None)

  input：需要做卷积的输入数据
  这是一个4维的张量（[batch, in_height,in_width, in_channels]）
  要求类型为 float32 或 float64 其中之一
• filter：卷积核， [filter_height, filter_width, in_channels, out_channels]
• strides：图像每一维的步长，是一个一维向量，长度为4
• padding：定义元素边框与元素内容之间的空间
  “SAME"或"VALID”，这个值决定了不同的卷积方式
  当为"SAME"时，表示边缘填充，适用于全尺寸操作
  当为"VALID"时，表示边缘不填充
• use_cudnn_on_gpu：bool类型，是否使用cudnn加速
• name：该操作的名称
• 返回值：返回一个tensor，即 feature map

def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='VALID')

tf.nn.max_pool(value, ksize, strides, padding, name=None)

# 第一层卷积 每个5x5的patch中算出6个特征
W_conv1 = weight_variable([5, 5, 1, 6])
b_conv1 = bias_variable([6])

# 第一层 relu 激活
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)

# 第一层池化
h_pool1 = max_pool_2x2(h_conv1)

# 第二层卷积 每个5x5的patch中算出16个特征
W_conv2 = weight_variable([5, 5, 6, 16])
b_conv2 = bias_variable([16])

# 第二层 relu 激活
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)

# 第二层池化
h_pool2 = max_pool_2x2(h_conv2)

W_fc1 = weight_variable([4 * 4 * 16, 120])
b_fc1 = bias_variable([120])
h_pool2_flat = tf.reshape(h_pool2, [-1, 4 * 4 * 16])  # 重新展开
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

W_fc2 = weight_variable([120, 84])
b_fc2 = bias_variable([84])
h_fc2 = tf.nn.relu(tf.matmul(h_fc1, W_fc2) + b_fc2)

W_fc3 = weight_variable([84, 10])
b_fc3 = bias_variable([10])
forward = tf.matmul(h_fc2, W_fc3) + b_fc3
pred = tf.nn.softmax(forward)

with tf.name_scope("LossFunction"):
loss_function = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=forward, labels=y))

4. 训练模型

• 设置超参数：

  train_epochs = 20  # 迭代次数
  learning_rate = 0.001  # 学习率

• 定义Adam优化器，设置学习率和优化目标损失最小化：

  optimizer = tf.train.AdamOptimizer(learning_rate).minimize(loss_function)

• 定义预测类别匹配情况

  correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))

  tf.equal(A, B) ：对比这两个矩阵或者向量的相等的元素，相等返回 True，相反返回 False
  tf.argmax(input,axis) ：根据axis取值的不同返回每行或者每列最大值的索引，axis 表示维度，0：第一维度（行），1：第二维度（列），-1：最后一个维度
  其实，这里的最终求得的索引，恰好就表示图片上的数字

• 定义准确率，将布尔值转化成浮点数，再求平均值

  accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

• 创建会话：

  sess = tf.Session()  # 建立会话
  init = tf.global_variables_initializer()  # 变量初始化
  sess.run(init)

• 设置批次大小和数量：
  如果在处理完整个5.5万个训练图片的训练集之后才进行一次训练
  这样的处理速度相对缓慢
  如果在处理完整个5.5万个训练图片的训练集之前先让梯度下降法处理一部分
  算法速度会更快
  可以把训练集分割为小一点的子集训练
  如100张训练图片，然后就进行梯度下降法处理
  这种梯度下降法处理方法称之为Mini-batch 梯度下降
  具体可参考深度学习笔记（9） 优化算法（一）

  # 每个批次的大小，每次放入的大小，每次放入 100张图片 以矩阵的方式
  batch_size = 100
  
  # 计算一共有多少个批次，数量整除大小训练出有多少批次
  n_batch = mnist.train.num_examples // batch_size

  mnist.train.next_batch　先打乱数据集，之后按数字的批次大小取值
  直到数据集全部取完，重新打乱数据，重新取值

• 批次迭代训练，显示迭代过程中的信息：

  for epoch in range(train_epochs):
  for batch in range(n_batch):
  xs, ys = mnist.train.next_batch(batch_size)
  sess.run(optimizer, feed_dict={x: xs, y: ys})
  # 批次训练完成之后，使用验证数据计算误差与准确率
  loss, acc = sess.run([loss_function, accuracy],
  feed_dict={x: mnist.validation.images,
  y: mnist.validation.labels})
  # 显示训练信息
  print("Train Epoch", '%02d' % (epoch + 1), "Loss=", '{:.9f}'.format(loss),
  "Accuracy=", "{:.4f}".format(acc))
  
  # Train Epoch 01 Loss= 0.108200222 Accuracy= 0.9696
  # Train Epoch 02 Loss= 0.066758297 Accuracy= 0.9822
  # ...
  # Train Epoch 19 Loss= 0.041715056 Accuracy= 0.9892
  # Train Epoch 20 Loss= 0.041373160 Accuracy= 0.9912

  过俩遍数据就已经准确率就超过98%
  最后代价为0.041373160，验证集的准确率为99.12%，这会应该满意了吧

5. 评估模型

• 测试集上评估模型预测的准确率

  accu_test = sess.run(accuracy, feed_dict={x: mnist.test.images, y: mnist.test.labels})
  print("Test Accuracy = ", accu_test)
  
  # Test Accuracy =  0.9902

• 验证集上评估模型预测的准确率

  accu_validation = sess.run(accuracy, feed_dict={x: mnist.validation.images, y: mnist.validation.labels})
  print("Validation Accuracy = ", accu_validation)
  
  # Validation Accuracy =  0.9912

  这样的99%准确率应该比较满意了吧

6. 模型预测

• 查看预测结果

  # 转换pred预测结果独热编码格式为数字0-9
  prediction_result = sess.run(tf.argmax(pred, 1), feed_dict={x: mnist.test.images})
  
  # # 查看第300-309张测试图片的预测结果
  print(prediction_result[300:310])
  
  # [4 7 1 2 4 0 2 7 4 3]

  但是这样没办法知道，预测的到底是不是正确的

• 预测结果可视化比对
  定义可视化函数：

  # 定义比对可视化函数
  def plot_images_labels_prediction(images,  # 图像列表
  labels,  # 标签列表
  prediction,  # 预测值列表
  index,  # 开始显示的索引
  num=5):  # 缺省一次显示5张
  fig = plt.gcf()  # 获取当前图表，get current figure
  fig.set_size_inches(10, 12)  # 1英寸等于2.54cm
  
  if num > 25:  # 最多显示25张图片
  num = 25
  
  for i in range(0, num):
  ax = plt.subplot(5, 5, i + 1)  # 获取当前要处理的图片
  ax.imshow(np.reshape(images[index], (28, 28)), cmap='binary')  # 显示第index个图像
  title = 'label = ' + str(np.argmax(labels[index]))  # 显示标签的标题
  if len(prediction) > 0:  # 如果有预测结果的话，添加显示预测的标题
  title += ',predict = ' + str(prediction[index])
  ax.set_title(title, fontsize=10)  # 显示图上的标题
  # 不显示坐标轴
  ax.set_xticks([])
  ax.set_yticks([])
  index += 1
  plt.show()

• 可视化第300-309张测试图片的预测结果对比

  plot_images_labels_prediction(mnist.test.images,
  mnist.test.labels,
  prediction_result,
  300, 10)

  
  这次的预测还是比较有信心的，抽取的10个数都预测正确

[1] python的代码地址:
https://github.com/JoveH-H/TensorFlow/blob/master/py/5.CNN-LeNet-5.py
[2] jupyter notebook的代码地址:
https://github.com/JoveH-H/TensorFlow/blob/master/ipynb/5.CNN-LeNet-5.ipynb
[3] MNIST 数据集 t10k-images-idx3-ubyte.gz
https://github.com/JoveH-H/TensorFlow/blob/master/data/t10k-images-idx3-ubyte.gz
[4] MNIST 数据集 t10k-labels-idx1-ubyte.gz
https://github.com/JoveH-H/TensorFlow/blob/master/data/t10k-labels-idx1-ubyte.gz
[5] MNIST 数据集 train-images-idx3-ubyte.gz
https://github.com/JoveH-H/TensorFlow/blob/master/data/train-images-idx3-ubyte.gz
[6] MNIST 数据集 train-labels-idx1-ubyte.gz
https://github.com/JoveH-H/TensorFlow/blob/master/data/train-labels-idx1-ubyte.gz

相关推荐：

深度学习笔记（27） 经典卷积网络
深度学习笔记（26） 卷积神经网络
深度学习笔记（9） 优化算法（一）
TensorFlow笔记（7） 多神经元分类
TensorFlow笔记（6） 单神经元分类

谢谢！