3.3 Model Checkpointing, Early Stopping y Callbacks en Keras

Entrenar redes neuronales puede presentar desafíos como el sobreajuste y largos períodos de entrenamiento. Para abordar estos problemas, Keras proporciona callbacks, herramientas poderosas que permiten el monitoreo y control en tiempo real del proceso de entrenamiento.

Estos callbacks desencadenan automáticamente acciones predefinidas en puntos específicos durante el entrenamiento, permitiendo ajustes y optimizaciones dinámicas. Entre los más valiosos se encuentran model checkpointing y early stopping. Model checkpointing garantiza que el mejor modelo se guarde durante el proceso de entrenamiento, mientras que early stopping termina inteligentemente el entrenamiento cuando las mejoras se estabilizan, evitando sobrecarga computacional innecesaria y sobreajuste.

Al aprovechar estos callbacks, los desarrolladores pueden mejorar significativamente la eficiencia y efectividad de sus pipelines de entrenamiento, logrando modelos más robustos y optimizados.

3.3.1 Model Checkpointing en Keras

El checkpointing de modelos es una técnica crucial en el aprendizaje profundo que consiste en guardar el estado del modelo en varios puntos durante el proceso de entrenamiento. Esta práctica sirve para varios propósitos:

Resiliencia ante interrupciones: El checkpointing de modelos protege contra interrupciones inesperadas, como fallos de energía o del sistema. Al mantener checkpoints guardados, se puede reanudar el entrenamiento desde el estado guardado más reciente, eliminando la necesidad de empezar desde cero.
Flexibilidad en la gestión del entrenamiento: Esta característica permite pausar y reanudar el entrenamiento según sea necesario, lo que resulta ventajoso cuando se trabaja con conjuntos de datos extensos o modelos intrincados que requieren duraciones prolongadas de entrenamiento.
Análisis de rendimiento detallado: Al preservar modelos en varios puntos a lo largo del entrenamiento, se obtiene la capacidad de realizar análisis profundos sobre cómo evoluciona el rendimiento del modelo a lo largo del tiempo.
Preservación del modelo óptimo: El mecanismo de checkpointing se puede configurar para guardar el modelo solo cuando demuestra un mejor rendimiento en el conjunto de validación, asegurando que siempre se conserve la versión más efectiva del modelo.

Keras simplifica este proceso mediante el callback ModelCheckpoint, que permite:

Guardar todo el modelo o solo los pesos.
Personalizar la frecuencia de guardado (p. ej., cada época, cada n pasos).
Especificar condiciones para el guardado (p. ej., solo cuando el modelo mejora en una métrica específica).
Controlar el formato y la ubicación de los archivos guardados.

Al aprovechar ModelCheckpoint, se pueden implementar pipelines de entrenamiento robustos que sean resilientes a interrupciones y capaces de capturar las mejores iteraciones del modelo.

Guardando los pesos del modelo durante el entrenamiento

El callback ModelCheckpoint es una herramienta poderosa en Keras que permite el guardado automático de los pesos del modelo o el modelo completo durante el proceso de entrenamiento. Este callback ofrece flexibilidad sobre cuándo y cómo se guarda el modelo, permitiendo a los desarrolladores capturar la mejor versión de su modelo.

Aspectos clave del callback ModelCheckpoint:

Frecuencia de guardado personalizable: Puedes configurar el callback para guardar al final de cada época o en intervalos específicos durante el entrenamiento.
Guardado basado en el rendimiento: El callback se puede configurar para guardar solo cuando una métrica especificada (p. ej., precisión o pérdida de validación) mejora.
Opciones flexibles de guardado: Puedes elegir guardar solo los pesos del modelo o toda la arquitectura junto con los pesos.
Convención de nombres configurable: El callback te permite especificar el formato y la convención de nombres de los archivos guardados, lo que facilita la gestión de múltiples checkpoints.

Al utilizar el callback ModelCheckpoint, puedes implementar un pipeline de entrenamiento robusto que preserve automáticamente las iteraciones más prometedoras de tu modelo, facilitando el proceso de selección y despliegue del modelo.

