MNIST数据集

MNIST数据集：包含7万张黑底白字手写数字图片，其中55000张为训练集， 5000张为验证集，10000张为测试集。每张图片大小为28*28像素，图片中纯黑色像素值为0，纯白色像素值为1。数据集的标签是长度为10的一维数组，数组中每个元素索引号表示对应数字出现的概率。 在将mnist数据集作为输入喂入神经网络时，需先将数据集中每张图片变为长度 784一维数组，将该数组作为神经网络输入特征喂入神经网络。

例如： 一张数字手写体图片变成长度为784的一维数组[0.0.0.0.0.231 0.235 0.459 ……0.219 0.0.0.0.]输入神经网络。该图片对应的标签为[0.0.0.0.0.0.1.0.0.0]，标签中索引号为6的元素为1，表示是数字6出现的概率为100%，则该图片对应的识别结果是6。

使用input_data模块中的read_data_sets()函数加载mnist数据集：

from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets(’./data/’,one_hot=True) 

在 read_data_sets()函数中有两个参数，第一个参数表示数据集存放路径，第二个参数表示数据集的存取形式。当第二个参数为Ture时，表示以独热码形式存取数据集。read_data_sets()函数运行时，会检查指定路径内是否已经有数据集，若指定路径中没有数据集，则自动下载，并将mnist数据集分为训练集train、验证集validation和测试集test存放。

返回mnist数据集中训练集train、验证集validation和测试集test样本数

在Tensorflow中用以下函数返回子集样本数：

①返回训练集train样本数

print “train data size:”,mnist.train.num_examples

输出结果：train data size:55000

②返回验证集validation样本数

print “validationdata size:”,mnist.validation.num_examples 

输出结果：validationdata size:5000

③返回测试集test样本数

print “test data size:”,mnist.test.num_examples 

输出结果：test data size:10000

使用train.labels函数返回mnist数据集标签

例如： 在mnist数据集中，若想要查看训练集中第0张图片的标签，则使用如下函数

mnist.train.labels[0] 输出结果：

array([0.,0.,0.,0.,0.,0.,1.,0.,0.,0]) 

使用train.images函数返回mnist数据集图片像素值

例如： 在 mnist 数据集中，若想要查看训练集中第 0 张图片像素值，则使用如下函数

mnist.train.images[0]

输出结果：

array([0. ,0. ,0. ,

           0. ,0. ,0. ,

          0. ,0. ,0. ,

          …  …  …]) 

使用mnist.train.next_batch()函数将数据输入神经网络

例如：

BATCH_SIZE = 200
xs,ys = mnist.train.next_batch(BATCH_SIZE)
print “xsshape:”,xs.shape
print “ys shape:”,ys.shape 

输出结果：xs.shape(200,784)

输出结果：ys.shape(200,10)

其中，mnist.train.next_batch()函数包含一个参数BATCH_SIZE，表示随机从训练集中抽取BATCH_SIZE个样本输入神经网络，并将样本的像素值和标签分别赋给xs和ys。在本例中，BATCH_SIZE设置为200，表示一次将200个样本的像素值和标签分别赋值给xs和ys，故xs的形状为(200,784)，对应的ys的形状为(200,10)。

实现“Mnist数据集手写数字识别”的常用函数：

①tf.get_collection(“”)函数表示从 collection 集合中取出全部变量生成一个列表。

②tf.add( )函数表示将参数列表中对应元素相加。

例如：

x=tf.constant([[1,2],[1,2]])    y=tf.constant([[1,1],[1,2]])  z=tf.add(x,y) print z

输出结果：

[[2,3],[2,4]] 

③tf.cast(x,dtype)函数表示将参数x转换为指定数据类型。

例如：

A = tf.convert_to_tensor(np.array([[1,1,2,4], [3,4,8,5]]))
print A.dtype   b = tf.cast(A, tf.float32)   print b.dtype

结果输出：

<dtype: ‘int64‘>
<dtype: ‘float32‘>

从输出结果看出，将矩阵A由整数型变为32位浮点型。

④tf.equal( )函数表示对比两个矩阵或者向量的元素。若对应元素相等，则返回True；若对应元素不相等，则返回False。

例如：

A = [[1,3,4,5,6]]   B =[[1,3,4,3,2]]
with tf.Session( ) as sess:
    print(sess.run(tf.equal(A, B))) 

输出结果：

[[True  True  True False False]]

