How to save keras model

Model saving & serialization APIs

save method

Saves the model to Tensorflow SavedModel or a single HDF5 file.

Arguments

Example

save_model function

Saves a model as a TensorFlow SavedModel or HDF5 file.

The SavedModel and HDF5 file contains:

Thus models can be reinstantiated in the exact same state, without any of the code used for model definition or training.

SavedModel serialization format

Keras SavedModel uses tf.saved_model.save to save the model and all trackable objects attached to the model (e.g. layers and variables). The model config, weights, and optimizer are saved in the SavedModel. Additionally, for every Keras layer attached to the model, the SavedModel stores:

The traced functions allow the SavedModel format to save and load custom layers without the original class definition.

Arguments

Raises

load_model function

Arguments

Returns

Raises

get_weights method

Retrieves the weights of the model.

Returns

A flat list of Numpy arrays.

set_weights method

Sets the weights of the layer, from NumPy arrays.

The weights of a layer represent the state of the layer. This function sets the weight values from numpy arrays. The weight values should be passed in the order they are created by the layer. Note that the layer’s weights must be instantiated before calling this function, by calling the layer.

For example, a Dense layer returns a list of two values: the kernel matrix and the bias vector. These can be used to set the weights of another Dense layer:

Arguments

Raises

save_weights method

Saves all layer weights.

Either saves in HDF5 or in TensorFlow format based on the save_format argument.

Arguments

Raises

load_weights method

Loads all layer weights, either from a TensorFlow or an HDF5 weight file.

If by_name is False weights are loaded based on the network’s topology. This means the architecture should be the same as when the weights were saved. Note that layers that don’t have weights are not taken into account in the topological ordering, so adding or removing layers is fine as long as they don’t have weights.

If by_name is True, weights are loaded into layers only if they share the same name. This is useful for fine-tuning or transfer-learning models where some of the layers have changed.

Only topological loading ( by_name=False ) is supported when loading weights from the TensorFlow format. Note that topological loading differs slightly between TensorFlow and HDF5 formats for user-defined classes inheriting from tf.keras.Model : HDF5 loads based on a flattened list of weights, while the TensorFlow format loads based on the object-local names of attributes to which layers are assigned in the Model ‘s constructor.

Arguments

Returns

Raises

get_config method

Note that get_config() does not guarantee to return a fresh copy of dict every time it is called. The callers should make a copy of the returned dict if they want to modify it.

Returns

from_config method

Creates a layer from its config.

Arguments

Returns

A layer instance.

model_from_config function

Instantiates a Keras model from its config.

Arguments

Returns

A Keras model instance (uncompiled).

Raises

to_json method

Returns a JSON string containing the network configuration.

Arguments

Returns

model_from_json function

Parses a JSON model configuration string and returns a model instance.

Arguments

Returns

A Keras model instance (uncompiled).

clone_model function

Clone a Functional or Sequential Model instance.

Model cloning is similar to calling a model on new inputs, except that it creates new layers (and thus new weights) instead of sharing the weights of the existing layers.

Note that clone_model will not preserve the uniqueness of shared objects within the model (e.g. a single variable attached to two distinct layers will be restored as two separate variables).

Arguments

Returns

An instance of Model reproducing the behavior of the original model, on top of new inputs tensors, using newly instantiated weights. The cloned model may behave differently from the original model if a custom clone_function modifies the layer.

Example

Note that subclassed models cannot be cloned, since their internal layer structure is not known. To achieve equivalent functionality as clone_model in the case of a subclassed model, simply make sure that the model class implements get_config() (and optionally from_config() ), and call:

How to save final model using keras?

I use KerasClassifier to train the classifier.

The code is below:

But How to save the final model for future prediction?

I usually use below code to save model:

But I don’t know how to insert the saving model’s code into KerasClassifier’s code.

8 Answers 8

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

The model has a save method, which saves all the details necessary to reconstitute the model. An example from the keras documentation:

you can save the model in json and weights in a hdf5 file format.

files «model_num.h5» and «model_num.json» are created which contain our model and weights

To use the same trained model for further testing you can simply load the hdf5 file and use it for the prediction of different data. here’s how to load the model from saved files.

To predict for different data you can use this

