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

Escalares de TensorBoard: registro de métricas de entrenamiento en Keras

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

Visión general

El aprendizaje automático implica invariablemente la comprensión de métricas clave como la pérdida y cómo cambian a medida que avanza el entrenamiento. Estas métricas pueden ayudarlo a comprender si está sobreajustado , por ejemplo, o si está entrenando innecesariamente durante demasiado tiempo. Es posible que desee comparar estas métricas en diferentes ejecuciones de entrenamiento para ayudar a depurar y mejorar su modelo.

El panel Scalars de TensorBoard le permite visualizar estas métricas usando una API simple con muy poco esfuerzo. Este tutorial presenta ejemplos muy básicos para ayudarlo a aprender cómo usar estas API con TensorBoard al desarrollar su modelo de Keras. Aprenderá a utilizar la devolución de llamada de Keras TensorBoard y las API de resumen de TensorFlow para visualizar escalares predeterminados y personalizados.

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

import numpy as np

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

Configurar datos para una regresión simple

Ahora usará Keras para calcular una regresión, es decir, encontrará la mejor línea de ajuste para un conjunto de datos emparejados. (Si bien el uso de redes neuronales y el descenso de gradientes es excesivo para este tipo de problema , constituye un ejemplo muy fácil de entender).

Usarás TensorBoard para observar cómo cambian el entrenamiento y la pérdida de prueba a lo largo de las épocas. Con suerte, verá que la pérdida de entrenamiento y prueba disminuirá con el tiempo y luego se mantendrá estable.

Primero, genere 1000 puntos de datos aproximadamente a lo largo de la línea y = 0.5x + 2 . Divida estos puntos de datos en conjuntos de prueba y entrenamiento. Su esperanza es que la red neuronal aprenda esta relación.

data_size = 1000
# 80% of the data is for training.
train_pct = 0.8

train_size = int(data_size * train_pct)

# Create some input data between -1 and 1 and randomize it.
x = np.linspace(-1, 1, data_size)
np.random.shuffle(x)

# Generate the output data.
# y = 0.5x + 2 + noise
y = 0.5 * x + 2 + np.random.normal(0, 0.05, (data_size, ))

# Split into test and train pairs.
x_train, y_train = x[:train_size], y[:train_size]
x_test, y_test = x[train_size:], y[train_size:]

Entrenamiento del modelo y pérdida de registros

Ahora está listo para definir, entrenar y evaluar su modelo.

Para registrar el escalar de pérdida mientras entrena, hará lo siguiente:

  1. Crea la devolución de llamada de Keras TensorBoard
  2. Especificar un directorio de registro
  3. Pase la devolución de llamada de TensorBoard a Model.fit () de Keras.

TensorBoard lee los datos de registro de la jerarquía del directorio de registros. En este cuaderno, el directorio de registro raíz es logs/scalars , con el sufijo de un subdirectorio con marca de tiempo. El subdirectorio con marca de tiempo te permite identificar y seleccionar fácilmente las ejecuciones de entrenamiento mientras usas TensorBoard e iteras en tu modelo.

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

model = keras.models.Sequential([
    keras.layers.Dense(16, input_dim=1),
    keras.layers.Dense(1),
])

model.compile(
    loss='mse', # keras.losses.mean_squared_error
    optimizer=keras.optimizers.SGD(lr=0.2),
)

print("Training ... With default parameters, this takes less than 10 seconds.")
training_history = model.fit(
    x_train, # input
    y_train, # output
    batch_size=train_size,
    verbose=0, # Suppress chatty output; use Tensorboard instead
    epochs=100,
    validation_data=(x_test, y_test),
    callbacks=[tensorboard_callback],
)

print("Average test loss: ", np.average(training_history.history['loss']))
Training ... With default parameters, this takes less than 10 seconds.
Average test loss:  0.05271831926424056

Examinando la pérdida usando TensorBoard

Ahora, inicie TensorBoard, especificando el directorio de registro raíz que usó anteriormente.

Espere unos segundos a que se active la interfaz de usuario de TensorBoard.

%tensorboard --logdir logs/scalars

Es posible que veas que TensorBoard muestra el mensaje "No hay paneles activos para el conjunto de datos actual". Eso es porque los datos de registro iniciales aún no se han guardado. A medida que avanza el entrenamiento, el modelo de Keras comenzará a registrar datos. TensorBoard se actualizará periódicamente y le mostrará sus métricas escalares. Si está impaciente, puede tocar la flecha Actualizar en la parte superior derecha.