Ejemplo: Usando ModelCheckpoint para guardar el mejor modelo

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping
from tensorflow.keras.datasets import mnist
import numpy as np
import matplotlib.pyplot as plt

# Load and preprocess the MNIST dataset
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.astype('float32') / 255
X_test = X_test.astype('float32') / 255
y_train = tf.keras.utils.to_categorical(y_train, 10)
y_test = tf.keras.utils.to_categorical(y_test, 10)

# Define the model
model = Sequential([
    Flatten(input_shape=(28, 28)),
    Dense(128, activation='relu'),
    Dense(64, activation='relu'),
    Dense(10, activation='softmax')
])

# Compile the model
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# Define the ModelCheckpoint callback
checkpoint_callback = ModelCheckpoint(
    filepath='best_model.h5',
    save_best_only=True,
    monitor='val_accuracy',
    mode='max',
    verbose=1
)

# Define the EarlyStopping callback
early_stopping_callback = EarlyStopping(
    monitor='val_loss',
    patience=3,
    restore_best_weights=True,
    verbose=1
)

# Train the model with callbacks
history = model.fit(
    X_train, y_train,
    epochs=20,
    batch_size=32,
    validation_split=0.2,
    callbacks=[checkpoint_callback, early_stopping_callback]
)

# Plot training history
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.title('Model Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.title('Model Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()

plt.tight_layout()
plt.show()

# Evaluate the model on the test set
test_loss, test_accuracy = model.evaluate(X_test, y_test, verbose=0)
print(f"Test accuracy: {test_accuracy:.4f}")

# Make predictions on a sample
sample = X_test[:5]
predictions = model.predict(sample)
predicted_classes = np.argmax(predictions, axis=1)
print("Predicted classes:", predicted_classes)

# Visualize sample predictions
plt.figure(figsize=(15, 3))
for i in range(5):
    plt.subplot(1, 5, i+1)
    plt.imshow(sample[i].reshape(28, 28), cmap='gray')
    plt.title(f"Predicted: {predicted_classes[i]}")
    plt.axis('off')
plt.tight_layout()
plt.show()

Desglose completo del código:

Importaciones y preparación de datos:
- Se importan los módulos necesarios de TensorFlow, Keras, NumPy y Matplotlib.
- Se carga, normaliza y codifican en one-hot las etiquetas del conjunto de datos MNIST.
Definición del modelo:
- Se crea un modelo Sequential con capas Flatten y Dense.
- El modelo se compila con el optimizador Adam, la pérdida categorical crossentropy y la métrica de precisión.
Callbacks:
- Se configura ModelCheckpoint para guardar el mejor modelo basado en la precisión de validación.
- EarlyStopping se configura para detener el entrenamiento si la pérdida de validación no mejora durante 3 épocas.
Entrenamiento del modelo:
- El modelo se entrena durante 20 épocas con un tamaño de lote de 32 y una división de validación del 20%.
- Se utilizan tanto ModelCheckpoint como EarlyStopping durante el entrenamiento.
Visualización:
- Se trazan las curvas de precisión de entrenamiento y validación a lo largo de las épocas.
- Se trazan las curvas de pérdida de entrenamiento y validación a lo largo de las épocas.
Evaluación del modelo:
- El modelo entrenado se evalúa en el conjunto de prueba para obtener la precisión final.
Realización de predicciones:
- Se hacen predicciones sobre una muestra de 5 imágenes de prueba.
- Se imprimen y visualizan las clases predichas.

Este ejemplo demuestra un flujo de trabajo completo para entrenar una red neuronal utilizando Keras, incluyendo la preparación de datos, la creación del modelo, el entrenamiento con callbacks, la visualización del historial de entrenamiento, la evaluación del modelo y la realización de predicciones. Muestra cómo utilizar eficazmente los callbacks ModelCheckpoint y EarlyStopping, así como cómo visualizar el rendimiento y las predicciones del modelo.

3.3.2 Early Stopping en Keras

Otro callback crucial en Keras es EarlyStopping, que monitorea el rendimiento del modelo en el conjunto de validación durante el entrenamiento. Esta herramienta poderosa detiene automáticamente el proceso de entrenamiento cuando el rendimiento del modelo en el conjunto de validación deja de mejorar, sirviendo como una protección efectiva contra el sobreajuste.

El sobreajuste ocurre cuando un modelo se especializa demasiado en los datos de entrenamiento, memorizando el ruido y las peculiaridades del conjunto en lugar de aprender patrones generalizables. Esto resulta en un modelo que funciona excepcionalmente bien con los datos de entrenamiento pero falla al generalizar en nuevos datos.

EarlyStopping aborda este problema al evaluar continuamente el rendimiento del modelo en un conjunto de validación separado durante el entrenamiento. Cuando el rendimiento del modelo en este conjunto comienza a estancarse o deteriorarse, sugiere que el modelo está comenzando a sobreajustarse. En este punto, el callback EarlyStopping interviene, terminando el proceso de entrenamiento.

Esta técnica ofrece varios beneficios:

Selección óptima del modelo: Asegura que el entrenamiento se detenga en el punto donde el modelo generaliza mejor.
Eficiencia en tiempo y recursos: Al prevenir iteraciones de entrenamiento innecesarias, ahorra recursos computacionales y tiempo.
Mejor generalización: El modelo resultante es más probable que funcione bien en nuevos datos no vistos, ya que no se le ha permitido sobreajustarse al conjunto de entrenamiento.

Implementar EarlyStopping en Keras es sencillo y altamente personalizable. Los usuarios pueden especificar qué métrica monitorear (p. ej., pérdida de validación o precisión), el número de épocas a esperar para mejorar (paciencia) y si restaurar los mejores pesos encontrados durante el entrenamiento. Esta flexibilidad hace que EarlyStopping sea una herramienta indispensable para desarrollar modelos robustos y generalizables.

Implementación de EarlyStopping

El callback EarlyStopping es una herramienta poderosa en Keras que monitorea una métrica de rendimiento especificada, como la pérdida o la precisión de validación, durante el proceso de entrenamiento. Su función principal es detener automáticamente el entrenamiento cuando la métrica seleccionada deja de mejorar después de un número predefinido de épocas, conocido como el parámetro de 'paciencia'.

Este callback cumple varios propósitos cruciales en el proceso de entrenamiento de modelos:

Prevenir el sobreajuste: Al detener el entrenamiento cuando el rendimiento en el conjunto de validación se estanca, EarlyStopping ayuda a prevenir que el modelo se sobreajuste a los datos de entrenamiento.
Optimizar el tiempo de entrenamiento: Elimina las épocas innecesarias que no contribuyen a la mejora del modelo, ahorrando recursos computacionales y tiempo.
Capturar el mejor modelo: Cuando se usa junto con el parámetro 'restore_best_weights', EarlyStopping asegura que el modelo retenga los pesos de la época con mejor rendimiento.

La flexibilidad de EarlyStopping permite a los desarrolladores ajustar su comportamiento modificando parámetros como:

'monitor': La métrica a seguir (p. ej., 'val_loss', 'val_accuracy').
'patience': El número de épocas a esperar para ver una mejora antes de detenerse.
'min_delta': El cambio mínimo en la cantidad monitoreada que califica como mejora.
'mode': Indica si la cantidad monitoreada debe minimizarse ('min') o maximizarse ('max').

Al aprovechar EarlyStopping, los científicos de datos e ingenieros de aprendizaje automático pueden crear pipelines de entrenamiento más eficientes y efectivos, lo que conduce a modelos que generalizan mejor en datos no vistos.

Ejemplo: Usando EarlyStopping para detener el entrenamiento cuando el rendimiento se estanca

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.callbacks import EarlyStopping
from tensorflow.keras.datasets import mnist
import numpy as np
import matplotlib.pyplot as plt

# Load and preprocess the MNIST dataset
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.astype('float32') / 255
X_test = X_test.astype('float32') / 255
y_train = tf.keras.utils.to_categorical(y_train, 10)
y_test = tf.keras.utils.to_categorical(y_test, 10)

# Define the model
model = Sequential([
    Flatten(input_shape=(28, 28)),
    Dense(128, activation='relu'),
    Dense(64, activation='relu'),
    Dense(10, activation='softmax')
])

# Compile the model
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# Define the EarlyStopping callback
early_stopping_callback = EarlyStopping(
    monitor='val_loss',
    patience=3,
    restore_best_weights=True,
    verbose=1
)

# Train the model with early stopping
history = model.fit(
    X_train, y_train,
    epochs=50,
    batch_size=32,
    validation_data=(X_test, y_test),
    callbacks=[early_stopping_callback]
)

# Plot training history
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.title('Model Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.title('Model Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()

plt.tight_layout()
plt.show()

# Evaluate the model on the test set
test_loss, test_accuracy = model.evaluate(X_test, y_test, verbose=0)
print(f"Test accuracy: {test_accuracy:.4f}")

Desglose del código:

Importaciones y preparación de datos:

Se importan los módulos necesarios de TensorFlow, Keras, NumPy y Matplotlib.
Se carga el conjunto de datos MNIST, se normalizan las imágenes y las etiquetas se codifican en one-hot.

Definición del modelo:

Se crea un modelo Sequential con capas Flatten y Dense.
El modelo se compila utilizando el optimizador Adam, la función de pérdida categorical crossentropy y la métrica de precisión.

Callback EarlyStopping:

EarlyStopping se configura para monitorear 'val_loss' con una paciencia de 3 épocas.
'restore_best_weights=True' asegura que el modelo conserve los pesos de su mejor rendimiento.
'verbose=1' proporciona actualizaciones sobre el early stopping durante el entrenamiento.

Entrenamiento del modelo:

El modelo se entrena por un máximo de 50 épocas con un tamaño de lote de 32.
Se utiliza el conjunto de pruebas completo como datos de validación.
El callback EarlyStopping se pasa al método fit.

Visualización:

Se trazan las curvas de precisión de entrenamiento y validación a lo largo de las épocas.
Se trazan las curvas de pérdida de entrenamiento y validación a lo largo de las épocas.

Evaluación del modelo:

El modelo final se evalúa en el conjunto de prueba para obtener la precisión final.

Este ejemplo demuestra un flujo de trabajo completo para entrenar una red neuronal utilizando Keras con early stopping. Incluye la preparación de datos, la creación del modelo, el entrenamiento con el callback EarlyStopping, la visualización del historial de entrenamiento y la evaluación del modelo. El callback EarlyStopping ayuda a evitar el sobreajuste al detener el proceso de entrenamiento cuando la pérdida de validación deja de mejorar, optimizando tanto el rendimiento del modelo como el tiempo de entrenamiento.

3.3.3 Uso de múltiples callbacks

Aprovechar múltiples callbacks durante el entrenamiento del modelo es una técnica poderosa que puede mejorar significativamente el proceso de entrenamiento y el rendimiento del modelo resultante. Una combinación común y altamente efectiva es el uso de los callbacks ModelCheckpoint y EarlyStopping. Esta combinación permite la preservación del modelo de mejor rendimiento y, al mismo tiempo, evita el sobreajuste al detener el entrenamiento cuando el rendimiento se estanca.

El callback ModelCheckpoint guarda el modelo en intervalos específicos durante el entrenamiento, normalmente cuando alcanza el mejor rendimiento en una métrica monitoreada (p. ej., precisión de validación). Esto asegura que, incluso si el rendimiento del modelo se degrada en épocas posteriores, la mejor versión aún se conserva.

Complementando esto, el callback EarlyStopping monitorea el rendimiento del modelo en el conjunto de validación y termina el entrenamiento si no se observa una mejora durante un número específico de épocas (definido por el parámetro 'patience'). Esto no solo previene el sobreajuste, sino que también optimiza los recursos computacionales al evitar iteraciones de entrenamiento innecesarias.

Combinando ModelCheckpoint y EarlyStopping

Puedes pasar una lista de callbacks a la función fit(), lo que te permite usar ModelCheckpoint y EarlyStopping simultáneamente. Esta combinación poderosa te permite optimizar el proceso de entrenamiento de tu modelo de varias maneras:

Guardado automático del modelo: ModelCheckpoint guardará tu modelo en intervalos especificados o cuando alcance su mejor rendimiento, asegurando que siempre tengas acceso a la mejor versión.
Prevención del sobreajuste: EarlyStopping monitorea el rendimiento del modelo en el conjunto de validación y detiene el entrenamiento cuando la mejora se estanca, ayudando a prevenir el sobreajuste.
Optimización de recursos: Al detener el entrenamiento cuando ya no es beneficioso, ahorras recursos computacionales y tiempo.
Flexibilidad en el monitoreo: Puedes configurar cada callback para monitorear métricas diferentes, proporcionando una vista completa del rendimiento de tu modelo durante el entrenamiento.

Este enfoque no solo agiliza el proceso de entrenamiento, sino que también mejora la calidad y la capacidad de generalización del modelo final. Al aprovechar estos callbacks en conjunto, creas una pipeline de entrenamiento robusta que se adapta a las necesidades específicas de tu proyecto de aprendizaje profundo.

Ejemplo: Combinando ModelCheckpoint y EarlyStopping

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping
from tensorflow.keras.datasets import mnist
import numpy as np
import matplotlib.pyplot as plt

# Load and preprocess the MNIST dataset
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.astype('float32') / 255
X_test = X_test.astype('float32') / 255
y_train = tf.keras.utils.to_categorical(y_train, 10)
y_test = tf.keras.utils.to_categorical(y_test, 10)

# Define the model
model = Sequential([
    Flatten(input_shape=(28, 28)),
    Dense(128, activation='relu'),
    Dense(64, activation='relu'),
    Dense(10, activation='softmax')
])

# Compile the model
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# Define both callbacks
checkpoint_callback = ModelCheckpoint(
    filepath='best_model.h5',
    save_best_only=True,
    monitor='val_accuracy',
    mode='max',
    verbose=1
)
early_stopping_callback = EarlyStopping(
    monitor='val_loss',
    patience=5,
    restore_best_weights=True,
    verbose=1
)

# Train the model with both callbacks
history = model.fit(
    X_train, y_train,
    epochs=100,
    batch_size=32,
    validation_data=(X_test, y_test),
    callbacks=[checkpoint_callback, early_stopping_callback]
)

# Plot training history
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.title('Model Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.title('Model Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()

plt.tight_layout()
plt.show()

# Evaluate the model on the test set
test_loss, test_accuracy = model.evaluate(X_test, y_test, verbose=0)
print(f"Test accuracy: {test_accuracy:.4f}")

Desglose del código:

Preparación de datos:

El conjunto de datos MNIST se carga y se preprocesa.
Las imágenes se normalizan al rango [0, 1].
Las etiquetas se codifican en one-hot.

Definición del modelo:

Se crea un modelo Sequential con capas Flatten y Dense.
El modelo se compila con el optimizador Adam, la función de pérdida categorical crossentropy y la métrica de precisión.

Definición de callbacks:

ModelCheckpoint se configura para guardar el mejor modelo basado en la precisión de validación.
EarlyStopping se configura para monitorear la pérdida de validación con una paciencia de 5 épocas.

Entrenamiento del modelo:

El modelo se entrena por un máximo de 100 épocas con un tamaño de lote de 32.
Ambos callbacks (ModelCheckpoint y EarlyStopping) se utilizan durante el entrenamiento.

Visualización:

La precisión de entrenamiento y validación se grafica a lo largo de las épocas.
La pérdida de entrenamiento y validación se grafica a lo largo de las épocas.

Evaluación del modelo:

El modelo final se evalúa en el conjunto de prueba para obtener la precisión de prueba.

Este ejemplo completo demuestra cómo usar eficazmente los callbacks ModelCheckpoint y EarlyStopping en Keras. ModelCheckpoint guarda el mejor modelo durante el entrenamiento, mientras que EarlyStopping previene el sobreajuste al detener el proceso de entrenamiento cuando el rendimiento del modelo en el conjunto de validación deja de mejorar. La adición del preprocesamiento de datos, la definición del modelo y la visualización de los resultados proporciona un flujo de trabajo completo para entrenar y evaluar un modelo de red neuronal.

3.3.4 Callbacks personalizados en Keras

Keras también te permite crear callbacks personalizados para ampliar la funcionalidad del proceso de entrenamiento. Con los callbacks personalizados, puedes ejecutar tu propio código en cualquier punto del ciclo de entrenamiento, como al inicio o al final de una época, o después de cada lote. Esta característica poderosa permite a los desarrolladores implementar una amplia gama de comportamientos personalizados y capacidades de monitoreo.

Los callbacks personalizados se pueden utilizar para diversos propósitos, incluyendo:

Registrar métricas o información personalizadas durante el entrenamiento.
Implementar programaciones dinámicas de la tasa de aprendizaje.
Guardar puntos de control del modelo basados en criterios personalizados.
Visualizar el progreso del entrenamiento en tiempo real.
Implementar early stopping basado en condiciones complejas.

Para crear un callback personalizado, debes heredar de la clase tf.keras.callbacks.Callback y sobrescribir uno o más de sus métodos. Estos métodos corresponden a diferentes puntos en el proceso de entrenamiento, como:

on_train_begin y on_train_end: Se llaman al inicio y al final del entrenamiento.
on_epoch_begin y on_epoch_end: Se llaman al inicio y al final de cada época.
on_batch_begin y on_batch_end: Se llaman antes y después de procesar cada lote.

Al implementar estos métodos, puedes inyectar lógica personalizada en puntos específicos del proceso de entrenamiento, permitiendo un control detallado y el monitoreo del comportamiento de tu modelo. Esta flexibilidad convierte a los callbacks personalizados en una herramienta esencial para practicantes avanzados de aprendizaje profundo e investigadores.

Creación de un Callback personalizado

Un callback personalizado se puede crear heredando de la clase tf.keras.callbacks.Callback. Esta característica poderosa te permite inyectar lógica personalizada en varias etapas del proceso de entrenamiento. Al sobrescribir métodos específicos de la clase Callback, puedes ejecutar código personalizado al inicio o fin del entrenamiento, de las épocas o incluso de los lotes individuales.

Algunos métodos clave que puedes sobrescribir incluyen:

on_train_begin(self, logs=None): Llamado una vez al inicio del entrenamiento.
on_train_end(self, logs=None): Llamado una vez al final del entrenamiento.
on_epoch_begin(self, epoch, logs=None): Llamado al inicio de cada época.
on_epoch_end(self, epoch, logs=None): Llamado al final de cada época.
on_batch_begin(self, batch, logs=None): Llamado justo antes de procesar cada lote.
on_batch_end(self, batch, logs=None): Llamado al final de cada lote.

Estos métodos proporcionan acceso a detalles internos del entrenamiento a través del diccionario 'logs', lo que te permite hacer un seguimiento de métricas, modificar hiperparámetros dinámicamente o implementar comportamientos de entrenamiento complejos que no son posibles con los callbacks incorporados.

Los callbacks personalizados son particularmente útiles para tareas como implementar programaciones de tasa de aprendizaje personalizadas, registrar el progreso detallado del entrenamiento, early stopping basado en criterios complejos o incluso integrarse con herramientas externas de monitoreo. Aprovechando esta flexibilidad, puedes adaptar el proceso de entrenamiento para satisfacer los requisitos específicos de tu proyecto de aprendizaje profundo.

Ejemplo: Callback personalizado para monitorear la tasa de aprendizaje

import tensorflow as tf
from tensorflow.keras.callbacks import Callback
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.datasets import mnist
import numpy as np
import matplotlib.pyplot as plt

# Load and preprocess the MNIST dataset
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train, X_test = X_train / 255.0, X_test / 255.0
y_train = tf.keras.utils.to_categorical(y_train, 10)
y_test = tf.keras.utils.to_categorical(y_test, 10)

# Define a custom callback to log learning rates and accuracy at the end of each epoch
class LearningRateAndAccuracyLogger(Callback):
    def __init__(self):
        super().__init__()
        self.learning_rates = []
        self.accuracies = []
    
    def on_epoch_end(self, epoch, logs=None):
        current_lr = self.model.optimizer._decayed_lr(tf.float32).numpy()
        current_accuracy = logs.get('accuracy')
        self.learning_rates.append(current_lr)
        self.accuracies.append(current_accuracy)
        print(f"\nEpoch {epoch + 1}: Learning rate is {current_lr:.6f}, Accuracy is {current_accuracy:.4f}")

# Define the model
model = Sequential([
    Flatten(input_shape=(28, 28)),
    Dense(128, activation='relu'),
    Dense(64, activation='relu'),
    Dense(10, activation='softmax')
])

# Compile the model with a custom learning rate schedule
initial_learning_rate = 0.01
lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(
    initial_learning_rate,
    decay_steps=1000,
    decay_rate=0.9,
    staircase=True)
model.compile(optimizer=Adam(learning_rate=lr_schedule),
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# Instantiate the custom callback
lr_accuracy_logger = LearningRateAndAccuracyLogger()

# Train the model with the custom callback
history = model.fit(X_train, y_train, 
                    epochs=10, 
                    batch_size=32, 
                    validation_data=(X_test, y_test),
                    callbacks=[lr_accuracy_logger])

# Plot the learning rate and accuracy over epochs
plt.figure(figsize=(12, 5))
plt.subplot(1, 2, 1)
plt.plot(range(1, 11), lr_accuracy_logger.learning_rates)
plt.title('Learning Rate over Epochs')
plt.xlabel('Epoch')
plt.ylabel('Learning Rate')

plt.subplot(1, 2, 2)
plt.plot(range(1, 11), lr_accuracy_logger.accuracies)
plt.title('Accuracy over Epochs')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')

plt.tight_layout()
plt.show()

# Evaluate the model on the test set
test_loss, test_accuracy = model.evaluate(X_test, y_test, verbose=0)
print(f"\nFinal test accuracy: {test_accuracy:.4f}")

Desglose del código:

Importaciones y Preparación de Datos:
- Importamos las bibliotecas necesarias incluyendo TensorFlow, Keras y matplotlib.
- El conjunto de datos MNIST se carga y preprocesa: las imágenes se normalizan y las etiquetas se codifican en one-hot.
Definición del Callback Personalizado:
- Definimos una clase de callback personalizada LearningRateAndAccuracyLogger que hereda de Callback.
- Este callback registra tanto la tasa de aprendizaje como la precisión al final de cada época.
- Almacena estos valores en listas para su posterior visualización.
Definición del Modelo:
- Se define un modelo Sequential simple con capas Flatten y Dense.
- La arquitectura del modelo es adecuada para la tarea de clasificación de dígitos MNIST.
Compilación del Modelo:
- Utilizamos una programación personalizada de la tasa de aprendizaje (ExponentialDecay) para disminuir la tasa de aprendizaje con el tiempo.
- El modelo se compila con el optimizador Adam, pérdida de entropía cruzada categórica y métrica de precisión.
Entrenamiento del Modelo:
- El modelo se entrena durante 10 épocas con un tamaño de lote de 32.
- Utilizamos el callback personalizado LearningRateAndAccuracyLogger durante el entrenamiento.
Visualización:
- Después del entrenamiento, graficamos la tasa de aprendizaje y la precisión a lo largo de las épocas usando matplotlib.
- Esto proporciona una representación visual de cómo estos métricos cambian durante el entrenamiento.
Evaluación del Modelo:
- Finalmente, evaluamos el modelo en el conjunto de prueba para obtener la precisión final de prueba.

Este ejemplo demuestra un uso integral de callbacks personalizados en Keras. No solo registra la tasa de aprendizaje sino que también rastrea la precisión, implementa una programación personalizada de la tasa de aprendizaje e incluye la visualización de estas métricas durante el curso del entrenamiento. Este enfoque proporciona una comprensión más profunda del proceso de entrenamiento y del rendimiento del modelo.