You can use model.save(filepath) to save a Keras model into a single HDF5 file which will contain:

In your Python code probable the last line should be:

The model returned by load_model() is a compiled model ready to be used (unless the saved model was never compiled in the first place).

Serialization and saving

Authors: Kathy Wu, Francois Chollet
Date created: 2020/04/28
Last modified: 2020/04/28
Description: Complete guide to saving & serializing models.

Introduction

A Keras model consists of multiple components:

The Keras API makes it possible to save all of these pieces to disk at once, or to only selectively save some of them:

Let’s take a look at each of these options. When would you use one or the other, and how do they work?

How to save and load a model

If you only have 10 seconds to read this guide, here’s what you need to know.

Saving a Keras model:

Loading the model back:

Now, let’s look at the details.

Setup

Whole-model saving & loading

You can save an entire model to a single artifact. It will include:

You can switch to the H5 format by:

SavedModel format

SavedModel is the more comprehensive save format that saves the model architecture, weights, and the traced Tensorflow subgraphs of the call functions. This enables Keras to restore both built-in layers as well as custom objects.

Example:

What the SavedModel contains

For detailed information on the SavedModel format, see the SavedModel guide (The SavedModel format on disk).

How SavedModel handles custom objects

When saving the model and its layers, the SavedModel format stores the class name, call function, losses, and weights (and the config, if implemented). The call function defines the computation graph of the model/layer.

In the absence of the model/layer config, the call function is used to create a model that exists like the original model which can be trained, evaluated, and used for inference.

Nevertheless, it is always a good practice to define the get_config and from_config methods when writing a custom model or layer class. This allows you to easily update the computation later if needed. See the section about Custom objects for more information.

The first loaded model is loaded using the config and CustomModel class. The second model is loaded by dynamically creating the model class that acts like the original model.

Configuring the SavedModel

Keras H5 format

Keras also supports saving a single HDF5 file containing the model’s architecture, weights values, and compile() information. It is a light-weight alternative to SavedModel.

Example:

Format Limitations

Keras SavedModel format limitations:

The tracing done by SavedModel to produce the graphs of the layer call functions allows SavedModel be more portable than H5, but it comes with drawbacks.

Saving the architecture

The model’s configuration (or architecture) specifies what layers the model contains, and how these layers are connected*. If you have the configuration of a model, then the model can be created with a freshly initialized state for the weights and no compilation information.

*Note this only applies to models defined using the functional or Sequential apis not subclassed models.

Configuration of a Sequential model or Functional API model

These types of models are explicit graphs of layers: their configuration is always available in a structured form.

get_config() and from_config()

Calling config = model.get_config() will return a Python dict containing the configuration of the model. The same model can then be reconstructed via Sequential.from_config(config) (for a Sequential model) or Model.from_config(config) (for a Functional API model).

The same workflow also works for any serializable layer.

Layer example:

Sequential model example:

Functional model example:

to_json() and tf.keras.models.model_from_json()

Example:

Custom objects

Models and layers

In order to save/load a model with custom-defined layers, or a subclassed model, you should overwrite the get_config and optionally from_config methods. Additionally, you should register the custom object so that Keras is aware of it.

Custom functions

Custom-defined functions (e.g. activation loss or initialization) do not need a get_config method. The function name is sufficient for loading as long as it is registered as a custom object.

Loading the TensorFlow graph only

Defining the config methods

Example:

Registering the custom object

Keras keeps a note of which class generated the config. From the example above, tf.keras.layers.serialize generates a serialized form of the custom layer:

Custom layer and function example

In-memory model cloning

Example:

Saving & loading only the model’s weights values

You can choose to only save & load a model’s weights. This can be useful if:

APIs for in-memory weight transfer

Weights can be copied between different objects by using get_weights and set_weights :

Transfering weights from one layer to another, in memory

Transfering weights from one model to another model with a compatible architecture, in memory

The case of stateless layers

Because stateless layers do not change the order or number of weights, models can have compatible architectures even if there are extra/missing stateless layers.

APIs for saving weights to disk & loading them back

Weights can be saved to disk by calling model.save_weights in the following formats:

The default format for model.save_weights is TensorFlow checkpoint. There are two ways to specify the save format:

There is also an option of retrieving weights as in-memory numpy arrays. Each API has its pros and cons which are detailed below.

TF Checkpoint format

Example:

Format details

Transfer learning example

Essentially, as long as two models have the same architecture, they are able to share the same checkpoint.

Example:

It is generally recommended to stick to the same API for building models. If you switch between Sequential and Functional, or Functional and subclassed, etc., then always rebuild the pre-trained model and load the pre-trained weights to that model.

How to save keras model

So far, at MachineCurve, we have primarily focused on how to train models with Keras. This is nice, but a bit useless if we cannot save the models that we’ve trained. Training is expensive and we shouldn’t want to retrain a model every time we want to use it.

Now, fortunately, the Keras deep learning framework supports saving trained models and loading them for later use. This is exactly what we want!

In this blog post, we will therefore find out how it works. Firstly, we’ll train a model, which serves as our case for today’s blog. Secondly, we’ll find out how we can save this model, either as an HDF5 file («old style saving») or a SavedModel file («new style saving»). Finally, we’ll load this model again, and show you how to generate new predictions with it.

Are you ready? Let’s go! 😎

Our training scenario

So, for this purpose, we’ll be using this model today:

It’s an adaptation of our Keras model for valid padding, where the architecture is optimized to the structure of our dataset (for example, we’re using sparse categorical crossentropy loss because our targets are integers rather than one-hot encoded vectors).

Now, at a high level, this is what the code above does:

With this model, we can now take a look at how to save your model, the architecture only, the weights only, and so on. This includes a look at how to load that stuff again too, haha! 🙂

Saving your whole model

But first, saving the model.

In order to save whole models, Keras provides the save_model definition:

You can provide these attributes (TensorFlow, n.d.):

Saving our model in SavedModel format

Now, let’s take a look at what this means for our model.

Fortunately, it’s a simple one, so we can simply specify the model and the filepath and we’re done. Add this to your code and run it to train the model:

Don’t forget to add save_model to your imports and to create a directory called save_model at the filepath you specify.

After running the model, indeed, our save_model folder is now full of model files:

Saving our model in HDF5 format

If you created a folder saved_model as before, you would get this error:

The reason why this error occurs is that the HDF5 file format ensures that data is contained, i.e. that it is hierarchically structured in just one file. You thus have to remove the directory and run the code again, and voila:

Loading the whole model

The first thing that we’ll have to do if we wish to load our Keras model is adding a few extra imports. Firstly, add load_model to your tensorflow.keras.models import:

We can then load the model:

Et voila, you’ve loaded your model 🙂

Now, while filepath is pretty clear, what do custom_objects and compile mean?

If the model you want to load includes custom layers or other custom classes or functions, you can pass them to the loading mechanism via the custom_objects argument.

Predictions for new data

With the model we loaded, we can generate predictions for new data:

In this blog post, we saw how we can utilize Keras facilities for saving and loading models: i.e., the save_model and load_model calls. Through them, we’ve been able to train a Keras model, save it to disk in either HDF5 or SavedModel format, and load it again.

I hope this blog was useful for you! If it was, feel free to leave a comment in the comments section below 💬 Please do the same if you have questions, when you think I’ve made a mistake or when you have other remarks.

Thank you for reading MachineCurve today and happy engineering! 😎

Save and load Keras models

Introduction

A Keras model consists of multiple components:

The Keras API makes it possible to save all of these pieces to disk at once, or to only selectively save some of them:

Let’s take a look at each of these options. When would you use one or the other, and how do they work?

How to save and load a model

If you only have 10 seconds to read this guide, here’s what you need to know.

Saving a Keras model:

Loading the model back:

Now, let’s look at the details.

Setup

Whole-model saving & loading

You can save an entire model to a single artifact. It will include:

You can switch to the H5 format by:

SavedModel format

SavedModel is the more comprehensive save format that saves the model architecture, weights, and the traced Tensorflow subgraphs of the call functions. This enables Keras to restore both built-in layers as well as custom objects.

Example:

What the SavedModel contains

For detailed information on the SavedModel format, see the SavedModel guide (The SavedModel format on disk).

How SavedModel handles custom objects

When saving the model and its layers, the SavedModel format stores the class name, call function, losses, and weights (and the config, if implemented). The call function defines the computation graph of the model/layer.

In the absence of the model/layer config, the call function is used to create a model that exists like the original model which can be trained, evaluated, and used for inference.

Nevertheless, it is always a good practice to define the get_config and from_config methods when writing a custom model or layer class. This allows you to easily update the computation later if needed. See the section about Custom objects for more information.

The first loaded model is loaded using the config and CustomModel class. The second model is loaded by dynamically creating the model class that acts like the original model.

Configuring the SavedModel

Keras H5 format

Keras also supports saving a single HDF5 file containing the model’s architecture, weights values, and compile() information. It is a light-weight alternative to SavedModel.

Example:

Limitations

Compared to the SavedModel format, there are two things that don’t get included in the H5 file:

Saving the architecture

The model’s configuration (or architecture) specifies what layers the model contains, and how these layers are connected*. If you have the configuration of a model, then the model can be created with a freshly initialized state for the weights and no compilation information.

*Note this only applies to models defined using the functional or Sequential apis not subclassed models.

Configuration of a Sequential model or Functional API model

These types of models are explicit graphs of layers: their configuration is always available in a structured form.

get_config() and from_config()

Calling config = model.get_config() will return a Python dict containing the configuration of the model. The same model can then be reconstructed via Sequential.from_config(config) (for a Sequential model) or Model.from_config(config) (for a Functional API model).

The same workflow also works for any serializable layer.

Layer example:

Sequential model example:

Functional model example:

to_json() and tf.keras.models.model_from_json()

Example:

Custom objects

Models and layers

In order to save/load a model with custom-defined layers, or a subclassed model, you should overwrite the get_config and optionally from_config methods. Additionally, you should use register the custom object so that Keras is aware of it.

Custom functions

Custom-defined functions (e.g. activation loss or initialization) do not need a get_config method. The function name is sufficient for loading as long as it is registered as a custom object.

Loading the TensorFlow graph only

Note that this method has several drawbacks:

Defining the config methods

Example:

Registering the custom object

Keras keeps a note of which class generated the config. From the example above, tf.keras.layers.serialize generates a serialized form of the custom layer:

Custom layer and function example

In-memory model cloning

Example:

Saving & loading only the model’s weights values

You can choose to only save & load a model’s weights. This can be useful if:

APIs for in-memory weight transfer

Weights can be copied between different objects by using get_weights and set_weights :

Transfering weights from one layer to another, in memory

Transfering weights from one model to another model with a compatible architecture, in memory

The case of stateless layers

Because stateless layers do not change the order or number of weights, models can have compatible architectures even if there are extra/missing stateless layers.

APIs for saving weights to disk & loading them back

Weights can be saved to disk by calling model.save_weights in the following formats:

The default format for model.save_weights is TensorFlow checkpoint. There are two ways to specify the save format:

There is also an option of retrieving weights as in-memory numpy arrays. Each API has its pros and cons which are detailed below.

TF Checkpoint format

Example:

Format details

Transfer learning example

Essentially, as long as two models have the same architecture, they are able to share the same checkpoint.

Example:

It is generally recommended to stick to the same API for building models. If you switch between Sequential and Functional, or Functional and subclassed, etc., then always rebuild the pre-trained model and load the pre-trained weights to that model.

The next question is, how can weights be saved and loaded to different models if the model architectures are quite different? The solution is to use tf.train.Checkpoint to save and restore the exact layers/variables.

Example:

HDF5 format

The HDF5 format contains weights grouped by layer names. The weights are lists ordered by concatenating the list of trainable weights to the list of non-trainable weights (same as layer.weights ). Thus, a model can use a hdf5 checkpoint if it has the same layers and trainable statuses as saved in the checkpoint.

Example:

Note that changing layer.trainable may result in a different layer.weights ordering when the model contains nested layers.

Transfer learning example

When loading pretrained weights from HDF5, it is recommended to load the weights into the original checkpointed model, and then extract the desired weights/layers into a new model.

Example:

Except as otherwise noted, the content of this page is licensed under the Creative Commons Attribution 4.0 License, and code samples are licensed under the Apache 2.0 License. For details, see the Google Developers Site Policies. Java is a registered trademark of Oracle and/or its affiliates.