Keras Save Cannot Load Again Load a Weight File Containing

How to Save and Load Your Keras Deep Learning Model

Last Updated on August 27, 2020

Keras is a elementary and powerful Python library for deep learning.

Given that deep learning models tin can take hours, days and even weeks to train, it is of import to know how to salve and load them from disk.

In this post, y'all will find how you lot can save your Keras models to file and load them up once again to make predictions.

Afterward reading this tutorial you will know:

• How to relieve model weights and model architecture in divide files.
• How to salve model compages in both YAML and JSON format.
• How to save model weights and compages into a single file for afterward apply.

Kick-start your project with my new book Deep Learning With Python, including footstep-by-pace tutorials and the Python source code files for all examples.

Let's get started.

• Update Mar 2017: Added instructions to install h5py first.
• Update Mar/2017: Updated examples for changes to the Keras API.
• Update Mar/2018: Added alternate link to download the dataset.
• Update May/2019: Added department on saving and loading the model to a single file.
• Update Sep/2019: Added annotation about using PyYAML version 5.

How to Save and Load Your Keras Deep Learning Models
Photo past art_inthecity, some rights reserved.

Tutorial Overview

If you are new to Keras or deep learning, run into this step-by-step Keras tutorial.

Keras separates the concerns of saving your model architecture and saving your model weights.

Model weights are saved to HDF5 format. This is a filigree format that is platonic for storing multi-dimensional arrays of numbers.

The model structure can be described and saved using two different formats: JSON and YAML.

In this post nosotros are going to look at two examples of saving and loading your model to file:

• Relieve Model to JSON.
• Salve Model to YAML.

Each example will too demonstrate saving and loading your model weights to HDF5 formatted files.

The examples volition use the aforementioned simple network trained on the Pima Indians onset of diabetes binary classification dataset. This is a small dataset that contains all numerical data and is easy to piece of work with. Y'all tin can download this dataset and place it in your working directory with the filename "pima-indians-diabetes.csv" (update: download from here).

Confirm that you have the latest version of Keras installed (e.chiliad. v2.2.4 as of May 2019).

Note: Saving models requires that yous accept the h5py library installed. Y'all tin install it easily as follows:

Need help with Deep Learning in Python?

Take my complimentary two-week e-mail course and discover MLPs, CNNs and LSTMs (with code).

Click to sign-up now and too get a costless PDF Ebook version of the course.

Relieve Your Neural Network Model to JSON

JSON is a simple file format for describing data hierarchically.

Keras provides the power to depict whatsoever model using JSON format with a to_json() function. This can be saved to file and subsequently loaded via the model_from_json() function that will create a new model from the JSON specification.

The weights are saved direct from the model using the save_weights() role and afterwards loaded using the symmetrical load_weights() function.

The example below trains and evaluates a unproblematic model on the Pima Indians dataset. The model is and so converted to JSON format and written to model.json in the local directory. The network weights are written to model.h5 in the local directory.

The model and weight data is loaded from the saved files and a new model is created. Information technology is important to compile the loaded model before it is used. This is so that predictions made using the model tin can use the appropriate efficient ciphering from the Keras backend.

The model is evaluated in the aforementioned manner printing the same evaluation score.

ane 2 3 4 5 vi 7 8 9 10 11 12 13 fourteen 15 16 17 eighteen 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 xl 41 42 43 44 45 46 47 48 49

# MLP for Pima Indians Dataset Serialize to JSON and HDF5 from keras . models import Sequential from keras . layers import Dense from keras . models import model_from_json import numpy import os # gear up random seed for reproducibility numpy . random . seed ( 7 ) # load pima indians dataset dataset = numpy . loadtxt ( "pima-indians-diabetes.csv" , delimiter = "," ) # split into input (X) and output (Y) variables X = dataset [ : , 0 : 8 ] Y = dataset [ : , eight ] # create model model = Sequential ( ) model . add ( Dense ( 12 , input_dim = eight , activation = 'relu' ) ) model . add ( Dumbo ( 8 , activation = 'relu' ) ) model . add ( Dense ( 1 , activation = 'sigmoid' ) ) # Compile model model . compile ( loss = 'binary_crossentropy' , optimizer = 'adam' , metrics = [ 'accuracy' ] ) # Fit the model model . fit ( Ten , Y , epochs = 150 , batch_size = 10 , verbose = 0 ) # evaluate the model scores = model . evaluate ( 10 , Y , verbose = 0 ) impress ( "%s: %.2f%%" % ( model . metrics_names [ 1 ] , scores [ i ] * 100 ) ) # serialize model to JSON model_json = model . to_json ( ) with open ( "model.json" , "west" ) as json_file : json_file . write ( model_json ) # serialize weights to HDF5 model . save_weights ( "model.h5" ) print ( "Saved model to disk" ) # later... # load json and create model json_file = open ( 'model.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.h5" ) print ( "Loaded model from disk" ) # evaluate loaded model on test information loaded_model . compile ( loss = 'binary_crossentropy' , optimizer = 'rmsprop' , metrics = [ 'accuracy' ] ) score = loaded_model . evaluate ( X , Y , verbose = 0 ) impress ( "%s: %.2f%%" % ( loaded_model . metrics_names [ 1 ] , score [ 1 ] * 100 ) )

