Keras Save Cannot Load Again Load a Weight File Containing

How to Save and Load Your Keras Deep Learning Model

Last Updated on Baronial 27, 2020

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

Given that deep learning models can take hours, days and even weeks to railroad train, it is important to know how to save and load them from deejay.

In this mail service, y'all will discover how you tin save your Keras models to file and load them up over again to make predictions.

After reading this tutorial y'all volition know:

• How to save model weights and model architecture in separate files.
• How to save model architecture in both YAML and JSON format.
• How to salvage model weights and architecture into a single file for afterwards use.

Boot-first your projection with my new book Deep Learning With Python, including pace-by-step tutorials and the Python source code files for all examples.

Let's get started.

• Update Mar 2017: Added instructions to install h5py start.
• Update Mar/2017: Updated examples for changes to the Keras API.
• Update Mar/2018: Added alternating link to download the dataset.
• Update May/2019: Added section on saving and loading the model to a unmarried file.
• Update Sep/2019: Added notation about using PyYAML version 5.

How to Relieve and Load Your Keras Deep Learning Models
Photograph by art_inthecity, some rights reserved.

Tutorial Overview

If you are new to Keras or deep learning, see this stride-past-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 grid format that is ideal for storing multi-dimensional arrays of numbers.

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

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

• Save Model to JSON.
• Save Model to YAML.

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

The examples will use the aforementioned uncomplicated network trained on the Pima Indians onset of diabetes binary nomenclature dataset. This is a small dataset that contains all numerical information and is easy to work with. You 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.g. v2.2.4 equally of May 2019).

Annotation: Saving models requires that you have the h5py library installed. You lot can install it easily as follows:

Demand assistance with Deep Learning in Python?

Take my free two-calendar week email grade and notice MLPs, CNNs and LSTMs (with code).

Click to sign-up now and also become 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 ability to describe any model using JSON format with a to_json() role. This can be saved to file and later loaded via the model_from_json() part that will create a new model from the JSON specification.

The weights are saved directly from the model using the save_weights() function and later loaded using the symmetrical load_weights() part.

The example below trains and evaluates a simple 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. It is of import to compile the loaded model before it is used. This is and so that predictions made using the model can apply the advisable efficient computation from the Keras backend.

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

1 two 3 4 v 6 7 eight 9 ten eleven 12 13 14 15 16 17 xviii nineteen xx 21 22 23 24 25 26 27 28 29 thirty 31 32 33 34 35 36 37 38 39 40 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 bone # ready random seed for reproducibility numpy . random . seed ( seven ) # load pima indians dataset dataset = numpy . loadtxt ( "pima-indians-diabetes.csv" , delimiter = "," ) # carve up into input (10) and output (Y) variables X = dataset [ : , 0 : eight ] Y = dataset [ : , 8 ] # create model model = Sequential ( ) model . add together ( Dense ( 12 , input_dim = 8 , activation = 'relu' ) ) model . add ( Dumbo ( eight , activation = 'relu' ) ) model . add ( 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 ( "%due south: %.2f%%" % ( model . metrics_names [ 1 ] , scores [ 1 ] * 100 ) ) # 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" ) # later on... # 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" ) impress ( "Loaded model from disk" ) # evaluate loaded model on exam data loaded_model . compile ( loss = 'binary_crossentropy' , optimizer = 'rmsprop' , metrics = [ 'accurateness' ] ) score = loaded_model . evaluate ( Ten , 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 consequence.

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 ii 3 4 v half-dozen 7 8 9 10 eleven 12 xiii 14 xv 16 17 18 19 20 21 22 23 24 25 26 27 28 29 xxx 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 sixty 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 xc 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":true,                "batch_input_shape":[                   null,                   8                ],                "dtype":"float32",                "units":12,                "activation":"relu",                "use_bias":truthful,                "kernel_initializer":{                   "class_name":"VarianceScaling",                   "config":{                      "scale":1.0,                      "mode":"fan_avg",                      "distribution":"uniform",                      "seed":null                   }                },                "bias_initializer":{                   "class_name":"Zeros",                   "config":{                   }                },                "kernel_regularizer":null,                "bias_regularizer":zero,                "activity_regularizer":cypher,                "kernel_constraint":nix,                "bias_constraint":nil             }          },          {             "class_name":"Dense",             "config":{                "name":"dense_2",                "trainable":true,                "dtype":"float32",                "units":8,                "activation":"relu",                "use_bias":true,                "kernel_initializer":{                   "class_name":"VarianceScaling",                   "config":{                      "calibration":1.0,                      "mode":"fan_avg",                      "distribution":"uniform",                      "seed":null                   }                },                "bias_initializer":{                   "class_name":"Zeros",                   "config":{                   }                },                "kernel_regularizer":naught,                "bias_regularizer":null,                "activity_regularizer":null,                "kernel_constraint":null,                "bias_constraint":null             }          },          {             "class_name":"Dense",             "config":{                "proper name":"dense_3",                "trainable":true,                "dtype":"float32",                "units":1,                "activation":"sigmoid",                "use_bias":truthful,                "kernel_initializer":{                   "class_name":"VarianceScaling",                   "config":{                      "scale":1.0,                      "mode":"fan_avg",                      "distribution":"uniform",                      "seed":null                   }                },                "bias_initializer":{                   "class_name":"Zeros",                   "config":{                   }                },                "kernel_regularizer":goose egg,                "bias_regularizer":null,                "activity_regularizer":null,                "kernel_constraint":goose egg,                "bias_constraint":aught             }          }       ]    },    "keras_version":"2.2.5",    "backend":"tensorflow" }

