Tensorflow入门之MNIST手写数字识别实战教程

学习一门编程语言时，入门的第一件事几乎都是打印“Hello World”。MNIST手写数字识别就像是机器学习领域里的Hello World。通过Tensorflow实现MNIST手写数字识别将让我们快速地入门机器学习以及了解Tensorflow的使用。

---

---

数据集介绍

MNIST数据集主要由一些手写数字的图片和相应的标签组成，图片一共有10类，分别对应从0~9，共10个阿拉伯数字，如下图所示。

原始的MNIST数据库包含4个文件，见下表。

文件名	大小	用途
train-images-idx3-ubyte.gz	≈9.45MB	训练图像数据
train-labels-idx 1-ubyte.gz	≈0.03MB	训练图像的标签
t10-images-idx3-ubyte.gz	≈1.75MB	测试图像数据
t10k-labels-idxl-ubyte.gz	≈4.4KB	测试图像的标签

在MNIST数据集中有两类图像：一类是训练图像，另一类是测试图像。训练图像一共有60000张，测试图像有10000张。在Tensorflow中不需要去单独下载MNIST数据集，它为我们提供了方便的封装，可以直接加载MNIST数据。

---

开始训练模型

导入包和数据集

导入Tensorflow和MNIST数据集

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
# 读取MNIST数据集，如果不存在会实现下载
mnist = input_data.read_data_sets("/tmp/MNIST_data/", False, one_hot=True)

定义占位符和变量

# 创建x，x是占位符，代表待识别的图片。
x = tf.placeholder("float", [None, 784])

# 在这里，我们都用全为零的张量来初始化W和b。因为我们要学习W和b的值，它们的初值可以随意设置。
# 权重：W的维度是[784，10]，因为我们想要用784维的图片向量乘以它以得到一个10维的证据值向量，每一位对应不同数字类。
W = tf.Variable(tf.zeros([784, 10]))

# 偏置值：b的形状是[10]，所以我们可以直接把它加到输出上面。
b = tf.Variable(tf.zeros([10]))

# y表示模型的输出，softmax模型可以用来给不同的对象分配概率。即使在之后，我们训练更加精细的模型时，最后一步也需要用softmax来分配概率。
y = tf.nn.softmax(tf.matmul(x, W) + b)

# y_是实际的图像标签，同样以占位符表示，是以独热表示的。
y_ = tf.placeholder("float", [None, 10])

tf.placeholder(dtype, shape=None, name=None) 占位符

tf.Variable() 变量

tf.nn.softmax(logits, name=None) Softmax回归

构造损失和梯度下降

构造完损失并使用梯度下降法优化损失

# 根据y和y_构造交叉熵损失
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))

# 有了损失就可以用梯度下降法针对模型的参数（W和b）进行优化
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

tf.reduce_sum(input_tensor, reduction_indices=None, keep_dims=False, name=None) 计算输入tensor元素的和
tf.train.GradientDescentOptimizer(learning_rate) 基于一定的学习率进行梯度优化训练

创建Session，初始化变量

创建一个session。只有在session中才能运行优化步骤train_step

# 添加一个操作来初始化创建的变量
init = tf.initialize_all_variables()
# 创建一个session。只有在session中才能运行优化步骤train_step
sess = tf.Session()
sess.run(init)

init = tf.initialize_all_variables() 用于初始化变量，需要session来启动
tf.Session() 创建一个会话，当上下文管理器退出时会话关闭和资源释放自动完成

开始训练

这里我们让模型循环训练1000次。该循环的每个步骤中，我们都会随机抓取训练数据中的100个批处理数据点，然后我们用这些数据点作为参数替换之前的占位符来运行train_step。

for i in range(1000):
    # batch_xs和batch_ys对应这占位符x和y_
    batch_xs, batch_ys = mnist.train.next_batch(100)
    sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})

feed_dict 给使用placeholder创建出来的tensor赋值

准确率验证

训练完成后，就可以对模型的准确率进行验证。

# 正确的预测结果
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
# 计算预测准确值，它们都是Tensor
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
# 这里是获取最终模型的准确率
print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

tf.argmax(input, dimension, name=None) 返回input最大值的索引index

tf.equal(x, y, name=None) 逐个对比两个矩阵或向量的元素，相同返回True，不相同返回False

