神经网络像一个黑盒，我们无法解释清楚单个权重或偏置对输出的影响，但如果我们可以得到权重和偏置在训练过程中的变化趋势，对它们有一个宏观认识，也是不错的。运用summary就可以实现上述目的，具体如下：
1、定义summary，如
mean=tf.reduce_mean(w1)
stddev=tf.sqrt(tf.reduce_mean(tf.square(w1-mean)))
tf.summary.scalar(‘mean’,mean)
tf.summary.scalar(‘stddev’,stddev)
tf.summary.scalar(‘max’,tf.reduce_max(w1))
tf.summary.scalar(‘min’,tf.reduce_min(w1))
2、合并summary，merged=tf.summary.merge_all()
3、生成summary，summary, _ = sess.run([merged, train], feed_dict={x:batch_xs, y:batch_ys, keep_prob:0.9})
4、将计算图保存在logs文件夹，writer=tf.summary.FileWriter(‘logs’,sess.graph)
5、将summary保存在logs文件夹，writer.add_summary(summary,epoch)

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

# 获取数据集
# one_hot设置为True，将标签数据转化为0/1，如[1,0,0,0,0,0,0,0,0,0]
mnist=input_data.read_data_sets('MNIST_data',one_hot=True)

# 定义一个批次的大小
batch_size=100
n_batch=mnist.train.num_examples//batch_size

# 变量分析
def variable_summaries(var):
	with tf.name_scope('summaries'):
		mean=tf.reduce_mean(var)
		stddev=tf.sqrt(tf.reduce_mean(tf.square(var-mean)))
		tf.summary.scalar('mean',mean)
		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) #直方图

# 定义三个placeholder
# 行数值为None，None可以取任意数，本例中将取值100，即取决于pitch_size
# 列数值为784，因为输入图像尺寸已由28*28转换为1*784
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')

with tf.name_scope('keep_prob'):
	keep_prob=tf.placeholder(tf.float32)

# 定义学习率
with tf.name_scope('lr'):
	lr=tf.Variable(0.001,dtype=tf.float32)

# 定义一个神经网络
with tf.name_scope('l1'):
	# 权重初始值为0不是最优的，应该设置为满足截断正态分布的随机数，收敛速度更快
	w1=tf.Variable(tf.truncated_normal([784,1000],stddev=0.1),name='w1')
	# 权重分析
	variable_summaries(w1)
	# 偏置初始值为0不是最优的，可以设置为0.1，收敛速度更快
	b1=tf.Variable(tf.zeros([1000])+0.1,name='b1')
	# 偏置分析
	variable_summaries(b1)
	# 引入激活函数
	l1=tf.nn.tanh(tf.matmul(x,w1)+b1,name='l1')
	# 引入dropout
	l1_drop=tf.nn.dropout(l1,keep_prob,name='l1_drop')

with tf.name_scope('l2'):
	w2=tf.Variable(tf.truncated_normal([1000,100],stddev=0.1),name='w2')
	variable_summaries(w2)
	b2=tf.Variable(tf.zeros([100])+0.1,name='b2')
	variable_summaries(b2)
	l2=tf.nn.tanh(tf.matmul(l1_drop,w2)+b2,name='l2')
	l2_drop=tf.nn.dropout(l2,keep_prob,name='l2_drop')

with tf.name_scope('output'):
	w3=tf.Variable(tf.truncated_normal([100,10],stddev=0.1),name='w3')
	variable_summaries(w3)
	b3=tf.Variable(tf.zeros([10])+0.1,name='b3')
	variable_summaries(b3)
	# softmax的作用是将tf.matmul(l2_drop,w3)+b3的结果转换为概率值
	# 假设tf.matmul(l2_drop,w3)+b3的结果为[1,5,3]，转换为概率值为[0.016,0.867,0.117]
	prediction=tf.nn.softmax(tf.matmul(l2_drop,w3)+b3)

# 定义损失函数
with tf.name_scope('loss'):
	# 由于输出神经元为softmax，交叉熵损失函数比均方误差损失函数收敛速度更快
	# loss=tf.reduce_mean(tf.square(y-prediction))
	loss=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y,logits=prediction))
	# loss分析
	tf.summary.scalar('loss',loss)