在矩阵A和B中，第1、2、3个元素相等，第4、5个元素不等，故输出结果中，第1、2、3个元素取值为True，第4、5个元素取值为False。

⑤tf.reduce_mean(x,axis)函数表示求取矩阵或张量指定维度的平均值。若不指定第二个参数，则在所有元素中取平均值；若指定第二个参数为0，则在第一维元素上取平均值，即每一列求平均值；若指定第二个参数为1，则在第二维元素上取平均值，即每一行求平均值。

例如：

x = [[1., 1.][2., 2.]]
print(tf.reduce_mean(x))

输出结果：1.5

print(tf.reduce_mean(x, 0))

输出结果：[1.5, 1.5]

print(tf.reduce_mean(x, 1))

输出结果：[1., 1.]

⑥tf.argmax(x,axis)函数表示返回指定维度axis下，参数x中最大值索引号。

例如：

在tf.argmax([1,0,0],1)函数中，axis为1，参数x为[1,0,0]，表示在参数x

的第一个维度取最大值对应的索引号，故返回0。

⑦os.path.join()函数表示把参数字符串按照路径命名规则拼接。

例如：

import os os.path.join(‘/hello/‘,‘good/boy/‘,‘doiido‘)

输出结果：‘/hello/good/boy/doiido‘

⑧字符串.split( )函数表示按照指定“拆分符”对字符串拆分，返回拆分列表。

例如：‘./model/mnist_model-1001‘.split(‘/‘)[-1].split(‘-‘)[-1]

在该例子中，共进行两次拆分。第一个拆分符为‘/’，返回拆分列表，并提取列表中索引为-1的元素即倒数第一个元素；第二个拆分符为‘-’，返回拆分列表，并提取列表中索引为-1的元素即倒数第一个元素，故函数返回值为1001。

⑨tf.Graph( ).as_default( )函数表示将当前图设置成为默认图，并返回一个上下文管理器。该函数一般与with关键字搭配使用，应用于将已经定义好的神经网络在计算图中复现。

例如：

with tf.Graph().as_default() as g，表示将在Graph()内定义的节点加入到计算图g中。

神经网络模型的保存

在反向传播过程中，一般会间隔一定轮数保存一次神经网络模型，并产生三个文件（保存当前图结构的.meta文件、保存当前参数名的.index文件、保存当前参数的.data文件），在Tensorflow中如下表示：

saver = tf.train.Saver()
with tf.Session() as sess:
    for i in range(STEPS):
        if i % 轮数 == 0:
           saver.save(sess, os.path.join(MODEL_SAVE_PATH,MODEL_NAME),global_step=global_step)

其中，tf.train.Saver()用来实例化saver对象。上述代码表示，神经网络每循环规定的轮数，将神经网络模型中所有的参数等信息保存到指定的路径中，并在存放网络模型的文件夹名称中注明保存模型时的训练轮数。

神经网络模型的加载 在测试网络效果时，需要将训练好的神经网络模型加载，在Tensorflow中这样表示：

with tf.Session() as sess:
    ckpt =tf.train.get_checkpoint_state(存储路径)
        if ckpt and ckpt.model_checkpoint_path:
             saver.restore(sess,ckpt.model_checkpoint_path)

在with结构中进行加载保存的神经网络模型，若ckpt和保存的模型在指定路径中存在，则将保存的神经网络模型加载到当前会话中。

加载模型中参数的滑动平均值

在保存模型时，若模型中采用滑动平均，则参数的滑动平均值会保存在相应文件中。通过实例化saver对象，实现参数滑动平均值的加载，在Tensorflow中如下表示：

ema = tf.train.ExponentialMovingAverage(滑动平均基数)
ema_restore = ema.variables_to_restore()
saver = tf.train.Saver(ema_restore)

神经网络模型准确率评估方法在网络评估时，一般通过计算在一组数据上的识别准确率，评估神经网络的效果。

在Tensorflow中这样表示：

correct_prediction= tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy =tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

在上述中，y 表示在一组数据（即batch_size 个数据）上神经网络模型的预测结果，y 的形状为[batch_size,10]，每一行表示一张图片的识别结果。通过tf.argmax()函数取出每张图片对应向量中最大值元素对应的索引值，组成长度为输入数据batch_size个的一维数组。通过tf.equal()函数判断预测结果张量和实际标签张量的每个维度是否相等，若相等则返回True，不相等则返回False。通过 tf.cast()函数将得到的布尔型数值转化为实数型，再通过tf.reduce_mean()函数求平均值，最终得到神经网络模型在本组数据上的准确率。

