5 Effective Ways to Load Weights from Checkpoint and Re-evaluate Models in Keras

Rate this post

๐Ÿ’ก Problem Formulation: When training deep learning models, it’s common practice to save checkpoints at regular intervals to safeguard against data loss due to crashes or halts in training. Loading these saved checkpoints to re-evaluate a model’s performance is essential for resuming training, conducting inference, or comparing model versions. This article delves into how to load weights from saved checkpoints in Kerasโ€”using Pythonโ€”and how to subsequently re-evaluate the model’s performance on new data.

Method 1: Using load_weights() to Restore Checkpoint

Keras’ load_weights() method allows for easy restoration of model weights from a saved checkpoint file. This function requires the path to the checkpoint file and expects the architecture of the model to be identical to the one used when the weights were saved.

Here’s an example:

from keras.models import load_model

# Assuming you have your model architecture already defined as 'model'

# Load the weights from the checkpoint

# Compile the model (if you intend to train it further or evaluate)
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# Evaluate the model on new data
results = model.evaluate(X_test, Y_test)

The output from the above code snippet would look like:

loss: 0.35 - accuracy: 0.88

This code snippet illustrates how to load Keras model weights from a checkpoint and evaluate the model’s performance on a test dataset. The output displays the loss and accuracy achieved by the model on the dataset provided.

Method 2: Using Model Checkpoint Callback

The ModelCheckpoint callback in Keras can be used to save a model’s weights at different stages of training. Upon training completion, these weights can be restored for model re-evaluation or further training.

Here’s an example:

from keras.callbacks import ModelCheckpoint

# Define a checkpoint callback
checkpoint = ModelCheckpoint(filepath='weights_best.h5', save_best_only=True)

# Train the model with the callback
model.fit(X_train, Y_train, epochs=10, callbacks=[checkpoint])

# Later...

# Load the best weights and re-evaluate
result = model.evaluate(X_test, Y_test, verbose=1)

The output will reveal the model’s performance with the best weights:

loss: 0.30 - accuracy: 0.90

This method includes training the model with a callback that continuously saves the best-performing weights, which can later be loaded using load_weights() and evaluated against a test set to confirm the performance metrics.

Method 3: Directly Loading During Model Initialization

When defining a Keras model, you can immediately load the desired weights if you have the checkpoint file ready. This method is efficient for quickly setting up a model with pre-trained weights.

Here’s an example:

from keras.models import Sequential
from keras.layers import Dense

# Define your model architecture
model = Sequential([
    Dense(64, activation='relu'),
    Dense(10, activation='softmax')

# Load the weights directly after initialization

# Continue with the compilation and evaluation of the model
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
evaluation = model.evaluate(X_test, Y_test)

Expect an output akin to:

loss: 0.42 - accuracy: 0.85

In this example, weights are loaded into the model immediately after its creation. This approach is straightforward and useful when you want to load weights into a fresh model instance before compiling and running evaluation.

Method 4: Loading Weights by Layer

In situations where the model architectures differ, or when youโ€™re interested in transferring weights between layers, you can selectively load weights by layer names. This requires a careful approach to ensure compatibility between layers.

Hereโ€™s an example:

from keras.models import load_model

# Load the entire model from a checkpoint
original_model = load_model('complete_model.h5')

# Assume 'model' is your new model with a similar architecture

# Transfer weights from the original model to the new model for each layer
for layer in original_model.layers:
    if layer.name in [target_layer.name for target_layer in model.layers]:

# Evaluate the adjusted model
results = model.evaluate(X_test, Y_test)

The output will be:

loss: 0.38 - accuracy: 0.87

This technique is useful when merging weight data from one model to another. By matching layer names and transferring weights, you can preserve learned features, which can be beneficial for tasks like fine-tuning or feature extraction.

Bonus One-Liner Method 5: Quick Load and Test

For a rapid one-liner solution to load weights and evaluate a Keras model, ensure you have the same architecture and compiled model ready to load the weights and execute the evaluation in one go.

Hereโ€™s an example:

results = model.load_weights('quick_checkpoint.h5').evaluate(X_test, Y_test)

The output might look something like this:

loss: 0.33 - accuracy: 0.89

This compact one-liner is a combination of methods for loading weights and immediate evaluation. It assumes that the model is properly compiled and the architecture is ready to accept the weights.


  • Method 1: Using load_weights() to Restore Checkpoint. This is the conventional method for loading weights in Keras. Its strength lies in its simplicity and the fact that it’s well-integrated with Keras’ workflow. However, it assumes the same model architecture and may not work if there are discrepancies.
  • Method 2: Using Model Checkpoint Callback. Ideal for automation and continuous saving of the best models during training. It ensures you always have the best model ready to be loaded, but setting it up requires prior planning and understanding of callbacks.
  • Method 3: Directly Loading During Model Initialization. It’s a straightforward and efficient way to set up a pre-trained model, assuming you have the weights ready to be loaded. Its downside is it offers no flexibility if the model architecture is not a perfect match with the checkpoint.
  • Method 4: Loading Weights by Layer. This method offers flexibility in transferring learned features across models. It can be quite powerful for model tuning or when dealing with models that share some components. Still, it requires a granular understanding of model architectures and matching layer names meticulously.
  • Bonus One-Liner Method 5: Quick Load and Test. When speed is paramount, and everything is set up correctly, this method offers a condensed workflow. It’s not as versatile as other methods and assumes that the model and checkpoints are fully compatible and ready to go.