Notation: Your results may vary given the stochastic nature of the algorithm or evaluation procedure, or differences in numerical precision. Consider running the example a few times and compare the average outcome.

Running this example provides the output below.

acc: 78.78% Saved model to disk Loaded model from disk acc: 78.78%

The JSON format of the model looks like the following:

1 two 3 iv 5 6 7 viii nine 10 11 12 13 14 15 16 17 eighteen 19 20 21 22 23 24 25 26 27 28 29 xxx 31 32 33 34 35 36 37 38 39 forty 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 lxxx 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107

{    "class_name":"Sequential",    "config":{       "proper name":"sequential_1",       "layers":[          {             "class_name":"Dense",             "config":{                "name":"dense_1",                "trainable":truthful,                "batch_input_shape":[                   null,                   8                ],                "dtype":"float32",                "units":12,                "activation":"relu",                "use_bias":truthful,                "kernel_initializer":{                   "class_name":"VarianceScaling",                   "config":{                      "scale":1.0,                      "way":"fan_avg",                      "distribution":"uniform",                      "seed":null                   }                },                "bias_initializer":{                   "class_name":"Zeros",                   "config":{                   }                },                "kernel_regularizer":zip,                "bias_regularizer":null,                "activity_regularizer":nix,                "kernel_constraint":null,                "bias_constraint":null             }          },          {             "class_name":"Dumbo",             "config":{                "proper noun":"dense_2",                "trainable":true,                "dtype":"float32",                "units":eight,                "activation":"relu",                "use_bias":true,                "kernel_initializer":{                   "class_name":"VarianceScaling",                   "config":{                      "calibration":1.0,                      "style":"fan_avg",                      "distribution":"uniform",                      "seed":zilch                   }                },                "bias_initializer":{                   "class_name":"Zeros",                   "config":{                   }                },                "kernel_regularizer":null,                "bias_regularizer":null,                "activity_regularizer":null,                "kernel_constraint":null,                "bias_constraint":cipher             }          },          {             "class_name":"Dumbo",             "config":{                "name":"dense_3",                "trainable":true,                "dtype":"float32",                "units":one,                "activation":"sigmoid",                "use_bias":true,                "kernel_initializer":{                   "class_name":"VarianceScaling",                   "config":{                      "calibration":one.0,                      "manner":"fan_avg",                      "distribution":"uniform",                      "seed":null                   }                },                "bias_initializer":{                   "class_name":"Zeros",                   "config":{                   }                },                "kernel_regularizer":nix,                "bias_regularizer":null,                "activity_regularizer":zip,                "kernel_constraint":nil,                "bias_constraint":null             }          }       ]    },    "keras_version":"2.two.5",    "backend":"tensorflow" }

Save Your Neural Network Model to YAML

This example is much the same as the in a higher place JSON example, except the YAML format is used for the model specification.

Notation, this example assumes that you accept PyYAML 5 installed, for example:

In this example, the model is described using YAML, saved to file model.yaml and later loaded into a new model via the model_from_yaml() role.

Weights are handled in the same way as higher up in HDF5 format as model.h5.

1 2 3 4 five 6 7 8 9 10 11 12 13 xiv xv sixteen 17 eighteen 19 twenty 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

