Tutorial TensorFlow: Monitorización de entrenamiento

Uso de callbacks en Keras

Los callbacks en Keras son objetos que permiten intervenir en el proceso de entrenamiento de un modelo en diferentes puntos, como al inicio y al final de una época, antes y después de una batch, entre otros. Facilitan la monitorización, el ajuste de hiperparámetros y la gestión de recursos durante el entrenamiento, proporcionando una mayor flexibilidad y control sobre el proceso.

Entre los callbacks más utilizados se encuentran:

• ModelCheckpoint: Guarda el modelo en intervalos específicos o cuando se mejora una métrica determinada.
• EarlyStopping: Detiene el entrenamiento cuando una métrica de validación no mejora después de un número definido de épocas.
• ReduceLROnPlateau: Reduce la tasa de aprendizaje cuando una métrica ha dejado de mejorar.
• TensorBoard: Permite la visualización de métricas y el gráfico del modelo en TensorBoard.

Para utilizar callbacks en Keras, se deben pasar como una lista al parámetro callbacks del método fit. A continuación, se presenta un ejemplo práctico:

from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping, TensorBoard

# Definir callbacks
checkpoint = ModelCheckpoint(
    'modelo_mejor.keras',
    monitor='val_loss',
    save_best_only=True,
    mode='min',
    verbose=1
)

early_stop = EarlyStopping(
    monitor='val_loss',
    patience=10,
    mode='min',
    verbose=1
)

tensorboard = TensorBoard(log_dir='./logs')

# Entrenar el modelo con callbacks
history = modelo.fit(
    X_train, y_train,
    epochs=100,
    batch_size=32,
    validation_data=(X_val, y_val),
    callbacks=[checkpoint, early_stop, tensorboard]
)

En este ejemplo, el ModelCheckpoint guarda el modelo cada vez que la pérdida de validación (val_loss) mejora. El EarlyStopping detiene el entrenamiento si no hay mejora en val_loss durante 10 épocas consecutivas, evitando así el sobreajuste. Por último, TensorBoard facilita la visualización de las métricas de entrenamiento y validación durante el proceso.

Además de estos, Keras permite crear callbacks personalizados heredando de la clase base Callback. Esto es útil para implementar funcionalidades específicas que no están cubiertas por los callbacks estándar. Un ejemplo sencillo de un callback personalizado podría ser:

from tensorflow.keras.callbacks import Callback

class CustomCallback(Callback):
    def on_epoch_end(self, epoch, logs=None):
        if logs.get('accuracy') > 0.95:
            print("\nPrecisión alcanzada, deteniendo el entrenamiento.")
            self.model.stop_training = True

# Utilizar el callback personalizado
custom_callback = CustomCallback()

history = modelo.fit(
    X_train, y_train,
    epochs=100,
    batch_size=32,
    validation_data=(X_val, y_val),
    callbacks=[custom_callback]
)

En este caso, el CustomCallback detiene el entrenamiento una vez que la precisión (accuracy) supera el 95%, permitiendo una parada condicional basada en métricas específicas.

El uso adecuado de callbacks en Keras optimiza el proceso de entrenamiento, mejora el rendimiento del modelo y facilita la gestión de recursos computacionales, lo que es esencial para el desarrollo de modelos eficientes y efectivos.

Guardado y carga de checkpoints

El guardado de checkpoints es una práctica esencial en el entrenamiento de modelos de aprendizaje profundo, ya que permite almacenar el estado del modelo en puntos específicos durante el proceso de entrenamiento. Esto facilita la recuperación del modelo en caso de interrupciones inesperadas y permite retomar el entrenamiento desde el último checkpoint válido, evitando la pérdida de progreso.

En TensorFlow Keras, el guardado de checkpoints se realiza principalmente a través del callback ModelCheckpoint. Este callback está diseñado para guardar el modelo, los pesos del modelo o ambas cosas en intervalos definidos, como al final de cada época. A continuación, se muestra un ejemplo de configuración de ModelCheckpoint para guardar únicamente los pesos del modelo cuando la métrica de validación mejora:

from tensorflow.keras.callbacks import ModelCheckpoint

