How to Save and Load Your Keras Deep Learning Model

 

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

Since deep learning models can take hours, days, and even weeks to train, it is important to know how to save and load them from a disk.

In this post, you will discover how to save your Keras models to files and load them up again to make predictions.

After reading this tutorial, you will 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 save model weights and architecture into a single file for later use

Tutorial Overview

If you are new to Keras or deep learning, see 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 an HDF5 format. This grid format is ideal 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, you will look at three examples of saving and loading your model to a file:

• Save Model to JSON
• Save Model to YAML
• Save Model to HDF5

The first two examples save the model architecture and weights separately. The model weights are saved into an HDF5 format file in all cases.

The examples will use the same 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 work with. You 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 TensorFlow v2.x installed (e.g., v2.9 as of June 2022).

Note: Saving models requires that you have the h5py library installed. It is usually installed as a dependency with TensorFlow. You can also install it easily as follows:

1	sudo pip install h5py

Save 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() function. This can be saved to a file and later loaded via the model_from_json() function 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() function.

The example below trains and evaluates a simple model on the Pima Indians dataset. The model is then 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 important to compile the loaded model before it is used. This is so that predictions made using the model can use the appropriate efficient computation from the Keras backend.

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 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

# MLP for Pima Indians Dataset Serialize to JSON and HDF5 from tensorflow.keras.models import Sequential, model_from_json from tensorflow.keras.layers import Dense import numpy import os # fix 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[:,8] # create model model = Sequential() model.add(Dense(12, input_dim=8, activation='relu')) model.add(Dense(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(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[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...   # 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 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 example a few times and compare the average outcome.

Running this example provides the output below.

1 2 3 4

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 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 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 60 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 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107

{      "class_name":"Sequential",    "config":{         "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":true,                "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":null,                "activity_regularizer":null,                "kernel_constraint":null,                "bias_constraint":null             }          },          {               "class_name":"Dense",             "config":{                  "name":"dense_2",                "trainable":true,                "dtype":"float32",                "units":8,                "activation":"relu",                "use_bias":true,                "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":null,                "activity_regularizer":null,                "kernel_constraint":null,                "bias_constraint":null             }          },          {               "class_name":"Dense",             "config":{                  "name":"dense_3",                "trainable":true,                "dtype":"float32",                "units":1,                "activation":"sigmoid",                "use_bias":true,                "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":null,                "activity_regularizer":null,                "kernel_constraint":null,                "bias_constraint":null             }          }       ]    },    "keras_version":"2.2.5",    "backend":"tensorflow" }

Save Your Neural Network Model to YAML

Note: This method only applies to TensorFlow 2.5 or earlier. If you run it in later versions of TensorFlow, you will see a RuntimeError with the message “Method model.to_yaml() has been removed due to security risk of arbitrary code execution. Please use model.to_json() instead.”

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

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

1	sudo pip install PyYAML

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() function.

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 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

# MLP for Pima Indians Dataset serialize to YAML and HDF5 from tensorflow.keras.models import Sequential, model_from_yaml from tensorflow.keras.layers import Dense 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:8] Y = dataset[:,8] # create model model = Sequential() model.add(Dense(12, input_dim=8, activation='relu')) model.add(Dense(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(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[1], scores[1]*100))   # serialize model to YAML model_yaml = model.to_yaml() with open("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...   # 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=['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 example a few times and compare the average outcome.

Running the example displays the following output.

1 2 3 4

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 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 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 60 61 62 63 64 65 66 67 68 69 70 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: null       dtype: float32       kernel_constraint: null       kernel_initializer:         class_name: VarianceScaling         config:           distribution: uniform           mode: fan_avg           scale: 1.0           seed: null       kernel_regularizer: null       name: 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: null       dtype: float32       kernel_constraint: null       kernel_initializer:         class_name: VarianceScaling         config:           distribution: uniform           mode: fan_avg           scale: 1.0           seed: null       kernel_regularizer: null       name: dense_2       trainable: true       units: 8       use_bias: true   - class_name: Dense     config:       activation: sigmoid       activity_regularizer: null       bias_constraint: null       bias_initializer:         class_name: Zeros         config: {}       bias_regularizer: null       dtype: float32       kernel_constraint: null       kernel_initializer:         class_name: VarianceScaling         config:           distribution: uniform           mode: fan_avg           scale: 1.0           seed: null       kernel_regularizer: null       name: dense_3       trainable: true       units: 1       use_bias: true   name: sequential_1 keras_version: 2.2.5

Save Model Weights and Architecture Together

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

Saving the model in this way includes everything you need to know about the model, including:

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

This means that you can load and use the model directly without having to re-compile it as you had to in the examples above.

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 save() function on the model and specifying the filename.

The example below demonstrates this by first fitting a model, evaluating it, and saving it to the file model.h5.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

# MLP for Pima Indians Dataset saved to single file from numpy import loadtxt from tensorflow.keras.models import Sequential from tensorflow.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(Dense(12, input_dim=8, activation='relu')) model.add(Dense(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(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[1], scores[1]*100)) # save 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 procedure, or differences in numerical precision. Consider running the example a few times and compare the average outcome.

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

1 2	acc: 77.73% Saved model to disk

You can later load this model from the file and use it.

Note that in the Keras library, there is another function doing the same, as follows:

1 2 3 4

... # equivalent to: model.save("model.h5") from tensorflow.keras.models import save_model save_model(model, "model.h5")

How to Load a Keras Model

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

In this case, you load the model, summarize the architecture, and evaluate it on the same dataset to confirm the weights and architecture are the same.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

# load and evaluate a saved model from numpy import loadtxt from tensorflow.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:8] Y = dataset[:,8] # evaluate the model score = model.evaluate(X, Y, verbose=0) print("%s: %.2f%%" % (model.metrics_names[1], score[1]*100))

Running the example first loads the model, prints a summary of the model architecture, and 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 outcome.

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

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

Protocol Buffer Format

While saving and loading a Keras model using HDF5 format is the recommended way, TensorFlow supports yet another format, the protocol buffer. It is considered faster to save and load a protocol buffer format, but doing so will produce multiple files. The syntax is the same, except that you do not need to provide the .h5 extension to the filename:

1 2 3 4 5 6 7 8 9

# save model and architecture to single file model.save("model")   # ... later   # load model model = load_model('model') # print summary model.summary()

These will create a directory “model” with the following files:

1 2 3 4 5 6 7

model/ |-- assets/ |-- keras_metadata.pb |-- saved_model.pb `-- variables/     |-- variables.data-00000-of-00001     `-- variables.index

This is also the format used to save a model in TensorFlow v1.x. You may encounter this when you download a pre-trained model from TensorFlow Hub.

Further Reading

• How can I save a Keras model? in the Keras documentation
• About Keras models in the Keras documentation

Summary

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

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

You 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.

Do you have any questions about saving your deep learning models or this post?
Ask your questions in the comments, and I will do my best to answer them.