Introduction

In Keras, the input layer is part of the model graph, not just a setting you flip after the fact. If you need a new input shape or a different input tensor, the normal solution is to rebuild a model that starts with a new keras.Input(...) and then reuse compatible layers or weights from the original model.

Why You Usually Rebuild Instead of Replace

A Functional Keras model is a directed graph of tensors and layers. The original input tensor is connected to downstream layers through that graph, so there is no safe in-place mutation that simply swaps one input node for another.

That is why the usual pattern is:

1. create a new input tensor
2. call existing layers on it in the same order when shapes are compatible
3. build a new Model

Rebuilding a Functional Model with a New Input

Here is a small example that reuses existing layers while changing the input shape.

1from keras import Input, Model
2from keras.layers import Dense, Flatten
3
4old_input = Input(shape=(28, 28, 1), name="old_input")
5x = Flatten()(old_input)
6x = Dense(64, activation="relu", name="dense_1")(x)
7output = Dense(10, activation="softmax", name="predictions")(x)
8old_model = Model(old_input, output)
9
10new_input = Input(shape=(32, 32, 1), name="new_input")
11y = Flatten()(new_input)
12y = old_model.get_layer("dense_1")(y)
13new_output = old_model.get_layer("predictions")(y)
14new_model = Model(new_input, new_output)

The dense layers can be reused only because the flattened feature size is still compatible. If the new input changes the downstream tensor size, some reused layers will no longer match.

When Shapes Are Not Compatible

If the old model expects one feature shape and the new input produces another, you need an adapter layer or partial weight reuse. A common approach is to insert resizing, pooling, or projection logic before the reused stack.

1from keras import Input, Model
2from keras.layers import Dense, Flatten, Resizing
3
4base_input = Input(shape=(28, 28, 1))
5x = Flatten()(base_input)
6x = Dense(64, activation="relu")(x)
7base_output = Dense(10, activation="softmax")(x)
8base_model = Model(base_input, base_output)
9
10new_input = Input(shape=(64, 64, 1))
11adapted = Resizing(28, 28)(new_input)
12new_output = base_model(adapted)
13wrapped_model = Model(new_input, new_output)

This pattern is often better than trying to force incompatible weights into a new shape.

clone_model and New Input Tensors

Keras also provides clone_model for rebuilding a model from configuration. This is useful when you want a structurally similar model but a different input tensor.

1from keras import Input
2from keras.models import clone_model
3
4new_input = Input(shape=(28, 28, 1), name="replacement_input")
5cloned = clone_model(old_model, input_tensors=new_input)
6cloned.set_weights(old_model.get_weights())

This approach is convenient when you want a fresh graph with the same layer configuration and compatible weights.

Sequential Models Need the Same Mindset

Sequential models are simpler, but the same rule applies. If the input contract changes, rebuild the model or wrap the original model with a new preprocessing front end. Do not expect model.input assignment to work as a supported graph rewrite.

Common Pitfalls

• Trying to mutate the input layer in place usually fights the way Keras models are built.
• Reusing layers without checking shape compatibility causes weight or tensor-shape errors.
• Forgetting to copy weights after cloning creates a structurally correct model with random parameters.
• Replacing the input without updating preprocessing can break model behavior even when shapes match.
• Confusing a new input tensor with a new batch size is common. Batch size changes usually do not require rebuilding the model.

Summary

• In Keras, replacing an input layer usually means rebuilding the model graph with a new Input.
• Reuse existing layers only when the new input produces compatible shapes.
• Add adapter or preprocessing layers when the new input shape differs materially.
• 'clone_model is useful for creating a fresh graph with a replacement input tensor.'
• Treat the input layer as part of the model structure, not as a mutable setting.