Esta página foi traduzida pela API Cloud Translation.
Switch to English

Introdução ao TensorBoard

Ver em TensorFlow.org Executar no Google Colab Ver fonte no GitHub

No aprendizado de máquina, para melhorar algo, muitas vezes você precisa ser capaz de medi-lo. O TensorBoard é uma ferramenta para fornecer as medições e visualizações necessárias durante o fluxo de trabalho de aprendizado de máquina. Permite rastrear métricas de experimentos como perda e precisão, visualizar o gráfico do modelo, projetar incorporações em um espaço dimensional mais baixo e muito mais.

Este início rápido mostrará como começar rapidamente com o TensorBoard. Os guias restantes neste site fornecem mais detalhes sobre recursos específicos, muitos dos quais não estão incluídos aqui.

 # Load the TensorBoard notebook extension
%load_ext tensorboard
 
 import tensorflow as tf
import datetime
 
 # Clear any logs from previous runs
!rm -rf ./logs/ 
 

Usando o conjunto de dados MNIST como exemplo, normalize os dados e escreva uma função que crie um modelo Keras simples para classificar as imagens em 10 classes.

 mnist = tf.keras.datasets.mnist

(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

def create_model():
  return tf.keras.models.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(512, activation='relu'),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10, activation='softmax')
  ])
 
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step

Usando o TensorBoard com o Keras Model.fit ()

Ao treinar com o Model.fit () de Keras, adicionar o retorno de chamada tf.keras.callbacks.TensorBoard garante que os logs sejam criados e armazenados. Além disso, ative a computação do histograma a cada época com histogram_freq=1 (isso está desativado por padrão)

Coloque os logs em um subdiretório com carimbo de data e hora para permitir a seleção fácil de diferentes execuções de treinamento.

 model = create_model()
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

log_dir = "logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)

model.fit(x=x_train, 
          y=y_train, 
          epochs=5, 
          validation_data=(x_test, y_test), 
          callbacks=[tensorboard_callback])
 
Train on 60000 samples, validate on 10000 samples
Epoch 1/5
60000/60000 [==============================] - 15s 246us/sample - loss: 0.2217 - accuracy: 0.9343 - val_loss: 0.1019 - val_accuracy: 0.9685
Epoch 2/5
60000/60000 [==============================] - 14s 229us/sample - loss: 0.0975 - accuracy: 0.9698 - val_loss: 0.0787 - val_accuracy: 0.9758
Epoch 3/5
60000/60000 [==============================] - 14s 231us/sample - loss: 0.0718 - accuracy: 0.9771 - val_loss: 0.0698 - val_accuracy: 0.9781
Epoch 4/5
60000/60000 [==============================] - 14s 227us/sample - loss: 0.0540 - accuracy: 0.9820 - val_loss: 0.0685 - val_accuracy: 0.9795
Epoch 5/5
60000/60000 [==============================] - 14s 228us/sample - loss: 0.0433 - accuracy: 0.9862 - val_loss: 0.0623 - val_accuracy: 0.9823

<tensorflow.python.keras.callbacks.History at 0x7fc8a5ee02e8>

Inicie o TensorBoard pela linha de comando ou em uma experiência de notebook. As duas interfaces são geralmente as mesmas. Nos notebooks, use a mágica da linha %tensorboard . Na linha de comando, execute o mesmo comando sem "%".

 %tensorboard --logdir logs/fit
 

Uma breve visão geral dos painéis mostrados (guias na barra de navegação superior):

  • O painel Scalars mostra como a perda e as métricas mudam a cada época. Você pode usá-lo para também rastrear a velocidade do treinamento, a taxa de aprendizado e outros valores escalares.
  • O painel do Graphs ajuda a visualizar seu modelo. Nesse caso, o gráfico de camadas Keras é mostrado, o que pode ajudá-lo a garantir que ele seja construído corretamente.
  • Os painéis Distribuições e Histogramas mostram a distribuição de um tensor ao longo do tempo. Isso pode ser útil para visualizar pesos e desvios e verificar se eles estão mudando da maneira esperada.

Plug-ins adicionais do TensorBoard são ativados automaticamente quando você registra outros tipos de dados. Por exemplo, o retorno de chamada do Keras TensorBoard também permite registrar imagens e incorporações. Você pode ver quais outros plugins estão disponíveis no TensorBoard clicando no menu suspenso "inativo" no canto superior direito.

