TensorFlow实战——MNIST数字识别问题

TensorFlow实战——MNIST数字识别问题

MNIST数据处理

因为MNSIT数据集在机器学习领域非常有名，所以TensorFlow提供了一个类来处理MNIST数据。这个类会自动下载并转化MNIST数据的格式，将数据从原始的数据包中解析成训练和测试神经网络时使用的格式。
样例程序

from tensorflow.examples.tutorials.mnist import input_data
#载入MNIST数据集，如果指定地址下没有下载好的数据，那么TensorFlow会自动下载
mnist = input_data.read_data_sets("/path'', one_hot=True)
print "Training data size: ", mnist.train.num_examples #training data size:55000
print "Validating data size: ", mnist.validation.num_examples #Validating data size:5000
print "Testing data size: ", mnist.test.num_examples #Testing data size:10000
print "Example training data: ", mnist.train.images[0]#第一个样例的特征 [0. 0. 0. ... 0.380 0.376 .. 0.]
print "Example training data label: ", mnist.train.labels[0]#第一个样例的标签[0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]

为了方便使用随机梯度下降，input_data.read_data_sets函数生成的类还提供了mnist.train.next_batch函数，它可以从所有的训练数据中读取一小部分作为一个训练batch。
样例代码

batch_size = 100
xs, ys = mnist.train.next_batch(batch_size)#注意有两个返回值
#从train的集合中选取batch_size个训练数据
print "X shape:", xs.shape#(100, 784)
print "Y shape:", ys.shape#(100, 10)

TensorFlow训练神经网络

在MNIST数据集上实现指数衰减学习率、正则化和滑动平均模型的代码。

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

INPUT_NODE = 784#输入层的节点数
OUTPUT_NODE = 10#输出层的节点数

LAYER1_NODE = 500#隐藏层的节点数

BATCH_SIZE = 100#一个训练batch中的训练数据个数，数字越小，训练过程越接近随机梯度下降，数字越大，训练越接近梯度下降

LEARNING_RATE_BASE = 0.8#初始学习率
LEARNING_RATE_DECAY = 0.99#学习率的衰减率
REGULARIZATION_RATE = 0.0001#正则化参数
TRAINING_STEPS = 30000#训练轮数
MOVING_AVERAGE_DECAY = 0.99#滑动平均衰减率
#辅助函数，计算前向传播结果。avg_class为滑动平均类
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
    #有滑动平均类。首先使用avg_class.average函数来计算变量的滑动平均值，然后再进行前向传播。
    else:
        layer1 = tf.nn.relu(tf.matmul(input_tensor, avg_class.average(weights1))
            + avg_class.average(biases1))#weight和bias都需要使用滑动平均值
        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')#用placeholder机制处理训练集
    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)
    #在所有代表神经网络参数的变量上使用滑动平均。
    #tf.trainable_variables返回的是GraphKeys.TRAINABLE_VARIABLES的集合。
    variable_averages_op = variable_averages.apply(tf.trainable_variables())
    #使用滑动平均模型的前向传播。
    average_y = inference(
        x, variable_averages, weights1, biases1, weights2, biases2)
    #计算交叉熵刻画预测与真实值的损失。使用sparse_softmax_cross_entropy_with_logits函数计算交叉熵，当问题只有一个正确答案时，可以加快计算速度。函数的第一个参数是不包括softmax层的前向传播结果，第二个是正确答案。
    #因为标准答案是一个长度为10的一维数组，而函数需要提供的是一个正确答案的数字，所以需要使用tf.argmax函数来获取正确答案对应的类别编号。
    #注意该函数与之前版本相比，需要用参数名来指定具体的参数类型，即logits和labels
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
    #计算在当前batch中所有样例的交叉熵平均值
    cross_entropy_mean = tf.reduce_mean(cross_entropy)
    #L2正则化损失函数初始化
    regularizer = tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE)
    #计算正则化损失，一般不使用偏置项。
    regularization = regularizer(weights1) + regularizer(weights2)
    #总损失要相加起来
    loss = cross_entropy_mean + regularization
    #设置学习率。global_step为当前迭代的轮数，初始化为0.
    learning_rate = tf.train.exponential_decay(LEARNING_RATE_BASE, global_step, mnist.train.num_examples / BATCH_SIZE, LEARNING_RATE_DECAY)
    #使用tf.train.GradientDescentOptimizer优化算法来优化损失函数。
    train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step = global_step)
    #在训练神经网络模型时，每过一遍数据既需要通过反向传播来更新神经网络中的参数，又要更新每一个参数的滑动平均值。为了一次完成多个操作，TensorFlow提供了tf.control_dependencies和tf.group两种机制。
    #下面两行程序和train_op = tf.group(train_step, variables_averages_op)是等价的。
    with tf.control_dependencies([train_step, variable_averages_op]):
        train_op = tf.no_op(name='train')
    #计算预测值与真实值的结果是否正确。
    correct_prediction = tf.equal(tf.argmax(average_y, 1), tf.argmax(y_, 1))
    #计算精确度，正确率。tf.cast用于将一个布尔型的数值转换为实数型，然后用reduce_mean计算平均值
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    #初始化会话并开始训练过程
    with tf.Session() as sess:
        tf.initialize_all_variables().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:#每1000轮输出一次在验证集上的测试结果
                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))
            #产生这一轮使用的一个batch的训练数据，运行训练过程
            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("/tmp/data", one_hot=True)
    train(mnist)
