tensorflow2.0之tensorboard可视化

本文主要介绍一下在tensorflow2.0下tensorboard可视化的操作。从三个小方面来分别介绍。

1. 在keras.fit下调用tensorboard（以下代码在Jupyter-Notebooks中运行）
   我们用mnist手写数字识别数据集当来编译和训练网络

#首先导入模块
import tensorflow as tf
import datetime #datetime模块提供用于处理日期和时间的类，引入
#    datetime模块主要是为了能够进行可视化区分，假如我们要训练好几次网络，每次时间不同，
#    引入这个模块后就可以在tensorboard可视化界面中记录每次所训练的结果，方便对照
#数据的加载与处理
(x_train,y_train),(x_test,y_test)=tf.keras.datasets.mnist.load_data()
x_train=tf.expand_dims(x_train,-1)
x_test =tf.expand_dims(x_test,-1)
x_train=tf.cast(x_train/255,tf.float32)
x_test=tf.cast(x_test/255,tf.float32)
y_train=tf.cast(y_train,tf.int64)
y_test=tf.cast(y_test,tf.int64)
db_train=tf.data.Dataset.from_tensor_slices((x_train,y_train))
db_test=tf.data.Dataset.from_tensor_slices((x_test,y_test))
db_train=db_train.repeat().shuffle(60000).batch(128)
db_test=db_test.repeat().batch(128)
#创建一个简单模型
model=tf.keras.Sequential([    
         tf.keras.layers.Conv2D(64,[3,3],activation='relu',input_shape=[None,None,1]),
         tf.keras.layers.Conv2D(128,[3,3],activation='relu'),    
         tf.keras.layers.Conv2D(256,[3,3],activation='relu'),
         tf.keras.layers.GlobalMaxPooling2D(),
         tf.keras.layers.Dense(10,activation='softmax')
         ])
#模型编译
model.compile(optimizer='adam',
             loss='sparse_categorical_crossentropy',
             metrics=['accuracy'])

#下面的方法是直接在Jupyter-Notebooks中
#写入路径
import os
log_dir=os.path.join('logs',datetime.datetime.now().strftime("%Y%m%d-%H%M%S"))#在tensorboard可视化界面中会生成带时间标志的文件
tensorboard_callback=tf.keras.callbacks.TensorBoard(log_dir,histogram_freq=1)#回调tensorflow自带的tensorboard
model.fit(db_train,         
                  epochs=10,         
                  steps_per_epoch=60000//128,
                  validation_data=db_test,
                  validation_steps=10000//128,
                  callbacks=[tensorboard_callback]
                           )
                           

训练日志：训练完毕
接下来直接在Jupyter-Notebooks中打开tensorboard

%load_ext tensorboard  #这行代码加载tensorboard
%matplotlib inline    #在线可视化
%tensorboard --logdir logs   #加载生成的logs 文件

运行完程序后直接在Jupyter-Notebooks中就打开了tensorboard界面

SCALARS表示的是标量的一些图，比如准确率、损失率等，GRAPHS为模型的结构图

DISTRIBUTIONS为kernel、bias的分布及变化情况

HISTOGRAME为bias和kernel的直方分布图（在图中我们可以看到不同时间点训练得到的结果）

2.自定义变量的tensorflow可视化
比如我们要重新调整回归模型并记录自定义学习率。首先我们使用创建文件编写器tf.summary.creat_file_writer()定义自定义学习率功能，然后传递给kerasLearingRateSchedual进行回调。在学习率功能内用tf.summary.scalar()记录自定义学习率，最后将LearingRateSchaduler回调传递给model.fit()
下面是具体代码（跟上面一样的被省略掉了）

import tensorflow as tf
...
import os
log_dir=os.path.join('logs',datetime.datetime.now().strftime("%Y%m%d-%H%M%S"))
tensorboard_callback=tf.keras.callbacks.TensorBoard(log_dir,histogram_freq=1)
#用文件编写器将文件写入磁盘
file_writer=tf.summary.creat_file_writer(log_dir+'/lr')#定义文件存放地址，比如这个路径放在了log_dirxia下面的lr这个文件夹里面
#将file_writer设置为默认的文件编写器
file_writer.set__as_default()#当我们用tf.summary.creat_file_writer写文件时file_writer.set__as_default()就回默认将文件写入log_dir+'/lr'文件中

