TensorFlow Mechanics 101

2017-12-17

TensorFlow

本教程是为了展示如何使用 TensorFlow 来训练和评估一个简单的前馈神经网络来进行手写数字的分类。我们的目标读者，是有兴趣使用TensorFlow的资深机器学习人士。

教程文件

本教程使用如下文件：

File	Purpose
mnist.py	建立一个全连接 MNIST 模型
fully_connected_feed.py	利用下载的数据集训练构建好的MNIST模型的主要代码，以数据反馈字典（feed dictionary）的形式作为输入模型。

只需要直接运行fully_connected_feed.py文件，就可以开始训练：

1	python fully_connected_feed.py

准备数据

下载

在 run_training() 方法一开始，input_data.read_data_sets() 函数能确保正确的数据已经被下载到本地的训练文件夹中，然后将这些数据解压并返回一个含有DataSet实例的字典。

1	data_sets = input_data.read_data_sets(FLAGS.train_dir, FLAGS.fake_data)

注意：fake_data标记是用于单元测试的，读者可以不必理会。

数据集	目的
data_sets.train	55000个图像和标签（labels），作为主要训练集
data_sets.validation	5000个图像和标签，用于迭代验证训练准确度
data_sets.test	10000个图像和标签，用于最终测试训练准确度（trained accuracy)

输入和 Placeholders

placeholder_inputs() 创建两个 tf.placeholder 操作，定义传入图表中的shape参数，shape参数中包括batch_size值，后续还会将实际的训练用例传入图表。

1 2	images_placeholder = tf.placeholder(tf.float32, shape=(batch_size,mnist.IMAGE_PIXELS)) labels_placeholder = tf.placeholder(tf.int32, shape=(batch_size))

在训练循环（training loop）的后续步骤中，传入的整个图像和标签数据集会被切片，以符合每一个操作所设置的batch_size值，占位符操作将会被填补以符合这个batch_size值。然后使用feed_dict参数，将数据传入sess.run()函数。

建立图

在为数据创建 placeholders 后，就可以运行mnist.py文件，经过三阶段的模式函数操作：inference()， loss()，和training()。图表就构建完成了。

inference() —— 尽可能地构建好图表，满足促使神经网络向前反馈并做出预测的要求。
loss() —— 往inference图表中添加生成损失（loss）所需要的操作（ops）。
training() —— 往loss图表中添加计算并应用梯度（gradients）所需的操作。

Inference 推断

Inference() 函数尽可能建立图，返回一个预测输出的张量 tensor。

它接受图像占位符为输入，在此基础上借助ReLu(Rectified Linear Units)激活函数，构建一对全连接层（layers），以及一个有着十个节点（node）、指明了输出logtis模型的线性层。

每一层都创建于一个唯一的tf.name_scope之下，创建于该作用域之下的所有元素都将带有其前缀。

with tf.name_scope('hidden1'):
    weights = tf.Variable(tf.truncated_normal([IMAGE_PIXELS, 
                                               hidden1_units],
                                              stddev=1.0 / math.sqrt(float(IMAGE_PIXELS))),
                          name='weights')
    biases = tf.Variable(tf.zeros([hidden1_units]), name='biases')

在定义的作用域中，每一层所使用的weights和biases都在tf.Variable实例中生成，并且包含了各自要求的shape。

例如，当这些层是在hidden1作用域下生成时，赋予权重变量的独特名称将会是”hidden1/weights”。

每个变量在构建时，都会获得初始化操作（initializer ops）。

在这个最常见的情况下，weidhts 初始化为 tf.truncated_normal 并给定维度为2维张量。其中第一个维度代表该层中权重变量所连接（connect from）的单元数量，第二个维度代表该层中权重变量所连接到的（connect to）单元数量。对于名叫hidden1的第一层，相应的维度则是[IMAGE_PIXELS, hidden1_units]，因为权重变量将图像输入连接到了hidden1层。tf.truncated_normal初始函数将根据所得到的均值和标准差，生成一个随机分布（截断正态分布）。

biases 初始化为 tf.zeros 来确保它们所有的值都是0。shape 是它们所连接（connect from）的单元数量。

图表的三个主要操作，分别是两个tf.nn.relu操作，它们中嵌入了隐藏层所需的tf.matmul；以及logits模型所需的另外一个tf.matmul。三者依次生成，各自的tf.Variable实例则与输入占位符或下一层的输出tensor所连接。

1	hidden1 = tf.nn.relu(tf.matmul(images, weights) + biases)

1	hidden2 = tf.nn.relu(tf.matmul(hidden1, weights) + biases)

1	logits = tf.matmul(hidden2, weights) + biases

