Examinando o gráfico TensorFlow

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

Visão geral

Painel Gráficos de TensorBoard é uma ferramenta poderosa para analisar o seu modelo TensorFlow. Você pode visualizar rapidamente um gráfico conceitual da estrutura do seu modelo e garantir que corresponda ao design pretendido. Você também pode visualizar um gráfico de nível operacional para entender como o TensorFlow entende seu programa. Examinar o gráfico de nível operacional pode dar uma ideia de como alterar seu modelo. Por exemplo, você pode redesenhar seu modelo se o treinamento estiver progredindo mais lentamente do que o esperado.

Este tutorial apresenta uma visão geral rápida de como gerar dados de diagnóstico de gráfico e visualizá-los no painel de gráficos do TensorBoard. Você definirá e treinará um modelo sequencial Keras simples para o conjunto de dados Fashion-MNIST e aprenderá como registrar e examinar seus gráficos de modelo. Você também vai usar uma API rastreamento para gerar dados do gráfico para funções criadas usando o novo tf.function anotação.

Configurar

# Load the TensorBoard notebook extension.
%load_ext tensorboard

from datetime import datetime
from packaging import version

import tensorflow as tf
from tensorflow import keras

print("TensorFlow version: ", tf.__version__)
assert version.parse(tf.__version__).release[0] >= 2, \
    "This notebook requires TensorFlow 2.0 or above."

TensorFlow version:  2.2.0

import tensorboard
tensorboard.__version__

'2.2.1'

# Clear any logs from previous runs
rm -rf ./logs/

Defina um modelo Keras

Neste exemplo, o classificador é um modelo sequencial simples de quatro camadas.

# Define the model.
model = keras.models.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(32, activation='relu'),
    keras.layers.Dropout(0.2),
    keras.layers.Dense(10, activation='softmax')
])

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

Baixe e prepare os dados de treinamento.

(train_images, train_labels), _ = keras.datasets.fashion_mnist.load_data()
train_images = train_images / 255.0

Treine o modelo e registre os dados

Antes do treino, definir o retorno de chamada Keras TensorBoard , especificando o diretório de log. Ao passar esse retorno de chamada para Model.fit (), você garante que os dados do gráfico sejam registrados para visualização no TensorBoard.

# Define the Keras TensorBoard callback.
logdir="logs/fit/" + datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)

# Train the model.
model.fit(
    train_images,
    train_labels, 
    batch_size=64,
    epochs=5, 
    callbacks=[tensorboard_callback])

Epoch 1/5
938/938 [==============================] - 2s 2ms/step - loss: 0.6955 - accuracy: 0.7618
Epoch 2/5
938/938 [==============================] - 2s 2ms/step - loss: 0.4877 - accuracy: 0.8296
Epoch 3/5
938/938 [==============================] - 2s 2ms/step - loss: 0.4458 - accuracy: 0.8414
Epoch 4/5
938/938 [==============================] - 2s 2ms/step - loss: 0.4246 - accuracy: 0.8476
Epoch 5/5
938/938 [==============================] - 2s 2ms/step - loss: 0.4117 - accuracy: 0.8508
<tensorflow.python.keras.callbacks.History at 0x7f656ecc3fd0>

Gráfico de nível operacional

Inicie o TensorBoard e aguarde alguns segundos para a IU carregar. Selecione o painel de gráficos tocando em “Gráficos” na parte superior.

%tensorboard --logdir logs

Você também pode usar o TensorBoard.dev para criar um experimento hospedado e compartilhável.

!tensorboard dev upload \
  --logdir logs \
  --name "Sample op-level graph" \
  --one_shot

Por padrão, TensorBoard exibe o gráfico de nível op. (À esquerda, você pode ver a tag “Padrão” selecionada.) Observe que o gráfico está invertido; os dados fluem de baixo para cima, portanto, estão de cabeça para baixo em comparação com o código. No entanto, você pode ver que o gráfico corresponde à definição do modelo Keras, com arestas extras para outros nós de computação.

Os gráficos costumam ser muito grandes, então você pode manipular a visualização do gráfico:

  • Vá até zoom in e out
  • Arraste para pan
  • Clicando duas vezes alterna expansão nó (um nó pode ser um recipiente para outros nós)

Você também pode ver os metadados clicando em um nó. Isso permite que você veja entradas, saídas, formas e outros detalhes.

Gráfico conceitual

Além do gráfico de execução, TensorBoard também exibe um gráfico conceitual. Esta é uma visão apenas do modelo Keras. Isso pode ser útil se você estiver reutilizando um modelo salvo e quiser examinar ou validar sua estrutura.

Para ver o gráfico conceitual, selecione a tag “keras”. Para este exemplo, você verá um nó Sequential entrou em colapso. Clique duas vezes no nó para ver a estrutura do modelo:


Gráficos de tf.functions

Os exemplos até agora descreveram gráficos de modelos Keras, onde os gráficos foram criados definindo camadas Keras e chamando Model.fit ().

Você pode encontrar uma situação onde você precisa usar o tf.function anotação para "autógrafo" , ou seja, transformar uma função computação Python em um gráfico TensorFlow de alto desempenho. Para estas situações, você usa TensorFlow API Resumo rastreamento para registrar funções autografadas para visualização em TensorBoard.

Para usar a API de rastreamento de resumo:

  • Definir e anotar uma função com tf.function
  • Use tf.summary.trace_on() imediatamente antes de seu site chamada de função.
  • Adicionar informações de perfil (memória, tempo de CPU) para gráfico, passando profiler=True
  • Com um escritor arquivo Summary, chamada tf.summary.trace_export() para salvar os dados de log

Você pode então usar o TensorBoard para ver como sua função se comporta.

# The function to be traced.
@tf.function
def my_func(x, y):
  # A simple hand-rolled layer.
  return tf.nn.relu(tf.matmul(x, y))

# Set up logging.
stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
logdir = 'logs/func/%s' % stamp
writer = tf.summary.create_file_writer(logdir)

# Sample data for your function.
x = tf.random.uniform((3, 3))
y = tf.random.uniform((3, 3))

# Bracket the function call with
# tf.summary.trace_on() and tf.summary.trace_export().
tf.summary.trace_on(graph=True, profiler=True)
# Call only one tf.function when tracing.
z = my_func(x, y)
with writer.as_default():
  tf.summary.trace_export(
      name="my_func_trace",
      step=0,
      profiler_outdir=logdir)

%tensorboard --logdir logs/func

Agora você pode ver a estrutura da sua função conforme entendida pelo TensorBoard. Clique no botão de opção "Perfil" para ver as estatísticas da CPU e da memória.