Introduction

Loading a Keras model that was saved with a custom optimizer usually fails for one simple reason: Keras does not know how to reconstruct your optimizer class unless you provide it during deserialization. The right fix depends on whether you need to continue training with optimizer state or only need the model for inference.

Core Sections

When a custom optimizer matters

If you saved the full model with compile information, Keras tries to recreate:

• the model architecture
• the weights
• the loss
• the metrics
• the optimizer and its config

That is why custom optimizers cause load errors. Keras can rebuild built-in optimizers automatically, but custom classes must be supplied explicitly.

Loading with custom_objects

The standard solution is to pass the optimizer class in the custom_objects dictionary.

1import tensorflow as tf
2
3class MyAdam(tf.keras.optimizers.Adam):
4    def __init__(self, learning_rate=0.001, **kwargs):
5        super().__init__(learning_rate=learning_rate, **kwargs)
6
7
8model = tf.keras.models.load_model(
9    "saved_model_path",
10    custom_objects={"MyAdam": MyAdam}
11)

The key in custom_objects must match the serialized name that Keras stored. In many cases that is simply the class name.

Make the custom class serializable

If the optimizer has extra constructor arguments, implement get_config() so Keras can save and restore it correctly.

1import tensorflow as tf
2
3class MyAdam(tf.keras.optimizers.Adam):
4    def __init__(self, learning_rate=0.001, weight_decay=0.0, **kwargs):
5        super().__init__(learning_rate=learning_rate, **kwargs)
6        self.weight_decay = weight_decay
7
8    def get_config(self):
9        config = super().get_config()
10        config.update({
11            "weight_decay": self.weight_decay,
12        })
13        return config

Without get_config(), loading may still fail or silently restore an incomplete optimizer configuration.

If you only need inference, skip compilation

A lot of people are trying to load the model only to call predict(). In that case, you usually do not need the optimizer at all. Tell Keras not to restore compile state:

1import tensorflow as tf
2
3model = tf.keras.models.load_model(
4    "saved_model_path",
5    compile=False
6)
7
8predictions = model.predict(tf.random.normal((2, 8)))

This is the simplest and most robust option for inference services, evaluation scripts, or model conversion pipelines.

Continuing training with optimizer state

If you want to resume training exactly where it stopped, compile=False is not enough. You need:

• the custom optimizer class available
• a serializable optimizer config
• a compatible TensorFlow and Keras version

Then you can load and keep training:

1model = tf.keras.models.load_model(
2    "saved_model_path",
3    custom_objects={"MyAdam": MyAdam}
4)
5
6model.fit(train_dataset, epochs=1)

If version mismatches prevent optimizer restoration, a practical fallback is to load the model weights and then recompile with a freshly created optimizer instance. That loses optimizer momentum state, but training can still continue.

Registering custom objects cleanly

For larger projects, a registration decorator or a shared custom-object registry can reduce repeated boilerplate. The important part is consistency between the saving and loading environments.

1@tf.keras.utils.register_keras_serializable()
2class MyAdam(tf.keras.optimizers.Adam):
3    def __init__(self, learning_rate=0.001, **kwargs):
4        super().__init__(learning_rate=learning_rate, **kwargs)

Registration makes serialization cleaner, but you still need the class importable when the model is loaded.

Common Pitfalls

• Forgetting to pass the custom optimizer class in custom_objects when loading a compiled model.
• Trying to resume training with compile=False, which discards optimizer state restoration.
• Omitting get_config() on a custom optimizer that has extra constructor parameters.
• Expecting saved models to load identically across incompatible TensorFlow or Keras versions.
• Using a custom optimizer for inference-only workflows where loading without compilation would have been simpler.

Summary

• Keras needs access to custom optimizer classes during model deserialization.
• Use custom_objects or registered serializable classes when loading a compiled model.
• Implement get_config() so custom optimizer settings can be restored properly.
• Use compile=False when you only need inference and do not care about optimizer state.
• For resumed training, keep the class definition and runtime versions aligned with the environment that saved the model.