web-dev-qa-db-fra.com

Comment enregistrer le modèle final en utilisant keras?

J'utilise KerasClassifier pour former le classificateur.

Le code est ci-dessous:

import numpy
from pandas import read_csv
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasClassifier
from keras.utils import np_utils
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold
from sklearn.preprocessing import LabelEncoder
from sklearn.pipeline import Pipeline
# fix random seed for reproducibility
seed = 7
numpy.random.seed(seed)
# load dataset
dataframe = read_csv("iris.csv", header=None)
dataset = dataframe.values
X = dataset[:,0:4].astype(float)
Y = dataset[:,4]
# encode class values as integers
encoder = LabelEncoder()
encoder.fit(Y)
encoded_Y = encoder.transform(Y)
#print("encoded_Y")
#print(encoded_Y)
# convert integers to dummy variables (i.e. one hot encoded)
dummy_y = np_utils.to_categorical(encoded_Y)
#print("dummy_y")
#print(dummy_y)
# define baseline model
def baseline_model():
    # create model
    model = Sequential()
    model.add(Dense(4, input_dim=4, init='normal', activation='relu'))
    #model.add(Dense(4, init='normal', activation='relu'))
    model.add(Dense(3, init='normal', activation='softmax'))
    # Compile model
    model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

    return model

estimator = KerasClassifier(build_fn=baseline_model, nb_Epoch=200, batch_size=5, verbose=0)
#global_model = baseline_model()
kfold = KFold(n_splits=10, shuffle=True, random_state=seed)
results = cross_val_score(estimator, X, dummy_y, cv=kfold)
print("Accuracy: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

Mais comment sauvegarder le modèle final pour les prévisions futures?

J'utilise habituellement le code ci-dessous pour enregistrer le modèle:

# serialize model to JSON
model_json = model.to_json()
with open("model.json", "w") as json_file:
    json_file.write(model_json)
# serialize weights to HDF5
model.save_weights("model.h5")
print("Saved model to disk")

Mais je ne sais pas comment insérer le code du modèle de sauvegarde dans le code de KerasClassifier.

Je vous remercie.

pythonmachine-learningkeras
33
yensheng

Le modèle utilise une méthode save, qui enregistre tous les détails nécessaires à la reconstitution du modèle. Un exemple tiré de la documentation keras :

from keras.models import load_model

model.save('my_model.h5')  # creates a HDF5 file 'my_model.h5'
del model  # deletes the existing model

# returns a compiled model
# identical to the previous one
model = load_model('my_model.h5')
68
bogatron

vous pouvez enregistrer le modèle dans json et le pondérer dans un format de fichier hdf5.

# keras library import  for Saving and loading model and weights

from keras.models import model_from_json
from keras.models import load_model

# serialize model to JSON
#  the keras model which is trained is defined as 'model' in this example
model_json = model.to_json()


with open("model_num.json", "w") as json_file:
    json_file.write(model_json)

# serialize weights to HDF5
model.save_weights("model_num.h5")

les fichiers "model_num.h5" et "model_num.json" contenant notre modèle et nos poids sont créés

Pour utiliser le même modèle expérimenté pour des tests ultérieurs, vous pouvez simplement charger le fichier hdf5 et l’utiliser pour la prédiction de différentes données. voici comment charger le modèle à partir de fichiers sauvegardés.

# load json and create model
json_file = open('model_num.json', 'r')

loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)

# load weights into new model
loaded_model.load_weights("model_num.h5")
print("Loaded model from disk")

loaded_model.save('model_num.hdf5')
loaded_model=load_model('model_num.hdf5')

Pour prédire pour différentes données, vous pouvez utiliser cette

loaded_model.predict_classes("your_test_data here")
18
MMK

Vous pouvez utiliser model.save(filepath) pour enregistrer un modèle Keras dans un seul fichier HDF5 qui contiendra:

  • l'architecture du modèle, permettant de recréer le modèle.
  • les poids du modèle.
  • la configuration de l'entraînement (perte, optimiseur)
  • l'état de l'optimiseur, permettant de reprendre l'entraînement exactement là où vous l'avez laissé.

Dans votre code Python, la dernière ligne devrait être:

model.save("m.hdf5")

Cela vous permet de sauvegarder l'intégralité de l'état d'un modèle dans un seul fichier. Les modèles enregistrés peuvent être rétablis via keras.models.load_model().

Le modèle renvoyé par load_model() est un modèle compilé prêt à être utilisé (à moins que le modèle enregistré n'ait jamais été compilé).

model.save() arguments:

  • filepath: String, chemin du fichier dans lequel enregistrer les poids.
  • écraser: écraser n'importe quel fichier existant à l'emplacement cible ou fournir à l'utilisateur une invite manuelle.
  • include_optimizer: Si la valeur est True, enregistre l’état de l’optimiseur ensemble.
6
prosti

vous pouvez enregistrer le modèle et le charger de cette manière.

from keras.models import Sequential
from keras_contrib.losses import import crf_loss
from keras_contrib.metrics import crf_viterbi_accuracy

# To save model
model.save('my_model_01.hdf5')

# To load the model
custom_objects={'CRF': CRF,'crf_loss':crf_loss,'crf_viterbi_accuracy':crf_viterbi_accuracy}

# To load a persisted model that uses the CRF layer 
model1 = load_model("/home/abc/my_model_01.hdf5", custom_objects = custom_objects)
2
TRINADH NAGUBADI