《TensorFlow 实战Google深度学习框架》中MNIST数字识别问题程序的重构

前馈神经网络计算部分

#mnist_inference.py
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 is not 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
import os
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

import mnist_inference

#配置神经网络的参数
BATCH_SIZE = 100  # 每次batch打包的样本个数
LEARNING_RATE_BASE = 0.8  # 基础学习率
LEARNING_RATE_DECAY = 0.99  # 学习率的衰减率
REGULARAZTION_RATE = 0.0001  # 描述模型复杂度的正则化项在损失函数中的系数
TRAINING_STEPS = 30000  # 训练轮数
MOVING_AVERAGE_DECAY = 0.99  # 滑动平均衰减率
#保存模型的路径和文件名
MODEL_SAVE_PATH = "/path/"
MODEL_NAME = "model.ckpt"

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(REGULARAZTION_RATE)  # 正则化损失函数
    y = mnist_inference.inference(x, regularizer)# 计算初始化权值计算的输出
    global_step = tf.Variable(0, trainable=False)  # tensorFlow中参数可不可训练需要标明

    # 给定滑动平均衰减率和训练轮数的变量，初始化滑动平均类
    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(labels=tf.argmax(y_, 1), logits=y)  # labels=tf.argmax(y_, 1), logits=y
    # 这里tf.argmax(y_,1)表示在“行”这个维度上张量最大元素的索引号
    cross_entropy_mean = tf.reduce_mean(cross_entropy)
    loss = cross_entropy_mean + tf.add_n(tf.get_collection('losses'))
    # losses在mnist_inference中定义
    # tf.add_n为张量相加 https://blog.csdn.net/Hollake/article/details/79704129

    # 设置指数衰减的学习率。
    learning_rate = tf.train.exponential_decay(
        LEARNING_RATE_BASE,  # 基础学习率
        global_step,  # 迭代轮数
        mnist.train.num_examples / BATCH_SIZE,  # 过完所有训练数据需要的迭代次数
        LEARNING_RATE_DECAY,  # 学习率衰减速率
    )

    # 优化损失函数，用梯度下降法来优化
    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})#实际赋值y_的地方
            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("MNIST_data/", one_hot=True)
    train(mnist)


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

经过测试这个网络大约占用500m的显存

    config = tf.ConfigProto()
    config.gpu_options.allow_growth = True  # 程序按需申请内存
    with tf.Session(config=config) as sess:

经过试验可知，卷积网络占用内存主要和卷积核的深度（16,32,64,128）有关，而与全连接层的节点数量（512,2048）基本无关。

通过GPU-Z观察。

这里有一点要问题：

问：save模型过程中tensorflow有没有自动控制最多保存多少份ckpt文件的机制？

答：这个tf有的，saver = tf.train.Saver(max_to_keep=maxnum)，这里有个参数max_to_keep，一般没写出来，tf默认是5，所以其实最多只能存5份ckpt，后保存的会覆盖前面的。你可以设置它小于5。:D

忘记那里看到了的.....

还有：

_,是什么东西？

测试函数

#mnist_eval.py
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:# 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()
        # 通过使用variables_to_restore函数，可以使在加载模型的时候将影子变量直接映射到变量的本身，
        # 所以我们在获取变量的滑动平均值的时候只需要获取到变量的本身值而不需要去获取影子变量。
        saver = tf.train.Saver(variables_to_restore)
        # 保存
        # variables_to_restore中是变量的movingaverage名字到变量的mapping（就是个字典）。
        # 得到变量和影子变量的映射关系？

        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("MNIST_data/", one_hot=True)
    evaluate(mnist)


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