如何优雅地使用TensorBoard

摘要：保存的路径构建的，可通过获得我们将的返回值记为，然后在调用后，将会返回一个当前训练步数现在我们就可以使用查看训练过程了在中输入如下命令响应在浏览器中打开没错这就是我们和过程中的情况。

当我们训练一个deep learning模型时，怎么样判断当前是过拟合，还是欠拟合等状态呢？实践中，我们常常会将数据集分为三部分：train、validation、test。训练过程中，我们让模型尽力拟合train数据集，在validation数据集上测试拟合程度。当训练过程结束后，我们在test集上测试模型最终效果。有经验的炼丹师往往会通过模型在train和validation上的表现，来判断当前是否是过拟合，是否是欠拟合。这个时候，TensorBoard就派上了大用场！

有没有觉的一目了然呢？我强烈推荐大家使用TensorBoard，使用后炼丹功力显著提升！

下面，我来讲一下如何使用TensorBoard。要使用，也要优雅！
如果你喜欢自己梳理知识，自己尝试，那么不妨阅读官方文档：戳这里查看官方文档
不然的话，就随着老夫玩转TensorBoard吧 ^0^

熟悉一个新知识的时候，应该将不必要的东西最精简化，将注意力集中到我们最关注的地方，所以，我写了一个最简单的模型，在这个模型的基础上对TensorBoard进行探索。

首先看一下这个极简的线性模型：

import tensorflow as tf
import random

class Model(object):

    def __init__(self):
        self.input_x = tf.placeholder(dtype=tf.float32, shape=[None, ], name="x")
        self.input_y = tf.placeholder(dtype=tf.float32, shape=[None, ], name="y")

        W = tf.Variable(tf.random_uniform([1], -1.0, 1.0), dtype=tf.float32)
        b = tf.Variable(tf.random_uniform([1], -1.0, 1.0), dtype=tf.float32)

        y_predict = self.input_x * W + b
        self.loss = tf.reduce_sum(tf.abs(y_predict - self.input_y))

相信这个模型大家很快就能看懂，所以就不多说了。接下来看构造数据的代码：

x_all = []
y_all = []

random.seed(10)
for i in range(3000):
    x = random.random()
    y = 0.3 * x + 0.1 + random.random()
    x_all.append(x)
    y_all.append(y)

x_all = np.array(x_all)
y_all = np.array(y_all)
shuffle_indices = np.random.permutation(np.arange(len(x_all)))

x_shuffled = x_all[shuffle_indices]
y_shuffled = y_all[shuffle_indices]

bound = int(len(x_all) / 10 * 7)

x_train = x_shuffled[:bound]
y_train = y_shuffled[:bound]

x_val = x_shuffled[bound:]
y_val = y_shuffled[bound:]

这段代码里做了三件事：

构造3000个符合y = 0.3 * x + b关系，且增加了随机噪声的数据

对数据进行shuffle

按照7比3的比例，将3000个数据集划分为训练集和验证集两部分

下面是对数据按batch取出：

def batch_iter(data, batch_size, num_epochs, shuffle=True):
    """
    Generates a batch iterator for a dataset.
    """
    data = np.array(data)
    data_size = len(data)
    num_batches_per_epoch = int((len(data)-1)/batch_size) + 1
    for epoch in range(num_epochs):
        # Shuffle the data at each epoch
        if shuffle:
            shuffle_indices = np.random.permutation(np.arange(data_size))
            shuffled_data = data[shuffle_indices]
        else:
            shuffled_data = data
        for batch_num in range(num_batches_per_epoch):
            start_index = batch_num * batch_size
            end_index = min((batch_num + 1) * batch_size, data_size)
            yield shuffled_data[start_index:end_index]

然后就到了比较本篇博客的核心部分：
首先我来描述一下关键的函数（大部分同学内心一定是拒绝的 2333，所以建议先看下面的代码，然后再反过头来看函数的介绍）：

tf.summary.scalar(name, tensor, collections=None, family=None)，调用这个函数来观察Tensorflow的Graph中某个节点

tensor：我们想要在TensorBoard中观察的节点

name：为该节点设置名字，在TensorBoard中我们观察的曲线将会以name命名

tf.summary.merge(inputs, collections=None, name=None)

inputs：由scalar函数返回值组成的list

tf.summary.FileWriter,在给定的目录中创建一个事件文件(event file)，将summraies保存到该文件夹中。

__init__(logdir, graph=None, max_queue=10, flush_secs=120, graph_def=None, filename_suffix=None)

logdir：保存event file的路径

graph：　Tensorflow构建的graph，可通过session.graph获得

add_summary(summary, global_step=None)

summary：我们将tf.summary.merge的返回值记为summary_op，然后在调用sess.run(summary_op)后，将会返回一个summary

global_step：当前训练步数

with tf.Graph().as_default():
    sess = tf.Session()
    with sess.as_default():
        m = model.Model()
        global_step = tf.Variable(0, name="global_step", trainable=False)
        optimizer = tf.train.AdamOptimizer(1e-2)
        grads_and_vars = optimizer.compute_gradients(m.loss)
        train_op = optimizer.apply_gradients(grads_and_vars=grads_and_vars, global_step=global_step)

        loss_summary = tf.summary.scalar("loss", m.loss)

        train_summary_op = tf.summary.merge([loss_summary])
        train_summary_writer = tf.summary.FileWriter("./summary/train", sess.graph)

        dev_summary_op = tf.summary.merge([loss_summary])
        dev_summary_writer = tf.summary.FileWriter("./summary/dev", sess.graph)


        def train_step(x_batch, y_batch):
            feed_dict = {m.input_x: x_batch,
                         m.input_y: y_batch}
            _, step, summaries, loss = sess.run(
                [train_op, global_step, train_summary_op, m.loss], feed_dict)
            train_summary_writer.add_summary(summaries, step)

        def dev_step(x_batch, y_batch):
            feed_dict = {m.input_x: x_batch,
                         m.input_y: y_batch}

            step, summaries, loss = sess.run(
                [global_step, dev_summary_op, m.loss], feed_dict)
            dev_summary_writer.add_summary(summaries, step)

        sess.run(tf.global_variables_initializer())
        batches = batch_iter(list(zip(x_train, y_train)), 100, 100)
        for batch in batches:
            x_batch, y_batch = zip(*batch)
            train_step(x_batch, y_batch)
            current_step = tf.train.global_step(sess, global_step)
            if current_step % 3 == 0:
                print("
Evaluation:")
                dev_step(x_val, y_val)

现在我们就可以使用TensorBoard查看训练过程了~~
在terminal中输入如下命令:

tensorboard --logdir=summary

响应TensorBoard 0.4.0rc3 at http://liudaoxing-Lenovo-Rescuer-15ISK:6006 (Press CTRL+C to quit)

在浏览器中打开　"http://liudaoxing-Lenovo-Resc...:6006"

没错！这就是我们train和validation过程中loss的情况。

点击GRAPHS,就可以看到网络的结构

麻雀虽小，五脏俱全。希望大家有收获～