Mantenga a los mejores modelos durante Entrenamiento con Checkpointing

Los modelos de aprendizaje profundo pueden tardar horas, días o incluso semanas en entrenarse y si se interrumpe un curso de entrenamiento inesperadamente, puedes perder mucho trabajo.

Checkpointing de modelos de Redes Neuronales

El Checkpointing es una técnica de tolerancia a fallos para procesos de larga duración. Es donde se toma una instantánea del estado del sistema en caso de fallo. Si hay un problema, no todo está perdido. El punto de control puede utilizarse directamente como punto de partida para un nuevo recorrido, retomando donde se dejó. Al entrenar modelos de Deep Learning, el punto de control captura los pesos del modelo. Estos pesos pueden ser usados para hacer predicciones tal cual, o usados como base para la formación continua.
La librería Keras proporciona una capacidad de chequeo por medio de una API de devolución de llamada. El ModelCheckpoint devolución de llamada (callbacks) le permite determinar dónde controlar el peso de los modelos, cómo debe ser el peso del modelo y bajo qué circunstancias hacer un punto de control del modelo. La API permite especificar que métrica supervisar, como la pérdida o la precisión de la formación o la validación conjunto de datos. Puede especificar si desea buscar una mejora en la maximización o minimización del marcador. Por último, el nombre del archivo que se utiliza para almacenar los pesos puede incluir variables como la variable número de época (epoch). La instancia de ModelCheckpoint se puede pasar a la formación al llamar a la función fit() en el modelo. Nota, es posible que necesite instalar el h5py (para instalar ve aquí).

Mejoras en el modelo de red neuronal de Checkpoint

Un buen uso del checkpointing es sacar los pesos de los modelos cada vez que se produce una mejora observada durante el entrenamiento. El siguiente ejemplo crea una pequeña red neuronal para los indios Pima con el problema de clasificación binaria de la diabetes (ver el post). En el ejemplo se utiliza el 33% de los datos para la validación.
La función Checkpointing está configurada para guardar los pesos de la red sólo cuando hay una mejora en precisión de la clasificación en el conjunto de datos de validación (monitor=’val_acc’ y mode=’max’). Los pesos se almacenan en el archivo peso-mejoramiento-epoch-val_acc=.2f.hdf5.

# Checkpoint de pesos cuando la validacion mejora 
from keras.models import Sequential
from keras.layers import Dense
from keras.callbacks import ModelCheckpoint
import numpy
# semilla aleatoria
seed = 7
numpy.random.seed(seed)
# cargamos los datos
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
# dividimos
X = dataset[:,0:8]
Y = dataset[:,8]
# creacion del 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'))
# Compilacion del modelo
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
# checkpoint
filepath="weights-improvement-{epoch:02d}-{val_acc:.2f}.hdf5"
checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=1, save_best_only=True, mode='max')
callbacks_list = [checkpoint]
# Fit el modelo
model.fit(X, Y, validation_split=0.33, epochs=150, batch_size=10, callbacks=callbacks_list, verbose=0)

Al ejecutar el ejemplo se obtiene la siguiente salida, truncada por brevedad. En la salida se pueden ver casos en los que una mejora en la precisión del modelo en el conjunto de datos de validación resultó en una nueva ponderación que se escribía en el disco.

Epoch 00062: val_acc did not improve from 0.74016

Epoch 00063: val_acc did not improve from 0.74016

Epoch 00064: val_acc improved from 0.74016 to 0.74016, saving model to pesos-mejoras-64-0.74.hdf5

Epoch 00065: val_acc did not improve from 0.74016

Epoch 00066: val_acc improved from 0.74016 to 0.76772, saving model to pesos-mejoras-66-0.77.hdf5

Epoch 00067: val_acc did not improve from 0.76772

Epoch 00068: val_acc did not improve from 0.76772

Epoch 00069: val_acc did not improve from 0.76772

Epoch 00070: val_acc did not improve from 0.76772

También verá un número de les en su directorio de trabajo que contiene los pesos de red en formato HDF5. Por ejemplo:

