Tensorflow:实战Google深度学习框架 学习笔记（三）：MNIST数字识别

版权声明：作者水平有限，博客中难免不少纰漏甚至严重错误，希望大家指正。同时撰写最大的目的也在于交流学习，而不在关注和传播。任重而道远，与您共勉。 https://blog.csdn.net/yexiaohhjk/article/details/85803172

Tensorflow 学习笔记（三）：MNIST数字识别

前言

MNIST手写数字识别是一个非常经典入门的深度学习的实验，跟着《 Tensorflow:实战Google深度学习框架》第五章学习如何利用Tensorflow框架完成这个实验。

我发现每章内容知识点繁多，如果只是刷一遍不用也忘了，决定以小节为单位慢慢刷书，后面要用到哪个再慢慢看。
最近还有各种算法要学，得赶快投入学理论知识。
慢慢更新…

---

MNIST数据

下载MNIST数据

• 首先你可以选择去YannLeCun教授的网站下载用来训练和测试的MNIST数据集。

• 或者利用Tensorflow提供的一个类下载并处理MNIST数据。

详见下面代码.

MNIST数据的处理

from  tensorflow.examples.tutorials.mnist import input_data

#从指定路径./data/载入数据，如果没有就会从上面网址进行下载，耐心等待一会。
minist = input_data.read_data_sets("./data/" , one_hot = True)

#打印训练数据大小
print("Traninig data size: ", minist.train.num_examples)
#打印验证集数据大小
print("Validating data size: ", minist.validation.num_examples)
#打印测试集数据大小
print("Testing data size: ",minist.test.num_examples)
#打印训练集第一个数据
print("Example training data : ",minist.train.images[0])
#打印训练集第一个数据的结果
print("Example labels data : ",minist.train.labels[0])

上面代码，通过input_data.read_data_sets函数生成的类会自动将MNIST数据分成train,validation,test三个数据集。Minist数据集是由大小为28x28的手写数字图片构成，所以处理后的每一张图片变成一个长度为784（28x28）的一维数组。

同时为了方便使用随机梯度下降进行优化求解，input_data.read_data_sets函数生成的类提供了mnist.train.next_batch(batch_size)函数。可以从所有训练数据里读取指定batch_size大小的数据作为一个训练batch。

神经网络模型训练及不同模型结果的对比

【滑动平均模型】，【指数衰减模型的学习率】，【使用正则化】带来的正确率提升不是要很明显。这是由于滑动平均模型和指数衰减模型的学习率在一定程度上都是限制神经网络中的参数更新速度，然而在MNIST数据上，因为模型收敛速度很快，所以这两种优化对最终模型的影响不大。

Tensorflow训练神经网络

这个代码里有上一章提到的所有的优化的模块。说实话我看到这个代码，【滑动平均模型】，【指数衰减模型的学习率】由于原理不是很懂，看到是很懵逼的，不管了，先当黑盒学习吧（弱）。其他的仔细阅读注释问题不大。

#!/usr/bin/env python
# encoding: utf-8
'''
@author: MrYx
@github: https://github.com/MrYxJ 
@file: 全模型.py
@time: 18-12-15 下午10:25
'''

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

INPUT_NODE = 784  # 输入节点
OUTPUT_NODE = 10  # 输出节点
LAYER1_NODE = 800  # 隐藏层神经员个数

BATCH_SIZE = 100  # 每次batch打包的样本个数

# 模型相关的参数
LEARNING_RATE_BASE = 0.8
LEARNING_RATE_DECAY = 0.99
REGULARAZTION_RATE = 0.0001
TRAINING_STEPS = 50000
MOVING_AVERAGE_DECAY = 0.99

def inference(input_tensor, avg_class, weights1, biases1, weights2, biases2):
    # 不使用滑动平均类
    if avg_class == None:
        layer1 = tf.nn.relu(tf.matmul(input_tensor, weights1) + biases1)
        return tf.matmul(layer1, weights2) + biases2

    else:
        # 使用滑动平均类
        layer1 = tf.nn.relu(tf.matmul(input_tensor, avg_class.average(weights1)) + avg_class.average(biases1))
        return tf.matmul(layer1, avg_class.average(weights2)) + avg_class.average(biases2)

