Introduction

In Keras, reusing a Dense layer means reusing the same layer instance, which also means reusing the same weights. That is weight sharing, not copying. This is useful when multiple inputs should be transformed by the exact same learned projection, but it is different from cloning a layer configuration or creating a second independent layer with the same shape.

Reusing the Same Layer Instance

A Keras layer becomes reusable once you create it as an object and call it more than once.

1import tensorflow as tf
2
3shared_dense = tf.keras.layers.Dense(16, activation="relu")
4
5input_a = tf.keras.Input(shape=(8,))
6input_b = tf.keras.Input(shape=(8,))
7
8encoded_a = shared_dense(input_a)
9encoded_b = shared_dense(input_b)
10
11model = tf.keras.Model(inputs=[input_a, input_b], outputs=[encoded_a, encoded_b])
12model.summary()

Both branches use the same weight matrix and bias vector. Training on either branch updates the same shared parameters.

That is the standard Keras answer to layer reuse.

Why This Matters

Reusing a Dense layer is appropriate when you want the same learned transformation applied consistently across multiple inputs or time steps.

Typical use cases include:

• Siamese or twin-network architectures
• shared feature extraction across different branches
• applying the same projection to several tensors of compatible shape

If the semantics of the transformation must match exactly, shared weights are often the right design.

Reuse Is Not the Same as Copying

A common misunderstanding is thinking that reusing a layer gives each use its own weights. It does not. These two examples are different.

Shared weights:

shared = tf.keras.layers.Dense(16)
out1 = shared(input_a)
out2 = shared(input_b)

Independent weights:

1dense1 = tf.keras.layers.Dense(16)
2dense2 = tf.keras.layers.Dense(16)
3out1 = dense1(input_a)
4out2 = dense2(input_b)

The first pattern learns one set of parameters. The second learns two separate sets.

Shape Compatibility Still Applies

A reused Dense layer expects compatible input shapes each time it is called. Once the layer is built on its first input shape, later calls must agree on the input feature dimension.

For example, this works:

1shared = tf.keras.layers.Dense(8)
2
3a = tf.keras.Input(shape=(4,))
4b = tf.keras.Input(shape=(4,))
5
6shared(a)
7shared(b)

But if one input has shape (4,) and another has shape (10,), a single Dense layer cannot usually serve both because its weight matrix was created for one input width.

Reuse in Sequential vs Functional API

Layer reuse is most natural in the Functional API because you can explicitly wire the same layer into multiple graph branches.

While Sequential is convenient for straight-line stacks, it is not designed for branching and shared-layer graph topologies. If you are reusing a Dense layer across multiple paths, switch to the Functional API.

Reusing a Trained Dense Layer

You can also extract a trained Dense layer from an existing model and use it in a new model.

1import tensorflow as tf
2
3base_model = tf.keras.Sequential([
4    tf.keras.layers.Dense(32, activation="relu", input_shape=(8,)),
5    tf.keras.layers.Dense(16, activation="relu", name="shared_dense"),
6    tf.keras.layers.Dense(1)
7])
8
9shared_dense = base_model.get_layer("shared_dense")
10
11new_input = tf.keras.Input(shape=(8,))
12x = tf.keras.layers.Dense(32, activation="relu")(new_input)
13y = shared_dense(x)
14new_model = tf.keras.Model(new_input, y)

Because shared_dense is the same layer object, it carries its learned weights into the new model.

If you do not want continued updates to those weights, freeze it:

shared_dense.trainable = False

Then recompile the model before training.

When Cloning Is Better

Sometimes you want the same architecture but not the same weights. In that case, create a new layer instance with the same configuration instead of reusing the old one.

original = tf.keras.layers.Dense(16, activation="relu")
clone = tf.keras.layers.Dense.from_config(original.get_config())

This copies the configuration, not the learned parameters.

That is the right choice when symmetry of architecture matters but the branches should learn independently.

Common Pitfalls

The most common mistake is reusing a Dense layer and expecting separate weights for each call site. Another is trying to reuse one layer across incompatible input feature dimensions after it has already been built. Developers also often attempt shared-layer topologies inside Sequential, which becomes awkward or impossible compared to the Functional API. A final issue is reusing a trained layer in a new model and forgetting that updates in the new model will keep changing the shared weights unless the layer is frozen.

Summary

• Reusing a Dense layer means reusing the same layer instance and the same weights.
• This is useful for weight sharing across multiple inputs or branches.
• Shared reuse is different from cloning a layer configuration.
• Input shapes must stay compatible across calls to the reused layer.
• The Functional API is the cleanest way to build models with shared Dense layers.