[干货|实践] Tensorflow可视化

TensorBoard

1. 简介：TensorBoard是tensorflow官方推出的可视化工具，它可以将模型训练过程中的各种汇总数据展示出来，包括标量(Scalars)、图片(Images)、音频(Audio)、计算图(Graphs)、数据分布(Distributions)、直方图(Histograms)和潜入向量(Embeddigngs)。
2. 作用：tensorflow代码执行过程是先构建图，然后在执行，所以对中间过程的调试不太方便；除此之外，在使用tensorflow训练大型深度学习神经网络时，中间的计算过程可能非常复杂，因此为了理解、调试和优化网络，可以使用TensorBoard观察训练过程中的各种可视化数据。

---

TensorBoard可视化过程

在将可视化过程之前，为了方便理解，对之中设计的一些概念做一个简要介绍。

什么是Graph和Session

graph定义了computation，它不计算任何东西，不包含任何值，只是定义了你在代码中指定的操作。关于graph的官方文档地址：tf.Graph。若不建立graph，TensorFlow在加载库的时候会地创建图，并且将这个图指定为默认图。可以通过使用tf.get_default_graph()函数获得默认图的句柄。在大多数的TensorFlow程序中，都只是用默认图（graph）来处理。不过，当你定义的多个模型没有相互内在的依赖的情况下，创建多个图的时候很有用。下面，我们一个变量和三个操作定义一个图形：==variable==返回变量的当前值。 ==initialize==将42的初始值赋给那个变量。 ==assign==给该变量赋值13的新值。

#Defining the Graph
graph = tf.Graph()
with graph.as_default():
  variable = tf.Variable(42, name='foo')
  initialize = tf.global_variables_initializer()
  assign = variable.assign(13)

Session会话允许执行graph或graph的一部分。它为此分配资源（在一台或多台机器上）并保存中间结果和变量的实际值。要运行上面三个定义的操作中的任何一个时，我们需要为该graph创建一个会话Session。 因此会话Session需要分配内存来存储变量的当前值。

#Running Computations in a Session
with tf.Session(graph=graph) as sess:
  sess.run(initialize)
  sess.run(assign)
  print(sess.run(variable))
# Output: 13

可视化过程

1. 先建立一个graph
2. 确定要在graph中的哪些节点放置summary operations以记录信息
   使用tf.summary.scalar记录标量
   使用tf.summary.histogram记录数据的直方图
   使用tf.summary.distribution记录数据的分布图
   使用tf.summary.image记录图像数据
   ……
3. operations并不会去真的执行计算，除非你告诉他们需要去run,或者它被其他的需要run的operation所依赖。而我们上一步创建的这些summary operations其实并不被其他节点依赖，因此，我们需要特地去运行所有的summary节点。但是呢，一份程序下来可能有超多这样的summary 节点，要手动一个一个去启动自然是及其繁琐的，因此我们可以使用tf.summary.merge_all去将所有summary节点合并成一个节点，只要运行这个节点，就能产生所有我们之前设置的summary data。
4. 使用tf.summary.FileWriter将运行后输出的数据都保存到本地磁盘中
5. 运行整个程序，并在命令行输入运行tensorboard的指令，之后打开web端可查看可视化的结果

Tensorboard使用案例

使用最基础的识别手写字体的案例,建立一个简单的神经网络，让大家了解如何使用Tensorboard。可以从github获得源码。

导入包，定义超参数，载入数据

1. 首先还是导入需要的包：

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

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

1. 定义固定的超参数,方便待使用时直接传入。如果你问，这个超参数为啥要这样设定，如何选择最优的超参数？这个问题此处先不讨论，超参数的选择在机器学习建模中最常用的方法就是“交叉验证法”。而现在假设我们已经获得了最优的超参数，设置学利率为0.001，dropout的保留节点比例为0.9，最大循环次数为1000.
   另外，还要设置两个路径，第一个是数据下载下来存放的地方，一个是summary输出保存的地方。

max_step = 1000  # 最大迭代次数
learning_rate = 0.001   # 学习率
dropout = 0.9   # dropout时随机保留神经元的比例

data_dir = os.path.join('data', 'mnist')# 样本数据存储的路径
if not os.path.exists('log'):
    os.mkdir('log')
log_dir = 'log'   # 输出日志保存的路径

3.接着加载数据,下载数据是直接调用了tensorflow提供的函数read_data_sets,输入两个参数，第一个是下载到数据存储的路径，第二个one_hot表示是否要将类别标签进行独热编码。它首先回去找制定目录下有没有这个数据文件，没有的话才去下载，有的话就直接读取。所以第一次执行这个命令，速度会比较慢。

mnist = input_data.read_data_sets(data_dir,one_hot=True)

创建特征与标签的占位符，保存输入的图片数据到summary

1. 创建tensorflow的默认会话：

sess = tf.InteractiveSession()