def train(mnist):
    x = tf.placeholder(tf.float32, [None, INPUT_NODE], name='x-input')
    y_ = tf.placeholder(tf.float32, [None, OUTPUT_NODE], name='y-input')
    # 生成隐藏层的参数。
    weights1 = tf.Variable(tf.truncated_normal([INPUT_NODE, LAYER1_NODE], stddev=0.1))
    biases1 = tf.Variable(tf.constant(0.1, shape=[LAYER1_NODE]))

    weights2 = tf.Variable(tf.truncated_normal([LAYER1_NODE, OUTPUT_NODE], stddev=0.1))
    biases2 = tf.Variable(tf.constant(0.1, shape=[OUTPUT_NODE]))

    y = inference(x, None, weights1, biases1, weights2, biases2)

    # 定义训练轮数及相关的滑动平均类
    global_step = tf.Variable(0, trainable=False)
    variable_averages = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
    variables_averages_op = variable_averages.apply(tf.trainable_variables())
    average_y = inference(x, variable_averages, weights1, biases1, weights2, biases2)

    # 计算交叉熵及其平均值
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
    cross_entropy_mean = tf.reduce_mean(cross_entropy)

    regularizer = tf.contrib.layers.l2_regularizer(REGULARAZTION_RATE)
    regularaztion = regularizer(weights1) + regularizer(weights2)
    loss = cross_entropy_mean + regularaztion

    # 设置指数衰减的学习率。
    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)

    # 反向传播更新参数和更新每一个参数的滑动平均值
    with tf.control_dependencies([train_step, variables_averages_op]):
        train_op = tf.no_op(name='train')

    # 计算正确率
    correct_prediction = tf.equal(tf.argmax(average_y, 1), tf.argmax(y_, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

    # 初始化会话，并开始训练过程。
    with tf.Session() as sess:
        tf.global_variables_initializer().run()
        validate_feed = {x: mnist.validation.images, y_: mnist.validation.labels}
        test_feed = {x: mnist.test.images, y_: mnist.test.labels}

        # 循环的训练神经网络。
        for i in range(TRAINING_STEPS):
            if i % 1000 == 0:
                validate_acc = sess.run(accuracy, feed_dict=validate_feed)
                print("After %d training step(s), validation accuracy using average model is %g " % (i, validate_acc))

            xs, ys = mnist.train.next_batch(BATCH_SIZE)
            sess.run(train_op, feed_dict={x: xs, y_: ys})

        test_acc = sess.run(accuracy, feed_dict=test_feed)
        print(("After %d training step(s), test accuracy using average model is %g" % (TRAINING_STEPS, test_acc)))

def main(argv=None):
    mnist = input_data.read_data_sets("data/", one_hot=True)
    train(mnist)

if __name__=='__main__':
    main()
    

下面是去除【滑动平均模型】和隐藏层的代码，可以运行起来和上面对比一下结果差异：

#!/usr/bin/env python
# encoding: utf-8
'''
@author: MrYx
@github: https://github.com/MrYxJ 
@file: 无滑动模型优化-激活函数-sigmoid.py
@time: 19-1-4 下午4:15
'''
#!/usr/bin/env python
# encoding: utf-8
'''
@author: MrYx
@github: https://github.com/MrYxJ 
@file: 无滑动模型优化.py
@time: 18-12-19 下午9:52
'''

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

INPUT_NODE = 784  # 输入节点
OUTPUT_NODE = 10  # 输出节点
LAYER1_NODE = 800  # 隐藏层神经员个数
BATCH_SIZE = 100  # 每次batch打包的样本个数
# 模型相关的参数
LEARNING_RATE_BASE = 0.8
REGULARAZTION_RATE = 0.0001
TRAINING_STEPS = 50000

def train(mnist):
    x = tf.placeholder(tf.float32, [None, INPUT_NODE], name='x-input')
    y_ = tf.placeholder(tf.float32, [None, OUTPUT_NODE], name='y-input')
    # 生成隐藏层的参数。
    weights1 = tf.Variable(tf.truncated_normal([INPUT_NODE, OUTPUT_NODE], stddev=0.1))
    biases1 = tf.Variable(tf.constant(0.1, shape=[OUTPUT_NODE]))

    # weights2 = tf.Variable(tf.truncated_normal([LAYER1_NODE, OUTPUT_NODE], stddev=0.1))
    # biases2 = tf.Variable(tf.constant(0.1, shape=[OUTPUT_NODE]))

    layer1 = tf.nn.sigmoid(tf.matmul(x, weights1) + biases1)
    y = layer1

    # 定义训练轮数及相关的滑动平均类
    global_step = tf.Variable(0, trainable=False)

    # 计算交叉熵及其平均值
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
    cross_entropy_mean = tf.reduce_mean(cross_entropy)

    regularizer = tf.contrib.layers.l2_regularizer(REGULARAZTION_RATE)
    regularaztion = regularizer(weights1) + regularizer(weights1)
    loss = cross_entropy_mean + regularaztion

    # 设置指数衰减的学习率。
    # 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_BASE).minimize(loss, global_step=global_step)

    # 计算正确率
    correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

    # 初始化会话，并开始训练过程。
    with tf.Session() as sess:
        tf.global_variables_initializer().run()
        validate_feed = {x: mnist.validation.images, y_: mnist.validation.labels}
        test_feed = {x: mnist.test.images, y_: mnist.test.labels}

        # 循环的训练神经网络。
        for i in range(TRAINING_STEPS):
            if i % 1000 == 0:
                validate_acc = sess.run(accuracy, feed_dict=validate_feed)
                print("After %d training step(s), validation accuracy using average model is %g " % (i, validate_acc))

            xs, ys = mnist.train.next_batch(BATCH_SIZE)
            sess.run(train_step, feed_dict={x: xs, y_: ys})

        test_acc = sess.run(accuracy, feed_dict=test_feed)
        print(("After %d training step(s), test accuracy using average model is %g" % (TRAINING_STEPS, test_acc)))

def main(argv=None):
    mnist = input_data.read_data_sets("data/", one_hot=True)
    train(mnist)

if __name__=='__main__':
    main()

变量管理

主要利用命令空间：variable_scope()和get_variable('')函数来管理获取变量，达到简化函数参数的写法，大大提高了程序的可读性。

get_variable()和Variable()创建变量的过程是一样的。

#下面这两个定义等价
v = tf.get_variable("v",shape=[1],initalizer=tf.constant_initializer(1.0))
v = tf.Variable(tf.constant(1.0, shape=[1]),name="v")

他两最大的区别在于，指定变量名称的参数。对于Variable函数变量名称是一个可选的参数，但是对于get_variable变量名称是一个必填的参数,它会根据这个名字去创建或者获取变量。
如果是获取一个已创建的变量需要通过variable_scope函数来生成一个上下文管理器，并明确指定在这个上下文管理器里，并注意其参数reuse来决定获取是否是已经创建好的变量。

import tensorflow as tf
 with tf.variable_scope("layer1",reuse = False):
      v1 = tf.get_variable('v',[1]) 
      print(v1.name)  # layer1/v:0

在这里命令了一个名称为’layer1’的命名空间，reuse参数的bool值决定tf.get_variable()获取的是已经声明的变量还是新建变量，reuse默认为Fasle,表示创建一个新的变量。

TensorFlow模型持久化

神经网络的训练往往时间很长，Tensorflow提供一个非常简单的API来保存和还原神经网络的模型，实现边训练边测试效果。这个API 就是tf.train.Saver类。

Tensorflow通过saver.save()函数将模型保存到本地后缀为.ckpt的文件中，虽然路径只指名了一个文件路径，但文件目录下会出现四个文件。
这是因为TensorFlow会将计算图的结构和图上参数取值分开保存。

import tensorflow as tf
v1 = tf.Variable(tf.random_normal([1], stddev=1, seed=1))
v2 = tf.Variable(tf.random_normal([1], stddev=1, seed=1))
result = v1 + v2

init_op = tf.global_variables_initializer()
saver = tf.train.Saver()

with tf.Session() as sess:
    sess.run(init_op)
    #将模型保存到/path/to/model/model.ckpt
    saver.save(sess, "Saved_model/model.ckpt")

# 加载保存的模型
with tf.Session() as sess:
    saver.restore(sess, "Saved_model/model.ckpt")
    print(sess.run(result)) 

本地saved_model文件夹内会生成三个文件：

• model.ckpt.meta保存了Tensorflow计算图结构。
• model.ckpt保存了程序中每个变量的取值。
• checkpoint文件保存了一个目录下所有模型文件的列表。

持久化原理及数据格式

当调用saver.save函数时，Tensorflow程序会自动生成四个文件。TensorFlow模型持久化就是通过这四个文件完成的。首先Tensorflow是通过元图(MetaGraph)来记录计算图中的节点的信息以及运行计算图中节点所需要的元数据。
(待补充)

加入持久化的ＭNIST实践样例程序

上一节已经给出加入所有优化的完整Mnist手写识别实验的程序。然而没有加入持久化过程，当程序中途退出时，之前没有保存的模型再也无法使用。一般神经网络训练时间比较长，保存训练中间的结果是非常有必要。我们将上一节程序分成训练和测试两个独立的过程，这样使得每一个组件更加灵活。比如训练模型可以持续输出训练的模型，测试模型每隔一段时间检验最新的模型的正确率。

重构代码分成３个程序：
第一个是mnist_inference.py程序，定义了前向传播以及神经网络中参数初始化的过程。

#!/usr/bin/env python
# encoding: utf-8
'''
@author: MrYx
@github: https://github.com/MrYxJ 
@file: mnist_inference.py
@time: 19-1-17 上午10:28
'''

import tensorflow as tf

INPUT_NODE = 784
OUTPUT_NODE = 10
LAYER1_NODE = 500

def get_weight_variable(shape, regularizer):
    weights = tf.get_variable("weights", shape,
                              initializer=tf.truncated_normal_initializer(stddev=0.1))
    if regularizer != None:
        tf.add_to_collection('losses', regularizer(weights))
    return weights

def inference(input_tensor, regularizer):
    with tf.variable_scope('layer1'):
        weights = get_weight_variable([INPUT_NODE, LAYER1_NODE], regularizer)
        biases = tf.get_variable("biases", [LAYER1_NODE], initializer=tf.constant_initializer(0.0))
        layer1 = tf.nn.relu(tf.matmul(input_tensor, weights) + biases)

    with tf.variable_scope('layer2'):
        weights = get_weight_variable([LAYER1_NODE, OUTPUT_NODE], regularizer)
        biases = tf.get_variable("biases", [OUTPUT_NODE], initializer=tf.constant_initializer(0.0))
        layer2 = tf.matmul(layer1, weights) + biases
    return layer2

第二个是mnist_train.py,定义了神经网络训练的过程。

#!/usr/bin/env python
# encoding: utf-8


import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import mnist_inference

INPUT_NODE = 784  # 输入节点
OUTPUT_NODE = 10  # 输出节点
LAYER1_NODE = 800  # 隐藏层神经员个数

BATCH_SIZE = 100  # 每次batch打包的样本个数

# 模型相关的参数
BATCH_SIZE = 100
LEARNING_RATE_BASE = 0.8
LEARNING_RATE_DECAY = 0.99
REGULARIZATION_RATE = 0.0001
TRAINING_STEPS = 30000
MOVING_AVERAGE_DECAY = 0.99
MODEL_SAVE_PATH = "MNIST_model/"
MODEL_NAME = "mnist_model"


def train(mnist):
    # 定义输入输出placeholder。
    x = tf.placeholder(tf.float32, [None, mnist_inference.INPUT_NODE], name='x-input')
    y_ = tf.placeholder(tf.float32, [None, mnist_inference.OUTPUT_NODE], name='y-input')

    regularizer = tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE)
    y = mnist_inference.inference(x, regularizer)
    global_step = tf.Variable(0, trainable=False)

    # 定义损失函数、学习率、滑动平均操作以及训练过程。
    variable_averages = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
    variables_averages_op = variable_averages.apply(tf.trainable_variables())
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
    cross_entropy_mean = tf.reduce_mean(cross_entropy)
    loss = cross_entropy_mean + 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)
    with tf.control_dependencies([train_step, variables_averages_op]):
        train_op = tf.no_op(name='train')

    # 初始化TensorFlow持久化类。
    saver = tf.train.Saver()
    with tf.Session() as sess:
        tf.global_variables_initializer().run()

        for i in range(TRAINING_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(argv=None):
    mnist = input_data.read_data_sets("data/", one_hot=True)
    train(mnist)

if __name__=='__main__':
    tf.app.run()

第三个是mnist_eval.py

#!/usr/bin/env python
# encoding: utf-8
'''
@author: MrYx
@github: https://github.com/MrYxJ 
@file: mnist_eval.py
@time: 19-1-17 下午8:30
'''

import time
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import mnist_inference
import mnist_train

# 加载的时间间隔。
EVAL_INTERVAL_SECS = 10

def evaluate(mnist):
    with tf.Graph().as_default() as g:
        x = tf.placeholder(tf.float32, [None, mnist_inference.INPUT_NODE], name='x-input')
        y_ = tf.placeholder(tf.float32, [None, mnist_inference.OUTPUT_NODE], name='y-input')
        validate_feed = {x: mnist.validation.images, y_: mnist.validation.labels}

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

        variable_averages = tf.train.ExponentialMovingAverage(mnist_train.MOVING_AVERAGE_DECAY)
        variables_to_restore = variable_averages.variables_to_restore()
        saver = tf.train.Saver(variables_to_restore)
        
        while True:
            with tf.Session() as sess:
                ckpt = tf.train.get_checkpoint_state(mnist_train.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=validate_feed)
                    print("After %s training step(s), validation accuracy = %g" % (global_step, accuracy_score))
                else:
                    print('No checkpoint file found')
                    return
            time.sleep(EVAL_INTERVAL_SECS)

def main(argv=None):
    mnist = input_data.read_data_sets("../../../datasets/MNIST_data", one_hot=True)
    evaluate(mnist)

if __name__ == '__main__':
    tf.app.run()