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

Comience con TensorBoard

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

En el aprendizaje automático, para mejorar algo, a menudo necesita poder medirlo. TensorBoard es una herramienta para proporcionar las mediciones y visualizaciones necesarias durante el flujo de trabajo de aprendizaje automático. Permite rastrear métricas de experimentos como pérdida y precisión, visualizar el gráfico del modelo, proyectar incrustaciones en un espacio dimensional más bajo y mucho más.

Este inicio rápido le mostrará cómo comenzar rápidamente con TensorBoard. Las guías restantes en este sitio web proporcionan más detalles sobre capacidades específicas, muchas de las cuales no se incluyen aquí.

 # Load the TensorBoard notebook extension
%load_ext tensorboard
 
 import tensorflow as tf
import datetime
 
 # Clear any logs from previous runs
!rm -rf ./logs/ 
 

Usando el conjunto de datos MNIST como ejemplo, normalice los datos y escriba una función que cree un modelo Keras simple para clasificar las imágenes en 10 clases.

 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 con Keras Model.fit ()

Al entrenar con Model.fit () de Keras, agregar la tf.keras.callbacks.TensorBoard llamada tf.keras.callbacks.TensorBoard garantiza que los registros se creen y almacenen. Además, habilite el cálculo del histograma cada época con histogram_freq=1 (esto está desactivado de forma predeterminada)

Coloque los registros en un subdirectorio con marca de tiempo para permitir una fácil selección de diferentes carreras de entrenamiento.

 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 TensorBoard a través de la línea de comandos o dentro de una experiencia de cuaderno. Las dos interfaces son generalmente iguales. En los cuadernos, use la línea mágica %tensorboard . En la línea de comando, ejecute el mismo comando sin "%".

 %tensorboard --logdir logs/fit
 

Una breve descripción de los paneles mostrados (pestañas en la barra de navegación superior):

  • El panel de Scalars muestra cómo cambian las pérdidas y las métricas con cada época. Puede usarlo también para rastrear la velocidad de entrenamiento, la tasa de aprendizaje y otros valores escalares.
  • El panel de Gráficos le ayuda a visualizar su modelo. En este caso, se muestra el gráfico de capas de Keras que puede ayudarlo a asegurarse de que esté construido correctamente.
  • Los paneles de Distribuciones e Histogramas muestran la distribución de un Tensor a lo largo del tiempo. Esto puede ser útil para visualizar pesos y sesgos y verificar que están cambiando de la manera esperada.

Los complementos adicionales de TensorBoard se habilitan automáticamente cuando registra otros tipos de datos. Por ejemplo, la devolución de llamada Keras TensorBoard también le permite registrar imágenes e incrustaciones. Puede ver qué otros complementos están disponibles en TensorBoard haciendo clic en el menú desplegable "inactivo" hacia la esquina superior derecha.

Usando TensorBoard con otros métodos

Cuando tf.GradientTape() con métodos como tf.GradientTape() , use tf.summary para registrar la información requerida.

Use el mismo conjunto de datos que el anterior, pero tf.data.Dataset a tf.data.Dataset para aprovechar las capacidades de procesamiento por lotes:

 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)
 

El código de capacitación sigue el tutorial avanzado de inicio rápido , pero muestra cómo registrar métricas en TensorBoard. Elija pérdida y optimizador:

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

Cree métricas con estado que puedan usarse para acumular valores durante el entrenamiento y registrarse en cualquier 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')
 

Definir las funciones de entrenamiento y prueba:

 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 escritores de resumen para escribir los resúmenes en el disco en un directorio 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)
 

Empezar a entrenar. Use tf.summary.scalar() para registrar métricas (pérdida y precisión) durante la capacitación / prueba dentro del alcance de los redactores de resúmenes para escribir los resúmenes en el disco. Usted tiene control sobre qué métricas registrar y con qué frecuencia hacerlo. Otras funciones tf.summary permiten registrar otros tipos de datos.

 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 TensorBoard nuevamente, esta vez apuntándolo al nuevo directorio de registro. También podríamos haber comenzado TensorBoard para monitorear el entrenamiento mientras progresa.

 %tensorboard --logdir logs/gradient_tape
 

¡Eso es! Ahora ha visto cómo usar TensorBoard tanto a través de la devolución de llamada de Keras como a través de tf.summary para obtener más escenarios personalizados.