最后，包含输出的 logit 张量将会被返回。

Loss 损失

loss()函数通过添加所需的损失操作，进一步构建图表。

首先，labels_placeholer中的值，将被转换为64位 integers，然后添加一个 tf.nn.sparse_softmax_cross_entropy_with_logits 操作从 labels_placeholder 自动产生 1-hot labels 并用这些 1-hot labels 输出从 inference() 函数得到的 logits 处理后的交叉熵。

1
2
3

labels = tf.to_int64(labels)
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
    labels=labels, logits=logits, name='xentropy')

然后使用 tf.reduce_mean 根据 batch dimension 来平均交叉熵的值作为 total loss。

1	loss = tf.reduce_mean(cross_entropy, name='xentropy_mean')

注意：交叉熵是信息理论中的概念，可以让我们描述如果基于已有事实，相信神经网络所做的推测最坏会导致什么结果。更多详情，请查阅博文《可视化信息理论》

Training

training() 函数通过梯度下降法加入需要的操作来 minimize loss。

首先，该函数从loss()函数中获取损失tensor，将其交给tf.summary.scalar，后者在与tf.summary.FileWriter（见下文）配合使用时，可以向事件文件（events file）中生成汇总值（summary values）。在本篇教程中，每次写入汇总值时，它都会释放损失tensor的当前值（snapshot value）。

1	tf.summary.scalar('loss', loss)

Next，们实例化一个tf.train.GradientDescentOptimizer，负责按照所要求的学习效率（learning rate）应用梯度下降法（gradients）。

1	optimizer = tf.train.GradientDescentOptimizer(learining_rate)

之后，我们生成一个变量用于保存全局训练步骤（global training step）的数值，tf.train.Optimizer.minimize 函数更新系统中的训练权重（trainable weights）、增加全局步骤的操作。根据惯例，这个操作被称为 train_op，是TensorFlow会话（session）产生一个完整训练步骤所必须运行的操作（见下文）。

1 2	global_step = tf.Variable(0, name='global_step', trainable=False) train_op = optimizer.minimize(loss, global_step=global_step)

训练模型

一旦图表构建完毕，就通过fully_connected_feed.py文件中的用户代码进行循环地迭代式训练和评估。

The Graph

在run_training()这个函数的一开始，是一个Python语言中的with命令，这个命令表明所有已经构建的操作都要与默认的tf.Graph全局实例关联起来。

1	with tf.Graph().as_default():

tf.Graph实例是一系列可以作为整体执行的操作。TensorFlow的大部分场景只需要依赖默认图表一个实例即可。

利用多个图表的更加复杂的使用场景也是可能的，但是超出了本教程的范围。

The Session

完成全部的构建准备、生成全部所需的操作之后，我们就可以创建一个tf.Session，用于运行图表。

1	sess = tf.Session()

另外，也可以利用with代码块生成Session，限制作用域：

1	with tf.Session() as sess:

Session函数中没有传入参数，表明该代码将会依附于（如果还没有创建会话，则会创建新的会话）默认的本地会话。

生成会话之后，所有tf.Variable实例都会立即通过调用各自初始化操作中的tf.Session.run()函数进行初始化。

1 2	init = tf.global_variables_initializer() sess.run(init)

tf.Session.run()方法将会运行图表中与作为参数传入的操作相对应的完整子集。在初次调用时，init操作只包含了变量初始化程序tf.group。图表的其他部分不会在这里，而是在下面的训练循环运行。

Train Loop

初始化完成后，开始训练。

练的每一步都是通过用户代码控制，而能实现有效训练的最简单循环就是：

1 2	for step in range(FLAGS.max_steps): sess.run(train_op)

但是，本教程中的例子要更为复杂一点，原因是我们必须把输入的数据根据每一步的情况进行切分，以匹配之前生成的占位符。

Feed the Graph

执行每一步时，我们的代码会生成一个反馈字典（feed dictionary），其中包含对应步骤中训练所要使用的例子，这些例子的键就是其所代表的占位符操作。

fill_feed_dict() 函数会查询给定的DataSet，索要下一批次batch_size的图像和标签，与占位符相匹配的Tensor则会包含下一批次的图像和标签。

1 2	images_feed, labels_feed = data_set.next_batch(FLAGS.batch_size, FLAGS.fake_data)

然后，以占位符为键，创建一个Python字典对象，键值则是其代表的反馈tensor。

feed_dict = {
    images_placeholder: images_feed, 
    labels_placeholder: labels_feed,
}

这个字典随后作为feed_dict参数，传入sess.run()函数中，为这一步的训练提供输入样例。

检查 Status

在运行sess.run函数时，要在代码中明确其需要获取的两个值：[train_op, loss]。

