Introduction

After training an autoencoder, it is common to reuse only the encoder for embeddings or only the decoder for reconstruction experiments. The cleanest way to do this is to design the original model with an explicit latent boundary and then create submodels from the trained graph. In Keras, functional models make this straightforward because intermediate tensors can be reused to build new Model objects that share the trained weights.

Build the Autoencoder with a Clear Latent Layer

If you know ahead of time that you will want separate encoder and decoder models, name the latent layer and keep the architecture explicit.

1import numpy as np
2from tensorflow import keras
3from tensorflow.keras import layers
4
5input_dim = 32
6latent_dim = 8
7
8inputs = keras.Input(shape=(input_dim,), name="ae_input")
9x = layers.Dense(64, activation="relu", name="enc_dense_1")(inputs)
10latent = layers.Dense(latent_dim, activation="linear", name="latent")(x)
11
12x = layers.Dense(64, activation="relu", name="dec_dense_1")(latent)
13outputs = layers.Dense(input_dim, activation="sigmoid", name="reconstruction")(x)
14
15autoencoder = keras.Model(inputs=inputs, outputs=outputs, name="autoencoder")
16autoencoder.compile(optimizer="adam", loss="mse")

The key design choice here is the named latent tensor. That is the split point for the two exported components.

Train the Full Model Normally

The full autoencoder is trained end to end.

1x_train = np.random.rand(2000, input_dim).astype("float32")
2
3autoencoder.fit(
4    x_train,
5    x_train,
6    epochs=3,
7    batch_size=64,
8    verbose=0,
9)

The training data above is synthetic so the example stays runnable. In real use, the same extraction pattern applies to image, text, tabular, or signal data.

Extract the Encoder

The encoder is just a new model that starts at the original input and ends at the latent output.

1encoder = keras.Model(
2    inputs=autoencoder.input,
3    outputs=autoencoder.get_layer("latent").output,
4    name="encoder",
5)
6
7z = encoder.predict(x_train[:5], verbose=0)
8print(z.shape)

Because this model reuses tensors from the trained autoencoder graph, it shares the learned weights automatically.

Rebuild the Decoder Using Trained Layers

To extract the decoder, create a new input shaped like the latent vector and pass it through the trained decoder layers.

1latent_input = keras.Input(shape=(latent_dim,), name="decoder_input")
2x = autoencoder.get_layer("dec_dense_1")(latent_input)
3decoded = autoencoder.get_layer("reconstruction")(x)
4
5decoder = keras.Model(inputs=latent_input, outputs=decoded, name="decoder")
6
7reconstructed = decoder.predict(z, verbose=0)
8print(reconstructed.shape)

The important detail is layer reuse. Do not create brand-new decoder layers with the same configuration. If you do, you will get untrained weights instead of the learned decoder.

Verify That the Split Models Match the Original

It is good practice to prove that decoder(encoder(x)) matches the original autoencoder output.

1full_output = autoencoder.predict(x_train[:5], verbose=0)
2split_output = decoder.predict(encoder.predict(x_train[:5], verbose=0), verbose=0)
3
4max_abs_diff = float(np.max(np.abs(full_output - split_output)))
5print(max_abs_diff)

For a correctly extracted model, the difference should be zero or extremely small due to floating-point details.

Save the Components Separately

Once extracted, save the pieces you need for later use.

encoder.save("encoder.keras")
decoder.save("decoder.keras")

If another service will consume the encoder output, also record the latent dimension and any preprocessing rules. The model file alone is often not enough to define the contract safely.

Subclassed Models Need More Planning

Extraction is easiest with the Functional API. If your autoencoder was built as a subclassed model, it is better to expose self.encoder and self.decoder explicitly during model design. Trying to recover those boundaries after training is much harder because the graph is not as directly reusable.

In other words, if you think you may need the pieces later, build the model in a way that makes those pieces first-class from day one.

Common Pitfalls

The most common mistake is rebuilding the decoder with new layers instead of reusing the trained layers. That creates the right shape but the wrong weights.

Another issue is extracting from a model that has no clear latent boundary. If there is no named intermediate tensor, the split becomes brittle and easy to break during refactoring.

Teams also sometimes forget to validate equivalence between the full model and the split path. A quick numerical check catches wiring mistakes immediately.

Finally, preprocessing matters. If the encoder was trained on normalized input, inference code must apply the same normalization before calling the extracted model.

Summary

• Build the original autoencoder with an explicit latent layer if you expect to split it later.
• Extract the encoder by creating a new Model from original input to latent output.
• Extract the decoder by reusing the trained decoder layers on a new latent input.
• Validate that the split models reproduce the original autoencoder behavior.
• Save model artifacts together with latent-dimension and preprocessing metadata.