# MLP for Pima Indians Dataset serialize to YAML and HDF5 from keras . models import Sequential from keras . layers import Dense from keras . models import model_from_yaml import numpy import os # fix random seed for reproducibility seed = 7 numpy . random . seed ( seed ) # load pima indians dataset dataset = numpy . loadtxt ( "pima-indians-diabetes.csv" , delimiter = "," ) # split into input (X) and output (Y) variables X = dataset [ : , 0 : eight ] Y = dataset [ : , 8 ] # create model model = Sequential ( ) model . add ( Dumbo ( 12 , input_dim = 8 , activation = 'relu' ) ) model . add ( Dense ( eight , activation = 'relu' ) ) model . add together ( Dense ( 1 , activation = 'sigmoid' ) ) # Compile model model . compile ( loss = 'binary_crossentropy' , optimizer = 'adam' , metrics = [ 'accuracy' ] ) # Fit the model model . fit ( X , Y , epochs = 150 , batch_size = 10 , verbose = 0 ) # evaluate the model scores = model . evaluate ( X , Y , verbose = 0 ) print ( "%s: %.2f%%" % ( model . metrics_names [ one ] , scores [ 1 ] * 100 ) ) # serialize model to YAML model_yaml = model . to_yaml ( ) with open ( "model.yaml" , "westward" ) as yaml_file : yaml_file . write ( model_yaml ) # serialize weights to HDF5 model . save_weights ( "model.h5" ) impress ( "Saved model to disk" ) # later... # load YAML and create model yaml_file = open ( 'model.yaml' , 'r' ) loaded_model_yaml = yaml_file . read ( ) yaml_file . close ( ) loaded_model = model_from_yaml ( loaded_model_yaml ) # load weights into new model loaded_model . load_weights ( "model.h5" ) print ( "Loaded model from disk" ) # evaluate loaded model on test data loaded_model . compile ( loss = 'binary_crossentropy' , optimizer = 'rmsprop' , metrics = [ 'accurateness' ] ) score = loaded_model . evaluate ( X , Y , verbose = 0 ) print ( "%south: %.2f%%" % ( loaded_model . metrics_names [ 1 ] , score [ 1 ] * 100 ) )

Note: Your results may vary given the stochastic nature of the algorithm or evaluation procedure, or differences in numerical precision. Consider running the example a few times and compare the boilerplate outcome.

Running the example displays the following output.

acc: 78.78% Saved model to disk Loaded model from disk acc: 78.78%

The model described in YAML format looks like the following:

1 two 3 4 5 half dozen seven viii ix 10 eleven 12 13 14 15 16 17 18 nineteen xx 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 lxx 71 72 73 74 75 76 77 78

backend: tensorflow class_name: Sequential config:   layers:   - class_name: Dumbo     config:       activation: relu       activity_regularizer: null       batch_input_shape: !!python/tuple       - null       - 8       bias_constraint: null       bias_initializer:         class_name: Zeros         config: {}       bias_regularizer: nil       dtype: float32       kernel_constraint: naught       kernel_initializer:         class_name: VarianceScaling         config:           distribution: uniform           mode: fan_avg           scale: 1.0           seed: null       kernel_regularizer: null       proper noun: dense_1       trainable: true       units: 12       use_bias: true   - class_name: Dense     config:       activation: relu       activity_regularizer: null       bias_constraint: null       bias_initializer:         class_name: Zeros         config: {}       bias_regularizer: cypher       dtype: float32       kernel_constraint: zip       kernel_initializer:         class_name: VarianceScaling         config:           distribution: uniform           way: fan_avg           scale: 1.0           seed: null       kernel_regularizer: zip       name: dense_2       trainable: truthful       units: 8       use_bias: true   - class_name: Dense     config:       activation: sigmoid       activity_regularizer: null       bias_constraint: zip       bias_initializer:         class_name: Zeros         config: {}       bias_regularizer: null       dtype: float32       kernel_constraint: nix       kernel_initializer:         class_name: VarianceScaling         config:           distribution: uniform           mode: fan_avg           scale: 1.0           seed: null       kernel_regularizer: null       proper noun: dense_3       trainable: truthful       units: 1       use_bias: true   proper name: sequential_1 keras_version: 2.2.v

Save Model Weights and Compages Together

Keras also supports a simpler interface to relieve both the model weights and model architecture together into a single H5 file.

Saving the model in this mode includes everything we need to know most the model, including:

• Model weights.
• Model compages.
• Model compilation details (loss and metrics).
• Model optimizer land.

This means that we tin can load and employ the model directly, without having to re-compile it every bit nosotros did in the examples above.

Note: this is the preferred style for saving and loading your Keras model.

How to Relieve a Keras Model

You can save your model by calling the save() function on the model and specifying the filename.

