¡Google I/O es una envoltura! Póngase al día con las sesiones de TensorFlow Ver sesiones

Examinando el gráfico de TensorFlow

Ver en TensorFlow.org Ejecutar en Google Colab Ver fuente en GitHub Descargar cuaderno

Descripción general

Los gráficos de tablero TensorBoard es una poderosa herramienta para examinar su modelo TensorFlow. Puede ver rápidamente un gráfico conceptual de la estructura de su modelo y asegurarse de que coincida con su diseño previsto. También puede ver un gráfico de nivel de operación para comprender cómo TensorFlow entiende su programa. Examinar el gráfico de nivel de operación puede darle una idea de cómo cambiar su modelo. Por ejemplo, puede rediseñar su modelo si el entrenamiento avanza más lento de lo esperado.

Este tutorial presenta una descripción general rápida de cómo generar datos de diagnóstico de gráficos y visualizarlos en el panel de gráficos de TensorBoard. Definirá y entrenará un modelo secuencial de Keras simple para el conjunto de datos Fashion-MNIST y aprenderá a registrar y examinar los gráficos de su modelo. También utilizará un rastreo de API para generar datos de gráficos para funciones creadas utilizando la nueva tf.function anotación.

Configuración

# 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/

Definir un modelo de Keras

En este ejemplo, el clasificador es un modelo secuencial simple de cuatro capas.

# 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'])

Descarga y prepara los datos de entrenamiento.

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

Entrene el modelo y registre los datos

Antes del entrenamiento, definir la devolución de llamada Keras TensorBoard , especificando el directorio de registro. Al pasar esta devolución de llamada a Model.fit (), te aseguras de que los datos del gráfico se registren para su visualización en 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 nivel de operación

Inicie TensorBoard y espere unos segundos hasta que se cargue la interfaz de usuario. Seleccione el panel de gráficos tocando "Gráficos" en la parte superior.

%tensorboard --logdir logs

Opcionalmente, también puede usar TensorBoard.dev para crear un experimento alojado que se pueda compartir.

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

Por defecto, TensorBoard muestra el gráfico de nivel op. (A la izquierda, puede ver la etiqueta "Predeterminado" seleccionada.) Tenga en cuenta que el gráfico está invertido; los datos fluyen de abajo hacia arriba, por lo que están al revés en comparación con el código. Sin embargo, puede ver que el gráfico coincide mucho con la definición del modelo de Keras, con bordes adicionales a otros nodos de cálculo.

Los gráficos suelen ser muy grandes, por lo que puede manipular la visualización del gráfico:

  • De desplazamiento para acercar y alejar
  • Arrastra para
  • Haciendo doble clic alterna expansión nodo (un nodo puede ser un contenedor para otros nodos)

También puede ver los metadatos haciendo clic en un nodo. Esto le permite ver entradas, salidas, formas y otros detalles.

Gráfico conceptual

Además de la gráfica ejecución, TensorBoard también muestra un gráfico conceptual. Esta es una vista solo del modelo de Keras. Esto puede resultar útil si está reutilizando un modelo guardado y desea examinar o validar su estructura.

Para ver el gráfico conceptual, seleccione la etiqueta "keras". Para este ejemplo, verá un nodo secuencial colapsado. Haga doble clic en el nodo para ver la estructura del modelo:


Gráficos de funciones tf.

Los ejemplos hasta ahora han descrito gráficos de modelos de Keras, donde los gráficos se han creado definiendo capas de Keras y llamando a Model.fit ().

Puede encontrarse con una situación en la que necesita para utilizar el tf.function anotación a "autógrafo" , es decir, transformar una función de cálculo de Python en un gráfico TensorFlow de alto rendimiento. Para estas situaciones, se utiliza TensorFlow API Resumen de seguimiento para registrar las funciones autografiados para la visualización en TensorBoard.

Para utilizar la API de seguimiento de resumen:

  • Definir y anotar una función con tf.function
  • Utilice tf.summary.trace_on() inmediatamente antes de su sitio llamada a la función.
  • Añadir información del perfil (memoria, tiempo de CPU) a la gráfica al pasar profiler=True
  • Con un escritor archivo de resumen, llamada tf.summary.trace_export() para guardar los datos de registro

Luego puede usar TensorBoard para ver cómo se comporta su función.

# 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

Ahora puede ver la estructura de su función tal como la entiende TensorBoard. Haga clic en el botón de radio "Perfil" para ver las estadísticas de la CPU y la memoria.