Aunque logres entrenar la mejor arquitectura de todas y encontrar los mejores parámetros posibles, si cierras tu notebook, pierdes todo el progreso. Es de vitar importancia conocer cómo cargar y descargar nuestros modelos.

Los modelos tienen 3 componentes principales: La arquitectura (que define la cantidad de capas, neuronas y entradas de la red), los pesos (que son los valores que se entrenan a la red) y las etiquetas (estas se usan especialmente en transfer learning para dar contexto al modelo).

Indaguemos en el código sobre cómo cargar y descargar modelos.

Cargando y descargando arquitecturas sin pesos

Puedes usar la arquitectura de un modelo para basarte a la hora de entrenar otros modelos, esto no traerá los pesos, por lo que no será útil para realizar predicciones.

Con el método get_config de tus modelos puedes adquirir un JSON completo con la información de la arquitectura de tu red.

fullscreen
config_dict = hypermodel.get_config()

Para cargar un modelo con base en esta configuración basará con usar el método from_config de los modelos secuenciales de Keras enviando como parámetro el JSON de configuración.

fullscreen
model_same_config = tf.keras.Sequential.from_config(config_dict)

Si resumimos el nuevo modelo nos encontraremos con las mismas dimensiones que el original.

fullscreen
model_same_config.summary()

Descargando arquitecturas con pesos

Para guardar arquitecturas con pesos es necesario usar el callback de ModelCheckpoint que nos permitirá guardar en disco el modelo con sus pesos.

fullscreen
from tensorflow.keras.callbacks import ModelCheckpoint

Crearemos un modelo vacío que guardaremos después.

fullscreen
model_weight = get_model()
model_weight.compile(optimizer = "adam", loss = "categorical_crossentropy", metrics = ["accuracy"])

Crearemos la configuración para nuestro callback. Definimos el path donde se guardará el modelo, cada cuando se guardará, si solo guardará los pesos y el output de texto a recibir.

fullscreen
checkpoint_path = "model_checkpoints/checkpoint"

checkpoint_weight = ModelCheckpoint(
    filepath = checkpoint_path,
    frecuency = "epoch",
    save_weight_only = True,
    verbose = 1
)

Entrenaremos el modelo sin olvidar agregar el callback.

fullscreen
history_weight = model_weight.fit(
    train_generator, 
    epochs = 20,
    callbacks = [checkpoint_weight],
    validation_data = validation_generator
)

Con esto hemos guardado un historial entero de nuestro modelo, puedes revisarlo en el directorio model_checkpoints/checkpoint.

Si deseas guardar manualmente los pesos de tu red lo puedes haces con el método save indicando el directorio de salida. Esta manera únicamente guardará la última iteración, por lo que si por alguna razón la red sufrió un daño en esta etapa, no podrás revertirlo (a comparación del callback que guarda el historial entero).

fullscreen
model_weight.save("model_manual/my_model")

Cargando arquitectura con pesos

Crearemos un nuevo modelo hueco con la misma estructura que el original.

fullscreen
model_weights2 = get_model()
model_weights2.compile(optimizer = "adam", loss = "categorical_crossentropy", metrics = ["accuracy"])

Para cargar el modelo desde disco nos basta con usar el método load_weights indicando la locación a cargar.

fullscreen
model_weights2.load_weights(checkpoint_path)

Si evaluamos el desempeño del modelo original y el cargado nos daremos cuenta que son literalmente el mismo, reafirmando que el proceso de carga fue correcto.

fullscreen
model_weights2.evaluate(test_generator)
57/57 [==============================] - 3s 41ms/step - loss: 0.9109 - accuracy: 0.8494
[0.9108972549438477, 0.8494144082069397]

model_weight.evaluate(test_generator)
57/57 [==============================] - 2s 31ms/step - loss: 0.9109 - accuracy: 0.8494
[0.9108973145484924, 0.8494144082069397]

Ya conoces cómo cargar y descargar arquitecturas huecas o con pesos (en historial o de una sola época), ahora indagaremos sobre las mejores decisiones a la hora de cargar modelos.

Contribución creada por Sebastián Franco Gómez.