Almacenamiento y carga de modelos: pesos y arquitectura

Curso Profesional de Redes Neuronales con TensorFlow

Contenido del curso

Cómo utilizar TensorFlow 2.0 con Python

Manejo y preprocesamiento de datos para redes neuronales

Optimización de precisión de modelos

Almacenamiento y carga de modelos

Fundamentos de aprendizaje por transferencia

Resultados de entrenamiento

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0012:20

Almacenamiento y carga de modelos: pesos y arquitectura

Curso Profesional de Redes Neuronales con TensorFlow

Clase 18 de 28

Clase 18 / 28

Recursos

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.

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.

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

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

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.

from tensorflow.keras.callbacks import ModelCheckpoint

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

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.

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.

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).

model_weight.save("model_manual/my_model")

Cargando arquitectura con pesos

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

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.

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.

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.

FELIX DAVID CORDOVA GARCIA

Hace 5 años

¿En el minuto 10:08 se menciona que puedes guardar los pesos de una interación en específica, la numero 7, como se hace eso? ¿Como elegir guardar los pesos de una epoca en especifico? Yo se que se puede guardar la mejor configuración pero eso es otra historia

Adonai Vera

Profesor

Hace 5 años

Hola Felix David Excelente pregunta, la clave principa es utilizar checkpoints durante el proceso de entrenamiento. Durante la instancia del checkpoint debes definir que metricas vas a tener en cuenta, y a su vez definir las rutas de almacenamiento, lo que te permitira ir almacenando los modelos en cada epochs. Tu mismo creas los criterios, si quieres almacenar unicamente los epochs en donde el accuracy de validación sea el mas alto puedes definir esa parametro.

Te dejo por aca más documentación: https://www.tensorflow.org/tutorials/keras/save_and_load#save_checkpoints_during_training En el apartado: Save checkpoints during training

Y a su vez un pequeño script para inicializar el checkpoint y en este caso almacena unicamente los pesos, teniendo en cuenta el accuracy de validación y buscando que sea lo maximo posible.

checkpoint_path = "training_1/cp.ckpt"
checkpoint_dir = os.path.dirname(checkpoint_path)

# Create a callback that saves the model's weights
cp_callback = tf.keras.callbacks.ModelCheckpoint(
    filepath=checkpoint_filepath,
    save_weights_only=True,
    monitor='val_accuracy',
    mode='max',
    save_best_only=True)

# Train the model with the new callback
model.fit(train_images, 
          train_labels,  
          epochs=10,
          validation_data=(test_images, test_labels),
          callbacks=[cp_callback])  # Pass callback to training

Revisalo y me cuentas que tal. Saludos

Comentarios (11)11 comentarios

luis fernando Tapia

frank hurtado

Henry Mendiburu Díaz

Daniel Alejandro Lopez

Raul Perez-Alejo Neyra

Hace 4 años

Juan Acevedo

Hace un año

MARIO AYALA

Brian Chuquiruna

Hace 2 años

Platzi

Robert Yesid Barrios Acendra

Jefferson Conza

Jhon Freddy Tavera Blandon

Hace 3 años

Daniel de Jesús Martínez Vega

Cómo utilizar TensorFlow 2.0 con Python

Redes Neuronales y TensorFlow: Crea Modelos de IA desde Cero

Programación con TensorFlow 2 y Python: Fundamentos y Aplicaciones

Manejo y preprocesamiento de datos para redes neuronales

Carga y Procesamiento de Bases de Datos en Inteligencia Artificial

Carga de Bases de Datos JSON desde GCP en Google Colab

Codificación Base64 y Gestión de Imágenes en Google Colab

Preprocesamiento y limpieza de datos

Keras datasets

Datasets generators

Aprende a buscar bases de datos para deep learning

Cómo distribuir los datos

Crear la red neural, definir capas, compilar, entrenar, evaluar y predicciones

Optimización de precisión de modelos

Métodos de regularización: overfitting y underfitting

Recomendaciones prácticas para ajustar un modelo

Métricas para medir la eficiencia de un modelo: callback

Monitoreo del entrenamiento en tiempo real: early stopping y patience

KerasTuner: construyendo el modelo

KerasTuner: buscando la mejor configuración para tu modelo

Almacenamiento y carga de modelos

Almacenamiento y carga de modelos: pesos y arquitectura

Criterios para almacenar los modelos

Fundamentos de aprendizaje por transferencia

Introducción al aprendizaje por transferencia

Cuándo utilizar aprendizaje por transferencia

Carga de sistemas pre-entrenados en Keras

API funcional de Keras

Uso sistemas pre-entrenados de TensorFlow Hub

Resultados de entrenamiento

Introducción a variables relevantes del TensorBoard

Análisis y publicación de resultados del entrenamiento

Introducción al despliegue de modelos en producción

Siguientes pasos con deep learning

Almacenamiento y carga de modelos: pesos y arquitectura