# Definir el callback ModelCheckpoint para guardar solo los pesos
checkpoint_weights = ModelCheckpoint(
    'pesos_mejores.h5',
    monitor='val_accuracy',
    save_best_only=True,
    save_weights_only=True,
    mode='max',
    verbose=1
)

# Entrenar el modelo con el callback
history = modelo.fit(
    X_train, y_train,
    epochs=50,
    batch_size=32,
    validation_data=(X_val, y_val),
    callbacks=[checkpoint_weights]
)

En este ejemplo, ModelCheckpoint guarda los pesos del modelo en el archivo pesos_mejores.h5 cada vez que la precisión de validación (val_accuracy) mejora. La opción save_best_only=True asegura que solo se guarden los pesos cuando hay una mejora en la métrica monitorizada, optimizando el almacenamiento utilizado.

Además de guardar únicamente los pesos, es posible guardar todo el modelo, incluyendo su arquitectura, pesos y configuración de entrenamiento, utilizando el parámetro save_best_only=False y save_weights_only=False. Esto es útil cuando se desea reutilizar el modelo completo para futuras inferencias o para continuar el entrenamiento en sesiones posteriores.

# Definir el callback ModelCheckpoint para guardar todo el modelo
checkpoint_model = ModelCheckpoint(
    'modelo_completo_mejor.h5',
    monitor='val_loss',
    save_best_only=True,
    save_weights_only=False,
    mode='min',
    verbose=1
)

# Entrenar el modelo con el callback
history = modelo.fit(
    X_train, y_train,
    epochs=100,
    batch_size=64,
    validation_data=(X_val, y_val),
    callbacks=[checkpoint_model]
)

Para cargar un modelo guardado en un checkpoint, Keras proporciona funciones como load_model y load_weights. Si se ha guardado solo los pesos, se debe cargar la arquitectura del modelo primero y luego los pesos. Por ejemplo:

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# Definir la arquitectura del modelo
modelo = Sequential([
    Dense(64, activation='relu', input_shape=(input_dim,)),
    Dense(1, activation='sigmoid')
])

# Cargar los pesos guardados
modelo.load_weights('pesos_mejores.h5')

# Compilar el modelo antes de usarlo
modelo.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

En caso de haber guardado todo el modelo, la carga es más sencilla, ya que se puede restaurar directamente la arquitectura, los pesos y la configuración de entrenamiento:

from tensorflow.keras.models import load_model

# Cargar el modelo completo
modelo_completo = load_model('modelo_completo_mejor.h5')

# El modelo está listo para ser usado tanto para entrenamiento adicional como para inferencia

El uso adecuado de checkpoints no solo garantiza la integridad del proceso de entrenamiento ante fallos o interrupciones, sino que también facilita la experimentación, permitiendo comparar diferentes versiones del modelo basadas en sus rendimientos en los conjuntos de validación. Además, al separar el guardado de pesos y la estructura completa del modelo, se ofrece una mayor flexibilidad para gestionar y reutilizar los recursos de manera eficiente en distintos escenarios de desarrollo y producción.

Early stopping

El early stopping es una técnica de regularización utilizada durante el entrenamiento de modelos de aprendizaje profundo para prevenir el sobreajuste. Consiste en detener el proceso de entrenamiento antes de que alcance el número máximo de épocas, basándose en la evolución de una métrica de validación. Al hacerlo, se garantiza que el modelo mantenga una buena capacidad de generalización sobre datos no vistos.

En Keras, el early stopping se implementa mediante el callback EarlyStopping. Este callback monitorea una métrica específica y detiene el entrenamiento si no se observa una mejora significativa en dicha métrica después de un número determinado de épocas de paciencia. A continuación, se detallan los parámetros más relevantes de EarlyStopping:

• monitor: Especifica la métrica a monitorear, por ejemplo, 'val_loss' o 'val_accuracy'.
• patience: Número de épocas sin mejora antes de detener el entrenamiento. Un valor mayor permite mayor tolerancia a fluctuaciones temporales.
• min_delta: Cambio mínimo en la métrica que se considera como una mejora. Ayuda a definir la sensibilidad del callback.
• mode: Define si la métrica debe ser mínima ('min'), máxima ('max') o automáticamente inferida ('auto').
• restore_best_weights: Si se establece en True, restaura los pesos del modelo correspondientes a la mejor época registrada.