Usando o TensorBoard com outros métodos

Ao treinar com métodos como tf.GradientTape() , use tf.summary para registrar as informações necessárias.

Use o mesmo conjunto de dados acima, mas converta-o em tf.data.Dataset para aproveitar os recursos de lote:

 train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test))

train_dataset = train_dataset.shuffle(60000).batch(64)
test_dataset = test_dataset.batch(64)
 

O código de treinamento segue o tutorial de início rápido avançado , mas mostra como registrar métricas no TensorBoard. Escolha perda e otimizador:

 loss_object = tf.keras.losses.SparseCategoricalCrossentropy()
optimizer = tf.keras.optimizers.Adam()
 

Crie métricas stateful que podem ser usadas para acumular valores durante o treinamento e registradas a qualquer momento:

 # Define our metrics
train_loss = tf.keras.metrics.Mean('train_loss', dtype=tf.float32)
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy('train_accuracy')
test_loss = tf.keras.metrics.Mean('test_loss', dtype=tf.float32)
test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy('test_accuracy')
 

Defina as funções de treinamento e teste:

 def train_step(model, optimizer, x_train, y_train):
  with tf.GradientTape() as tape:
    predictions = model(x_train, training=True)
    loss = loss_object(y_train, predictions)
  grads = tape.gradient(loss, model.trainable_variables)
  optimizer.apply_gradients(zip(grads, model.trainable_variables))

  train_loss(loss)
  train_accuracy(y_train, predictions)

def test_step(model, x_test, y_test):
  predictions = model(x_test)
  loss = loss_object(y_test, predictions)

  test_loss(loss)
  test_accuracy(y_test, predictions)
 

Configure gravadores de resumo para gravar os resumos em disco em um diretório de logs diferente:

 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_summary_writer = tf.summary.create_file_writer(train_log_dir)
test_summary_writer = tf.summary.create_file_writer(test_log_dir)
 

Comece a treinar. Use tf.summary.scalar() para registrar métricas (perda e precisão) durante o treinamento / teste no escopo dos tf.summary.scalar() de resumo para gravar os resumos no disco. Você tem controle sobre quais métricas devem ser registradas e com que frequência. Outras funções tf.summary permitem registrar outros tipos de dados.

 model = create_model() # reset our model

EPOCHS = 5

for epoch in range(EPOCHS):
  for (x_train, y_train) in train_dataset:
    train_step(model, optimizer, x_train, y_train)
  with train_summary_writer.as_default():
    tf.summary.scalar('loss', train_loss.result(), step=epoch)
    tf.summary.scalar('accuracy', train_accuracy.result(), step=epoch)

  for (x_test, y_test) in test_dataset:
    test_step(model, x_test, y_test)
  with test_summary_writer.as_default():
    tf.summary.scalar('loss', test_loss.result(), step=epoch)
    tf.summary.scalar('accuracy', 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))

  # Reset metrics every epoch
  train_loss.reset_states()
  test_loss.reset_states()
  train_accuracy.reset_states()
  test_accuracy.reset_states()
 
Epoch 1, Loss: 0.24321186542510986, Accuracy: 92.84333801269531, Test Loss: 0.13006582856178284, Test Accuracy: 95.9000015258789
Epoch 2, Loss: 0.10446818172931671, Accuracy: 96.84833526611328, Test Loss: 0.08867532759904861, Test Accuracy: 97.1199951171875
Epoch 3, Loss: 0.07096975296735764, Accuracy: 97.80166625976562, Test Loss: 0.07875105738639832, Test Accuracy: 97.48999786376953
Epoch 4, Loss: 0.05380449816584587, Accuracy: 98.34166717529297, Test Loss: 0.07712937891483307, Test Accuracy: 97.56999969482422
Epoch 5, Loss: 0.041443776339292526, Accuracy: 98.71833038330078, Test Loss: 0.07514958828687668, Test Accuracy: 97.5

Abra o TensorBoard novamente, desta vez apontando-o para o novo diretório de log. Também poderíamos ter iniciado o TensorBoard para monitorar o treinamento enquanto ele progride.

 %tensorboard --logdir logs/gradient_tape
 

É isso aí! Agora você viu como usar o TensorBoard por meio do retorno de chamada Keras e do tf.summary para cenários mais personalizados.