python - tutorial - tensorflow español

Cargar un modelo Keras entrenado y continuar entrenando

Question

Me preguntaba si era posible guardar un modelo Keras parcialmente entrenado y continuar el entrenamiento después de cargar el modelo nuevamente.

La razón de esto es que tendré más datos de entrenamiento en el futuro y no quiero volver a entrenar todo el modelo nuevamente.

Las funciones que estoy usando son:

#Partly train model
model.fit(first_training, first_classes, batch_size=32, nb_epoch=20)

#Save partly trained model
model.save(''partly_trained.h5'')

#Load partly trained model
from keras.models import load_model
model = load_model(''partly_trained.h5'')

#Continue training
model.fit(second_training, second_classes, batch_size=32, nb_epoch=20)

Edición 1: ejemplo completamente funcional agregado

Con el primer conjunto de datos después de 10 épocas, la pérdida de la última época será de 0.0748 y la precisión de 0.9863.

Después de guardar, eliminar y volver a cargar el modelo, la pérdida y la precisión del modelo entrenado en el segundo conjunto de datos será 0.1711 y 0.9504 respectivamente.

¿Es esto causado por los nuevos datos de capacitación o por un modelo completamente reentrenado?

"""
Model by: http://machinelearningmastery.com/
"""
# load (downloaded if needed) the MNIST dataset
import numpy
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense
from keras.utils import np_utils
from keras.models import load_model
numpy.random.seed(7)

def baseline_model():
    model = Sequential()
    model.add(Dense(num_pixels, input_dim=num_pixels, init=''normal'', activation=''relu''))
    model.add(Dense(num_classes, init=''normal'', activation=''softmax''))
    model.compile(loss=''categorical_crossentropy'', optimizer=''adam'', metrics=[''accuracy''])
    return model

if __name__ == ''__main__'':
    # load data
    (X_train, y_train), (X_test, y_test) = mnist.load_data()

    # flatten 28*28 images to a 784 vector for each image
    num_pixels = X_train.shape[1] * X_train.shape[2]
    X_train = X_train.reshape(X_train.shape[0], num_pixels).astype(''float32'')
    X_test = X_test.reshape(X_test.shape[0], num_pixels).astype(''float32'')
    # normalize inputs from 0-255 to 0-1
    X_train = X_train / 255
    X_test = X_test / 255
    # one hot encode outputs
    y_train = np_utils.to_categorical(y_train)
    y_test = np_utils.to_categorical(y_test)
    num_classes = y_test.shape[1]

    # build the model
    model = baseline_model()

    #Partly train model
    dataset1_x = X_train[:3000]
    dataset1_y = y_train[:3000]
    model.fit(dataset1_x, dataset1_y, nb_epoch=10, batch_size=200, verbose=2)

    # Final evaluation of the model
    scores = model.evaluate(X_test, y_test, verbose=0)
    print("Baseline Error: %.2f%%" % (100-scores[1]*100))

    #Save partly trained model
    model.save(''partly_trained.h5'')
    del model

    #Reload model
    model = load_model(''partly_trained.h5'')

    #Continue training
    dataset2_x = X_train[3000:]
    dataset2_y = y_train[3000:]
    model.fit(dataset2_x, dataset2_y, nb_epoch=10, batch_size=200, verbose=2)
    scores = model.evaluate(X_test, y_test, verbose=0)
    print("Baseline Error: %.2f%%" % (100-scores[1]*100))

Answer 1

El problema podría ser que usa un optimizador diferente, o argumentos diferentes para su optimizador. Acabo de tener el mismo problema con un modelo pre-entrenado personalizado, usando

reduce_lr = ReduceLROnPlateau(monitor=''loss'', factor=lr_reduction_factor,
                              patience=patience, min_lr=min_lr, verbose=1)

para el modelo preentrenado, por el cual la tasa de aprendizaje original comienza en 0.0003 y durante la capacitación previa se reduce a la tasa de aprendizaje mínimo, que es 0.000003

Acabo de copiar esa línea en el script que usa el modelo pre-entrenado y obtuve muy malas precisiones. Hasta que noté que la última tasa de aprendizaje del modelo previamente entrenado era la tasa de aprendizaje mínima, es decir, 0.000003. Y si empiezo con esa tasa de aprendizaje, obtengo exactamente las mismas precisiones para comenzar como la salida del modelo pre-entrenado, lo cual tiene sentido, ya que comenzar con una tasa de aprendizaje que es 100 veces mayor que la última tasa de aprendizaje utilizada en el modelo resultará en un gran sobreimpulso de GD y, por lo tanto, en precisiones muy disminuidas.

Answer 2

En realidad, model.save guarda toda la información necesaria para reiniciar la capacitación en su caso. Lo único que podría estropearse al recargar el modelo es su estado de optimizador. Para comprobar eso, intente save y volver a cargar el modelo y entrenarlo en los datos de entrenamiento.

Answer 3

También podría estar golpeando Concept Drift, consulte En caso de que vuelva a entrenar un modelo cuando haya nuevas observaciones disponibles . También existe el concepto de olvido catastrófico que discuten un montón de artículos académicos. Aquí hay uno con MNIST Investigación empírica del olvido catastrófico

Answer 4

Tenga en cuenta que Keras a veces tiene problemas con los modelos cargados, como here . Esto podría explicar casos en los que no se parte de la misma precisión entrenada.

Answer 5

Todo lo anterior ayuda, debe reanudar desde la misma tasa de aprendizaje () que el LR cuando se guardaron el modelo y los pesos. Configúrelo directamente en el optimizador.

Tenga en cuenta que la mejora desde allí no está garantizada, porque el modelo puede haber alcanzado el mínimo local, que puede ser global. No tiene sentido reanudar un modelo para buscar otro mínimo local, a menos que intente aumentar la tasa de aprendizaje de manera controlada y empujar el modelo a un mínimo posiblemente mejor no muy lejos.