Charger un modèle Keras formé et continuer la formation
la raison en est que j'aurai plus de données de formation à l'avenir et je ne veux pas retravailler tout le modèle à nouveau.
Les fonctions que j'utilise sont:
#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)
Edit 1: ajout de travail entièrement exemple
<!-Avec le premier ensemble de données après 10 époques la perte de la dernière époque sera 0.0748 et l'exactitude 0.9863.après enregistrement, suppression et rechargement du modèle, la perte et la précision du modèle formé sur le second ensemble de données seront respectivement de 0,1711 et 0,9504.
est-ce dû aux nouvelles données de formation ou à un modèle entièrement reformé?
"""
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))
4 réponses
- model.save
enregistre toutes les informations nécessaires pour redémarrer la formation dans votre cas. La seule chose qui pourrait être gâchée en rechargeant le modèle est votre état d'optimiseur. Pour vérifier que - essayez d' save
et recharger le modèle et l'entraîner sur les données d'entraînement.
le problème pourrait être que vous utilisez un optimiseur différent - ou des arguments différents à votre optimiseur. Je viens d'avoir le même problème avec un modèle personnalisé pré-formé, en utilisant
reduce_lr = ReduceLROnPlateau(monitor='loss', factor=lr_reduction_factor,
patience=patience, min_lr=min_lr, verbose=1)
pour le modèle pré-formé, où le taux d'apprentissage initial commence à 0.0003 et pendant la préformation il est réduit au taux d'apprentissage minimum, qui est de 0.000003
je viens de copier cette ligne sur le script qui utilise le modèle pré-formé et a obtenu de très mauvaises précisions. Jusqu'À Ce Que Je on a remarqué que le dernier taux d'apprentissage du modèle pré-formé était le taux d'apprentissage min, c'est-à-dire 0,000003. Et si je commence avec ce taux d'apprentissage, j'obtiens exactement les mêmes précisions au départ que la sortie du modèle pré - formé-ce qui est logique, car commencer avec un taux d'apprentissage qui est 100 fois plus grand que le dernier taux d'apprentissage utilisé dans le modèle pré-formé se traduira par un dépassement énorme de GD et donc dans des précisions fortement diminuées.
Tous les ci-dessus permet de vous reprendre à partir du même taux d'apprentissage() que le LR lorsque le modèle et les poids ont été sauvegardés. Définir directement sur l'optimiseur.
notez que l'amélioration de là n'est pas garantie, parce que le modèle peut avoir atteint le minimum local, qui peut être global. Il n'y a pas de raison de reprendre un modèle afin de chercher un autre minimum local, à moins que vous ayez l'intention d'augmenter le taux d'apprentissage d'une manière contrôlée et de pousser le modèle dans un peut-être un meilleur minimum pas loin.