Guardar y cargar modelos en Tensorflow

El desarrollo del modelo se puede guardar tanto antes como después de la prueba. Como resultado, un modelo continuará donde lo dejó para eliminar largos períodos de entrenamiento. Todavía puede compartir su modelo y hacer que otros lo repliquen si lo guarda. La mayoría de los profesionales del aprendizaje automático comparten lo siguiente cuando publican modelos y técnicas de prueba:

• Código para crear el modelo.
• Los pesos entrenados para el modelo.

Compartir esta información permite a otros comprender mejor cómo funciona el modelo y probarlo con nuevos datos.

Aparte de eso, enseñar los modelos de aprendizaje automático requerirá mucho tiempo y esfuerzo. Sin embargo, apagar la computadora portátil o la máquina hace que todos esos pesos y más desaparezcan a medida que se vacía la memoria. Es importante guardar los modelos para optimizar la reutilización con el fin de aprovechar al máximo su tiempo.

Tan pronto como terminemos de evaluar nuestro modelo, podemos continuar guardándolo.

Las formas en que podemos guardar y cargar nuestro modelo de aprendizaje automático son las siguientes:

• Usando la función incorporada model.save()
• Usando la función incorporada model.save_weights()

Usando el método save()

Ahora podemos guardar nuestro modelo simplemente llamando al método save() y pasando la ruta del archivo como argumento. Esto guardará el modelo

• Arquitectura modelo
• Pesos del modelo
• Estado del optimizador del modelo (para continuar desde donde lo dejamos)

Sintaxis: tensorflow.keras.X.save(ubicación/nombre_del_modelo)

• Aquí X se refiere a la subclase Sequential, Functional Model o Model. Todos ellos tienen el método save().
• La ubicación junto con el nombre del modelo se pasa como parámetro en este método. Si solo se pasa el nombre del modelo, el modelo se guarda en la misma ubicación que el archivo de Python.

Podemos cargar el modelo que se guardó usando el método load_model() presente en el módulo tensorflow.

Sintaxis: tensorflow.keras.models.load_model(ubicación/modelo_nombre)

La ubicación junto con el nombre del modelo se pasa como parámetro en este método.

NOTA: Si especificamos “.h5”, el modelo se guardará en formato hdf5; si no se especifica ninguna extensión, el modelo se guardará en formato nativo de TensorFlow.

Usando el método save_weights()

Ahora simplemente puede guardar los pesos de todas las capas usando el método save_weights(). Guarda los pesos de las capas contenidas en el modelo. Se recomienda usar el método save() para guardar modelos h5 en lugar del método save_weights() para guardar un modelo usando tensorflow. Sin embargo, los modelos h5 también se pueden guardar usando el método save_weights().

Sintaxis: tensorflow.keras.Model.save_weights(ubicación/weights_name)

La ubicación junto con el nombre de los pesos se pasa como parámetro en este método. Si solo se pasa el nombre de los pesos, se guarda en la misma ubicación que el archivo de Python.

A continuación se muestra un programa donde guardamos los pesos de un modelo inicial:

# import module
import tensorflow
 
# create object
model=tensorflow.keras.Model()
 
# assign location
path='Weights_folder/Weights'
 
# save
model.save_weights(path)

Creará una nueva carpeta llamada carpeta de pesos y guardará todos los pesos como mis pesos en formato nativo de Tensorflow. Habrá tres carpetas en total.

• punto de control: es un archivo legible por humanos con el siguiente texto,

model_checkpoint_path: "Weights"
all_model_checkpoint_paths: "Weights"

• data-00000-of-00001: Este archivo contiene los pesos reales del modelo.
• índice: este archivo le dice a TensorFlow qué pesos se almacenan y dónde.

Podemos cargar el modelo que se guardó usando el método load_weights().

Sintaxis:

tensorflow.keras.Model.load_weights(ubicación/weights_name)

