为什么需要TensorBoard

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

TensorBoard的效果

有没有觉的一目了然呢？我强烈推荐大家使用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:]

这段代码里做了三件事：

1. 构造3000个符合y = 0.3 * x + b关系，且增加了随机噪声的数据
2. 对数据进行shuffle
3. 按照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('\nEvaluation:')
                dev_step(x_val, y_val)

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

1. tensorboard --logdir=summary
2. 响应TensorBoard 0.4.0rc3 at http://liudaoxing-Lenovo-Rescuer-15ISK:6006 (Press CTRL+C to quit)
3. 在浏览器中打开　’http://liudaoxing-Lenovo-Resc…:6006′

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

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

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