Callbacks y TensorBoard (Redes neuronales)

Como vimos en la anterior entrada, para entrenamientos muy largos podemos salvar el modelo en mitad del entrenamiento utilizando callbacks

El método fit() acepta el argumento callbacks que nos permite especificar la lista de objetos que Keras llamará al comienzo y al final de su entrenamiento y al comienzo y final de cada época e incluso antes y después de procesar cada lote. Por ejemplo ModelCheckpoint salva los puntos de chequeo (checkpoints) de nuestro modelo a intervalos regulares durante el entrenamiento, por defecto al principio y al final de cada época.

En la entrada anterior donde entrenábamos el modelo podemos hacer 

checkpoint_cb = keras.callbacks.ModelCheckpoint("mi_modelo_keras.h5", save_best_only=True)

history = model.fit(train_data, train_labels, epochs=30,

validation_data=(test_data , test_labels), callbacks=[checkpoint_cb])

Si utilizamos un set de validación durante el entrenamiento, podemos definir el parámetro save_best_only=True en la definición del ModelCheckpoint. Si definimos este parámetro sólo salvará el modelo en su mejor ejecución, de modo que no debemos preocuparnos de entrenamientos demasiado largos o de sobrecargar el set de entrenamiento: simplemente restauraremos el último modelo salvado después del entrenamiento y este modelo será el mejor modelo del set de entrenamiento.

#restauramos la mejor ejecución del modelo

model = keras.models.load_model("mi_modelo_keras.h5")

Este sistema se conoce como early stopping. Consiste en parar el entrenamiento tan pronto como el error de validación alcanza un mínimo.

Otra forma de implementar early stopping es utilizar la llamada EarlyStopping. Esto interrumpirá el entrenamiento cuando no detecte progreso en el set de validación durante un número de épocas (llamado el argumento de la paciencia) y que opcionalmente nos devuelve al mejor modelo. Podemos combinar ambas técnicas para salvar los checkpoints del modelo en caso de que el ordenador se  cuelgue o se apague inesperadamente y al mismo tiempo parar el entrenamiento cuando no detecte más progreso, para evitar pérdidas de tiempo y de recursos.

#early stopping

early_stopping_cb = keras.callbacks.EarlyStopping(patience=10,

                                                  restore_best_weights=True)

history = model.fit(train_data, train_labels, epochs=100,

                    validation_data=(test_data , test_labels),

                    callbacks=[checkpoint_cb, early_stopping_cb])

En este caso, el número de épocas puede ser grande, pues el entrenamiento se detendrá automáticamente cuando no haya más progreso. Además no es necesario restaurar el mejor modelo salvado  por que EarlyStopping mantendrá los mejores pesos y los restaurará automáticamente al final del entrenamiento.

Hay más callbacks disponibles en keras.callbacks.

Si necesitamos control extra, podemos fácilmente definir nuestros propios callbacks. Por ejemplo si queremos definir un callback que muestre la relación entre la validación y la pérdida durante el entrenamiento (por ejemplo para detectar el sobreentrenamiento)

#customizar un callback

class PrintValTrainRatioCallback(keras.callbacks.Callback):

    def on_epoch_end(self, epoch, logs):

        print("\nval/train: {:.2f}".format(logs["val_loss"] / logs["loss"]))

 

val_train_ratio_cb = PrintValTrainRatioCallback()

history = model.fit(train_data, train_labels, epochs=1,

                    validation_data=(test_data , test_labels),

                    callbacks=[val_train_ratio_cb])

Además de on_epoch_end podemos utilizar otros callbacks como on_epoch_begin, on_batch_begin, on_batch_end, pueden utilizarse durante la evaluación y predicciones por ejemplo como depuración. 

Tensorboard para visualización

Tensorboard es una herramienta de visualización interactiva que nos permite ver las curvas de aprendizaje entre diferentes ejecuciones, analiza estadísticas de entrenamiento y visualiza datos complejos multidimensionales  y en 3D. Esta herramienta se instala automáticamente con la instalación de Tensorflow. 

Para utilizarlo debemos modificar las salidas del programa que deseamos visualizar. Debemos adaptarlas a un tipo de archivo de log binario llamado event files (ficheros de eventos). Cada fichero binario es llamado summary (resumen). El servidor TensorBoard monitorizará el directorio de log y automáticamente tomará los cambios y los visualizará. Esto nos permitirá visualizar los datos en tiempo real (con un pequeño retraso), tales como las curvas de aprendizaje. En general debemos apuntar el servidor de TensorBoard a un directorio raíz de log y configurar el programa, de modo que se escribirá en un subdirectorio diferente cada vez que los ejecutemos. Esto nos permitirá visualizar y comparar datos de múltiples ejecuciones de nuestro programa , sin tenerlo todo mezclado.

Comenzaremos definiendo el directorio de log que utilizaremos para TensorBoard. Además crearemos una pequeña función que generará un subdirectorio basado en la fecha y hora actuales en cada diferente ejecución. Además debemos incluir información extra en el subdirectorio, tal como puede ser el nombre del directorio o información sobre diferentes hiperparámetros, de modo que después nos resulte sencillo encontrar la información en su correspondiente directorio.

import os

root_logdir = os.path.join(os.curdir, "mis_logs")

def get_run_logdir():

    import time

    run_id = time.strftime("run_%Y_%m_%d-%H_%M_%S")

    return os.path.join(root_logdir, run_id)

 

run_logdir = get_run_logdir()

run_logdir

checkpoint_cb = keras.callbacks.ModelCheckpoint("mi_modelo_keras.h5", save_best_only=True)

tensorboard_cb = keras.callbacks.TensorBoard(run_logdir)

history = model.fit(train_data, train_labels, epochs=30,

                    validation_data=(test_data, test_labels),

                    callbacks=[tensorboard_cb])

Y esto es todo, una vez ejecutado este código el callback TensorBoard(() se ha encargado de crear una estructura de directorios y durante el entrenamiento crea archivos de eventos y escribe resúmenes sobre ellos, después de correr el programa una segunda vez (quizás después de cambiar algún valor de un hiperparámetro) encontraremos una estructura de directorios similar a esta:

Mis_logs

-run_2021_06_27-17_14_44

-train

-plugins/profile/2021_06_27_15_14_46

-validation

Hay un directorio por cada ejecución, cada uno contiene un subdirectorio para los logs de entrenamiento y uno para los logs de validación.  Ambos contienen archivos de evento. Esto permite a TensorBoard mostrarnos exactamente el tiempo que el modelo ha consumido en cada parte del modelo  en cada dispositivo (si hay varios dispositivos) lo cual es muy útil por ejemplo para detectar posibles cuellos de botella.

Servidor TensorBoard

El siguiente paso es activar el servidor de TensoBoard, se puede hacer por comando en un terminal. Si hemos instalado TensorFlow dentro de un entorno virtual deberíamos tenerlo ya activado

Por comandos sería algo así

 

Una vez activado y después de entrenar nuestro modelo, basta con abrir un navegador y teclear http://localhost:6006

Con esto obtendremos una pantalla similar a esta

 

Vemos el interfaz web de TensorBoard. Tenemos dos pestañas, Scalars y Graphs. Abajo a la izquierda podemos seleccionar los logs que queremos visualizar. Tambien podemos elegir el gráfico y otras opciones del mismo.