# 定义训练方式
with tf.name_scope('train'):
	# 优化器通过调整loss里的参数，使loss不断减小
	# AdamOptimizer比GradientDescentOptimizer收敛速度更快
	# train=tf.train.GradientDescentOptimizer(0.2).minimize(loss)
	train=tf.train.AdamOptimizer(lr).minimize(loss)

# 计算准确率
with tf.name_scope('accuracy'):
	# tf.argmax返回第一个参数中最大值的下标
	# tf.equal比较两个参数是否相等，返回True或False
	correct_prediction=tf.equal(tf.argmax(y,1),tf.argmax(prediction,1))
	# tf.cast将布尔类型转换为浮点类型
	accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
	# accuracy分析
	tf.summary.scalar('accuracy',accuracy)

# 合并所有summary
merged=tf.summary.merge_all()

with tf.Session() as sess:
	# 变量初始化
	sess.run(tf.global_variables_initializer())
	# 生成计算图
	writer=tf.summary.FileWriter('logs',sess.graph)
	# epoch为周期数，所有批次训练完为一个周期
	for epoch in range(20):
		# 调整学习率
		sess.run(tf.assign(lr,0.001*(0.95**epoch)))
		for batch in range(n_batch):
			# 每次取出batch_size条数据进行训练
			batch_xs, batch_ys = mnist.train.next_batch(batch_size)
			summary, _ = sess.run([merged, train], feed_dict={x:batch_xs, y:batch_ys, keep_prob:0.9})
		# 将summary添加到计算图中
		writer.add_summary(summary,epoch)
		learning_rate=sess.run(lr)
		test_acc = sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels,keep_prob:0.9})
		train_acc = sess.run(accuracy,feed_dict={x:mnist.train.images,y:mnist.train.labels,keep_prob:0.9})
		print('epoch=',epoch,' ','learning_rate=%.7f' % learning_rate,' ','test_acc=',test_acc,' ','train_acc=',train_acc)

运行结果：

在命令行窗口输入tensorboard --logdir logs，得到一个网址，用谷歌浏览器打开该网址，即可查看计算图和summary
########################################################################
########################################################################
w1变化趋势：

########################################################################
########################################################################
b1变化趋势：

########################################################################
########################################################################
w2变化趋势：

########################################################################
########################################################################
b2变化趋势：

########################################################################
########################################################################
w3变化趋势：

########################################################################
########################################################################
b3变化趋势：

loss变化趋势：

accuracy变化趋势：

我们知道，Keras有一个非常有好的功能是summary，可以打印显示网络结构和参数，一目了然。但是，Pytorch本身好像不支持这一点。不过，幸好有一个工具叫torchsummary，可以实现和Keras几乎一样的效果。

pip install torchsummary

然后我们定义好网络结构之后，就可以用summary来打印显示了。假设我们定义的网络结构是一个叫Generator的类。

import torch
from torchsummary import summary

# 需要使用device来指定网络在GPU还是CPU运行
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
netG_A2B = Generator(3, 3).to(device)
summary(netG_A2B, input_size=(3, 256, 256))

