Comece a usar o TensorBoard

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Ver no TensorFlow.org Executar no Google Colab Ver fonte no GitHub Baixar caderno

No aprendizado de máquina, para melhorar algo, muitas vezes você precisa ser capaz de medir. TensorBoard é uma ferramenta para fornecer as medidas e visualizações necessárias durante o fluxo de trabalho de aprendizado de máquina. Ele permite rastrear métricas de experimentos como perda e precisão, visualizar o gráfico do modelo, projetar embeddings para um espaço dimensional inferior e muito mais.

Este guia de início rápido mostra como começar a usar o TensorBoard rapidamente. 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 MNIST conjunto de dados como exemplo, normalizar os dados e escrever uma função que cria um modelo simples Keras 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 TensorBoard com Keras Model.fit ()

Ao treinar com o Keras Model.fit () , adicionando o tf.keras.callbacks.TensorBoard callback garante que os logs são criados e armazenados. Além disso, permitir histograma computação cada época com histogram_freq=1 (este é desligado por padrão)

Coloque os logs em um subdiretório com carimbo de data / hora para permitir a fácil seleção 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 por meio da linha de comando ou em uma experiência de notebook. As duas interfaces são geralmente iguais. Em cadernos, use o %tensorboard mágica line. 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):

  • Os shows do painel escalares como a perda e métricas mudar com cada época. Você também pode usá-lo para rastrear a velocidade de treinamento, a taxa de aprendizado e outros valores escalares.
  • O painel Gráficos ajuda a visualizar o seu modelo. Nesse caso, o gráfico Keras de camadas é mostrado, o que pode ajudá-lo a garantir que ele seja construído corretamente.
  • As distribuições e histogramas painéis mostram a distribuição de um Tensor ao longo do tempo. Isso pode ser útil para visualizar pesos e vieses e verificar se eles estão mudando de forma esperada.

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

Uso do TensorBoard com outros métodos

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

Use o mesmo conjunto de dados acima, mas convertê-lo para tf.data.Dataset para tirar proveito de dosagem capacidades:

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 formação segue o avançado quickstart tutorial, mas mostra como log métricas para TensorBoard. Escolha perda e otimizador:

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

Crie métricas com estado 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 os gravadores de resumo para gravar os resumos no disco em um diretório de registros 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() às métricas (perda e de precisão) log durante o treino / teste no âmbito dos escritores de resumo para escrever os resumos para o disco. Você tem controle sobre quais métricas registrar e com que freqüência fazê-lo. Outros tf.summary funções activar o registo de 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! Você já viu como usar TensorBoard tanto através do callback Keras e através tf.summary para mais cenários personalizados.

TensorBoard.dev: hospedar e compartilhar os resultados do seu experimento de ML

TensorBoard.dev é um serviço público e gratuito que permite fazer upload de seus registros TensorBoard e obter um link permanente que pode ser compartilhado com todos em trabalhos acadêmicos, posts de blogs, mídias sociais, etc. Isso pode permitir uma melhor reprodutibilidade e colaboração.

Para usar TensorBoard.dev, execute o seguinte comando:

!tensorboard dev upload \
  --logdir logs/fit \
  --name "(optional) My latest experiment" \
  --description "(optional) Simple comparison of several hyperparameters" \
  --one_shot

Note-se que esta invocação usa o prefixo de exclamação ( ! ) Para invocar o shell em vez do prefixo por cento ( % ) para invocar a magia colab. Ao invocar este comando a partir da linha de comando, não há necessidade de nenhum dos prefixos.

Ver um exemplo aqui .

Para mais detalhes sobre como usar TensorBoard.dev, consulte https://tensorboard.dev/#get-started