Se usó la API de Cloud Translation para traducir esta página.
Switch to English

Examen del gráfico TensorFlow

Ver en TensorFlow.org Ejecutar en Google Colab Ver código fuente en GitHub

Visión general

El tablero de gráficos de TensorBoard es una herramienta poderosa 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 operativo para comprender cómo TensorFlow entiende su programa. Examinar el gráfico de nivel operativo puede darle una idea de cómo cambiar su modelo. Por ejemplo, puede rediseñar su modelo si la capacitación avanza más lentamente 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 formará un modelo secuencial Keras simple para el conjunto de datos Fashion-MNIST y aprenderá a registrar y examinar los gráficos de su modelo. También utilizará una API de rastreo para generar datos gráficos para las funciones creadas con la nueva anotación tf.function .

Preparar

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

Descargue y prepare los datos de entrenamiento.

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

Entrenar el modelo y registrar datos

Antes de entrenar, defina la devolución de llamada Keras TensorBoard , especificando el directorio de registro. Al pasar esta devolución de llamada a Model.fit (), se asegura 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 operativo

Inicie TensorBoard y espere unos segundos a que se cargue la IU. Seleccione el panel de Gráficos tocando "Gráficos" en la parte superior.

 %tensorboard --logdir logs
 

Por defecto, TensorBoard muestra el gráfico de nivel operativo. (A la izquierda, puede ver la etiqueta "Predeterminada" 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 estrechamente 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:

  • Desplácese para acercar y alejar
  • Arrastra para desplazarte
  • Hacer doble clic alterna la expansión del nodo (un nodo puede ser un contenedor para otros nodos)

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

Gráfica conceptual

Además del gráfico de ejecución, TensorBoard también muestra un gráfico conceptual . Esta es solo una vista del modelo Keras. Esto puede ser ú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 contraído. 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 encontrar una situación en la que necesite usar la anotación tf.function para "autografiar" , es decir, transformar, una función de cálculo de Python en un gráfico TensorFlow de alto rendimiento. Para estas situaciones, utiliza la API de seguimiento de resumen de TensorFlow para registrar funciones autografiadas para su visualización en TensorBoard.

Para usar la API de seguimiento de resumen:

  • Defina y anote una función con tf.function
  • Use tf.summary.trace_on() inmediatamente antes de su sitio de llamada de función.
  • Agregue información de perfil (memoria, tiempo de CPU) al gráfico pasando profiler=True
  • Con un escritor de archivos de resumen, llame a 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 CPU y memoria.