Tensorflow笔记——使用mnist数据集

1.加载mnist数据集

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

• read_data_sets()函数

            第一个参数：表示数据集存放路径

            第二个参数one_hot：true表示以独热码形式存取数据集。

该函数运行时，会检查指定路径内是否已经有数据集，若指定路径中没有数据集，则自动下载。

该路径下会有四个压缩包：训练集train，测试集test，验证集validation。

• 训练集、验证集和测试集：以训练集为例

mnist.train.num_examples	返回样本数
mnist.train.labels	返回数据集标签。例如查看训练集中第0张图片的标签，则使用如下函数mnist.train.labels[0]
mnist.train.images	返回数据集图片像素值。例如想要查看训练集第0张图片像素值，则使用如下函数mnist.train.images[0]
mnist.train.next_batch()	将数据输入神经网络。 例如： BATCH_SIZE = 200 xs,ys = mnist.train.next_batch(BATCH_SIZE) print “xs shape:”,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'>
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]]
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. 2.]
tf.argmax(x, axis)	返回指定维度axis下，参数x中最大值索引号 例如： x = [[1., 3.], [4., 2.]] with tf.Session() as sess:     print(sess.run(tf.argmax(x, 1))) 输出结果：[1 0]
os.path.join()	表示把参数字符串按照路径命名规则拼接 例如： print(os.path.join('/hello/', 'good/boy/', 'doiido')) 输出结果：/hello/good/boy/doiido
字符串.split()	表示按照指定“拆分符”对字符串拆分，返回拆分列表。 例如： print('./model/mnist_model-1001'.split('/')[-1].split('-')[-1]) 输出结果：1001 在该例子中，共进行两次拆分。 第一个拆分符为‘/’，返回拆分列表并提取列表中索引为-1的元素即倒数第一个元素；第二个拆分符为‘-’，返回拆分列表并提取列表中索引为-1 的元素即倒数第一个元素，故函数返回值为 1001。
tf.Graph().as_default()	表示将当前图设置成为默认图，并返回一个上下文管理器。 该函数与with关键字搭配使用,应用于将已经定义好的神经网络在计算图中复现。 例如： with tf.Graph().as_default() as g，表示将在 Graph()内定义的节点加入到 计算图 g 中。

2.神经网络模型的保存：

  在反向传播过程中，一般会间隔一定轮数保存一次神经网络模型，并产生三个文件：

• 保存当前图结构的.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 对象。上述代码表示，神经网络每循环规定的轮数，将神经网络模型中所有的参数等信息保存到指定的路径中，并在存放网络模型的文件夹名称中注明保存模型时的训练轮数。

3.神经网络模型的加载

  在测试网络效果时，需要将训练好的神经网络模型加载。在 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 和保存的模型在指定路径中存在，则将保存的神经网络模型加载到当前会话中。

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

在保存模型时，若模型中采用滑动平均，则参数的滑动平均值会保存在相应文件中。

通过实例化 saver 对象，实现参数滑动平均值的加载。在 Tensorflow 中如下表示：

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

5.神经网络模型准确率评估方法

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

    在 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()函数求平均值，

  最终得到神经网络模型在本组数据上的准确率。

 

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

6.前向传播过程（forward.py）

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

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

# 前向传播过程中，需要定义神经网络中的参数 w 和偏置 b，定义由输入到输出的网络结构
def get_weight(shape, regularizer):  # 设置参数w，包括参数w的形状和是否正则化的标志
def get_bias(shape):  # 设置偏置b

# 例如
# 权重初始化
def get_weight(shape):
  initial = tf.truncated_normal(shape, stddev=0.1)
  return tf.Variable(initial)

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

7.反向传播过程（backword.py）

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

def backward( mnist ):
    x = tf.placeholder(dtype, shape )  # 实现训练样本x和样本标签y_占位
    y_ = tf.placeholder(dtype, shape )  # dtype表示数据类型，shape表示数据形状

    # 定义前向传播函数
    y = forward( )
    global_step =
    loss =   # 定义的损失函数，一般为预测值与样本标签的交叉熵（或均方误差）与正则化损失之和

    # 用优化算法对模型进行优化(GradientDescentOptimizer、AdamOptimizer、MomentumOptimizer）
    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( )

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

•   正则化项regularization

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

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

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

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

# 表示softmax()函数与交叉熵一起使用
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'))

• 指数衰减学习率

    在训练模型时，使用指数衰减学习率可以使模型在训练的前期快速收敛接近较优解，又可以保证模型在训练后期不会有太大波动。

   运用指数衰减学习率，需要在反向传播过程即 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')