The example beneath demonstrates this past commencement fitting a model, evaluating it and saving it to the file model.h5.

1 two 3 iv five half dozen vii 8 9 10 11 12 13 14 15 16 17 eighteen 19 twenty 21 22 23 24

# MLP for Pima Indians Dataset saved to unmarried file from numpy import loadtxt from keras . models import Sequential from keras . layers import Dense # load pima indians dataset dataset = loadtxt ( "pima-indians-diabetes.csv" , delimiter = "," ) # split into input (X) and output (Y) variables 10 = dataset [ : , 0 : eight ] Y = dataset [ : , viii ] # define model model = Sequential ( ) model . add together ( Dumbo ( 12 , input_dim = eight , activation = 'relu' ) ) model . add together ( Dense ( 8 , activation = 'relu' ) ) model . add ( Dense ( 1 , activation = 'sigmoid' ) ) # compile model model . compile ( loss = 'binary_crossentropy' , optimizer = 'adam' , metrics = [ 'accurateness' ] ) # Fit the model model . fit ( Ten , Y , epochs = 150 , batch_size = 10 , verbose = 0 ) # evaluate the model scores = model . evaluate ( X , Y , verbose = 0 ) print ( "%s: %.2f%%" % ( model . metrics_names [ i ] , scores [ 1 ] * 100 ) ) # save model and compages to single file model . save ( "model.h5" ) print ( "Saved model to disk" )

Annotation: Your results may vary given the stochastic nature of the algorithm or evaluation process, or differences in numerical precision. Consider running the case a few times and compare the average upshot.

Running the example fits the model, summarizes the models performance on the training dataset and saves the model to file.

acc: 77.73% Saved model to deejay

We tin can afterwards load this model from file and employ it.

How to Load a Keras Model

Your saved model tin so be loaded afterward past calling the load_model() role and passing the filename. The role returns the model with the same architecture and weights.

In this instance, we load the model, summarize the compages and evaluate it on the same dataset to ostend the weights and architecture are the same.

# load and evaluate a saved model from numpy import loadtxt from keras . models import load _model # load model model = load_model ( 'model.h5' ) # summarize model. model . summary ( ) # load dataset dataset = loadtxt ( "pima-indians-diabetes.csv" , delimiter = "," ) # split into input (X) and output (Y) variables X = dataset [ : , 0 : viii ] Y = dataset [ : , viii ] # evaluate the model score = model . evaluate ( 10 , Y , verbose = 0 ) print ( "%due south: %.2f%%" % ( model . metrics_names [ i ] , score [ 1 ] * 100 ) )

Running the instance beginning loads the model, prints a summary of the model architecture then evaluates the loaded model on the same dataset.

Note: Your results may vary given the stochastic nature of the algorithm or evaluation procedure, or differences in numerical precision. Consider running the example a few times and compare the boilerplate effect.

The model achieves the same accurateness score which in this case is 77%.

_________________________________________________________________ Layer (type)                 Output Shape              Param # ================================================================= dense_1 (Dense)              (None, 12)                108 _________________________________________________________________ dense_2 (Dense)              (None, 8)                 104 _________________________________________________________________ dense_3 (Dumbo)              (None, 1)                 9 ================================================================= Full params: 221 Trainable params: 221 Non-trainable params: 0 _________________________________________________________________ acc: 77.73%

Further Reading

• How tin I save a Keras model? in the Keras documentation.
• Almost Keras models in the Keras documentation.

Summary

In this postal service, you discovered how to serialize your Keras deep learning models.

You learned how yous can save your trained models to files and later load them up and use them to make predictions.

Yous also learned that model weights are easily stored using  HDF5 format and that the network structure tin can be saved in either JSON or YAML format.

Practice you accept any questions nearly saving your deep learning models or almost this post?
Ask your questions in the comments and I will do my best to reply them.

Develop Deep Learning Projects with Python!

 What If Yous Could Develop A Network in Minutes

...with just a few lines of Python

Discover how in my new Ebook:
Deep Learning With Python

Information technology covers cease-to-cease projects on topics like:
Multilayer Perceptrons,Convolutional Nets andRecurrent Neural Nets, and more...

Finally Bring Deep Learning To
Your Ain Projects

Skip the Academics. But Results.

Come across What's Inside

diazfrund1991.blogspot.com

Source: https://machinelearningmastery.com/save-load-keras-deep-learning-models/

Share this post