1. 创建输入数据的占位符，分别创建特征数据x，标签数据y_
   在tf.placeholder()函数中传入了3个参数，第一个是定义数据类型为float32；第二个是数据的大小，特征数据是大小784的向量，标签数据是大小为10的向量，None表示不定死大小，到时候可以传入任何数量的样本；第3个参数是这个占位符的名称。

with tf.name_scope('input'):
    x = tf.placeholder(tf.float32, [None, 784], name='x-input')
    y_ = tf.placeholder(tf.float32, [None, 10], name='y-input')

1. 使用tf.summary.image保存图像信息
   特征数据其实就是图像的像素数据拉升成一个1*784的向量，现在如果想在tensorboard上还原出输入的特征数据对应的图片，就需要将拉升的向量转变成28 * 28 * 1的原始像素了，于是可以用tf.reshape()直接重新调整特征数据的维度：
   将输入的数据转换成[28 * 28 * 1]的shape，存储成另一个tensor，命名为image_shaped_input。
   为了能使图片在tensorbord上展示出来，使用tf.summary.image将图片数据汇总给tensorbord。
   tf.summary.image（）中传入的第一个参数是命名，第二个是图片数据，第三个是最多展示的张数，此处为10张

with tf.name_scope('input_reshape'):
    image_shaped_input = tf.reshape(x, [-1, 28, 28, 1])
    tf.summary.image('input', image_shaped_input, 10)

创建初始化参数的方法，与参数信息汇总到summary的方法

1. 在构建神经网络模型中，每一层中都需要去初始化参数w,b,为了使代码简介美观，最好将初始化参数的过程封装成方法function。
   创建初始化权重w的方法，生成大小等于传入的shape参数，标准差为0.1,正态分布的随机数，并且将它转换成tensorflow中的variable返回。

def weight_variable(shape):
    """Create a weight variable with appropriate initialization."""
    initial = tf.truncated_normal(shape, stddev=0.1)
    return tf.Variable(initial)

创建初始换偏执项b的方法，生成大小为传入参数shape的常数0.1，并将其转换成tensorflow的variable并返回

def bias_variable(shape):
    """Create a bias variable with appropriate initialization."""
    initial = tf.constant(0.1, shape=shape)
    return tf.Variable(initial)

1. 我们知道，在训练的过程在参数是不断地在改变和优化的，我们往往想知道每次迭代后参数都做了哪些变化，可以将参数的信息展现在tenorbord上，因此我们专门写一个方法来收录每次的参数信息。

def variable_summaries(var):
    """Attach a lot of summaries to a Tensor (for TensorBoard visualization)."""
    with tf.name_scope('summaries'):
      # 计算参数的均值，并使用tf.summary.scaler记录
      mean = tf.reduce_mean(var)
      tf.summary.scalar('mean', mean)

      # 计算参数的标准差
      with tf.name_scope('stddev'):
        stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean)))
      # 使用tf.summary.scaler记录记录下标准差，最大值，最小值
      tf.summary.scalar('stddev', stddev)
      tf.summary.scalar('max', tf.reduce_max(var))
      tf.summary.scalar('min', tf.reduce_min(var))
      # 用直方图记录参数的分布
      tf.summary.histogram('histogram', var)

构建神经网络层

1. 创建第一层隐藏层
   创建一个构建隐藏层的方法,输入的参数有：
   input_tensor：特征数据
   input_dim：输入数据的维度大小
   output_dim：输出数据的维度大小(=隐层神经元个数）
   layer_name：命名空间
   act=tf.nn.relu：激活函数（默认是relu)

def nn_layer(input_tensor, input_dim, output_dim, layer_name, act=tf.nn.relu):
    """Reusable code for making a simple neural net layer.
    It does a matrix multiply, bias add, and then uses relu to nonlinearize.
    It also sets up name scoping so that the resultant graph is easy to read,
    and adds a number of summary ops.
    """
    # 设置命名空间
    with tf.name_scope(layer_name):
      # 调用之前的方法初始化权重w，并且调用参数信息的记录方法，记录w的信息
      with tf.name_scope('weights'):
        weights = weight_variable([input_dim, output_dim])
        variable_summaries(weights)
      # 调用之前的方法初始化权重b，并且调用参数信息的记录方法，记录b的信息
      with tf.name_scope('biases'):
        biases = bias_variable([output_dim])
        variable_summaries(biases)
      # 执行wx+b的线性计算，并且用直方图记录下来
      with tf.name_scope('linear_compute'):
        preactivate = tf.matmul(input_tensor, weights) + biases
        tf.summary.histogram('linear', preactivate)
      # 将线性输出经过激励函数，并将输出也用直方图记录下来
      activations = act(preactivate, name='activation')
      tf.summary.histogram('activations', activations)

      # 返回激励层的最终输出
      return activations

调用隐层创建函数创建一个隐藏层：输入的维度是特征的维度784，神经元个数是500，也就是输出的维度。