9.测试过程（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 and ckpt.model_checkpoint_path:
                    # 恢复会话
                    saver.restore(sess, ckpt.model_checkpoint_path)
                    # 恢复轮数
                    global_ste = ckpt.model_checkpoint_path.split('/')[-1].spit('-')[-1]
                    # 计算准确率
                    accuracy_score = sess.run(accuracy, feed_dict={x:测试数据, y_:测试数据标签 })
                    # 打印提示
                    print("After %s training step(s), test accuracy=%g" % (global_step, accuracy_score))
                # 如果没有模型
                else:
                    print('No checkpoint file found') #模型不存在提示
                    return


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

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

10.代码

实现手写体 mnist 数据集的识别任务，共分为三个模块文件：

• 描述网络结构的前向传播过程文件（mnist_forward.py）
• 描述网络参数优化方法的反向传播 过 程 文 件（ mnist_backward.py ）
• 验 证 模 型 准 确 率 的 测 试 过 程 文 件（mnist_test.py）。

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

 在前向传播过程中，需要定义：

• 网络模型输入层个数
• 隐藏层节点数
• 输出层个数
• 网络参数 w、偏置 b
• 由输入到输出的神经网络架构

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

import tensorflow as tf

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


# 权重w初始化
def get_weight(shape, regularizer):
    w = tf.Variable(tf.truncated_normal(shape, stddev=0.1))

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


# 偏置数b
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])
    # 由于输出 y 要经过 softmax 函数，使其符合概率分布，故输出 y 不经过 relu 函数
    y = tf.matmul(y1, w2) + b2
    return y

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

反向传播过程实现：

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

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

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import new.mnist_forward as mnist_forward  # 前向传播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 = "./Learn_Model/"  # 模型保存路径
MODEL_NAME = "mnist_model"          # 模型名称


def backward(mnist):
    # 给训练数据x和标签y_占位
    x = tf.placeholder(tf.float32, [None, mnist_forward.INPUT_NODE])
    y_ = tf.placeholder(tf.float32, [None, mnist_forward.OUTPUT_NODE])
    # 调用前向传播函数并正则化，计算训练集上的预测结果
    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 = 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)

    # 定义参数的滑动平均
    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')

    # 设置保存模型的个数为50，默认是5个
    saver = tf.train.Saver(max_to_keep=50, keep_checkpoint_every_n_hours=1)

    # 实现所有参数初始化
    with tf.Session() as sess:
        init_op = tf.global_variables_initializer()
        sess.run(init_op)

        for i in range(STEPS):
            # 每次喂入BATCH_SIZE组训练数据和对应标签
            xs, ys = mnist.train.next_batch(BATCH_SIZE)
            _, loss_value, step = sess.run([train_op, loss, global_step], feed_dict={x: xs, y_: ys})
            # 每1000轮打印一次损失函数值信息，并将当前会话加载到指定路径
            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=step)


def main():
    # 加载模型
    mnist = input_data.read_data_sets("MNIST_data", one_hot=True)
    # 训练模型
    backward(mnist)


if __name__ == '__main__':
    main()

其中tf.train.Saver(max_to_keep=50, keep_checkpoint_every_n_hours=1)  第一个参数用来设置保存模型的个数为50，默认是5个

10.3 测试过程文件（mnist_test.py）

当训练完模型后，给神经网络模型输入测试集验证网络的准确性和泛化性。

注意，所用的测试集和训练集是相互独立的。

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

import time
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import new.mnist_forward as mnist_forward
import new.mnist_backward as mnist_backward

TEST_INTERVAL_SECS = 5  # 五秒循环间隔时间


def test(mnist):
    # 复现之前定义的计算图
    with tf.Graph().as_default() as g:
        x = tf.placeholder(tf.float32, [None, mnist_forward.INPUT_NODE])
        y_ = tf.placeholder(tf.float32, [None, mnist_forward.OUTPUT_NODE])
        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))

        for i in range(0, 50):
            with tf.Session() as sess:
                ckpt = tf.train.get_checkpoint_state(mnist_backward.MODEL_SAVE_PATH)
                if ckpt and ckpt.all_model_checkpoint_paths:
                    saver.restore(sess, ckpt.all_model_checkpoint_paths[i])
                    global_step = ckpt.all_model_checkpoint_paths[i].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))
                else:
                    print("No checkpoint file found")
                    return
            time.sleep(TEST_INTERVAL_SECS)


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


if __name__ == '__main__':
    main()

对于ckpt:

首先查看checkpoint文件：

ckpt = tf.train.get_checkpoint_state(mnist_backward.MODEL_SAVE_PATH)  # 用于加载checkpoint

而ckpt.model_checkpoint_path 表示获取最新的，也就是：

ckpt.all_model_checkpoint_paths：表示获取除了第一条外所有的。也就是：

ckpt.all_model_checkpoint_paths[0]表示：

 

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

随着训练轮数的增加，网络模型的损失函数值在不断降低，并且在测试集上的准确率在不断提升，有较好的泛化能力。