Keras的TensorFlow后端是否依赖Eager Execution？能否混合构建图并训练？

1. Does Keras' TensorFlow backend depend on Eager Execution? #

No, it doesn’t.

While TensorFlow 2.x defaults to Eager Execution (the imperative, "run-as-you-write" mode), Keras was built to work seamlessly with both Eager Execution and TensorFlow’s traditional static computation graph mode. You can explicitly disable Eager Execution if needed, and Keras will still function properly with the TensorFlow backend.

In fact, before TF 2.0, static graphs were the only mode available, and Keras worked flawlessly with them back then. Even today, you can toggle between modes using tf.compat.v1.disable_eager_execution() (though this is less common now) or wrap parts of your code in tf.function to convert Eager-style code into an optimized static graph for better performance.

2. If there's no dependency, can we build a TensorFlow computation graph using Keras and TensorFlow operations, then train the whole model with Keras' high-level APIs? #

Absolutely—and this is a go-to workflow for developers who want the flexibility of TensorFlow’s low-level graph operations paired with Keras’ convenient, battle-tested training utilities.

Here’s how to pull it off:

• Embed TensorFlow ops into custom Keras layers: You can create custom Keras layers that use raw TensorFlow operations (like tf.matmul, tf.nn.relu) instead of Keras’ built-in layers. These custom layers integrate smoothly into Keras models (whether using Sequential or Functional API).
• Enforce static graph execution with tf.function: Wrap your training step (or let Keras handle this under the hood) with tf.function to convert Eager-style code into an optimized static graph.
• Use Keras’ training tools as usual: Once your model is assembled (combining Keras layers and TF ops), you can still rely on model.compile(), model.fit(), and other Keras high-level APIs to manage training loops, loss calculation, metrics, and optimization.

Quick Example Code #

import tensorflow as tf
from tensorflow import keras

# Custom Keras layer using raw TensorFlow operations
class TFCustomLayer(keras.layers.Layer):
    def __init__(self, units=32):
        super().__init__()
        self.units = units

    def build(self, input_shape):
        self.w = self.add_weight(shape=(input_shape[-1], self.units),
                                 initializer="random_normal",
                                 trainable=True)
        self.b = self.add_weight(shape=(self.units,),
                                 initializer="zeros",
                                 trainable=True)

    def call(self, inputs):
        # Use native TensorFlow operations for computation
        return tf.nn.relu(tf.matmul(inputs, self.w) + self.b)

# Build a mixed model: Keras layers + custom TF layer
model = keras.Sequential([
    keras.layers.Dense(64, activation="relu", input_shape=(784,)),
    TFCustomLayer(32),
    keras.layers.Dense(10, activation="softmax")
])

# Compile and train with Keras' high-level APIs
model.compile(optimizer="adam",
              loss="sparse_categorical_crossentropy",
              metrics=["accuracy"])

# Dummy training data
x_train = tf.random.normal((1000, 784))
y_train = tf.random.uniform((1000,), maxval=10, dtype=tf.int32)

model.fit(x_train, y_train, epochs=5)

This example uses a custom layer with raw TensorFlow ops, integrates it into a Keras Sequential model, and trains it using Keras’ fit()—all while leveraging TensorFlow’s computation graph (thanks to tf.function implicitly wrapping the training loop in TF 2.x).

内容的提问来源于stack exchange，提问作者nairouz mrabah