Save Your Neural Network Model to YAML

This instance is much the same as the above JSON case, except the YAML format is used for the model specification.

Note, this example assumes that you lot have PyYAML 5 installed, for instance:

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

Weights are handled in the same way as to a higher place in HDF5 format as model.h5.

i 2 iii 4 5 6 7 8 ix x 11 12 thirteen 14 15 sixteen 17 eighteen 19 twenty 21 22 23 24 25 26 27 28 29 thirty 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 = seven 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 : 8 ] Y = dataset [ : , 8 ] # create model model = Sequential ( ) model . add ( Dense ( 12 , input_dim = 8 , activation = 'relu' ) ) model . add ( Dense ( viii , activation = 'relu' ) ) model . add ( Dumbo ( 1 , activation = 'sigmoid' ) ) # Compile model model . compile ( loss = 'binary_crossentropy' , optimizer = 'adam' , metrics = [ 'accuracy' ] ) # Fit the model model . fit ( 10 , Y , epochs = 150 , batch_size = 10 , verbose = 0 ) # evaluate the model scores = model . evaluate ( Ten , Y , verbose = 0 ) impress ( "%south: %.2f%%" % ( model . metrics_names [ 1 ] , scores [ 1 ] * 100 ) ) # serialize model to YAML model_yaml = model . to_yaml ( ) with open up ( "model.yaml" , "w" ) as yaml_file : yaml_file . write ( model_yaml ) # serialize weights to HDF5 model . save_weights ( "model.h5" ) print ( "Saved model to disk" ) # later on... # load YAML and create model yaml_file = open up ( '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 examination data loaded_model . compile ( loss = 'binary_crossentropy' , optimizer = 'rmsprop' , metrics = [ 'accuracy' ] ) score = loaded_model . evaluate ( X , Y , verbose = 0 ) print ( "%s: %.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 case a few times and compare the average 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 similar the post-obit:

i 2 three 4 v 6 vii 8 9 10 11 12 thirteen 14 15 sixteen 17 18 19 20 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 lx 61 62 63 64 65 66 67 68 69 seventy 71 72 73 74 75 76 77 78

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

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 way includes everything we need to know about the model, including:

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

This means that we can load and use the model direct, without having to re-compile information technology equally we did in the examples higher up.

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

How to Save a Keras Model

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

The example below demonstrates this by outset plumbing equipment a model, evaluating it and saving information technology to the file model.h5.

ane 2 3 4 five 6 7 viii 9 x xi 12 13 14 15 sixteen 17 eighteen 19 20 21 22 23 24

# MLP for Pima Indians Dataset saved to single 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 X = dataset [ : , 0 : 8 ] Y = dataset [ : , 8 ] # define model model = Sequential ( ) model . add ( Dumbo ( 12 , input_dim = 8 , activation = 'relu' ) ) model . add together ( Dense ( 8 , activation = 'relu' ) ) model . add ( Dumbo ( ane , activation = 'sigmoid' ) ) # compile model model . compile ( loss = 'binary_crossentropy' , optimizer = 'adam' , metrics = [ 'accurateness' ] ) # Fit the model model . fit ( 10 , Y , epochs = 150 , batch_size = 10 , verbose = 0 ) # evaluate the model scores = model . evaluate ( X , Y , verbose = 0 ) impress ( "%south: %.2f%%" % ( model . metrics_names [ one ] , scores [ i ] * 100 ) ) # salvage model and architecture to single file model . save ( "model.h5" ) print ( "Saved model to disk" )

Note: 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 boilerplate consequence.

Running the example fits the model, summarizes the models operation on the preparation dataset and saves the model to file.

acc: 77.73% Saved model to deejay

Nosotros can afterward load this model from file and use it.

How to Load a Keras Model

Your saved model can and then be loaded later by calling the load_model() role and passing the filename. The function returns the model with the aforementioned compages and weights.

In this case, we load the model, summarize the architecture and evaluate information technology on the same dataset to confirm the weights and compages are the aforementioned.

# 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 = "," ) # carve up into input (10) and output (Y) variables X = dataset [ : , 0 : 8 ] Y = dataset [ : , 8 ] # evaluate the model score = model . evaluate ( 10 , Y , verbose = 0 ) print ( "%s: %.2f%%" % ( model . metrics_names [ 1 ] , score [ 1 ] * 100 ) )

Running the instance first 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 average effect.

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

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

Further Reading

• How can I salve a Keras model? in the Keras documentation.
• Almost Keras models in the Keras documentation.

Summary

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

You lot learned how you can relieve 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 can be saved in either JSON or YAML format.

Exercise you have any questions about saving your deep learning models or about 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 You Could Develop A Network in Minutes

...with just a few lines of Python

Discover how in my new Ebook:
Deep Learning With Python

It covers end-to-finish projects on topics like:
Multilayer Perceptrons,Convolutional Nets andRecurrent Neural Nets, and more...

Finally Bring Deep Learning To
Your Own Projects

Skip the Academics. Just Results.

Meet What's Inside

yuegary2001.blogspot.com

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

Share this post