Introduction

When people say they are "using TensorFlow layers in Keras," they usually mean building Keras models with the layer classes provided by tf.keras.layers. In modern TensorFlow, that is the normal path: Keras gives you the model-building API, and TensorFlow provides the execution engine and the layer implementations you compose into the network.

The Normal Pattern

A basic Keras model built from TensorFlow layers looks like this:

1import tensorflow as tf
2
3model = tf.keras.Sequential([
4    tf.keras.layers.Dense(32, activation="relu", input_shape=(10,)),
5    tf.keras.layers.Dense(1)
6])
7
8model.compile(optimizer="adam", loss="mse")
9model.summary()

Here the layers are TensorFlow-provided Keras layers, and the model itself is also a Keras object. There is no conflict between the two. This is exactly how the integrated API is designed to be used.

Functional API with TensorFlow Layers

For more complex models, the Functional API is often better than Sequential because it handles branching, multiple inputs, and non-linear graphs.

1import tensorflow as tf
2
3inputs = tf.keras.Input(shape=(20,))
4x = tf.keras.layers.Dense(64, activation="relu")(inputs)
5x = tf.keras.layers.Dropout(0.2)(x)
6outputs = tf.keras.layers.Dense(3, activation="softmax")(x)
7
8model = tf.keras.Model(inputs=inputs, outputs=outputs)
9model.summary()

The important concept is that layers behave like callable objects. You instantiate the layer, then call it on a tensor-like input to get the next symbolic tensor in the graph.

Why This Works Cleanly

Keras layers are part of the TensorFlow ecosystem in this usage model. That means:

• the layer objects understand Keras model tracking,
• weights are managed automatically,
• the training loop can discover trainable variables,
• and saving/loading integrates with the rest of the model.

So the practical answer is not "how do I mix two unrelated systems?" It is "use tf.keras.layers as your standard building blocks inside Keras models."

Writing a Custom Layer

If the built-in layers are not enough, you can create a custom layer by subclassing tf.keras.layers.Layer.

1import tensorflow as tf
2
3class ScaleLayer(tf.keras.layers.Layer):
4    def __init__(self, factor, **kwargs):
5        super().__init__(**kwargs)
6        self.factor = factor
7
8    def call(self, inputs):
9        return inputs * self.factor
10
11inputs = tf.keras.Input(shape=(4,))
12x = ScaleLayer(0.5)(inputs)
13model = tf.keras.Model(inputs, x)
14
15print(model(tf.ones((1, 4))))

This is still fully within the Keras model system. Custom layers are the extension point when built-ins do not match the computation you need.

Why Namespace Consistency Matters

One source of confusion is mixing imports from different Keras variants. In TensorFlow-centered code, use tf.keras.layers consistently unless you have a very specific reason not to.

That keeps the model, layers, serialization behavior, and runtime backend aligned. It also makes the codebase easier to search and maintain because one API path is used throughout.

It also reduces subtle confusion when reading old examples that mix standalone Keras imports with TensorFlow-integrated ones.

Common Pitfalls

• Treating TensorFlow layers and Keras models as if they were separate incompatible systems.
• Mixing namespaces inconsistently instead of using tf.keras.layers throughout the project.
• Using Sequential for architectures that really need the Functional API.
• Writing a custom layer as a plain function when it should be a reusable Layer subclass.
• Forgetting that layers are called on tensors to produce the next stage of the model graph.

Summary

• In modern TensorFlow, using TensorFlow layers in Keras usually means using tf.keras.layers inside Keras models.
• This is the standard integrated model-building approach, not an unusual workaround.
• 'Sequential works for simple stacks, while the Functional API handles more complex architectures.'
• Custom layers can be built by subclassing tf.keras.layers.Layer.
• Consistent use of the tf.keras namespace keeps models, layers, and training behavior aligned.