Introduction

Keras preprocessing layers let you move input transformation into the model itself, which is useful because training and inference then use the same logic automatically. The second part of the problem is understanding where tensor values should come from. Sometimes you adapt() a preprocessing layer from data, and sometimes you inject fixed constants or write a custom layer that transforms tensors explicitly.

Why Put Preprocessing Inside the Model

When preprocessing lives outside the model, it is easy for training code and serving code to drift apart. A Keras preprocessing layer keeps the transformation in the graph.

Typical benefits are:

• one definition for both training and inference
• easier export of the whole pipeline
• fewer manual preprocessing bugs

This is especially useful for normalization, rescaling, text vectorization, and categorical lookup.

Example with a Built-In Normalization Layer

A standard pattern is to create the layer, adapt() it on sample data, and place it at the start of the model.

1import numpy as np
2import tensorflow as tf
3
4x_train = np.array([[1.0], [2.0], [3.0], [4.0]], dtype=np.float32)
5y_train = np.array([2.0, 4.0, 6.0, 8.0], dtype=np.float32)
6
7normalizer = tf.keras.layers.Normalization()
8normalizer.adapt(x_train)
9
10model = tf.keras.Sequential([
11    tf.keras.Input(shape=(1,)),
12    normalizer,
13    tf.keras.layers.Dense(1)
14])
15
16model.compile(optimizer='adam', loss='mse')
17model.fit(x_train, y_train, epochs=5, verbose=0)
18print(model.predict(np.array([[5.0]], dtype=np.float32), verbose=0))

The normalization statistics are stored in the layer, so you do not need separate manual scaling logic later.

When You Need Fixed Tensor Values

Sometimes the preprocessing step depends on fixed constants rather than statistics learned from data. In that case, use TensorFlow operations directly or create a custom layer.

1import tensorflow as tf
2
3class OffsetLayer(tf.keras.layers.Layer):
4    def __init__(self, offset, **kwargs):
5        super().__init__(**kwargs)
6        self.offset = tf.constant(offset, dtype=tf.float32)
7
8    def call(self, inputs):
9        return inputs + self.offset
10
11model = tf.keras.Sequential([
12    tf.keras.Input(shape=(3,)),
13    OffsetLayer([1.0, 0.0, -1.0]),
14    tf.keras.layers.Dense(2)
15])
16
17x = tf.constant([[10.0, 20.0, 30.0]])
18print(model(x))

Here the tensor values are set explicitly through tf.constant, not learned with adapt().

Preprocessing with Lambda or Built-In Layers

For simple arithmetic transforms, a built-in layer or a small Lambda-style transform is enough.

1import tensorflow as tf
2
3inputs = tf.keras.Input(shape=(2,))
4x = tf.keras.layers.Rescaling(scale=1.0 / 255.0)(inputs)
5outputs = tf.keras.layers.Dense(1)(x)
6model = tf.keras.Model(inputs, outputs)

Use built-in layers whenever they match the need because they are easier to serialize, inspect, and maintain than ad hoc tensor logic.

adapt() Versus set_weights()

A common point of confusion is whether preprocessing values should come from adapt() or set_weights().

• use adapt() when the layer is designed to learn preprocessing statistics from data
• use set_weights() only if the layer exposes weights that you intentionally want to overwrite
• use constants or a custom layer when the transform is fixed by design

For example, Normalization expects either adapt() or direct weight assignment with the right internal structure. If you only want to subtract a constant or rescale by known values, a custom layer is usually clearer.

Keep the Transformation Differentiable Only If Needed

Preprocessing layers often sit at the model input and do not need trainable behavior. If the transformation is deterministic, keep it simple. Do not create trainable weights unless the preprocessing itself is part of the learned model.

That distinction helps avoid accidental coupling between feature preparation and model optimization.

Common Pitfalls

• Keeping preprocessing outside the model and then serving raw inputs that were never transformed the same way as training data.
• Using a custom layer for simple scaling when a built-in preprocessing layer already exists.
• Trying to use adapt() on a layer that actually needs fixed constant values instead of learned statistics.
• Setting weights manually without understanding the layer's expected internal weight shapes.
• Mixing trainable model parameters with deterministic preprocessing logic for no real reason.

Summary

• Preprocessing layers make training and inference use the same input transformation.
• Use built-in layers such as Normalization or Rescaling whenever possible.
• Use adapt() for statistics learned from sample data.
• Use constants or a custom layer when the tensor values should be fixed explicitly.
• Keep preprocessing simple, explicit, and close to the model input.