hidden1 = nn_layer(x, 784, 500, 'layer1')

1. 创建一个dropout层，,随机关闭掉hidden1的一些神经元，并记录keep_prob

 with tf.name_scope('dropout'):
    keep_prob = tf.placeholder(tf.float32)
    tf.summary.scalar('dropout_keep_probability', keep_prob)
    dropped = tf.nn.dropout(hidden1, keep_prob)

1. 创建一个输出层，输入的维度是上一层的输出:500,输出的维度是分类的类别种类：10，激活函数设置为全等映射identity.（暂且先别使用softmax,会放在之后的损失函数中一起计算）

y = nn_layer(dropped, 500, 10, 'layer2', act=tf.identity)

创建损失函数

使用tf.nn.softmax_cross_entropy_with_logits来计算softmax并计算交叉熵损失,并且求均值作为最终的损失值。

with tf.name_scope('loss'):
    # 计算交叉熵损失（每个样本都会有一个损失）
    diff = tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y)
    with tf.name_scope('total'):
      # 计算所有样本交叉熵损失的均值
      cross_entropy = tf.reduce_mean(diff)

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

训练，并计算准确率

1. 使用AdamOptimizer优化器训练模型，最小化交叉熵损失

with tf.name_scope('train'):
    train_step = tf.train.AdamOptimizer(learning_rate).minimize(
        cross_entropy)

1. 计算准确率,并用tf.summary.scalar记录准确率

with tf.name_scope('accuracy'):
    with tf.name_scope('correct_prediction'):
      # 分别将预测和真实的标签中取出最大值的索引，弱相同则返回1(true),不同则返回0(false)
      correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
    with tf.name_scope('accuracy'):
      # 求均值即为准确率
      accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
tf.summary.scalar('accuracy', accuracy)

合并summary operation, 运行初始化变量

将所有的summaries合并，并且将它们写到之前定义的log_dir路径

# summaries合并
merged = tf.summary.merge_all()
# 写到指定的磁盘路径中
train_writer = tf.summary.FileWriter(log_dir + '/train', sess.graph)
test_writer = tf.summary.FileWriter(log_dir + '/test')

# 运行初始化所有变量
tf.global_variables_initializer().run()

准备训练与测试的两个数据，循环执行整个graph进行训练与评估

1. 现在我们要获取之后要喂入的数据.
   如果是train==true，就从mnist.train中获取一个batch样本，并且设置dropout值；
   如果是不是train=false,则获取minist.test的测试数据，并且设置keep_prob为1，即保留所有神经元开启。

def feed_dict(train):
    """Make a TensorFlow feed_dict: maps data onto Tensor placeholders."""
    if train:
      xs, ys = mnist.train.next_batch(100)
      k = dropout
    else:
      xs, ys = mnist.test.images, mnist.test.labels
      k = 1.0
    return {x: xs, y_: ys, keep_prob: k}

1. 开始训练模型。
   每隔10步，就进行一次merge, 并打印一次测试数据集的准确率，然后将测试数据集的各种summary信息写进日志中。
   每隔100步，记录原信息
   其他每一步时都记录下训练集的summary信息并写到日志中。

for i in range(max_steps):
    if i % 10 == 0:  # 记录测试集的summary与accuracy
      summary, acc = sess.run([merged, accuracy], feed_dict=feed_dict(False))
      test_writer.add_summary(summary, i)
      print('Accuracy at step %s: %s' % (i, acc))
    else:  # 记录训练集的summary
      if i % 100 == 99:  # Record execution stats
        run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
        run_metadata = tf.RunMetadata()
        summary, _ = sess.run([merged, train_step],
                              feed_dict=feed_dict(True),
                              options=run_options,
                              run_metadata=run_metadata)
        train_writer.add_run_metadata(run_metadata, 'step%03d' % i)
        train_writer.add_summary(summary, i)
        print('Adding run metadata for', i)
      else:  # Record a summary
        summary, _ = sess.run([merged, train_step], feed_dict=feed_dict(True))
        train_writer.add_summary(summary, i)
train_writer.close()
test_writer.close()

执行程序，tensorboard生成可视化

1. 运行整个程序，在程序中定义的summary node就会将要记录的信息全部保存在指定的logdir路径中了，训练的记录会存一份文件，测试的记录会存一份文件。
2. 进入linux命令行，运行以下代码，等号后面加上summary日志保存的路径（在程序第一步中就事先自定义了）

tensorboard --logdir='log'

执行命令之后会出现一条信息，上面有网址，将网址在浏览器中打开就可以看到我们定义的可视化信息了。可视化后的展示详情见GitHub中README部分。

参考资料

[1] github代码链接

---

<个人网页blog已经上线，一大波干货即将来袭：https://faiculty.com/>

/* 版权声明：公开学习资源，只供线上学习，不可转载，如需转载请联系本人 .*/