Guarde sus modelos para más tarde con Serialización

Dado que los modelos de aprendizaje profundo pueden tomar horas, días e incluso semanas para entrenar, es importante saber cómo guardarlos y cargarlos desde el disco.

Descripción general del tutorial

Keras da la posibilidad de guardar su arquitectura de modelo y guardar los pesos del modelo. Los pesos de los modelos se guardan en formato HDF5. Este es un formato de cuadrícula que es ideal para almacenar matrices multidimensionales de números. La estructura modelo puede describirse y grabarse (y cargarse) utilizando dos formatos diferentes: JSON y YAML.
Cada ejemplo también demostrará cómo guardar y cargar los pesos de sus modelos con formato HDF5. Los ejemplos utilizarán la misma red simple formada en el conjunto de datos de clasificación binaria de la diabetes de los indios Pima.

Formato HDF5

El Formato de Datos Jerárquico o HDF5 es un formato de almacenamiento de datos flexible y eso es conveniente para almacenar grandes matrices de valores reales, como lo tenemos en los pesos de las redes neuronales. Puede que necesite instalar el soporte de Python para el formato HDF5. Puede hacerlo utilizando su sistema de gestión de paquetes Python preferido, como Pip:

pip install h5py

Guarde su modelo de red neuronal en JSON

JSON es un formato de fichero simple para describir datos jerárquicamente. Keras proporciona la capacidad de describir cualquier modelo usando el formato JSON con una función to_json(). Esto se puede guardar y luego ser cargado a través de la función model_from_json() que creará un nuevo modelo a partir de la especificación de JSON.

Los pesos se memorizan directamente desde el modelo mediante la función save_weights() y se cargan posteriormente mediante la función load_weights(). El siguiente ejemplo muestra los entrenamientos y evalúa un modelo simple sobre el conjunto de datos de los indios Pima. A continuación, se convierte la estructura modelo al formato JSON y escrito en model.json en el directorio local. Los pesos de la red son escrito con model.h5 en el directorio local.

El modelo y los datos de peso se cargan desde las lecciones guardadas y se crea un nuevo modelo. Es importante compilar el modelo cargado antes de usarlo. Esto es para que las predicciones hechas usando el modelo tengan la eficiente computación apropiada desde el backend de Keras. El modelo es evaluado de la misma manera imprimiendo la misma puntuación.

# MLP con datos de la tribu PIMA Serializado para JSON y HDF5
from keras.models import Sequential
from keras.layers import Dense
from keras.models import model_from_json
import numpy
# semilla aleatoria
numpy.random.seed(7)
# cargamos los datos
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
# se dividen los datos de entrada (X) y los de salida(Y)
X = dataset[:,0:8]
Y = dataset[:,8]
# crea el modelo
model = Sequential()
model.add(Dense(12, input_dim=8, kernel_initializer='uniform', activation='relu'))
model.add(Dense(8, kernel_initializer='uniform', activation='relu'))
model.add(Dense(1, kernel_initializer='uniform', activation='sigmoid'))
# Se Compila el model
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
# ajusta el modelo
model.fit(X, Y, epochs=150, batch_size=10, verbose=0)
# evalua el modelo
scores = model.evaluate(X, Y, verbose=0)
print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
# serializa el modelo para JSON
model_json = model.to_json()
with open("model.json", "w") as json_file:
  json_file.write(model_json)
#serializan los pesos (weights) para HDF5
model.save_weights("model.h5")
print("Modelo guardado en el PC")
# despues...
# carga el json y crea el modelo
json_file = open('model.json', 'r')
loaded_model_json = json_file.read()

json_file.close()
loaded_model = model_from_json(loaded_model_json)
# se cargan los pesos (weights) en el nuevo modelo
loaded_model.load_weights("model.h5")
print("Modelo cargado desde el PC")
# se evalua el modelo cargado con los datos de los test
loaded_model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy'])
score = loaded_model.evaluate(X, Y, verbose=0)
print("%s: %.2f%%" % (loaded_model.metrics_names[1], score[1]*100))

