Introduction

In TensorFlow 2, custom SavedModel signatures let you control exactly how a model is called after export. Instead of relying only on Keras defaults, you can define named entry points with explicit input signatures, which is useful for serving, batch inference, or exposing multiple prediction methods from the same model.

What a Signature Really Is

A SavedModel signature is a callable graph with a fixed input contract and named outputs. When a serving system loads the model, it uses those signatures to know what tensors to accept and what tensors to return.

Keras already gives you a default serving path when you call model.save(...), but that default may not be enough if you want:

• custom input names
• multiple entry points
• preprocessing inside the exported call
• different inference methods for different clients

Define a Serving Function With input_signature

The usual pattern is to wrap model inference in a tf.function whose input signature is explicit.

1import tensorflow as tf
2
3model = tf.keras.Sequential([
4    tf.keras.layers.Input(shape=(4,)),
5    tf.keras.layers.Dense(3, activation="relu"),
6    tf.keras.layers.Dense(1)
7])
8
9@tf.function(input_signature=[tf.TensorSpec(shape=[None, 4], dtype=tf.float32, name="features")])
10def serve(features):
11    predictions = model(features, training=False)
12    return {"predictions": predictions}

That function becomes a clean serving contract: one input tensor named features, one output named predictions.

Save With Custom Signatures

Once the function is defined, save the model with tf.saved_model.save.

1import tempfile
2
3export_dir = tempfile.mkdtemp()
4
5tf.saved_model.save(
6    model,
7    export_dir,
8    signatures={
9        "serving_default": serve,
10        "predict": serve,
11    },
12)
13
14print(export_dir)

Here the same callable is exported under two signature names. You can also export different callables if the behavior should differ.

Verify the Exported Signatures

After saving, load the model and inspect what signatures exist.

1loaded = tf.saved_model.load(export_dir)
2print(list(loaded.signatures.keys()))
3
4result = loaded.signatures["serving_default"](
5    features=tf.ones((2, 4), dtype=tf.float32)
6)
7print(result)

This step matters because signature mistakes are easy to make silently. Verifying the saved artifact is part of the workflow, not an optional extra.

When model.save Is Enough

If you only need the standard Keras serving behavior, model.save(...) is often sufficient. Reach for custom signatures when the exported API should be deliberate rather than implicit.

A good rule is simple:

• use default saving for ordinary training and reload workflows
• use explicit signatures for serving or integration contracts

Custom signatures also make model boundaries clearer for other teams. Instead of telling a serving client to inspect whatever Keras exported by default, you give it a documented entry point with stable tensor names and output keys. That is often the difference between a model artifact that is merely saved and one that is genuinely deployable.

Common Pitfalls

The biggest mistake is forgetting input_signature. Without it, TensorFlow may trace in a way that is less stable or less explicit for serving.

Another mistake is returning raw tensors without naming outputs when downstream systems expect a clear output dictionary.

A third mistake is exporting a signature that uses preprocessing state or variables that are not built yet. Make sure the model has been called at least once or otherwise built before export.

Summary

• Custom SavedModel signatures define explicit exported call contracts.
• Use @tf.function(input_signature=...) to describe inputs clearly.
• Save with tf.saved_model.save(..., signatures={...}) when you need named serving entry points.
• Verify the exported signatures after saving instead of assuming they are correct.
• Use custom signatures only when the default Keras export is not expressive enough.