for step in range(FLAGS.max_steps):
    feed_dict = fill_feed_dict(data_sets.train,
                               images_placeholder,
                               labels_placeholder)
    _, loss_value = sess.run([train_op, loss],
                             feed_dict=feed_dict)

因为要获取这两个值，sess.run()会返回一个有两个元素的元组。其中每一个Tensor对象，对应了返回的元组中的numpy数组，而这些数组中包含了当前这步训练中对应Tensor的值。由于train_op并不会产生输出，其在返回的元祖中的对应元素就是None，所以会被抛弃。但是，如果模型在训练中出现发散，loss Tensor的值可能会变成NaN，所以我们要获取它的值，并记录下来。

假设训练没有 MaNs，训练循环会每隔100个训练步骤，就打印一行简单的状态文本，告知用户当前的训练状态。

1 2	if step % 100 == 0: print('Step %d: loss = %.2f (%.3f sec)' % (step, loss_value, duration)

Status 可视化

为了释放 TensorBoard 所使用的事件文件（events file），所有的即时数据（在这里只有一个）都要在图表构建阶段合并至一个 Tensor 中。

1	summary = tf.summary.merge_all()

在 session 创建后，一个 tf.summary.FileWriter 将会被初始化来写入 events files，它包括了 graph 本身与 summaries 的值。

1	summary_writer = tf.summary.FileWriter(FLAGS.train_dir, sess.graph)

最后，每次运行 summary 时，都会往事件文件中写入最新的即时数据，函数的输出会传入事件文件读写器（writer）的add_summary()函数。

1 2	summary_str = sess.run(summary, feed_dict=feed_dict) summary_writer.add_summary(summary_str, step)

当事件文件写入时，应用 training folder 打开一个TensorBoard，查看即时数据的情况。

注意：了解更多如何构建并运行TensorBoard的信息，请查看相关教程Tensorboard：训练过程可视化。

保存检查点 checkpoint

为了得到可以用来后续恢复模型以进一步训练或评估的检查点文件（checkpoint file），我们实例化一个tf.train.Saver。

1	saver = tf.train.Saver()

在训练循环中，tf.train.Saver.save 方法会定期被调用来将当前所有可训练变量的值写入检查点文件到训练目录。

1	saver.save(sess, FLAGS.train_dir, global_step=step)

这样，我们以后就可以使用 tf.train.Saver.restore()方法，重载模型的参数，继续训练。

1	saver.restore(sess, FLAGS.train_dir)

评估模型

每一千步循环后，代码会在训练集与测试集上尝试评估这个模型。do_eval() 函数会被调用三次，分别使用训练数据集、验证数据集合测试数据集。

print('Training Data Eval:')
do_eval(sess,
        eval_correct,
        images_placeholder,
        labels_placeholder,
        data_sets.train)
print('Validation Data Eval:')
do_eval(sess,
        eval_correct,
        images_placeholder,
        labels_placeholder,
        data_sets.validation)
print('Test Data Eval:')
do_eval(sess,
        eval_correct,
        images_placeholder,
        labels_placeholder,
        data_sets.test)

注意，更复杂的使用场景通常是，先隔绝data_sets.test测试数据集，只有在大量的超参数优化调整（hyperparameter tuning）之后才进行检查。但是，由于MNIST问题比较简单，我们在这里一次性评估所有的数据。

建立 Eval Graph 评估图

在进入训练循环之前，我们应该先调用mnist.py文件中的evaluation函数，传入的logits和标签参数要与loss函数的一致。这样做是为了先构建Eval操作。

1	eval_correct = mnist.evaluation(logits, labels_placeholder)

evaluation() 函数会生成 tf.nn.in_top_k 操作，如果在K个最有可能的预测中可以发现真的标签，那么这个操作就会将模型输出标记为正确。在本文中，我们把K的值设置为1，也就是只有在预测是真的标签时，才判定它是正确的。

1	eval_correct = tf.nn.in_top_k(logits, labels, 1)

评估输出

之后，我们可以创建一个循环，往其中添加feed_dict，并在调用sess.run()函数时传入eval_correct操作，目的就是用给定的数据集评估模型。

1
2
3

for step in range(steps_per_epoch):
    feed_dict = fill_feed_dict(data_set, images_placeholder, labels_placeholder)
    true_count += sess.run(eval_correct, feed_dict=feed_dict)

true_count变量会累加所有in_top_k操作判定为正确的预测之和。接下来，只需要将正确测试的总数，除以例子总数，就可以得出准确率了。

1 2	precision = true_count / num_examples print(' Num examples: %d Num correct: %d Precision @ 1: %0.04f' % (num_examples, true_count, precision))