Tutorial de TensorBoard: Visualización de gráficos con TensorFlow

Por: evelyn clarke evelyn clarke
Hours Actualizado

⚡ Resumen inteligente

TensorBoard es la interfaz visual para las ejecuciones de entrenamiento de TensorFlow, donde se muestran curvas de pérdida, gráficos de modelos, histogramas de pesos e incrustaciones. Este tutorial escribe archivos de eventos con un estimador y luego abre el panel de control en el puerto 6006.

  • 🔘 Cinco paneles de control: Los escalares, gráficos, distribuciones, histogramas y proyectores leen cada uno un tipo de resumen diferente.
  • ☑️ Directorio de registro: El argumento model_dir decide dónde escribe TensorFlow los archivos events.out.tfevents.
  • ✅ Comando de lanzamiento: Ejecuta tensorboard –logdir=RUTA y luego abre http://localhost:6006 en cualquier navegador.
  • 🧪 Tasa de aprendizaje: Una curva de pérdida irregular indica una tasa demasiado alta para que el modelo converja.
  • 🛠️ TensorFlow 2: La función de devolución de llamada de Keras TensorBoard reemplaza el registro del estimador que se muestra en el ejemplo original.
  • ⚠️ Solución de Problemas: Un panel de control vacío casi siempre significa que la ruta del directorio de registros no coincide con la ejecución del entrenamiento.
Descubre más

Tutorial de TensorBoard: Visualización de gráficos con TensorFlow

¿Qué es TensorBoard?

TensorBoard es la interfaz utilizada para visualizar el gráfico y otras herramientas para comprender, depurar y optimizar el modelo. Es una herramienta que proporciona mediciones y visualizaciones para un flujo de trabajo de aprendizaje automático. Ayuda track métricas como la pérdida y la precisión, visualizan el gráfico del modelo y proyectan incrustaciones en espacios de menor dimensión.

TensorBoard incluye TensorFlow y funciona como un pequeño servidor web local que lee los archivos de eventos que un trabajo de entrenamiento escribe en el disco.

Ejemplo de visualización de grafos de TensorFlow usando TensorBoard

La imagen que aparece a continuación proviene del gráfico de TensorBoard que generarás en este tutorial. Es el panel principal:

Panel de control de TensorBoard Scalars que muestra la curva de pérdida promedio del regresor DNN entrenado.

En la imagen a continuación, puede ver el panel de visualización de gráficos de TensorBoard. El panel contiene diferentes pestañas, que están vinculadas al nivel de información que agrega cuando ejecuta el modelo.

Barra de navegación de TensorBoard con las pestañas Escalares, Gráficos, Distribuciones, Histogramas y Proyector.

  • Escalares: Mostrar información útil diversa durante el entrenamiento del modelo.
  • Gráficos: Mostrar el modelo
  • Histograma: Mostrar pesos con un histograma
  • Distribución: Mostrar la distribución del peso
  • Proyector: Mostrar el análisis de componentes principales y el algoritmo T-SNE. La técnica utilizada para la reducción de dimensionalidad.

Durante este tutorial de TensorBoard, entrenarás un modelo simple. deep learning modelo, y el gráfico que produce se lee de abajo hacia arriba.

Si observas el gráfico, podrás comprender cómo funciona el modelo. Las insignias numeradas en la captura de pantalla a continuación marcan estas cuatro etapas:

  1. Poner en cola los datos en el modelo: enviar una cantidad de datos igual al tamaño del lote en el modelo, es decir, el número de fuentes de datos después de cada iteración.
  2. Alimentar los datos a los tensores.
  3. Entrenar a la modelo
  4. Muestra el número de lotes durante la capacitación. Guarde el modelo en el disco.

Gráfico de TensorFlow en TensorBoard con nodos numerados para la cola de entrada, el bloque dnn y la operación de guardado.