模块化搭建神经网络

神经网络八股包括前向传播过程、反向传播过程、反向传播过程中用到的正则化、指数衰减学习率、滑动平均方法的设置、以及测试模块。

前向传播过程（forward.py）

前向传播过程完成神经网络的搭建，结构如下：

def forward(x, regularizer):

def forward(x, regularizer):
    w=
    b=
    y=
return y
def get_weight(shape, regularizer):
def get_bias(shape):          

前向传播过程中，需要定义神经网络中的参数w和偏置b，定义由输入到输出的网络结构。通过定义函数get_weight()实现对参数w的设置，包括参数w的形状和是否正则化的标志。同样，通过定义函数get_bias()实现对偏置b的设置。

反向传播过程（backword.py）

反向传播过程完成网络参数的训练，结构如下：

def backward( mnist ):
x  = tf.placeholder(dtype, shape )
y_ = tf.placeholder(dtype, shape )
#定义前向传播函数
y  = forward( )
global_step =
loss =
train_step =tf.train.GradientDescentOptimizer(learning_rate).
minimize(loss,global_step=global_step)
#实例化saver对象
saver = tf.train.Saver() with tf.Session() as sess:
#初始化所有模型参数
tf.initialize_all_variables().run()
#训练模型
  for i in range(STEPS):
     sess.run(train_step,feed_dict={x:   , y_:   })
         if i % 轮数 == 0:
            print
          saver.save(   )

反向传播过程中，用tf.placeholder(dtype, shape)函数实现训练样本x和样本标签y_占位，函数参数dtype表示数据的类型，shape表示数据的形状；y表示定义的前向传播函数forward；loss表示定义的损失函数，一般为预测值与样本标签的交叉熵（或均方误差）与正则化损失之和；train_step表示利用优化算法对模型参数进行优化，常用优化算法GradientDescentOptimizer、AdamOptimizer、MomentumOptimizer算法，在上述代码中使用的GradientDescentOptimizer优化算法。接着实例化saver对象，其中利用tf.initialize_all_variables().run()函数实例化所有参数模型，利用sess.run( )函数实现模型的训练优化过程，并每间隔一定轮数保存一次模型。

正则化、指数衰减学习率、滑动平均方法的设置

①正则化项regularization

当在前向传播过程中即forward.py文件中，设置正则化参数regularization为 1时，则表明在反向传播过程中优化模型参数时，需要在损失函数中加入正则化项。 结构如下：

首先，需要在前向传播过程即forward.py文件中加入

if regularizer !=None: tf.add_to_collection(‘losses‘, tf.contrib.layers.l2_regularizer(regularizer)(w))

其次，需要在反向传播过程即backword.py文件中加入

ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.argmax(y_, 1)) cem = tf.reduce_mean(ce)
loss = cem + tf.add_n(tf.get_collection(‘losses‘)) 

其中，tf.nn.sparse_softmax_cross_entropy_with_logits()表示softmax()函数与交叉熵一起使用。

②指数衰减学习率 在训练模型时，使用指数衰减学习率可以使模型在训练的前期快速收敛接近较优解，又可以保证模型在训练后期不会有太大波动。运用指数衰减学习率，需要在反向传播过程即backword.py文件中加入：

learning_rate = tf.train.exponential_decay( LEARNING_RATE_BASE,  global_step,
LEARNING_RATE_STEP, LEARNING_RATE_DECAY,  staircase=True)

③滑动平均 在模型训练时引入滑动平均可以使模型在测试数据上表现的更加健壮。

需要在反向传播过程即backword.py文件中加入：

ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY,global_step)
ema_op = ema.apply(tf.trainable_variables())    with tf.control_dependencies([train_step, ema_op]):
train_op = tf.no_op(name=‘train‘)

测试过程（test.py）

当神经网络模型训练完成后，便可用于测试数据集，验证神经网络的性能。结构

如下： 首先，制定模型测试函数test()