tf.cast(x, dtype, name=None) 将x或者x.values转换为dtype

tf.reduce_mean(input_tensor, reduction_indices=None, keep_dims=False, name=None) 求tensor中平均值

最终的预测结果是：0.9173

上面所使用的Softmax回归是一个比较简单的模型，预测的准确率不高，在下面将使用卷积神经网络将预测的准确率提升到99%。

---

使用卷积神经网络训练模型

导入包和数据集

依旧是导入Tensorflow和MNIST数据集

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

创建占位符

# x为训练图像的占位符，y_为训练图像标签的占位符。
x = tf.placeholder("float", shape=[None, 784])
y_ = tf.placeholder("float", shape=[None, 10])

定义神经网络

# 第一层神经网络

# 函数weight_variable可以返回一个给定形状的变量并自动以截断正态分布初始化
def weight_variable(shape):
  initial = tf.truncated_normal(shape, stddev=0.1)
  return tf.Variable(initial)

# 函数bias_variable同样可以返回一个给定形状的变量，初始化时所有值是0.1
def bias_variable(shape):
  initial = tf.constant(0.1, shape=shape)
  return tf.Variable(initial)

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

def max_pool_2x2(x):
  return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
                        strides=[1, 2, 2, 1], padding='SAME')
                        
# [5, 5, 1, 32]代表卷积核尺寸为5×5，一个颜色通道，32个不同的卷积核。
W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])

# 将单张图片从784维向量重新还原为28×28的矩阵图片，-1代表样本数量不固定，1代表颜色通道。
x_image = tf.reshape(x, [-1,28,28,1])

# 进行卷积计算，卷积计算后用ReLu作为激活函数
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)

# 调用函数max_pool_2x2进行一次池化操作
h_pool1 = max_pool_2x2(h_conv1)

# 第二层神经网络
W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)

全连接层
W_fc1 = weight_variable([7 * 7 * 64, 1024])
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
# 使用Dropout（防止神经网络过度拟合），keep_prob是一个占位符，训练时为5，测试时为1
keep_prob = tf.placeholder("float")
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

全连接层，把1024量闺岱句量转换成 10维，对应 10 个向量 
W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])
y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)

tf.truncated_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None) 从截断的正态分布中输出随机值

tf.constant(value, dtype=None, shape=None, name=‘Const’, verify_shape=False) 常量

tf.nn.conv2d(input, filter, strides, padding, use_cudnn_on_gpu=None, data_format=None, name=None) 卷积函数：在给定的4D input与 filter下计算2D卷积,输入shape为 [batch, height, width, in_channels]

tf.nn.max_pool(value, ksize, strides, padding, data_format=’NHWC’, name=None) 最大值方法池化

tf.reshape(tensor, shape, name=None) 改变tensor的形状

tf.nn.relu(features, name=None) 激活函数

tf.nn.dropout(x, keep_prob, noise_shape=None, seed=None, name=None) 计算dropout，keep_prob为keep概率
noise_shape为噪声的shape

构造损失和梯度下降

定义损失函数为cross_entropy，优化器使用Adam，学习率为1e-4

cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)

tf.train.AdamOptimizer : 使用Adam 算法的Optimizer

定义测试的准确率

correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

创建Session，初始化变量

sess = tf.InteractiveSession()
sess.run(tf.initialize_all_variables())

开始训练

设置训练时候Dropout的keep_prob的比率为0.5，mini-batch为50，共进行20000次训练迭代。

for i in range(20000):
  batch = mnist.train.next_batch(50)
  if i%100 == 0:
    train_accuracy = accuracy.eval(feed_dict={x:batch[0], y_: batch[1], keep_prob: 1.0})
    print ("step %d, training accuracy %g" % (i, train_accuracy))
  train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
print ("test accuracy %g" % accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))

训练结束打印准确率