之后，就可以打印网络结构了。一个示例结构如下：

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1         [-1, 64, 224, 224]           1,792
              ReLU-2         [-1, 64, 224, 224]               0
            Conv2d-3         [-1, 64, 224, 224]          36,928
              ReLU-4         [-1, 64, 224, 224]               0
         MaxPool2d-5         [-1, 64, 112, 112]               0
            Conv2d-6        [-1, 128, 112, 112]          73,856
              ReLU-7        [-1, 128, 112, 112]               0
            Conv2d-8        [-1, 128, 112, 112]         147,584
              ReLU-9        [-1, 128, 112, 112]               0
        MaxPool2d-10          [-1, 128, 56, 56]               0
           Conv2d-11          [-1, 256, 56, 56]         295,168
             ReLU-12          [-1, 256, 56, 56]               0
           Conv2d-13          [-1, 256, 56, 56]         590,080
             ReLU-14          [-1, 256, 56, 56]               0
           Conv2d-15          [-1, 256, 56, 56]         590,080
             ReLU-16          [-1, 256, 56, 56]               0
        MaxPool2d-17          [-1, 256, 28, 28]               0
           Conv2d-18          [-1, 512, 28, 28]       1,180,160
             ReLU-19          [-1, 512, 28, 28]               0
           Conv2d-20          [-1, 512, 28, 28]       2,359,808
             ReLU-21          [-1, 512, 28, 28]               0
           Conv2d-22          [-1, 512, 28, 28]       2,359,808
             ReLU-23          [-1, 512, 28, 28]               0
        MaxPool2d-24          [-1, 512, 14, 14]               0
           Conv2d-25          [-1, 512, 14, 14]       2,359,808
             ReLU-26          [-1, 512, 14, 14]               0
           Conv2d-27          [-1, 512, 14, 14]       2,359,808
             ReLU-28          [-1, 512, 14, 14]               0
           Conv2d-29          [-1, 512, 14, 14]       2,359,808
             ReLU-30          [-1, 512, 14, 14]               0
        MaxPool2d-31            [-1, 512, 7, 7]               0
           Linear-32                 [-1, 4096]     102,764,544
             ReLU-33                 [-1, 4096]               0
          Dropout-34                 [-1, 4096]               0
           Linear-35                 [-1, 4096]      16,781,312
             ReLU-36                 [-1, 4096]               0
          Dropout-37                 [-1, 4096]               0
           Linear-38                 [-1, 1000]       4,097,000
================================================================
Total params: 138,357,544
Trainable params: 138,357,544
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.57
Forward/backward pass size (MB): 218.59
Params size (MB): 527.79
Estimated Total Size (MB): 746.96
----------------------------------------------------------------

原文链接：https://blog.csdn.net/jasminexjf/article/details/82817912

tensorboard 作为一款可视化神器，可以说是学习tensorflow时模型训练以及参数可视化的法宝。

而在训练过程中，主要用到了tf.summary()的各类方法，能够保存训练过程以及参数分布图并在tensorboard显示。

tf.summary有诸多函数：

1、tf.summary.scalar

用来显示标量信息，其格式为：

tf.summary.scalar(tags, values, collections=None, name=None)
 

例如：tf.summary.scalar('mean', mean)

一般在画loss,accuary时会用到这个函数。

2、tf.summary.histogram

用来显示直方图信息，其格式为：

tf.summary.histogram(tags, values, collections=None, name=None) 
 

例如： tf.summary.histogram('histogram', var)

一般用来显示训练过程中变量的分布情况

3、tf.summary.distribution

分布图，一般用于显示weights分布

4、tf.summary.text

可以将文本类型的数据转换为tensor写入summary中：

例如：

 

   

    

   
   

    

     text = """/a/b/c\\_d/f\\_g\\_h\\_2017"""
    
   

   

    

   
   

    

     summary_op0 = tf.summary.text('text', tf.convert_to_tensor(text))
    
   
 

5、tf.summary.image

输出带图像的probuf，汇总数据的图像的的形式如下： ' tag /image/0', ' tag /image/1'...，如：input/image/0等。