A continuación, se presenta un ejemplo práctico de cómo utilizar EarlyStopping en un modelo de Keras:

from tensorflow.keras.callbacks import EarlyStopping

# Definir el callback EarlyStopping
early_stop = EarlyStopping(
    monitor='val_loss',
    patience=5,
    min_delta=0.001,
    mode='min',
    restore_best_weights=True,
    verbose=1
)

# Entrenar el modelo con EarlyStopping
history = modelo.fit(
    X_train, y_train,
    epochs=100,
    batch_size=32,
    validation_data=(X_val, y_val),
    callbacks=[early_stop]
)

En este ejemplo, EarlyStopping monitorea la pérdida de validación (val_loss). Si no se observa una mejora de al menos 0.001 en val_loss durante 5 épocas consecutivas (patience=5), el entrenamiento se detendrá automáticamente y restaurará los pesos del modelo de la mejor época registrada. Esto ayuda a evitar que el modelo continúe entrenando innecesariamente, lo que podría llevar a un sobreajuste.

Es posible combinar EarlyStopping con otros callbacks para optimizar aún más el proceso de entrenamiento. Por ejemplo, al usarlo junto con ModelCheckpoint, se puede asegurar que no solo se detenga el entrenamiento temprano, sino también que se guarde el mejor modelo obtenido hasta el momento:

from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping

# Definir callbacks
checkpoint = ModelCheckpoint(
    'mejor_modelo.h5',
    monitor='val_accuracy',
    save_best_only=True,
    mode='max',
    verbose=1
)

early_stop = EarlyStopping(
    monitor='val_accuracy',
    patience=10,
    mode='max',
    restore_best_weights=True,
    verbose=1
)

# Entrenar el modelo con ambos callbacks
history = modelo.fit(
    X_train, y_train,
    epochs=100,
    batch_size=64,
    validation_data=(X_val, y_val),
    callbacks=[checkpoint, early_stop]
)

En este escenario, el entrenamiento se detendrá si la precisión de validación (val_accuracy) no mejora durante 10 épocas, y simultáneamente, se guardará el modelo con la mayor precisión registrada. Esta combinación garantiza tanto la eficiencia en el entrenamiento como la conservación del modelo con el mejor desempeño observado.

El uso adecuado del early stopping contribuye significativamente a la creación de modelos robustos y eficientes, al equilibrar el entrenamiento suficiente para aprender patrones relevantes y evitar el exceso de adaptación a los datos de entrenamiento.

TensorBoard para monitorización

TensorBoard es una herramienta de visualización que forma parte del ecosistema de TensorFlow, diseñada para facilitar la monitorización y análisis del proceso de entrenamiento de modelos de aprendizaje profundo. Proporciona una interfaz interactiva que permite a los desarrolladores visualizar métricas, gráficos computacionales, distribuciones de variables y otros aspectos relevantes del entrenamiento, lo que resulta fundamental para la optimización y diagnóstico de modelos complejos.

Para integrar TensorBoard en un flujo de trabajo con Keras, se utiliza el callback TensorBoard, que registra automáticamente los datos necesarios durante el entrenamiento. A continuación, se detalla cómo configurar y utilizar TensorBoard en un proyecto de TensorFlow Keras:

import tensorflow as tf
from tensorflow.keras.callbacks import TensorBoard
import datetime

# Definir el directorio para almacenar los logs de TensorBoard
log_dir = "logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = TensorBoard(log_dir=log_dir, histogram_freq=1)

# Entrenar el modelo con el callback de TensorBoard
history = modelo.fit(
    X_train, y_train,
    epochs=50,
    batch_size=32,
    validation_data=(X_val, y_val),
    callbacks=[tensorboard_callback]
)

En este ejemplo, se crea un directorio de logs único basado en la fecha y hora actuales, lo que permite mantener un historial organizado de diferentes sesiones de entrenamiento. El parámetro histogram_freq=1 indica que se generarán histogramas de los pesos de las capas después de cada época, proporcionando una visión detallada de cómo evolucionan los parámetros del modelo durante el entrenamiento.