#TensorFlow提供的一个主程序入口，tf.app.run会调用上面定义的main函数
if __name__ == '__main__':
    tf.app.run()

验证数据集的作用——判断模型效果

在上述程序的开始，设置了初始学习率、学习率衰减率等七种不同的参数，那么如何设置这些参数的取值保证模型精确度成了一个问题。在大部分情况下，配置神经网络的参数都是需要通过实验来调整的。虽然一个神经网络模型的效果最终是通过测试数据来评判的，但是我们不能直接通过模型在测试数据上的效果来选择参数。使用测试数据来选取参数可能会导致神经网络模型过度拟合测试数据，从而失去对未知数据的预判能力。
为了评测神经网络模型在不同参数下的效果，一般会从训练数据中抽取一部分作为验证数据。使用验证数据就可以评判不同参数取值下模型的表现。除了使用验证数据集，还可以采用交叉验证的方式来验证模型效果。但因为神经网络训练时间本身就比较长，采用交叉验证会花费大量时间，所以在海量数据的情况下，一般会更多地采用验证数据集的形式来评测模型的效果。

变量管理

当神经网络的结构更加复杂、参数更多时，就需要一个更好的方式来传递和管理神经网络中的参数了。TensorFlow提供了通过变量名称来创建或者获取一个变量的机制。通过这个机制，在不同的函数中可以直接通过变量的名字来使用变量，而不需要将变量通过参数的形式到处传递。
TensorFlow中通过变量名称获取变量的机制主要是通过tf.get_variable和tf.variable_scope函数实现的。
除了tf.Variable函数，TensorFlow还提供了tf.get_variable函数来创建或者获取变量。

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

TensorFlow提供了七种不同的初始化函数。


tf.get_variable函数与tf.Variable函数最大的区别在于指定变量名称的参数。对于tf.Variable函数，变量名称是一个可选的参数，通过name=”v”的形式给出。但是对于tf.get_variable函数，变量名称是一个必填的参数。这是为了避免无意识的变量复用造成的错误。
如果需要通过tf.get_variable获取一个已经创建的变量，需要通过tf.variable_scope函数来生成一个上下文管理器，并明确指定在这个上下文管理器中，tf.get_variable将直接获取已经生成的变量。

with tf.variable_scope("foo"):
    v = tf.get_variable("v", [1], initializer=tf.constant_initializer(1.0))
#在生成上下文管理器时，将参数reuse设置为true。这样tf.get_variable函数将直接获取已经声明的变量。
with tf.variable+scope("foo", reuse=True):
    v1 = tf.get_variable("v", [1])
    print v == v1#输出为True
#将参数reuse设置为True时，tf.variable_scope将只能获取已经创建过的变量。如果在未创建变量的命名空间中引用变量，那么将报错。

如果tf.variable_scope函数使用参数reuse=None或者reuse=False创建上下文管理器，tf.get_variable操作将创建新的变量。如果同名的变量已经存在，则tf.get_variable函数将报错。TensorFlow中tf.variable_scope函数是可以嵌套的。

with tf.variable_scope("root"):
    print tf.get_variable_scope().reuse#输出false
    with tf.variable_scope("foo", reuse=True):
        print tf.get_variable_scope().reuse#输出true
        with tf.variable_scope("bar"):
            print tf.get_variable_scope().reuse#输出true
    print tf.get_variable_scope().reuse#输出false

tf.variable_scope函数生成的上下文管理器也会创建一个TensorFlow中的命名空间，在命名空间内创建的变量名称都会带上这个命名空间名作为前缀。

with tf.variable_scope("foo"):
    v2 = tf.get_variable("v", [1])
    print v2.name#输出foo/v:0 在tf.variable_scope中创建的变量，名称前面会加入命名空间的名称，并通过/来分隔命名空间的名称和变量的名称 
with tf.variable_scope("foo"):
    with tf.variable_scope("bar"):
        v3 = tf.get_variable("v", [1])
        print v3.name#输出foo/bar/v:0
with tf.variable_scope("", reuse=True):
    v5 = tf.get_variable("foo/bar/v", [1])#可以直接通过带命名空间名称的变量名来获取其他命名空间下的变量。比如这里通过指定名称foo/bar/v来获取在命名空间foo/bar/中创建的变量