Al ejecutar este ejemplo se obtiene el resultado que se muestra a continuación. Muestra en primer lugar la precisión del modelo entrenado, el almacenamiento del modelo en disco en formato JSON, la carga del modelo y, en segundo lugar, la reevaluación del modelo cargado logrando la misma precisión.

acc: 75.91%
Modelo guardado en el PC
Modelo cargado desde el PC
acc: 75.91%

Si tienes curiosidad puedes abrir el formato JSON del modelo.

Guarde su modelo de red neuronal en YAML

Este ejemplo es muy parecido al ejemplo JSON anterior, excepto que se utiliza el formato YAML para la especificación del modelo. El modelo se describe usando YAML, guardado en model.yaml y luego cargado en un nuevo modelo a través de la función model_from_yaml(). Los pesos se manejan de la misma manera que arriba en formato HDF5 como model.h5.

# MLP con datos de la tribu PIMA Serializado para YAML y HDF5
from keras.models import Sequential
from keras.layers import Dense
from keras.models import model_from_yaml
import numpy
# semilla aleatoria
seed = 7
numpy.random.seed(seed)
# cargamos los datos
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
# dividimos entre las entradas (X) y las salidas (Y)
X = dataset[:,0:8]
Y = dataset[:,8]
# crea el modelo
model = Sequential()
model.add(Dense(12, input_dim=8, kernel_initializer='uniform', activation='relu'))
model.add(Dense(8, kernel_initializer='uniform', activation='relu'))
model.add(Dense(1, kernel_initializer='uniform', activation='sigmoid'))
# Compila el modelo
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
# Ajusta el modelo
model.fit(X, Y, epochs=150, batch_size=10, verbose=0)
# evalua el modelo
scores = model.evaluate(X, Y, verbose=0)
print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
# serializa el modelo para YAML
model_yaml = model.to_yaml()
with open("model.yaml", "w") as yaml_file:
  yaml_file.write(model_yaml)
# serializa los pesos(weights) para HDF5
model.save_weights("model.h5")

print("Modelo guardado al PC")
# despues...
#carga del YAML y crea el modelo
yaml_file = open('model.yaml', 'r')
loaded_model_yaml = yaml_file.read()
yaml_file.close()
loaded_model = model_from_yaml(loaded_model_yaml)
# cargamos los pesos (weights) en el nuevo modelo
loaded_model.load_weights("model.h5")
print("Modelo cargado desde el PC")
# evalua el modelo con los datos test
loaded_model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy'])
score = loaded_model.evaluate(X, Y, verbose=0)
print("%s: %.2f%%" % (loaded_model.metrics_names[1], score[1]*100))

Al ejecutar el ejemplo se muestra la salida a continuación. Una vez más, el ejemplo demuestra la precisión del modelo, la serialización, deserialización y reevaluación del modelo logrando los mismos resultados.

acc: 76.56%
Modelo guardado al PC
Modelo cargado desde el PC
acc: 76.56%

Igual que antes te invitamos a que abras el archivo YAML y mires lo que hay dentro en caso de curiosidad.

Resumen sobre el post “Guarde modelos con Serialización”

Guardar y cargar modelos son una capacidad importante para transplantar un modelo de Deep Learning en la investigación y el desarrollo a las operaciones. En esta lección usted descubrió cómo serializar sus modelos de aprendizaje profundo de Keras. Aprendiste:

• Cómo guardar los pesos de los modelos en les con formato HDF5 y cargarlos de nuevo más tarde.
• Cómo guardar las definiciones del modelo de Keras en JSON y cargarlas de nuevo.
• Cómo guardar las definiciones del modelo Keras en YAML y cargarlas de nuevo.

➡ Aprende mucho mas de Deep Learnign en nuestro curso:

Curso de Deep Learning