pesos-mejoras-64-0.74.hdf5

pesos-mejoras-66-0.77.hdf5

Esta es una estrategia de control muy simple. Puede crear muchos puntos de control innecesarios si la precisión de la validación sube y baja durante las épocas de formación. Sin embargo, se asegurará de que tiene una instantánea del mejor modelo descubierto durante su ejecución.

El mejor modelo de red neuronal con Checkpoint

Una estrategia de checkpoint sencilla es grabar los pesos de los modelos en el mismo nivel, siempre y cuando mejore la precisión de la validación. Esto se puede hacer fácilmente usando el mismo código desde arriba y cambiando el nombre de salida para que sea fijo (sin incluir información de puntuación o época). En este caso, los pesos de los modelos se escriben en los archivos como pesos.mejores.hdf5 sólo si la precisión de la clasificación del modelo en el conjunto de datos de validación mejora con respecto a la mejor vista hasta ahora.

from keras.models import Sequential
from keras.layers import Dense
from keras.callbacks import ModelCheckpoint
import numpy
# Fijar las semillas aleatorias para la reproducibilidad
seed = 7
numpy.random.seed(seed)
# cargar conjunto de datos de pima indians
dataset = numpy.loadtxt("pima.csv", delimiter=",")
# split into input (X) and output (Y) variables
X = dataset[:,0:8]
Y = dataset[:,8]
# crear 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'))
# Compilacion del modelo
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
# checkpoint
filepath="pesos.mejores.hdf5"
checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=1, save_best_only=True,mode='max')
callbacks_list = [checkpoint]
# Fit el modelo
model.fit(X, Y, validation_split=0.33, epochs=150, batch_size=10, callbacks=callbacks_list,verbose=0)

Entonces ahora en nuestro directoria deberíamos ver solo un archivo llamado pesos.mejores.hdf5

Cargando un Modelo de Red Neural Guardado

Ahora que hemos visto cómo controlar sus modelos de aprendizaje profundo durante la capacitación, necesita revisar cómo cargar y utilizar un modelo de checkpointed. El checkpoint sólo incluye los pesos de los modelos. Supone que conoce la estructura de grafo. Esto también puede ser serializado a un archivo en formato JSON o YAML. En el siguiente ejemplo, se conoce la estructura del modelo y se cargan los mejores pesos del experimento anterior, almacenados en el directorio de trabajo en el archivo pesos.mejores.hdf5 . El modelo se utiliza para hacer predicciones sobre todo el conjunto de datos.

# Cómo cargar y utilizar las pesas desde un checkpoint
from keras.models import Sequential
from keras.layers import Dense
import numpy
# Fijar las semillas aleatorias para la reproducibilidad
seed = 7
numpy.random.seed(seed)
# creacion del 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'))
# cargamos los pesos
model.load_weights("pesos.mejores.hdf5")
# Compilamos el modelo (requerido para hacer predicciones)
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
print("Modelo creado y pesos cargados del archivo")
# cargamos pima indians dataset
dataset = numpy.loadtxt("pima.csv", delimiter=",")
# dividido en variables de entrada (X) y salida (Y)
X = dataset[:,0:8]
Y = dataset[:,8]
# estimamos la precisión de todo el conjunto de datos utilizando los pesos cargados
scores = model.evaluate(X, Y, verbose=0)
print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))

Modelo creado y pesos cargados del archivo
acc: 77.34%

Resumendel post “Entrenamiento con Checkpointing”

En esta lección usted ha descubierto la importancia de revisar los modelos de aprendizaje profundo para carreras de entrenamiento largas. Aprendiste:

• Cómo usar Keras para controlar cada vez que se observa una mejora en el modelo.
• Cómo controlar sólo el mejor modelo observado durante el entrenamiento.
• Cómo cargar un modelo de puntos de control desde le y usarlo más tarde para hacer predicciones.

➡ ¿Quieres seguir aprendiendo de Inteligencia Artificial? Ingresa a nuestro curso de Deep Learning:

Curso de Deep Learning