La idea básica de TensorBoard es que una red neuronal puede comportarse como una caja negra, y se necesita una herramienta para inspeccionar lo que hay dentro. Piensa en TensorBoard como una linterna para adentrarte en la red.

Ayuda a comprender las dependencias entre operaciones, cómo se calculan los pesos, muestra la función de pérdida y mucha otra información útil. Cuando reúnes toda esta información, tienes una gran herramienta para depurar y encontrar cómo mejorar el modelo.

Para que te hagas una idea de lo útil que puede ser el gráfico de TensorBoard, observa las dos curvas de pérdida que aparecen a continuación:

Dos curvas de pérdida de TensorBoard una al lado de la otra, comparando un modelo que no aprende con un modelo que converge.

Una red neuronal decide cómo conectar las diferentes neuronas y cuántas capas se necesitan para que el modelo pueda predecir un resultado. Una vez definida la arquitectura, no solo es necesario entrenar el modelo, sino también una métrica que mida la precisión de la predicción. Esta métrica se denomina función de pérdida, y el objetivo es minimizarla, lo que significa que el modelo comete menos errores.

Cada algoritmo de entrenamiento repite el cálculo muchas veces hasta que la pérdida se estabiliza. Minimizar la pérdida también requiere una tasa de aprendizaje, que indica la velocidad a la que aprende el modelo. Si la tasa de aprendizaje es demasiado alta, el modelo nunca tendrá tiempo de aprender nada: esto se muestra en el gráfico de la izquierda, donde la línea sube y baja porque el modelo, en la práctica, está adivinando. El gráfico de la derecha muestra cómo la pérdida disminuye con las iteraciones hasta que la curva se aplana, lo que significa que el modelo ha encontrado una solución.

TensorBoard es una excelente herramienta para visualizar estas métricas y detectar posibles problemas. Una red neuronal puede tardar horas o semanas en encontrar una solución, y TensorBoard actualiza las métricas mientras el proceso sigue en marcha. Por lo tanto, no es necesario esperar hasta el final para comprobar si el modelo se entrena correctamente: abra TensorBoard, revise el progreso del entrenamiento y realice los cambios necesarios.

¿Cómo usar TensorBoard?

En esta sección, aprenderá cómo abrir TensorBoard desde la terminal en macOS y desde la línea de comandos en WindowsAquí nos centramos en la herramienta, no en el modelo, por lo que el código de entrenamiento se mantiene deliberadamente breve.

En primer lugar, debes importar las bibliotecas que utilizarás durante la formación.

## Import the library
import tensorflow as tf
import numpy as np

Tú creas los datos. Se trata de una matriz de 10000 filas y 5 columnas.

X_train = (np.random.sample((10000,5)))
y_train =  (np.random.sample((10000,1)))
X_train.shape

Resultado

(10000, 5)

El código que aparece a continuación transforma los datos y crea el modelo.

Tenga en cuenta que la tasa de aprendizaje es igual a 0.1. Si cambia esta tasa a un valor mayor, el modelo no encontrará una solución. Esto es lo que sucedió en el lado izquierdo de la imagen anterior.

El ejemplo utiliza un estimador de TensorFlow, la API de alto nivel que encapsula los cálculos matemáticos. Los estimadores pertenecen a la API de TensorFlow 1.x, por lo que los dos fragmentos siguientes se ejecutan en una instalación 1.x o a través de la tf.compat.v1 espacio de nombres

Para crear los archivos de registro, debe especificar la ruta. Esto se hace con el argumento model_dir.

En el ejemplo de TensorBoard que se muestra a continuación, usted almacena el modelo dentro del directorio de trabajo, es decir, donde almacena el cuaderno o Python archivo. Dentro de esta ruta, TensorFlow creará una carpeta llamada train con una subcarpeta llamada linreg.

feature_columns = [
      tf.feature_column.numeric_column('x', shape=X_train.shape[1:])]