Una vez iniciado el entrenamiento, se puede lanzar TensorBoard desde la línea de comandos apuntando al directorio de logs correspondiente:

tensorboard --logdir=logs/fit

Al acceder a http://localhost:6006/ en un navegador web, se visualizará la interfaz de TensorBoard, donde se pueden explorar diversas secciones:

• Scalars: Muestra gráficos de las métricas registradas, como la pérdida y la precisión tanto para el conjunto de entrenamiento como para el de validación, permitiendo evaluar el rendimiento del modelo a lo largo de las épocas.
• Graphs: Presenta el gráfico computacional del modelo, ofreciendo una representación visual de las operaciones y las conexiones entre capas. Esto es útil para verificar la arquitectura del modelo y detectar posibles inconsistencias.
• Histograms: Visualiza las distribuciones de los pesos y sesgos de cada capa en cada época, lo que ayuda a identificar problemas como la vanishing gradient o pesos que no están actualizándose adecuadamente.
• Distributions: Similar a los histogramas, pero presenta las distribuciones de los parámetros en una forma más condensada, facilitando la comparación entre diferentes épocas.
• Projector: Permite la visualización de vectores de alta dimensionalidad mediante técnicas de reducción de dimensionalidad como t-SNE o PCA, lo que es útil para explorar las representaciones internas aprendidas por el modelo.

Además de las funcionalidades básicas, TensorBoard soporta summaries personalizadas que permiten registrar información adicional relevante para el análisis del modelo. Por ejemplo, se pueden agregar imágenes, textos o gráficos específicos que proporcionen mayor contexto sobre el comportamiento del modelo:

from tensorflow.keras.callbacks import Callback
import matplotlib.pyplot as plt
import io

class ImageCallback(Callback):
    def __init__(self, log_dir, validation_data):
        super(ImageCallback, self).__init__()
        self.file_writer = tf.summary.create_file_writer(log_dir + '/images')
        self.validation_data = validation_data

    def on_epoch_end(self, epoch, logs=None):
        # Seleccionar un lote de datos de validación
        images, labels = self.validation_data
        predictions = self.model.predict(images)
        
        # Crear una figura de matplotlib
        fig, ax = plt.subplots()
        ax.scatter(labels, predictions)
        ax.set_xlabel('Valores Reales')
        ax.set_ylabel('Predicciones')
        ax.set_title('Comparación de Valores Reales vs Predicciones')
        
        # Convertir la figura a una imagen
        buf = io.BytesIO()
        plt.savefig(buf, format='png')
        plt.close(fig)
        buf.seek(0)
        image = tf.image.decode_png(buf.getvalue(), channels=4)
        image = tf.expand_dims(image, 0)
        
        # Registrar la imagen en TensorBoard
        with self.file_writer.as_default():
            tf.summary.image("Comparación de Predicciones", image, step=epoch)

# Definir el callback personalizado para imágenes
image_callback = ImageCallback(log_dir=log_dir, validation_data=(X_val, y_val))

# Entrenar el modelo con los callbacks de TensorBoard e imagen
history = modelo.fit(
    X_train, y_train,
    epochs=50,
    batch_size=32,
    validation_data=(X_val, y_val),
    callbacks=[tensorboard_callback, image_callback]
)

En este ejemplo, se crea un callback personalizado que genera un gráfico de dispersión comparando los valores reales con las predicciones del modelo al final de cada época. Esta visualización adicional puede ser invaluable para detectar tendencias o patrones que no son evidentes a partir de las métricas numéricas tradicionales.

Para acceder a las summaries personalizadas, se debe navegar a la sección correspondiente en la interfaz de TensorBoard, permitiendo una inspección más detallada del comportamiento del modelo.

Es importante destacar que el uso de TensorBoard no se limita a la monitorización durante el entrenamiento. También puede utilizarse para análisis post-entrenamiento, facilitando la comprensión de cómo el modelo procesa la información y cómo diferentes configuraciones afectan su rendimiento.

En resumen, TensorBoard es una herramienta esencial para cualquier desarrollador que trabaje con modelos de aprendizaje profundo en TensorFlow Keras, ya que proporciona una amplia gama de funcionalidades que mejoran la transparencia, interpretabilidad y eficiencia en el desarrollo y optimización de modelos complejos.