【本文使用的是TensorFlow1.x，如需TensorFlow2.x的内容参见我的“TensorFlow2实战”笔记】
一、问题描述
手写数字识别问题是一种分类问题，即输入手写的0~9，机器可识别出是什么数字。
二、MNIST数据集
本例我们使用MNIST数据集来训练和测试。
MNIST数据集来自美国国家标准与技术研究所（National Institute of Standards and Technology, NIST）。它由250个不同人手写的数字构成，其中一半来自高中学生，另一半来自人口普查局（Census Bureau）的工作人员。
MNIST数据集分为三部分：训练集Training set（55000条数据）、验证集Validation set（5000条数据）和测试集Test set（10000条数据）
1. 获取MNIST数据集
源数据可以通过链接 http://yann.lecun.com/exdb/mnist/ 获取，下载如下四个.gz文件
train-images-idx3-ubyte.gz: training set images (9912422 bytes)
train-labels-idx1-ubyte.gz: training set labels (28881 bytes)
t10k-images-idx3-ubyte.gz: test set images (1648877 bytes)
t10k-labels-idx1-ubyte.gz: test set labels (4542 bytes)
或者直接调用TensorFlow自带的教学示例来下载和读取文件
import tensorflow as tf
import tensorflow.examples.tutorials.mnist.input_data as input_data
#将数据保存到指定路径
mnist = input_data.read_data_sets('MNIST_data/', one_hot=True)
“MNIST_data/”是脚本所在文件夹的相对路径。如果指定目录下没有目标数据集，则会自动下载，需要等待一段实际，否则直接读取。one_hot置True是让标签以One Hot编码形式打开（后面会解释）
2. 训练集概况
先来看一下数据集的概况。用下面的命令输出训练集、验证集和测试集的数据量
print('Number of examples: \nTraining set %d \nValidation set %d \nTest set %d'
%(mnist.train.num_examples,mnist.validation.num_examples,mnist.test.num_examples))
输出
Number of examples:
Training set 55000
Validation set 5000
Test set 10000
每个example分为图像和标签两部分。图像像素是，而且因为是黑白的所以每个像素点用一个值表征，因此有
个特征。标签是10个元素的向量，代表0~9这十个数字，因为采用了One Hot编码，后面会细讲。因此，若查看训练集的图像和标签的形状
print('Shape of train images:', mnist.train.images.shape)
print('Shape of train labels:', mnist.train.labels.shape)
会输出
Shape of train images: (55000, 784)
Shape of train labels: (55000, 10)
表示55000个训练集，特征维度是784（将写成一行），标签维度是10。
3. 可视化Image
利用matplotlib库，定义可视化函数
import matplotlib.pyplot as plt
def plot_image(image):
plt.imshow(image.reshape(28,28),cmap='binary')
plt.show()
调用函数可视化训练集中下标1和下标10000的图像
plot_image(mnist.train.images[1])
plot_image(mnist.train.images[10000])
输出
4. One Hot标签
以训练集下标为1的标签为例
mnist.train.labels[1]
输出
array([0., 0., 0., 1., 0., 0., 0., 0., 0., 0.])
是10个元素一维数组，从左到右依次代表0~9，这里第四个元素为1即表示这个标签代表数字3。这种编码形式称为One Hot编码（或独热编码）。回忆前面读取MNIST时将参数one_hot置True
mnist = input_data.read_data_sets('MNIST_data/', one_hot=True)
就是将标签格式化为One Hot编码形式打开。如果False，则标签是0~9中的数字。
One Hot编码是一种稀疏向量，即只有一个元素为1，其他元素都是0。它常用于表示拥有有限个可能值的字符串或标识符，经常被运用于分类问题。
采用One Hot编码是为了定义一种公平的特征之间的距离，以做为损失函数计算的依据——比较学术的说法是“将离散特征的取值扩展到欧氏空间，使离散特征的某个取值对应于欧式空间的某个点，这样可以让特征特征之间的距离计算更加合理”。
例如，如果用数字本身的值做为标签，则1和3的距离小于8和3的距离，即机器会认为1比8更“像”3，这显然是不合理的（甚至有时3写出来来更像8……）。其实所有手写数字作为图形符号，地位应该是平等的，不应该认为谁和谁更近。而定义为One Hot编码，就能保证任意两个数字间都是等距的。
如何恢复原数字？根据One Hot编码的特性，可以简单地使用numpy的函数argmax来输出所代表的数字。argmax的作用是取得张量最大元素的索引
import numpy as np
print(np.argmax(mnist.train.labels[1]))
输出
3
5. 数据集的划分
上面讲过，MNIST把数据分为训练集（Training set）、验证集（Validation set）和测试集（Test set）。通常训练集的数据量远大于验证集和测试集，但也要求后两者足够大以达到统计学意义
上面“训练集概况”一节已经验证过，MNIST的训练集、验证集和测试集分别有55000条、5000条和10000条数据。
各集合的分工如下
三、模型定义
1. 定义占位符
训练时，会输入784维的特征和10维的标签
x=tf.placeholder(tf.float32,[None,784],name='x') #28*28个像素点的灰度图
y=tf.placeholder(tf.float32,[None,10],name='y') #10个类别以One Hot编码表示
2. 定义变量
定义被训练参数：权重w和偏置b
w=tf.Variable(tf.random_normal([784, 10]),name='w')
b=tf.Variable(tf.zeros([10]),name='b')
其中w以正态分布随机数赋初值，b直接以0为初值。
3. 定义前向计算
前向计算
即
forward=tf.matmul(x,w)+b
Softmax方程如下
目的是把所有类别的可能性以概率表示，且所有类别的概率和等于1。其实为了实现这种概率表示，最简单的方法是，而Softmax的不同之处就是把y写在了e的幂的位置。这样做的目的是突出差距——本来随差别的增大是线性增长的，用Softmax则是以指数增长的。
TensorFlow可直接调用softmax函数来实现
pred=tf.nn.softmax(forward)
4. 定义损失函数
逻辑回归问题如果使用均方差（MSE）做为损失函数，在梯度下降训练时会陷入局部最优
为避免这个问题，我们采用交叉熵损失函数
其中，是标签值（One Hot），
是预测值（Softmax）。两者其实都表示概率，而交叉熵刻画的是两个概率分布之间的距离。比如有一个“分三类”的问题，正确答案的One Hot编码是(1, 0, 0)。模型一的Softmax预测答案是(0.7, 0.1, 0.2)，则交叉熵损失是
模型二的Softmax预测答案是(0.5, 0.2, 0.3)，则交叉熵损失是
因为模型一的损失值小，所以模型一的预测更准确。而我们的手写数字识别问题其实就是一个“分十类”问题，数量增加而已，方法一样。
代码实现交叉熵损失函数
loss_function=tf.reduce_mean(-tf.reduce_sum(y*tf.log(pred),axis=1))
注意“*”不是矩阵乘法，而是两个形状相同的张量里对应位置元素两两相乘——结果还是相同的形状。另外，“axis=1”表示沿1轴方向，即矩阵的行的方向相加（axis=0则按列的方向）。
5. 改进损失函数
上述第3、4补定义了预测值和损失函数，使用的代码是
pred=tf.nn.softmax(forward) #定义预测值
loss_function=tf.reduce_mean(-tf.reduce_sum(y*tf.log(pred),axis=1)) #定义损失函数
代码是没错的，但是当pred接近于0的时候，计算机处理log(pred)会得出不稳定的结果，造成计算loss_function结果为NaN（Not a Number）。为避免这种情况，TensorFlow提供了专门计算Softmax交叉熵的函数。我们直接把forward和标签y输入得到loss，而不要先算Softmax再算交叉熵
loss_function=tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits_v2(logits=forward,
labels=y))
另外，pred定义还是有用的，为了后面观测和验证训练效果，但不再参与训练了。
6. 设定超参数
train_epochs=50 #训练轮数
learning_rate=0.01 #学习率
batch_size=100 #单次训练样本批量大小
后面训练计划采用随机小批量梯度下降（Mini-batch SGD），所以要设定单次训练样本批量大小，这里设为100
7. 选择优化器
依旧选用经典的梯度下降优化器，输入已经定义好的学习率和损失函数
optimizer=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss_function)
8. 定义准确率
定义准确率（accuracy）观测训练后的效果来。（只是一种观测手段，不参与训练）
首先定义预测正确性
correct_prediction=tf.equal(tf.argmax(pred,1),tf.argmax(y,1))
tf.argmax是获得最大值的下标，第一个参数是被判断张量，第二个参数是哪条轴。对于pred和y，它们都是n行10列的矩阵，轴1即行方向。所以tf.argmax(pred,1)和tf.argmax(y,1)会分别输出一个n行1列的向量，其中每个元素都是所对应行的10个值最大值的下标。
然后对这两个的向量使用tf.equal，就是判断相对应位置的值是否相等，输出也是一个
的向量。如果相等，则在输出向量的相同位置写True，不等则False。输出的这个向量即corret_prediction。
接着对这个的向量corret_prediction计算平均值即为准确率。但corret_prediction是由True和False组成的，所以要先转换为浮点的1.0和0.0才能计算平均值，可以通过cast函数实现。所以最后的代码为
accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
得到的accuracy是一个0~1的小数。
四、训练模型
训练模型的代码如下
loss_rec=[] #记录loss
acc_rec=[] #记录accuracy
with tf.Session() as sess:
init=tf.global_variables_initializer()
sess.run(init) #变量初始化
total_batch=int(mnist.train.num_examples/batch_size) #一轮训练多少批次
for epoch in range(train_epochs):
for batch in range(total_batch):
xs,ys=mnist.train.next_batch(batch_size) #读取小批量数据
sess.run(optimizer,feed_dict={x:xs,y:ys}) #执行训练
#每轮训练完成，使用验证集计算loss值和accuracy，并记录
loss,acc=sess.run([loss_function,accuracy],
feed_dict={x:mnist.validation.images,
y:mnist.validation.labels})
loss_rec.append(loss)
acc_rec.append(acc)
#打印每轮训练结果的信息
print('Epoch:','%02d'%(epoch),'Loss=','{:.9f}'.format(loss),
'Accuracy=','{:.4f}'.format(acc))
#训练结束
print('Train finished!')
打开一个Session，先初始化变量。
然后在每轮中按批次训练模型，每个批次有100个样本（因为上面超参数定义过batch_size=100）——这里使用了mnist自带的一个函数mnist.train.next_batch，它可以随机抽取指定数量的样本，并自动分成特征和标签作为输出。对于本例，即输出到xs是shape=(100,784)的矩阵，ys是shape=(100,10)的矩阵。另外，它会记录已经取过的样本，在下一次取样本时不再重复取，直到所有examples都被取过一遍，然后自动洗牌（shuffle）重新开始抽样。
把抽取的小批量样本xs和ys都feed给optimizer并运行session，即完成一次训练。每轮的训练次数（total_bach）等于训练样本总数（mnist.train.num_examples）除以抽样大小（batch_size）。
每轮训练完成，将验证集（validation set）全部代入损失函数和精度函数，记录计算出的损失（loss）和精度（acc），记录到loss_rec和acc_rec两个list里。
为了实时监控训练状态，每轮训练结束就打印一下轮次、损失值和精度值信息。当训练完成则打印“Train finished!”
运行后输出
Epoch: 00 Loss= 5.611262321 Accuracy= 0.2904
Epoch: 01 Loss= 3.490503073 Accuracy= 0.4554
Epoch: 02 Loss= 2.579448462 Accuracy= 0.5558
Epoch: 03 Loss= 2.104274750 Accuracy= 0.6190
Epoch: 04 Loss= 1.814090967 Accuracy= 0.6604
Epoch: 05 Loss= 1.615619183 Accuracy= 0.6914
Epoch: 06 Loss= 1.475754499 Accuracy= 0.7156
Epoch: 07 Loss= 1.368834615 Accuracy= 0.7360
Epoch: 08 Loss= 1.284839749 Accuracy= 0.7464
Epoch: 09 Loss= 1.219196916 Accuracy= 0.7568
Epoch: 10 Loss= 1.162911773 Accuracy= 0.7674
Epoch: 11 Loss= 1.115699649 Accuracy= 0.7768
Epoch: 12 Loss= 1.074900150 Accuracy= 0.7816
Epoch: 13 Loss= 1.038903713 Accuracy= 0.7880
Epoch: 14 Loss= 1.007751226 Accuracy= 0.7952
Epoch: 15 Loss= 0.979342580 Accuracy= 0.8006
Epoch: 16 Loss= 0.954365849 Accuracy= 0.8032
Epoch: 17 Loss= 0.932242095 Accuracy= 0.8080
Epoch: 18 Loss= 0.911442876 Accuracy= 0.8132
Epoch: 19 Loss= 0.891891003 Accuracy= 0.8164
Epoch: 20 Loss= 0.875307620 Accuracy= 0.8182
Epoch: 21 Loss= 0.858632624 Accuracy= 0.8204
Epoch: 22 Loss= 0.843405485 Accuracy= 0.8250
Epoch: 23 Loss= 0.829057992 Accuracy= 0.8246
Epoch: 24 Loss= 0.816572368 Accuracy= 0.8284
Epoch: 25 Loss= 0.803345025 Accuracy= 0.8300
Epoch: 26 Loss= 0.791507483 Accuracy= 0.8328
Epoch: 27 Loss= 0.780566335 Accuracy= 0.8344
Epoch: 28 Loss= 0.770188153 Accuracy= 0.8358
Epoch: 29 Loss= 0.760567009 Accuracy= 0.8374
Epoch: 30 Loss= 0.750789821 Accuracy= 0.8398
Epoch: 31 Loss= 0.742304325 Accuracy= 0.8404
Epoch: 32 Loss= 0.733399034 Accuracy= 0.8416
Epoch: 33 Loss= 0.725576639 Accuracy= 0.8444
Epoch: 34 Loss= 0.716947436 Accuracy= 0.8452
Epoch: 35 Loss= 0.710073769 Accuracy= 0.8468
Epoch: 36 Loss= 0.702525854 Accuracy= 0.8472
Epoch: 37 Loss= 0.696473360 Accuracy= 0.8498
Epoch: 38 Loss= 0.689174473 Accuracy= 0.8508
Epoch: 39 Loss= 0.682344496 Accuracy= 0.8520
Epoch: 40 Loss= 0.676750600 Accuracy= 0.8536
Epoch: 41 Loss= 0.670533299 Accuracy= 0.8540
Epoch: 42 Loss= 0.665123641 Accuracy= 0.8560
Epoch: 43 Loss= 0.659465015 Accuracy= 0.8566
Epoch: 44 Loss= 0.654203236 Accuracy= 0.8580
Epoch: 45 Loss= 0.648716569 Accuracy= 0.8590
Epoch: 46 Loss= 0.644182324 Accuracy= 0.8594
Epoch: 47 Loss= 0.639219463 Accuracy= 0.8608
Epoch: 48 Loss= 0.634452999 Accuracy= 0.8624
Epoch: 49 Loss= 0.630315661 Accuracy= 0.8624
Train finished!
可以看到Loss逐渐变小，Accuracy逐渐变大，直到趋于稳定，说明当前设置下（模型、超参数、损失函数等）训练已经达到极限。
五、评估和可视化结果
1. 评估模型
完成训练后，可以使用测试集评估一下准确度。还是在上面的session中执行
with tf.Session() as sess:
...
#用测试集评估训练结果
acc_test=sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels})
print('Test accuracy:',acc_test)
输出
Test accuracy: 0.8572
发现和验证集最后几轮的结果跟接近。然后再对比一下训练集精度
with tf.Session() as sess:
...
#训练集精度
acc_train=sess.run(accuracy,feed_dict={x:mnist.train.images,y:mnist.train.labels})
print('Train accuracy:',acc_train)
输出
Train accuracy: 0.8558546
训练集精度、验证集精度和测试精度都相近，说明训练没有过拟合。
2. 可视化结果
依旧在同一个session里写入以下代码，来保存已训练的模型对测试集所有examples的预测结果，注意用tf.argmax函数把One Hot转换为其对应的数字
with tf.Session() as sess:
...
#输出预测结果（把One Hot转换为实际数字）
prediction_result=sess.run(tf.argmax(pred,1),
feed_dict={x:mnist.test.images})
可以在console输入prediction_result，会返回
array([7, 5, 1, ..., 4, 8, 6], dtype=int64)
也可以输入prediction_result.shape查看其形状，返回
(10000,)
即测试集拥有examples的数量。
定义如下函数来可视化测试结果
def plot_images_labels_prediction(images, #图像列表
labels, #标签列表
prediction, #预测值
index, #从第index个开始显示
num=10): #显示几幅图像，缺省10
fig=plt.gcf() #获取当前图表，Get Current Figure
fig.set_size_inches(10,12) #设置图像尺寸，1inch=2.54cm
if num>25:
num=25 #限制最多显示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])) #在当前图title上显示信息
if len(prediction)>0:
title+=',predict'+str(prediction[index])
ax.set_title(title,fontsize=10) #显示title信息
ax.set_xticks([]) #不显示坐标轴
ax.set_yticks([])
index+=1
plt.show()
然后调用函数，查看测试集第10个example开始的15幅图片，并标出标签值和预测值
plot_images_labels_prediction(mnist.test.images, #测试集图像列表
mnist.test.labels, #测试集标签列表
prediction_result, #预测结果
10, #从第10条example开始显示
15) #显示15幅
输出
可以看到大部分预测和标签一致，但也有错误的，比如第一行第二幅。可以进一步优化模型和超参数来提高准确度。
附：完整代码
import tensorflow as tf
import tensorflow.examples.tutorials.mnist.input_data as input_data
import matplotlib.pyplot as plt
import numpy as np
#定义可视化函数（查看训练完成后结果用）
def plot_images_labels_prediction(images, #图像列表
labels, #标签列表
prediction, #预测值
index, #从第index个开始显示
num=10): #显示几幅图像，缺省10
fig=plt.gcf() #获取当前图表，Get Current Figure
fig.set_size_inches(10,12) #设置图像尺寸，1inch=2.54cm
if num>25:
num=25 #限制最多显示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])) #在当前图title上显示信息
if len(prediction)>0:
title+=',predict'+str(prediction[index])
ax.set_title(title,fontsize=10) #显示title信息
ax.set_xticks([]) #不显示坐标轴
ax.set_yticks([])
index+=1
plt.show()
#将数据保存到指定路径
mnist = input_data.read_data_sets('MNIST_data/', one_hot=True)
#数据集概况
print('Number of examples: \nTraining set %d \nValidation set %d \nTest set %d'
%(mnist.train.num_examples,mnist.validation.num_examples,mnist.test.num_examples))
print('Shape of train images:', mnist.train.images.shape)
print('Shape of train labels:', mnist.train.labels.shape)
def plot_image(image):
plt.imshow(image.reshape(28,28),cmap='binary')
plt.show()
plot_image(mnist.train.images[1])
plot_image(mnist.train.images[10000])
print(np.argmax(mnist.train.labels[1]))
#模型定义
x=tf.placeholder(tf.float32,[None,784],name='x') #28*28个像素点的灰度图
y=tf.placeholder(tf.float32,[None,10],name='y') #10个类别以One Hot编码表示
w=tf.Variable(tf.random_normal([784, 10]),name='w')
b=tf.Variable(tf.zeros([10]),name='b')
forward=tf.matmul(x,w)+b
pred=tf.nn.softmax(forward)
#交叉熵损失函数
loss_function=tf.reduce_mean(-tf.reduce_sum(y*tf.log(pred),axis=1)) #axis=1沿行的方向求和
#设定超参数
train_epochs=50 #训练轮数
learning_rate=0.01 #学习率
batch_size=100 #单次训练样本批量大小
#梯度下降优化器
optimizer=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss_function)
#定义准确率
correct_prediction=tf.equal(tf.argmax(pred,1),tf.argmax(y,1))
accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
#训练模型
loss_rec=[] #记录loss
acc_rec=[] #记录accuracy
with tf.Session() as sess:
init=tf.global_variables_initializer()
sess.run(init) #变量初始化
total_batch=int(mnist.train.num_examples/batch_size) #一轮训练多少批次
for epoch in range(train_epochs):
for batch in range(total_batch):
xs,ys=mnist.train.next_batch(batch_size) #读取小批量数据
sess.run(optimizer,feed_dict={x:xs,y:ys}) #执行训练
#每轮训练完成，使用验证集计算loss值和accuracy，并记录
loss,acc=sess.run([loss_function,accuracy],
feed_dict={x:mnist.validation.images,
y:mnist.validation.labels})
loss_rec.append(loss) #记录当前损失
acc_rec.append(acc) #记录当前精度
#打印每轮训练结果的信息
print('Epoch:','%02d'%(epoch),'Loss=','{:.9f}'.format(loss),
'Accuracy=','{:.4f}'.format(acc))
#训练结束
print('Train finished!')
#用测试集评估训练结果
acc_test=sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels})
print('Test accuracy:',acc_test)
#训练集精度
acc_train=sess.run(accuracy,feed_dict={x:mnist.train.images,y:mnist.train.labels})
print('Train accuracy:',acc_train)
#输出预测结果（把One Hot转换为实际数字）
prediction_result=sess.run(tf.argmax(pred,1),
feed_dict={x:mnist.test.images})
#可视化预测结果
plot_images_labels_prediction(mnist.test.images, #测试集图像列表
mnist.test.labels, #测试集标签列表
prediction_result, #预测结果
10, #从第10条example开始显示
15) #显示15幅