DNN_reg = tf.estimator.DNNRegressor(feature_columns=feature_columns,
# Indicate where to store the log file    
     model_dir='train/linreg',    
     hidden_units=[500, 300],    
     optimizer=tf.train.ProximalAdagradOptimizer(      
          learning_rate=0.1,      
          l1_regularization_strength=0.001    
      )
)

Resultado

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {&#x27;_model_dir': 'train/linreg', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1818e63828>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

El último paso de este ejemplo de visualización de gráficos con TensorFlow consiste en entrenar el modelo. Durante el entrenamiento, TensorFlow escribe información en el directorio del modelo.

# Train the estimator
train_input = tf.estimator.inputs.numpy_input_fn(    
     x={"x": X_train},    
     y=y_train, shuffle=False,num_epochs=None)
DNN_reg.train(train_input,steps=3000)

Resultado

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into train/linreg/model.ckpt.
INFO:tensorflow:loss = 40.060104, step = 1
INFO:tensorflow:global_step/sec: 197.061
INFO:tensorflow:loss = 10.62989, step = 101 (0.508 sec)
INFO:tensorflow:global_step/sec: 172.487
INFO:tensorflow:loss = 11.255318, step = 201 (0.584 sec)
INFO:tensorflow:global_step/sec: 193.295
INFO:tensorflow:loss = 10.604872, step = 301 (0.513 sec)
INFO:tensorflow:global_step/sec: 175.378
INFO:tensorflow:loss = 10.090343, step = 401 (0.572 sec)
INFO:tensorflow:global_step/sec: 209.737
INFO:tensorflow:loss = 10.057928, step = 501 (0.476 sec)
INFO:tensorflow:global_step/sec: 171.646
INFO:tensorflow:loss = 10.460144, step = 601 (0.583 sec)
INFO:tensorflow:global_step/sec: 192.269
INFO:tensorflow:loss = 10.529617, step = 701 (0.519 sec)
INFO:tensorflow:global_step/sec: 198.264
INFO:tensorflow:loss = 9.100082, step = 801 (0.504 sec)
INFO:tensorflow:global_step/sec: 226.842
INFO:tensorflow:loss = 10.485607, step = 901 (0.441 sec)
INFO:tensorflow:global_step/sec: 152.929
INFO:tensorflow:loss = 10.052481, step = 1001 (0.655 sec)
INFO:tensorflow:global_step/sec: 166.745
INFO:tensorflow:loss = 11.320213, step = 1101 (0.600 sec)
INFO:tensorflow:global_step/sec: 161.854
INFO:tensorflow:loss = 9.603306, step = 1201 (0.619 sec)
INFO:tensorflow:global_step/sec: 179.074
INFO:tensorflow:loss = 11.110269, step = 1301 (0.556 sec)
INFO:tensorflow:global_step/sec: 202.776
INFO:tensorflow:loss = 11.929443, step = 1401 (0.494 sec)
INFO:tensorflow:global_step/sec: 144.161
INFO:tensorflow:loss = 11.951693, step = 1501 (0.694 sec)
INFO:tensorflow:global_step/sec: 154.144
INFO:tensorflow:loss = 8.620987, step = 1601 (0.649 sec)
INFO:tensorflow:global_step/sec: 151.094
INFO:tensorflow:loss = 10.666125, step = 1701 (0.663 sec)
INFO:tensorflow:global_step/sec: 193.644
INFO:tensorflow:loss = 11.0349865, step = 1801 (0.516 sec)
INFO:tensorflow:global_step/sec: 189.707
INFO:tensorflow:loss = 9.860596, step = 1901 (0.526 sec)
INFO:tensorflow:global_step/sec: 176.423
INFO:tensorflow:loss = 10.695, step = 2001 (0.567 sec)
INFO:tensorflow:global_step/sec: 213.066
INFO:tensorflow:loss = 10.426752, step = 2101 (0.471 sec)
INFO:tensorflow:global_step/sec: 220.975
INFO:tensorflow:loss = 10.594796, step = 2201 (0.452 sec)
INFO:tensorflow:global_step/sec: 219.289
INFO:tensorflow:loss = 10.4212265, step = 2301 (0.456 sec)
INFO:tensorflow:global_step/sec: 215.123
INFO:tensorflow:loss = 9.668612, step = 2401 (0.465 sec)
INFO:tensorflow:global_step/sec: 175.65
INFO:tensorflow:loss = 10.009649, step = 2501 (0.569 sec)
INFO:tensorflow:global_step/sec: 206.962
INFO:tensorflow:loss = 10.477722, step = 2601 (0.483 sec)
INFO:tensorflow:global_step/sec: 229.627
INFO:tensorflow:loss = 9.877638, step = 2701 (0.435 sec)
INFO:tensorflow:global_step/sec: 195.792
INFO:tensorflow:loss = 10.274586, step = 2801 (0.512 sec)
INFO:tensorflow:global_step/sec: 176.803
INFO:tensorflow:loss = 10.061047, step = 2901 (0.566 sec)
INFO:tensorflow:Saving checkpoints for 3000 into train/linreg/model.ckpt.
INFO:tensorflow:Loss for final step: 10.73032.

<tensorflow.python.estimator.canned.dnn.DNNRegressor at 0x1818e63630>

En TensorFlow 2, la misma tarea la realiza la función de devolución de llamada de Keras TensorBoard, que escribe el gráfico y las métricas por época sin ningún código de estimador:

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

model.fit(train_images, train_labels, epochs=5,
          callbacks=[tensorboard_callback])

Una vez que finaliza la ejecución, el directorio de registro contiene un archivo de punto de control, un graph.pbtxt archivo y uno o más events.out.tfevents archivos — exactamente lo que lee TensorBoard.

ARTÍCULOS RELACIONADOS

Para macOS usuarios

La vista del Finder que se muestra a continuación muestra la nueva carpeta train/linreg creada dentro del directorio de trabajo.

macOS Lista de archivos que muestra las carpetas de registro train y linreg con los archivos checkpoint, events y graph.pbtxt.

Para Windows usuarios

On Windows Los mismos archivos aparecen en la ruta que le pasaste a model_dir, tal como se muestra resaltado en la barra de direcciones.

Windows Vista del explorador de la carpeta train linreg que contiene los archivos de eventos y puntos de control de TensorFlow.

El mismo formato de archivo de eventos es producido por PyTorchPor lo tanto, el panel de control no se limita a las ejecuciones de TensorFlow.

Ahora que tiene los eventos de registro escritos, puede abrir TensorBoard. TensorBoard se sirve en el puerto 6006 por defecto (Jupyter utiliza el puerto 8888). Utilice la terminal en macOS o el mensaje de Anaconda en Windows.

Para macOS usuarios

# Different for you
cd /Users/Guru99/tuto_TF
source activate hello-tf!

El cuaderno se encuentra en la ruta /Usuarios/Guru99/tuto_TF

Para Windows usuarios

cd C:\Users\Admin\Anaconda3
activate hello-tf

El cuaderno se almacena en la ruta C:\Users\Admin\Anaconda3

Para iniciar TensorBoard, ejecute el siguiente comando desde ese directorio.

Para macOS usuarios

tensorboard --logdir=./train/linreg

Para Windows usuarios

tensorboard --logdir=.\train\linreg

TensorBoard se sirve entonces en http://localhost:6006

Destacar Lo que controla
--logdir Directorio que contiene los archivos de eventos. Este es el único indicador obligatorio.
--port Puerto en el que servir. El valor predeterminado es 6006; cámbielo si una sesión anterior aún utiliza ese puerto.
--bind_all Servir en cada interfaz de red. TensorBoard se enlaza solo a localhost de forma predeterminada, por lo que el acceso remoto necesita este indicador y no se puede combinar con --host.
--reload_interval Con qué frecuencia, en segundos, se vuelve a escanear el directorio de registros en busca de nuevos datos.
--logdir_spec Método alternativo heredado que acepta varias rutas separadas por comas; --logdir Ya no admite ese formulario.

El tensorboard dev El subcomando ya no funciona: el servicio alojado TensorBoard.dev se cerró el 1 de enero de 2024. El uso local no se ve afectado.

En algunos equipos, la consola muestra el nombre del host en lugar de localhost, como se ve en el indicador de Anaconda a continuación. Ambas direcciones abren el mismo panel de control.

El indicador de Anaconda ejecuta el comando tensorboard e imprime la dirección del servidor en el puerto 6006.

Copia y pega la dirección en tu navegador favorito. Deberías ver el panel de control de Scalars que se muestra a continuación.

El panel de control de TensorBoard Scalars se abre en un navegador después de que el directorio de registros se carga correctamente.

Si ve algo como esto en su lugar:

Error de TensorBoard al leer la página: No se encontraron archivos de definición de grafos.

Significa que TensorBoard no puede encontrar el archivo de registro. Asegúrese de apuntar cd Siga el camino correcto o verifique que el evento de registro se haya creado correctamente. Si no fue así, vuelva a ejecutar el código de entrenamiento.

Si quieres cerrar TensorBoard, pulsa CTRL+C en la ventana del terminal.

Consejo: compruebe el directorio de trabajo actual en la consola de Anaconda.

Indicador de Anaconda que muestra el entorno hello-tf activo y el directorio de trabajo actual.

En la captura de pantalla anterior, el indicador se encuentra en C:\Users\Admin, por lo que el archivo de registro debería crearse en esa carpeta.

Preguntas Frecuentes

Una ejecución finalizada deja un índice de puntos de control, uno o más archivos model.ckpt, un archivo graph.pbtxt y al menos un archivo events.out.tfevents. TensorBoard solo lee los archivos de eventos; los puntos de control existen para que el entrenamiento pueda reanudarse desde donde se detuvo.

Sí. PyTorch Envíos y resumenWriter que emite el mismo formato de archivo de eventos, por lo que el comando tensorboard –logdir idéntico genera el panel de control. No cambia nada en el servidor, solo la biblioteca que produce los resúmenes.

No. El servicio alojado cerró el 1 de enero de 2024 y el subcomando dev de TensorBoard ahora devuelve un error. Comparta los resultados ejecutando TensorBoard dentro de un cuaderno como Google Colab, o exportando los gráficos como CSV o JSON.

Asigne a cada ejecución su propia subcarpeta dentro de una carpeta principal compartida y, a continuación, indique a la carpeta principal la ruta del comando –logdir. Cada subcarpeta aparecerá como una ejecución independiente en el panel izquierdo, y las curvas se dibujarán en los mismos ejes con una casilla de verificación para cada una.

El gráfico de nivel de operación es la vista predeterminada y muestra cómo TensorFlow interpreta el programa, dibujado de abajo hacia arriba. Al seleccionar la etiqueta keras, se cambia al gráfico conceptual, que muestra solo las capas del modelo y facilita la comparación con el diseño.

Los análisis automatizados generan docenas de ejecuciones a la vez, por lo que el panel de control se convierte en una herramienta de comparación en lugar de un monitor de una sola ejecución. El complemento HParams registra cada configuración junto con sus métricas, lo que permite ordenar las pruebas en lugar de leer las curvas una por una.

Copiloto de GitHub Redacta rápidamente las funciones de devolución de llamada y el código repetitivo del escritor de resúmenes. Trata la salida como un borrador: a menudo mezcla las API de TensorFlow 1.x y 2.x, así que verifica cada nombre con la documentación actual antes de ejecutar el código.

O bien no se escribió ningún archivo de eventos o la ruta pasada a –logdir no coincide con la que usó el trabajo de entrenamiento. Confirme que existe un archivo events.out.tfevents en esa carpeta y en Windows Inicie TensorBoard desde la misma letra de unidad.

Resumir este post con: