Introduction

In modern TensorFlow, Keras is not a separate add-on that you bolt onto the framework later. It is the high-level API built directly into TensorFlow as tf.keras. So "integrating a Keras model into TensorFlow" usually means either building the model with tf.keras, using it inside broader TensorFlow code such as custom training loops or tf.function, or exporting it for TensorFlow-serving-style workflows.

Build the Model with tf.keras

The simplest integration path is to define the model directly with tf.keras from the start.

1import tensorflow as tf
2
3model = tf.keras.Sequential([
4    tf.keras.layers.Input(shape=(20,)),
5    tf.keras.layers.Dense(64, activation="relu"),
6    tf.keras.layers.Dense(1, activation="sigmoid"),
7])
8
9model.compile(
10    optimizer="adam",
11    loss="binary_crossentropy",
12    metrics=["accuracy"],
13)

This is already a TensorFlow model. There is no separate integration step because tf.keras objects participate naturally in TensorFlow execution, saving, and deployment.

Train with the Standard Keras API

Once the model is defined, you can train it with the familiar Keras interface.

1import numpy as np
2import tensorflow as tf
3
4x_train = np.random.rand(100, 20).astype("float32")
5y_train = np.random.randint(0, 2, size=(100, 1)).astype("float32")
6
7model.fit(x_train, y_train, epochs=3, batch_size=16)

This uses TensorFlow under the hood for graph execution, gradients, and device placement while keeping the training code concise.

Use the Keras Model Inside TensorFlow Code

A Keras model is also a callable TensorFlow object, so you can use it in lower-level TensorFlow code such as GradientTape training loops.

1import tensorflow as tf
2
3optimizer = tf.keras.optimizers.Adam()
4loss_fn = tf.keras.losses.BinaryCrossentropy()
5
6@tf.function
7def train_step(x, y):
8    with tf.GradientTape() as tape:
9        predictions = model(x, training=True)
10        loss = loss_fn(y, predictions)
11
12    gradients = tape.gradient(loss, model.trainable_variables)
13    optimizer.apply_gradients(zip(gradients, model.trainable_variables))
14    return loss

This is one of the most important integration points: the Keras model can live inside a more customized TensorFlow training loop without any special wrapping.

Save the Model in TensorFlow-Friendly Formats

If the model needs to be served, exported, or reused later, save it in a TensorFlow-supported format.

model.save("saved_classifier.keras")

Or export a SavedModel-style directory when appropriate:

model.export("saved_classifier_export")

These outputs can then be loaded later for inference or deployment depending on the runtime you plan to use.

Load and Reuse the Model

Loading a saved Keras model keeps it inside the TensorFlow ecosystem.

1import tensorflow as tf
2
3loaded_model = tf.keras.models.load_model("saved_classifier.keras")
4result = loaded_model(tf.random.uniform((2, 20)))
5print(result)

This works because Keras serialization in TensorFlow preserves the model structure, weights, and often the training configuration as well.

Treat the Model as a Layer in Larger Systems

A Keras model can also be embedded inside another model or larger TensorFlow pipeline because models behave like layers.

1import tensorflow as tf
2
3base_model = tf.keras.Sequential([
4    tf.keras.layers.Input(shape=(20,)),
5    tf.keras.layers.Dense(32, activation="relu"),
6])
7
8full_model = tf.keras.Sequential([
9    base_model,
10    tf.keras.layers.Dense(1, activation="sigmoid"),
11])

This is useful for transfer learning, reusable feature extractors, and staged architectures where one model becomes a component of another.

Avoid Mixing Very Old Keras Assumptions

Older tutorials sometimes talk about "separate Keras" and "TensorFlow backend" as if they are still the main architecture decision. In current TensorFlow workflows, the important default is tf.keras. That keeps the model aligned with TensorFlow execution, serialization, callbacks, and deployment tooling.

If you are porting old code, the safest migration path is usually to replace legacy imports with tf.keras and then verify training and serialization behavior.

Common Pitfalls

• Thinking Keras and TensorFlow are still separate in normal modern TensorFlow usage.
• Building the model with one API style and then assuming it cannot participate in lower-level TensorFlow code.
• Saving the model without choosing a format that matches the later deployment path.
• Mixing legacy standalone Keras examples with modern tf.keras assumptions.
• Forgetting that a Keras model can be called like a TensorFlow function inside custom loops.

Summary

• In modern TensorFlow, Keras is integrated directly as tf.keras.
• A tf.keras model can be trained with the standard Keras API or used inside lower-level TensorFlow workflows.
• Keras models work naturally with GradientTape, tf.function, and TensorFlow saving formats.
• Saving and loading stay inside the TensorFlow ecosystem when you use tf.keras tools.
• Most integration questions are really about how you want to train, export, or compose the model, not whether Keras can work with TensorFlow at all.