 Ver en TensorFlow.org |  Ejecutar en Google Colab |  Ver fuente en GitHub |
Descripció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 ayudar a entender si está sobreajuste , por ejemplo, o si usted 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.
Los escalares de TensorBoard tablero de instrumentos permite visualizar estas métricas mediante 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 usar la devolución de llamada de Keras TensorBoard y las API de resumen de TensorFlow para visualizar escalares predeterminados y personalizados.
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
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 va a utilizar Keras para calcular una regresión, es decir, encontrar la mejor línea de ajuste para un conjunto de datos emparejados. (Durante el uso de redes neuronales y descenso de gradiente es una exageración para este tipo de problema , sí tiene un ejemplo muy fácil de entender.)
Usted va a utilizar TensorBoard para observar la formación y la pérdida de la prueba cómo el cambio a través de las épocas. Con suerte, verá que el entrenamiento y la pérdida de pruebas disminuyen con el tiempo y luego se mantienen estables.
En primer lugar, generar 1000 puntos de datos más o menos 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 la pérdida de escalar como se entrena, que va a hacer lo siguiente:
- Crear el Keras devolución de llamada TensorBoard
- Especificar un directorio de registro
- Pasar la devolución de llamada TensorBoard a Keras' Model.fit () .
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 subdirectorio sellos de tiempo. El subdirectorio con marca de tiempo te permite identificar y seleccionar fácilmente 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(learning_rate=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
Puede ver 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. La comparación de ejecuciones le 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.
Teniendo en cuenta los datos de entrada (60, 25, 2), la línea y = 0,5x + 2 debe ceder (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]]
¡Nada mal!
Registro de escalares personalizados
¿Qué pasa si desea registrar los valores personalizados, tales como una tasa de aprendizaje dinámico ? 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:
- Crear un escritor de archivos, utilizando
tf.summary.create_file_writer(). - Defina una función de tasa de aprendizaje personalizada. Esto se pasa al Keras LearningRateScheduler de devolución de llamada.
- Dentro de la función tasa de aprendizaje, el uso
tf.summary.scalar()para registrar la tasa de aprendizaje personalizado. - Pase la devolución de llamada de LearningRateScheduler a Model.fit ().
En general, para registrar un escalar a medida, es necesario utilizar tf.summary.scalar() con un escritor de archivos. El escritor de archivos es responsable de escribir los datos para esta ejecución en el directorio especificado y se utiliza de forma implícita cuando se utiliza el 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
Uso del selector de "corrimiento" de la izquierda, el aviso de que tiene una <timestamp>/metrics plazo. 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. También puede notar que el programa de tasa de aprendizaje devolvió valores discretos, según la época, pero la gráfica de la tasa de aprendizaje puede parecer suave. TensorBoard tiene un parámetro de suavizado que es posible que debas reducir a cero para ver los valores sin suavizar.
¿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]]