print ("test accuracy %g" % accuracy.eval(feed_dict={
    x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))

最终这个CNN模型得到的准确率约为99%

---

全部代码

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
# 读取MNIST数据集，如果不存在会实现下载
mnist = input_data.read_data_sets("MNIST_data/", False, one_hot=True)

# 第一个维度数字用来索引图片，第二个维度数字用来索引每张图片中的像素点。
# 创建x，x是占位符，代表待识别的图片。
x = tf.placeholder(tf.float32, [None, 784])

# 在这里，我们都用全为零的张量来初始化W和b。因为我们要学习W和b的值，它们的初值可以随意设置。
# W是Softmax模型的参数，将一个784维的输入转化为一个10维的输出
W = tf.Variable(tf.zeros([784, 10]))

# b是有一个softmax模型的参数，一般叫“偏置值”
b = tf.Variable(tf.zeros([10]))

#  y表示模型的输出，softmax模型可以用来给不同的对象分配概率。即使在之后，我们训练更加精细的模型时，最后一步也需要用softmax来分配概率。
y = tf.nn.softmax(tf.matmul(x, W) + b)

# y_是实际的图像标签，同样以占位符表示，是以独热表示的。
y_ = tf.placeholder("float", [None, 10])

# 根据y和y_构造交叉熵损失
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))

# 有了损失就可以用梯度下降法针对模型的参数（W和b）进行优化，学习率0.01
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

# 添加一个操作来初始化创建的变量
init = tf.initialize_all_variables()

# 在一个Session里面启动模型，并且初始化变量
# 创建一个session。只有在session中才能运行优化步骤train_step
sess = tf.Session()
sess.run(init)

# 开始训练模型，这里我们让模型循环训练1000次
# 该循环的每个步骤中，我们都会随机抓取训练数据中的100个批处理数据点，然后我们用这些数据点作为参数替换之前的占位符来运行train_step。
# batch_xs的形状为（100，784）的图像数据，batch_ys是形如（100，10）的实际标签。 batch_xs和batch_ys对应这占位符x和y_。
for i in range(1000):
    batch_xs, batch_ys = mnist.train.next_batch(100)
# 在session中运行train_step，运行是要传入占位符的值
    sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})

# 下述y的值是在上述训练最后一步已经计算获得，所以能够与原始标签y_进行比较
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
# 计算预测准确值，它们都是Tensor
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
# 这里是获取最终模型的准确率
print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

使用CNN训练模型代码

# 导入Tensorflow，加载MNIST数据
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

# 创建Session
sess = tf.InteractiveSession()

# x为训练图像的占位符，y_为训练图像标签的占位符。
x = tf.placeholder("float", shape=[None, 784])
y_ = tf.placeholder("float", shape=[None, 10])

# 函数weight_variable可以返回一个给定形状的变量并自动以截断正态分布初始化
def weight_variable(shape):
  initial = tf.truncated_normal(shape, stddev=0.1)
  return tf.Variable(initial)

# 函数bias_variable同样可以返回一个给定形状的变量，初始化时所有值是0.1
def bias_variable(shape):
  initial = tf.constant(0.1, shape=shape)
  return tf.Variable(initial)

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

def max_pool_2x2(x):
  return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
                        strides=[1, 2, 2, 1], padding='SAME')
# 第一层卷积层
W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])
x_image = tf.reshape(x, [-1,28,28,1])

# 进行卷积计算，卷积计算后用ReLu作为激活函数
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)

# 调用函数max_pool_2x2进行一次池化操作
h_pool1 = max_pool_2x2(h_conv1)


# 第二层卷积层
W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)

# 全连接层
W_fc1 = weight_variable([7 * 7 * 64, 1024])
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

# Dropout层，减轻过度拟合
keep_prob = tf.placeholder("float")
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

# 输出层
W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])
y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)

# 定义损失函数，使用Adam优化器，学习率为1e-4
cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)

# 定义测试的准确率
correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

# 初始化变量
sess.run(tf.initialize_all_variables())

# 开始训练模型，让模型循环训练20000次，每100步报告一次在验证集上的准确率
for i in range(20000):
  batch = mnist.train.next_batch(50)
  if i%100 == 0:
    train_accuracy = accuracy.eval(feed_dict={
        x:batch[0], y_: batch[1], keep_prob: 1.0})
    print ("step %d, training accuracy %g" % (i, train_accuracy))
  train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
  
# 训练结束后报告在测试集上的准确率，准确率约为99.2%
print ("test accuracy %g" % accuracy.eval(feed_dict={
    x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))

项目代码

GitHub地址：https://github.com/WellTung666/Tensorflow/tree/master/MNIST

参考资料

http://www.tensorfly.cn/tfdoc/tutorials/mnist_beginners.html