La ubicación junto con el nombre de los pesos se pasa como parámetro en este método.

Nota: Al cargar pesos para un modelo, primero debemos asegurarnos de que el diseño del modelo sea correcto. No podemos cargar los pesos de un modelo (que tiene 2 capas densas) a un modelo secuencial con 1 capa densa, ya que ambos no son congruentes.

A continuación se muestra un ejemplo que muestra todos los métodos anteriores para guardar y cargar el modelo. Aquí desarrollamos un modelo y lo entrenamos usando un conjunto de datos incorporado y finalmente guardamos y cargamos el modelo nuevamente de varias maneras.

Importar los módulos.

# import required modules
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.layers import Input, Conv2D, Dense, Flatten, Dropout
from tensorflow.keras.layers import GlobalMaxPooling2D, MaxPooling2D
from tensorflow.keras.layers import BatchNormalization
from tensorflow.keras.models import Model
from tensorflow.keras.models import load_model

Cargue y divida el conjunto de datos y luego cambie algunos atributos de los datos. 

# Load in the data
cifar10 = tf.keras.datasets.cifar10
 
# Distribute it to train and test set
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
print(x_train.shape, y_train.shape, x_test.shape, y_test.shape)
 
# Reduce pixel values
x_train, x_test = x_train / 255.0, x_test / 255.0
 
# flatten the label values
y_train, y_test = y_train.flatten(), y_test.flatten()

Producción:

Desarrolla el modelo añadiendo capas.

# number of classes
K = len(set(y_train))
# calculate total number of classes for output layer
print("number of classes:", K)
 
# Build the model using the functional API
# input layer
i = Input(shape=x_train[0].shape)
x = Conv2D(32, (3, 3), activation='relu', padding='same')(i)
x = BatchNormalization()(x)
x = Conv2D(32, (3, 3), activation='relu', padding='same')(x)
x = BatchNormalization()(x)
x = MaxPooling2D((2, 2))(x)
 
x = Conv2D(64, (3, 3), activation='relu', padding='same')(x)
x = BatchNormalization()(x)
x = Conv2D(64, (3, 3), activation='relu', padding='same')(x)
x = BatchNormalization()(x)
x = MaxPooling2D((2, 2))(x)
 
x = Conv2D(128, (3, 3), activation='relu', padding='same')(x)
x = BatchNormalization()(x)
x = Conv2D(128, (3, 3), activation='relu', padding='same')(x)
x = BatchNormalization()(x)
x = MaxPooling2D((2, 2))(x)
 
x = Flatten()(x)
x = Dropout(0.2)(x)
 
# Hidden layer
x = Dense(1024, activation='relu')(x)
x = Dropout(0.2)(x)
 
# last hidden layer i.e.. output layer
x = Dense(K, activation='softmax')(x)
 
model = Model(i, x)
model.summary()

Producción:

Guarde el modelo en formato h5 usando el método save().

# saving and loading the .h5 model
 
# save model
model.save('gfgModel.h5')
print('Model Saved!')
 
# load model
savedModel=load_model('gfgModel.h5')
savedModel.summary()

 Producción: 

 Guarde los pesos del modelo usando el método save_weights(). 

# saving and loading the model weights
 
# save model
model.save_weights('gfgModelWeights')
print('Model Saved!')
 
# load model
savedModel = model.load_weights('gfgModelWeights')
print('Model Loaded!')

Producción:

Guarde el modelo en formato h5 utilizando el método save_weights().

# saving and loading the .h5 model
 
# save model
model.save_weights('gfgModelWeights.h5')
print('Model Saved!')
 
# load model
savedModel = model.load_weights('gfgModelWeights.h5')
print('Model Loaded!')

Producción:

El modelo anterior fue desarrollado en Google colab. Entonces, al guardar los modelos, se almacenan temporalmente y se pueden descargar. A continuación se muestran los modelos y pesos guardados: