How to Reload a Fresh Model from a Saved Model in Keras Using Python

Rate this post

πŸ’‘ Problem Formulation: When working with machine learning models in Keras, it is common practice to save and load models. This allows for efficiency in both development and deployment by enabling reuse of pre-trained models. The challenge arises in loading these saved models correctly to continue training or for inference without introducing any issues from the saved state. Users need a reliable way to reload a saved model in Python so that it behaves exactly as it did at the time of saving.

Method 1: Using load_model() Function

The load_model() function in Keras is designed to easily load complete models that are saved in the HDF5 format, including the model architecture, weights, and training configuration (loss, optimizer). This method is quite straightforward and preserves the state of the optimizer, allowing for the seamless continuation of training, if needed.

Here’s an example:

from keras.models import load_model

# Assume you have already saved your model into 'path/to/your/model.h5'

# Load the model
model = load_model('path/to/your/model.h5')

# Continue working with your model


Layer (type)                 Output Shape              Param #  
... (architecture of the model is displayed here)
Total params: (total number of parameters)
Trainable params: (number of trainable parameters)
Non-trainable params: (number of non-trainable parameters)

This code snippet demonstrates the simplicity of reloading a fully trained Keras model from a file. By calling load_model() and passing the path to the saved model file, the complete model is reconstructed along with its compiled state.

Method 2: Reloading Model Weights Only

For scenarios where only the model weights are saved (usually in .h5 or .hdf5 file), one can reload these weights onto a newly instantiated model with the same architecture. This approach is useful when you have the model architecture code available and want to avoid storing the full model.

Here’s an example:

from keras.models import model_from_json

# Define your model architecture - this should be the same as the original model
json_file = open('model_architecture.json', 'r')
loaded_model_json =
loaded_model = model_from_json(loaded_model_json)

# Load the weights into the new model


Model weights loaded successfully.

The code snippet outlines loading the structure of the model from a JSON file and then applying the weights from a .h5 file. It’s crucial that the architecture defined in JSON matches the one used during training, or the weights will not fit the model correctly.

Method 3: Using Custom Objects

When a model includes custom layers or other custom objects, these need to be provided when loading the model using custom_objects argument. This ensures that Keras knows how to handle these custom-defined elements.

Here’s an example:

from keras.models import load_model

# Assume you have a custom object named 'CustomLayer'

# Load the model, include the custom objects in the dictionary
model = load_model('path/to/your/model_with_custom_layer.h5', 
                   custom_objects={'CustomLayer': CustomLayer})


Model with custom layers loaded successfully.

This code snippet shows how to load a pre-trained model that includes custom layers not included in Keras by default. When the load_model() function is called, the custom_objects parameter is used to specify a dictionary mapping the names of the custom objects to the actual Python objects.

Method 4: Compiling the Model After Loading

In some cases, one might want to adjust the optimizer, loss, or metrics when loading a saved model. This can be done by loading the model without compiling it and then compiling it manually with desired configurations.

Here’s an example:

from keras.models import load_model

# Load the model without compiling it
model = load_model('path/to/your/model.h5', compile=False)

# Compile the model with a different optimizer
model.compile(optimizer='adam', loss='mean_squared_error')


Compiled the model with adam optimizer and mean_squared_error loss.

In this example, the model is loaded but not compiled initially, as indicated by compile=False. Following the loading of the model, it is then manually compiled with a new optimizer and loss function.

Bonus One-Liner Method 5: Quick Load with Defaults

For a quick solution when default settings are satisfactory, one can use the load_model() function without any additional arguments.

Here’s an example:

model = load_model('path/to/your/model.h5')


Model loaded with default settings.

This one-liner is a concise way to load a fully-formatted Keras model when no adjustments or custom configurations are needed.


  • Method 1: Using load_model() function. Strengths: Easy and complete, recovers full model state. Weaknesses: File size might be large as it saves the entire model state.
  • Method 2: Reloading Model Weights Only. Strengths: Smaller file size, customizable. Weaknesses: Requires manual architecture setup identical to the initial model.
  • Method 3: Using Custom Objects. Strengths: Necessary for custom layers or objects, customizable. Weaknesses: Requires explicit definition of custom objects.
  • Method 4: Compiling the Model After Loading. Strengths: Allows for flexibility in optimization and loss functions post-loading. Weaknesses: Additional step to compile the model.
  • Method 5: Quick Load with Defaults. Strengths: Fastest and easiest method. Weaknesses: Inflexible, assumes defaults are acceptable.