Mientras observa el progreso del entrenamiento, observe cómo tanto la pérdida de entrenamiento como la de validación disminuyen rápidamente y luego permanecen estables. De hecho, podrías haber dejado de entrenar después de 25 épocas, porque el entrenamiento no mejoró mucho después de ese punto.

Desplácese sobre el gráfico para ver puntos de datos específicos. También puede intentar hacer zoom con el mouse o seleccionar parte de ellos para ver más detalles.

Observe el selector "Ejecuciones" a la izquierda. Una "ejecución" representa un conjunto de registros de una ronda de entrenamiento, en este caso el resultado de Model.fit (). Los desarrolladores suelen tener muchas, muchas ejecuciones, ya que experimentan y desarrollan su modelo a lo largo del tiempo.

Utilice el selector de ejecuciones para elegir ejecuciones específicas, o elija entre solo entrenamiento o validación. Comparar ejecuciones lo ayudará a evaluar qué versión de su código está resolviendo mejor su problema.

Bien, el gráfico de pérdida de TensorBoard demuestra que la pérdida disminuyó constantemente tanto para el entrenamiento como para la validación y luego se estabilizó. Eso significa que las métricas del modelo probablemente sean muy buenas. Ahora vea cómo se comporta realmente el modelo en la vida real.

Dados los datos de entrada (60, 25, 2), la línea y = 0.5x + 2 debería producir (32, 14.5, 3). ¿Está de acuerdo el modelo?

print(model.predict([60, 25, 2]))
# True values to compare predictions against: 
# [[32.0]
#  [14.5]
#  [ 3.0]]
[[32.234306 ]
 [14.5974245]
 [ 3.0074697]]

¡No está mal!

Registro de escalares personalizados

¿Qué sucede si desea registrar valores personalizados, como una tasa de aprendizaje dinámica ? Para hacer eso, necesita usar la API de resumen de TensorFlow.

Vuelva a entrenar el modelo de regresión y registre una tasa de aprendizaje personalizada. Así es cómo:

  1. Cree un escritor de archivos, usando tf.summary.create_file_writer() .
  2. Defina una función de tasa de aprendizaje personalizada. Esto se pasará a la devolución de llamada de Keras LearningRateScheduler .
  3. Dentro de la función de tasa de aprendizaje, use tf.summary.scalar() para registrar la tasa de aprendizaje personalizada.
  4. Pase la devolución de llamada LearningRateScheduler a Model.fit ().

En general, para registrar un escalar personalizado, debe usar tf.summary.scalar() con un escritor de archivos. El escritor de archivos es responsable de escribir datos para esta ejecución en el directorio especificado y se usa implícitamente cuando usa tf.summary.scalar() .

logdir = "logs/scalars/" + datetime.now().strftime("%Y%m%d-%H%M%S")
file_writer = tf.summary.create_file_writer(logdir + "/metrics")
file_writer.set_as_default()

def lr_schedule(epoch):
  """
  Returns a custom learning rate that decreases as epochs progress.
  """
  learning_rate = 0.2
  if epoch > 10:
    learning_rate = 0.02
  if epoch > 20:
    learning_rate = 0.01
  if epoch > 50:
    learning_rate = 0.005

  tf.summary.scalar('learning rate', data=learning_rate, step=epoch)
  return learning_rate

lr_callback = keras.callbacks.LearningRateScheduler(lr_schedule)
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)

model = keras.models.Sequential([
    keras.layers.Dense(16, input_dim=1),
    keras.layers.Dense(1),
])

model.compile(
    loss='mse', # keras.losses.mean_squared_error
    optimizer=keras.optimizers.SGD(),
)

training_history = model.fit(
    x_train, # input
    y_train, # output
    batch_size=train_size,
    verbose=0, # Suppress chatty output; use Tensorboard instead
    epochs=100,
    validation_data=(x_test, y_test),
    callbacks=[tensorboard_callback, lr_callback],
)

Veamos TensorBoard nuevamente.

%tensorboard --logdir logs/scalars

Con el selector "Ejecuciones" a la izquierda, observe que tiene una <timestamp>/metrics ejecutadas. Al seleccionar esta ejecución, se muestra un gráfico de "tasa de aprendizaje" que le permite verificar la progresión de la tasa de aprendizaje durante esta ejecución.

También puede comparar las curvas de pérdida de validación y entrenamiento de esta carrera con sus carreras anteriores.

¿Cómo funciona este modelo?

print(model.predict([60, 25, 2]))
# True values to compare predictions against: 
# [[32.0]
#  [14.5]
#  [ 3.0]]
[[32.234013 ]
 [14.5973015]
 [ 3.0074618]]