def test( mnist ):
with tf.Graph( ).as_default( ) as g:
#给x y_占位
x = tf.placeholder(dtype,shape)
y_ = tf.placeholder(dtype,shape)  #前向传播得到预测结果y
y = mnist_forward.forward(x,None)  #前向传播得到y
#实例化可还原滑动平均的saver
ema =tf.train.ExponentialMovingAverage(滑动衰减率)
    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(存储路径)
        #如果已有ckpt模型则恢复
                if ckpt andckpt.model_checkpoint_path:
                    #恢复会话
                        saver.restore(sess, ckpt.model_checkpoint_path)
                    #恢复轮数
                          global_ste = ckpt.model_checkpoint_path.split(‘/‘)[-1].split(‘-‘)[-1]
                    #计算准确率
                          accuracy_score = sess.run(accuracy,feed_dict={x:测试数据, y_:测试数据标签 })
                    # 打印提示
                         print("After %straining step(s), test accuracy=%g" % (global_step, accuracy_score))
                     #如果没有模型
                          else:
                   print(‘No checkpoint file found‘) #模型不存在提示
                   return     

其次，制定main()函数 def main():

#加载测试数据集
mnist =input_data.read_data_sets("./data/", one_hot=True)
#调用定义好的测试函数test()
   test(mnist) if __name__ == ‘__main__‘:
   main()

通过对测试数据的预测得到准确率，从而判断出训练出的神经网络模型的性能好坏。当准确率低时，可能原因有模型需要改进，或者是训练数据量太少导致过拟合。

手写数字识别准确率输出

实现手写体mnist数据集的识别任务，共分为三个模块文件，分别是描述网络结构的前向传播过程文件（mnist_forward.py）、描述网络参数优化方法的反向传播过程文件（mnist_backward.py）、验证模型准确率的测试过程文件（mnist_test.py）。

前向传播过程文件（mnist_forward.py）

在前向传播过程中，需要定义网络模型输入层个数、隐藏层节点数、输出层个数，定义网络参数w、偏置b，定义由输入到输出的神经网络架构。

实现手写体mnist数据集的识别任务前向传播过程如下：

#coding:utf-8
#1前向传播过程
import tensorflow as tf

#网络输入节点为784个（代表每张输入图片的像素个数）
INPUT_NODE = 784
#输出节点为10个（表示输出为数字0-9的十分类）
OUTPUT_NODE = 10
#隐藏层节点500个
LAYER1_NODE = 500

def get_weight(shape, regularizer):
    #参数满足截断正态分布，并使用正则化，
    w = tf.Variable(tf.truncated_normal(shape,stddev=0.1))
    #w = tf.Variable(tf.random_normal(shape,stddev=0.1))
    #将每个参数的正则化损失加到总损失中
    if regularizer != None: tf.add_to_collection(‘losses‘, tf.contrib.layers.l2_regularizer(regularizer)(w))
    return w

def get_bias(shape):
    #初始化的一维数组，初始化值为全 0
    b = tf.Variable(tf.zeros(shape))
    return b

def forward(x, regularizer):
    #由输入层到隐藏层的参数w1形状为[784,500]
    w1 = get_weight([INPUT_NODE, LAYER1_NODE], regularizer)
    #由输入层到隐藏的偏置b1形状为长度500的一维数组，
    b1 = get_bias([LAYER1_NODE])
    #前向传播结构第一层为输入 x与参数 w1矩阵相乘加上偏置 b1 ，再经过relu函数 ，得到隐藏层输出 y1。
    y1 = tf.nn.relu(tf.matmul(x, w1) + b1)
    #由隐藏层到输出层的参数w2形状为[500,10]
    w2 = get_weight([LAYER1_NODE, OUTPUT_NODE], regularizer)
    #由隐藏层到输出的偏置b2形状为长度10的一维数组
    b2 = get_bias([OUTPUT_NODE])
    #前向传播结构第二层为隐藏输出 y1与参 数 w2 矩阵相乘加上偏置 矩阵相乘加上偏置 b2，得到输出 y。
    #由于输出 。由于输出 y要经过softmax oftmax 函数，使其符合概率分布，故输出y不经过 relu函数
    y = tf.matmul(y1, w2) + b2
    return y

反向传播过程文件（mnist_backward.py）

反向传播过程实现利用训练数据集对神经网络模型训练，通过降低损失函数值，实现网络模型参数的优化，从而得到准确率高且泛化能力强的神经网络模型。

实现手写体mnist数据集的识别任务反向传播过程如下：

#coding:utf-8
#2反向传播过程
#引入tensorflow、input_data、前向传播mnist_forward和os模块
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import mnist_forward
import os