格式：tf.summary.image(tag, tensor, max_images=3, collections=None, name=Non

6、tf.summary.audio

展示训练过程中记录的音频 

7、tf.summary.merge_all

merge_all 可以将所有summary全部保存到磁盘，以便tensorboard显示。如果没有特殊要求，一般用这一句就可一显示训练时的各种信息了。

格式：tf.summaries.merge_all(key='summaries')

8、tf.summary.FileWriter

指定一个文件用来保存图。

格式：tf.summary.FileWritter(path,sess.graph)

可以调用其add_summary（）方法将训练过程数据保存在filewriter指定的文件中

Tensorflow Summary 用法示例:

 

   

    

   
   

    

     tf.summary.scalar(
     'accuracy',acc)                   
     #生成准确率标量图  
    
   

   

    

   
   

    

     merge_summary = tf.summary.merge_all()  
    
   

   

    

   
   

    

     train_writer = tf.summary.FileWriter(dir,sess.graph)
     #定义一个写入summary的目标文件，dir为写入文件地址  
    
   

   

    

   
   

    

     ......(交叉熵、优化器等定义)  
    
   

   

    

   
   

    

     for step 
     in xrange(training_step):                  
     #训练循环  
    
   

   

    

   
   

    

         train_summary = sess.run(merge_summary,feed_dict =  {...})
     #调用sess.run运行图，生成一步的训练过程数据  
    
   

   

    

   
   

    

         train_writer.add_summary(train_summary,step)
     #调用train_writer的add_summary方法将训练过程以及训练步数保存 
    
   
 

此时开启tensorborad：

1. tensorboard --logdir=/summary_dir 

便能看见accuracy曲线了。

另外，如果我不想保存所有定义的summary信息，也可以用tf.summary.merge方法有选择性地保存信息：

9、tf.summary.merge

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

一般选择要保存的信息还需要用到tf.get_collection()函数

示例：

 

   

    

   
   

    

     tf.summary.scalar(
     'accuracy',acc)                   
     #生成准确率标量图  
    
   

   

    

   
   

    

     merge_summary = tf.summary.merge([tf.get_collection(tf.GraphKeys.SUMMARIES,
     'accuracy'),...(其他要显示的信息)])  
    
   

   

    

   
   

    

     train_writer = tf.summary.FileWriter(dir,sess.graph)
     #定义一个写入summary的目标文件，dir为写入文件地址  
    
   

   

    

   
   

    

     ......(交叉熵、优化器等定义)  
    
   

   

    

   
   

    

     for step 
     in xrange(training_step):                  
     #训练循环  
    
   

   

    

   
   

    

         train_summary = sess.run(merge_summary,feed_dict =  {...})
     #调用sess.run运行图，生成一步的训练过程数据  
    
   

   

    

   
   

    

         train_writer.add_summary(train_summary,step)
     #调用train_writer的add_summary方法将训练过程以及训练步数保存  
    
   
 

使用tf.get_collection函数筛选图中summary信息中的accuracy信息，这里的 tf.GraphKeys.SUMMARIES  是summary在collection中的标志。
 

当然，也可以直接：

 

   

    

   
   

    

     acc_summary = tf.summary.scalar(
     'accuracy',acc)                   
     #生成准确率标量图  
    
   

   

    

   
   

    

     merge_summary = tf.summary.merge([acc_summary ,...(其他要显示的信息)])  
     #这里的[]不可省
    
   
 

 如果要在tensorboard中画多个数据图，需定义多个tf.summary.FileWriter并重复上述过程。

with tf.Graph().as_default():
    session_conf = tf.ConfigProto(
      allow_soft_placement=FLAGS.allow_soft_placement,   #是否允许tensorflow进行运算的软分配
      log_device_placement=FLAGS.log_device_placement)   ##是否允许tensorflow打印操作步骤    
    sess = tf.Session(config=session_conf)
    with sess.as_default():
        cnn = TextCNN(
            sequence_length=x_train.shape[1],
            num_classes=y_train.shape[1],
            vocab_size=len(vocab_processor.vocabulary_),
            embedding_size=FLAGS.embedding_dim,
            filter_sizes=list(map(int, FLAGS.filter_sizes.split(","))),
            num_filters=FLAGS.num_filters,
            l2_reg_lambda=FLAGS.l2_reg_lambda)        #L2正则化的系数lambda
        #另外一种计算梯度下降的方式，之前的都是tf.compat.v1.train.GradientDescentOptimizer(0.2).minimize(loss)
        # Define Training procedure
        global_step = tf.Variable(0, name="global_step", trainable=False)
        optimizer = tf.train.AdamOptimizer(1e-3)
        grads_and_vars = optimizer.compute_gradients(cnn.loss)    #计算梯度 
        train_op = optimizer.apply_gradients(grads_and_vars, global_step=global_step) #将compute_gradients()返回的值作为输入参数对variable进行更新

        # Keep track of gradient values and sparsity (optional)
        grad_summaries = []
        for g, v in grads_and_vars:
            if g is not None:
                grad_hist_summary = tf.summary.histogram("{}/grad/hist".format(v.name), g)        #tf.summary显示梯度的直方图
                sparsity_summary = tf.summary.scalar("{}/grad/sparsity".format(v.name), tf.nn.zero_fraction(g))   #tf.nn.zero_fraction计算所0在tensor类型的占比
                grad_summaries.append(grad_hist_summary)
                grad_summaries.append(sparsity_summary)
        grad_summaries_merged = tf.summary.merge(grad_summaries)   #相当于把信息合并

        # Output directory for models and summaries
        timestamp = str(int(time.time()))     #得到当前的时间
        out_dir = os.path.abspath(os.path.join(os.path.curdir, "runs", timestamp))   #根据时间定义了一个路径
        print("Writing to {}\n".format(out_dir))

        # Summaries for loss and accuracy
        loss_summary = tf.summary.scalar("loss", cnn.loss)
        acc_summary = tf.summary.scalar("accuracy", cnn.accuracy)

        # Train Summaries
        train_summary_op = tf.summary.merge([loss_summary, acc_summary, grad_summaries_merged]) #合并信息
        train_summary_dir = os.path.join(out_dir, "summaries", "train")  #定义训练可视化信息保存的路径
        train_summary_writer = tf.summary.FileWriter(train_summary_dir, sess.graph)

        # Dev summaries
        dev_summary_op = tf.summary.merge([loss_summary, acc_summary])
        dev_summary_dir = os.path.join(out_dir, "summaries", "dev")
        dev_summary_writer = tf.summary.FileWriter(dev_summary_dir, sess.graph)

        # Checkpoint directory. Tensorflow assumes this directory already exists so we need to create it
        checkpoint_dir = os.path.abspath(os.path.join(out_dir, "checkpoints"))   #返回绝对路径
        checkpoint_prefix = os.path.join(checkpoint_dir, "model")
        if not os.path.exists(checkpoint_dir):
            os.makedirs(checkpoint_dir)
        saver = tf.train.Saver(tf.global_variables(), max_to_keep=FLAGS.num_checkpoints)  #保存模型

        # Write vocabulary
        vocab_processor.save(os.path.join(out_dir, "vocab"))  #保存生成的词库

        # Initialize all variables
        sess.run(tf.global_variables_initializer())   

        def train_step(x_batch, y_batch):
            """
            A single training step
            """
            feed_dict = {
              cnn.input_x: x_batch,
              cnn.input_y: y_batch,
              cnn.dropout_keep_prob: FLAGS.dropout_keep_prob
            }
            _, step, summaries, loss, accuracy = sess.run(
                [train_op, global_step, train_summary_op, cnn.loss, cnn.accuracy],
                feed_dict)
            time_str = datetime.datetime.now().isoformat()       #获取当前的时间
            print("{}: step {}, loss {:g}, acc {:g}".format(time_str, step, loss, accuracy))
            train_summary_writer.add_summary(summaries, step)

        def dev_step(x_batch, y_batch, writer=None):
            """
            Evaluates model on a dev set
            """
            feed_dict = {
              cnn.input_x: x_batch,
              cnn.input_y: y_batch,
              cnn.dropout_keep_prob: 1.0
            }
            step, summaries, loss, accuracy = sess.run(
                [global_step, dev_summary_op, cnn.loss, cnn.accuracy],
                feed_dict)
            time_str = datetime.datetime.now().isoformat()
            print("{}: step {}, loss {:g}, acc {:g}".format(time_str, step, loss, accuracy))
            if writer:
                writer.add_summary(summaries, step)        #这里Writer还没有给他赋值，后面后面调用函数的时候有赋值tf.summary.FileWrite

        # Generate batches
        batches = data_helpers.batch_iter(
            list(zip(x_train, y_train)), FLAGS.batch_size, FLAGS.num_epochs)
        # Training loop. For each batch...
        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 % FLAGS.evaluate_every == 0:            #每隔多少步的训练后，评估一次，并保存模型
                print("\nEvaluation:")
                dev_step(x_dev, y_dev, writer=dev_summary_writer)
                print("")
            if current_step % FLAGS.checkpoint_every == 0:
                path = saver.save(sess, checkpoint_prefix, global_step=current_step)
                print("Saved model checkpoint to {}\n".format(path))