Cómo guardar el modelo de Scikit-Learn-Keras en un archivo de persistencia (pickle / hd5 / json / yaml)

Nuestros mejores investigadores han agotado sus provisiones de café, por su búsqueda noche y día por la respuesta, hasta que Sandra halló el hallazgo en Beanstalk y hoy la compartimos con nosotros.

Solución:

Editar 1 : Respuesta original sobre el modelo de ahorro

Con HDF5:

# saving model
json_model = model_tt.model.to_json()
open('model_architecture.json', 'w').write(json_model)
# saving weights
model_tt.model.save_weights('model_weights.h5', overwrite=True)


# loading model
from keras.models import model_from_json

model = model_from_json(open('model_architecture.json').read())
model.load_weights('model_weights.h5')

# dont forget to compile your model
model.compile(loss='binary_crossentropy', optimizer='adam')

Editar 2 : ejemplo de código completo con conjunto de datos de iris

# Train model and make predictions
import numpy
import pandas
from keras.models import Sequential, model_from_json
from keras.layers import Dense
from keras.utils import np_utils
from sklearn import datasets
from sklearn import preprocessing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder

# fix random seed for reproducibility
seed = 7
numpy.random.seed(seed)

# load dataset
iris = datasets.load_iris()
X, Y, labels = iris.data, iris.target, iris.target_names
X = preprocessing.scale(X)

# encode class values as integers
encoder = LabelEncoder()
encoder.fit(Y)
encoded_Y = encoder.transform(Y)

# convert integers to dummy variables (i.e. one hot encoded)
y = np_utils.to_categorical(encoded_Y)

def build_model():
    # create model
    model = Sequential()
    model.add(Dense(4, input_dim=4, init='normal', activation='relu'))
    model.add(Dense(3, init='normal', activation='sigmoid'))
    model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
    return model

def save_model(model):
    # saving model
    json_model = model.to_json()
    open('model_architecture.json', 'w').write(json_model)
    # saving weights
    model.save_weights('model_weights.h5', overwrite=True)

def load_model():
    # loading model
    model = model_from_json(open('model_architecture.json').read())
    model.load_weights('model_weights.h5')
    model.compile(loss='categorical_crossentropy', optimizer='adam')
    return model


X_train, X_test, Y_train, Y_test = train_test_split(X, y, test_size=0.3, random_state=seed)

# build
model = build_model()
model.fit(X_train, Y_train, nb_epoch=200, batch_size=5, verbose=0)

# save
save_model(model)

# load
model = load_model()

# predictions
predictions = model.predict_classes(X_test, verbose=0)
print(predictions)
# reverse encoding
for pred in predictions:
    print(labels[pred])

Tenga en cuenta que solo usé Keras, no la envoltura. Solo agrega algo de complejidad en algo simple. Además, el código es voluntario, no factorizado, por lo que puede tener una imagen completa.

Además, dijo que desea generar 1 o 0. No es posible en este conjunto de datos porque tiene 3 atenuaciones y clases de salida (Iris-setosa, Iris-versicolor, Iris-virginica). Si solo tuviera 2 clases, su salida se atenuaría y las clases serían 0 o 1 usando la función de salida sigmoidea.

Solo agregando a la respuesta de gaarv: si no necesita la separación entre la estructura del modelo (model.to_json()) y los pesos (model.save_weights()), puede utilizar uno de los siguientes:

• Utilice el incorporado keras.models.save_model y ‘keras.models.load_model` que almacenan todo junto en un archivo hdf5.
• Use pickle para serializar el objeto Model (o cualquier clase que contenga referencias a él) en un archivo / red / lo que sea.
  Desafortunadamente, Keras no admite pepinillos de forma predeterminada. Puede usar mi solución irregular que agrega esta característica que falta. El código de trabajo está aquí: http://zachmoshe.com/2017/04/03/pickling-keras-models.html

Otra gran alternativa es utilizar devoluciones de llamada cuando fit tu modelo. Específicamente el ModelCheckpoint devolución de llamada, así:

from keras.callbacks import ModelCheckpoint
#Create instance of ModelCheckpoint
chk = ModelCheckpoint("myModel.h5", monitor='val_loss', save_best_only=False)
#add that callback to the list of callbacks to pass
callbacks_list = [chk]
#create your model
model_tt = KerasClassifier(build_fn=create_model, nb_epoch=150, batch_size=10)
#fit your model with your data. Pass the callback(s) here
model_tt.fit(X_train,y_train, callbacks=callbacks_list)

Esto salvará tu entrenamiento cada época al myModel.h5 Archivo. Esto proporciona grandes beneficios, ya que puede detener su entrenamiento cuando lo desee (como cuando ve que ha comenzado a sobreajustarse) y aún así conservar el entrenamiento anterior.

Tenga en cuenta que esto guarda tanto la estructura como los pesos en el mismo hdf5 archivo (como lo muestra Zach), para que luego pueda cargar su modelo usando keras.models.load_model.

Si desea guardar solo sus pesos por separado, puede usar el save_weights_only=True argumento al crear una instancia de su ModelCheckpoint, lo que le permite cargar su modelo como explica Gaarv. Extrayendo de los documentos:

save_weights_only: si es True, solo se guardarán los pesos del modelo (model.save_weights (filepath)), de lo contrario se guardará el modelo completo (model.save (filepath)).

valoraciones y reseñas

Si te gustó nuestro trabajo, puedes dejar una sección acerca de qué le añadirías a esta reseña.

---

---

Utiliza Nuestro Buscador