#每轮喂入神经网络的图片数
BATCH_SIZE = 200
#初始学习率
LEARNING_RATE_BASE = 0.1
#学习率衰减率
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):
    #用placeholder给训练数据x和标签y_占位
    x = tf.placeholder(tf.float32, [None, mnist_forward.INPUT_NODE])
    y_ = tf.placeholder(tf.float32, [None, mnist_forward.OUTPUT_NODE])
    #调用mnist_forward文件中的前向传播过程forword()函数，并设置正则化，计算训练数据集上的预测结果y
    y = mnist_forward.forward(x, REGULARIZER)
    #当前计算轮数计数器赋值，设定为不可训练类型
    global_step = tf.Variable(0, trainable=False)

    #调用包含所有参数正则化损失的损失函数loss
    ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
    cem = tf.reduce_mean(ce)
    loss = cem + tf.add_n(tf.get_collection(‘losses‘))
    #设定指数衰减学习率learning_rate
    learning_rate = tf.train.exponential_decay(
        LEARNING_RATE_BASE,
        global_step,
        mnist.train.num_examples / BATCH_SIZE,
        LEARNING_RATE_DECAY,
        staircase=True)

    #使用梯度衰减算法对模型优化，降低损失函数
    #train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)
    train_step = tf.train.MomentumOptimizer(learning_rate,0.9).minimize(loss, global_step=global_step)
    #train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss, global_step=global_step)
    #定义参数的滑动平均
    ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
    ema_op = ema.apply(tf.trainable_variables())
    #实例化可还原滑动平均的saver
    #在模型训练时引入滑动平均可以使模型在测试数据上表现的更加健壮
    with tf.control_dependencies([train_step,ema_op]):
        train_op = tf.no_op(name=‘train‘)

    saver = tf.train.Saver()

    with tf.Session() as sess:
        #所有参数初始化
        init_op = tf.global_variables_initializer()
        sess.run(init_op)
        #每次喂入batch_size组（即200组）训练数据和对应标签，循环迭代steps轮
        for i in range(STEPS):
            xs, ys = mnist.train.next_batch(BATCH_SIZE)
            _, loss_value, step = sess.run([train_op, loss, global_step], feed_dict={x: xs, y_: ys})
            if i % 1000 == 0:
                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
    mnist = input_data.read_data_sets("./data/", one_hot=True)
    #反向传播
    backward(mnist)

if __name__ == ‘__main__‘:
    main()

测试过程文件（mnist_test.py）

当训练完模型后，给神经网络模型输入测试集验证网络的准确性和泛化性。注意，所用的测试集和训练集是相互独立的。 实现手写体mnist数据集的识别任务测试传播过程如下：

#coding:utf-8
#验证网络的准确性和泛化性
import time
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import mnist_forward
import mnist_backward
#程序5秒的循环间隔时间
TEST_INTERVAL_SECS = 5

def test(mnist):
    #利用tf.Graph()复现之前定义的计算图
    with tf.Graph().as_default() as g:
        #利用placeholder给训练数据x和标签y_占位
        x = tf.placeholder(tf.float32, [None, mnist_forward.INPUT_NODE])
        y_ = tf.placeholder(tf.float32, [None, mnist_forward.OUTPUT_NODE])
        #调用mnist_forward文件中的前向传播过程forword()函数
        y = mnist_forward.forward(x, None)
        #实例化具有滑动平均的saver对象，从而在会话被加载时模型中的所有参数被赋值为各自的滑动平均值，增强模型的稳定性
        ema = tf.train.ExponentialMovingAverage(mnist_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
                ckpt = tf.train.get_checkpoint_state(mnist_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]
                    accuracy_score = sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels})
                    print("After %s training step(s), test accuracy = %g" % (global_step, accuracy_score))
                #若模型不存在，则打印出模型不存在的提示，从而test()函数完成
                else:
                    print(‘No checkpoint file found‘)
                    return
            time.sleep(TEST_INTERVAL_SECS)

def main():
    #加载指定路径下的测试数据集
    mnist = input_data.read_data_sets("./data/", one_hot=True)
    test(mnist)

if __name__ == ‘__main__‘:
    main()

运行以上三个文件，可得到手写体 mnist 数据集的识别任务的运行结果：

从终端显示的运行结果可以看出，随着训练轮数的增加，网络模型的损失函数值在不断降低，并且在测试集上的准确率在不断提升，有较好的泛化能力。修改mnist_forward.py中w和b的初始化方法、修改隐藏层节点个数和隐藏层层数，修改mnist_backward.py代码中的超参数，找出最快提升准确度的“全连接网络”解决方案。

原文地址：https://www.cnblogs.com/xiaojianliu/p/9363305.html