#接下来定义一个学习率跟随epoch变化的函数
def lr_sche(epoch):	
    learning_rate=0.2#假如刚开始我们需要比较大一点的学习率，然后随着训练的进行，我们逐渐降低学习率
    if epoch >5:
    	learning_rate=0.02
    if epoch >10:
        learning_rate=0.01
    if epoch >20:
        learning_rate=0.005
    #记录学习率的变化
    tf.summary.scalar('learning_rate',data=learning_rate,step=epoch)#三个参数，第一个定义名称，第二个需要传递的数据，第三个step

    return learning_rate
#下面回调学习率的函数
lr_callback=tf.keras.callbacks.LearningRateScheduler(lr_sche)


model.fit(db_train,         
                  epochs=25,         
                  steps_per_epoch=60000//128,
                  validation_data=db_test,
                  validation_steps=10000//128,
                  callbacks=[tensorboard_callback,lr_callback]
                           )
#然后调用tensorboard进行可视化
%load_ext tensorboard  #这行代码加载tensorboard
%matplotlib inline    #在线可视化
%tensorboard --logdir logs

然后就可以观察我们自定义的学习率了

3.自定义训练的tensorboard可视化
我们要可视化训练过程中和测试过程中的准确率或者损失。
自定义训练基本流程跟上面一样，先数据预处理，然后建立网络模型，接下来不再是model.compile()和model.fit()了,而是要自定义了。代码如下：

import tensorflow as tf
...
model=tf.keras.Sequential([    
         tf.keras.layers.Conv2D(64,[3,3],activation='relu',input_shape=[None,None,1]),
         tf.keras.layers.Conv2D(128,[3,3],activation='relu'),    
         tf.keras.layers.Conv2D(256,[3,3],activation='relu'),
         tf.keras.layers.GlobalMaxPooling2D(),
         tf.keras.layers.Dense(10,activation='softmax')
         ])
#接下来自定义
optimizer=tf.keras.optimizers.Adam()
loss_func=tf.keras.losses.SparseCategoricalCrossentropy()

def loss(model,x,y):
    y_ =model(x)#此处的model就是我们创建的网络模型
    return loss_func(y,y_)
    
train_loss=tf.keras.metrics.Mean('train_loss')
train_accuracy=tf.keras.metrics.SparseCategoricalAccuracy('train_accuracy')
train_loss=tf.keras.metrics.Mean('train_loss')
train_accuracy=tf.keras.metrics.SparseCategoricalAccuracy('train_accuracy')     

def train_step(model,images,labels):
    with tf.GradientTape() as t:
        pred=model(images)
        loss_step=loss_func(labels,pred)
    grads=t.gradient(loss_step,model.trainable_variables)
    optimizers.apply_gradients(zip(grads,model.trainable_variables))
    train_loss=(loss_step)
    train_accuracy(labels,pred)
def test_step(model,images,labels):
    pred=model(images)
    loss_step=loss_func(labels,pred)
    test_loss(loss_step)
    test_accuracy(labels,pred)

到了这一步，就相当于我们完成了model.compile()和model.fit()
接下来用编辑器tf.summary.creat_file_writer()写入路径文件

current_time=datetime.datetime.now().strftime("%Y%m%d-%H%M%S")#记录当前时间
#分别创建目录
train_log_dir='logs/gradient_tape'+current_time+'/train'#表示训练目录
test_log_dir='logs/gradient_tape'+current_time+'/test'
train_writer=tf.summary.creat_file_writer(train_log_dir)
test_writer=tf.summary.creat_file_writer(test_log_dir)

接下来将训练过程写入磁盘

def train():
    for epoch in range(10):
        for (batch,(images,labels)) in enumerate(dataset):
            train_step(model,images,labels)
        with train_writer.as_default():#用with关联上下，train_writer作为默认编写器
            tf.summary.scalar('loss',train_loss.result(),step=epoch)
            tf.summary.scalar('acc',train_accuracy.result(),step=epoch)
        
        for (batch,(images,labels)) in enumerate(db_test):
            test_step(model,images,labels)
        with test_writer.as_default():
            tf.summary.scalar('loss',test_loss.result(),step=epoch)
            tf.summary.scalar('acc',test_accuracy.result(),step=epoch)
  
    template='Epoch {},Loss: {},Accuracy: {},Test Loss {},Test Accuracy: {}'
    print(template.format(epoch+1,
    			 train_loss.result(),
   			 train_accuracy.result()*100,
    			 test_loss.result(),
    			 test_accuracy.result()*100))
    train_loss.rest_states()
    train_accuracy.rest_states()
    test_loss.rest_states()
    test_accuracy.rest_states()

最后运行主函数

if __name__ =='__main':
    main()

最后调用tensorboard进行可视化即可查看。