Why does a raw tf op fail on the output of keras.Input in Keras 3?

## The two kinds of tensor in a Keras 3 program When you wire a model with the functional API you are not computing anything. `keras.Input(shape=(4,))` hands back a **KerasTensor**: a placeholder describing a future value's shape and dtype. Applying a layer to it records an edge in a graph and returns another KerasTensor. Only later, when you call the model on real data, do actual backend tensors — `tf.Tensor` under the TensorFlow backend — flow through. That separation existed in Keras 2 too, but there the symbolic tensor *was* a TensorFlow graph tensor, so mixing raw `tf.*` calls into functional wiring mostly worked. Keras 3 broke that on purpose. ## Why the refusal is deliberate Keras 3 runs the same model definition on TensorFlow, JAX or PyTorch. If a KerasTensor silently converted itself into a `tf.Tensor`, the model graph would quietly bake in a TensorFlow dependency and the definition would stop being portable — and the failure would appear much later, on a different backend, as an obscure error. So the conversion path is closed: a KerasTensor raises rather than converting, with a message stating that a KerasTensor cannot be used as input to a TensorFlow function. The error is usually confusing the first time because the line that fails looks innocent: ``` inputs = keras.Input(shape=(4,)) x = tf.reduce_mean(inputs, axis=-1, keepdims=True) # raises ``` Nothing about `tf.reduce_mean` is wrong; the argument is simply the wrong species of tensor. ## Fix 1 — keras.ops `keras.ops` is Keras 3's backend-agnostic numerics namespace, with a largely NumPy-shaped API (`keras.ops.mean`, `keras.ops.matmul`, `keras.ops.concatenate`, and so on) plus neural-network ops. Those functions accept KerasTensors and propagate shape/dtype symbolically, so they can be used directly while wiring a functional model: ``` x = keras.ops.mean(inputs, axis=-1, keepdims=True) # fine ``` This is the preferred fix when an equivalent op exists, because the resulting model still runs on any backend. ## Fix 2 — put the op inside a layer A layer's `call()` executes on **real** backend tensors, not placeholders. Under the TensorFlow backend those are `tf.Tensor` objects, so `tf.*` ops work there exactly as you expect: ``` class TFMean(keras.layers.Layer): def call(self, inputs): return tf.reduce_mean(inputs, axis=-1, keepdims=True) ``` Now `TFMean()(inputs)` is a legal functional-graph node: Keras applies the layer symbolically to build the edge and only runs the TensorFlow code when data arrives. `keras.layers.Lambda(lambda t: tf.reduce_mean(t, axis=-1, keepdims=True))` does the same thing inline, at the cost of weaker serialization — a Lambda holds arbitrary Python that has to be reconstructed at load time, so a named `Layer` subclass is the more durable choice in production code. The trade to state out loud: this fix works, but it pins the model to the TensorFlow backend. It is the right answer for a TensorFlow-only stack and the wrong one if backend portability is a goal. ## The subtlety candidates miss People over-generalise the error into "you can't use TensorFlow ops with Keras 3". Not true. The restriction is scoped to **symbolic tracing** — building a functional graph out of `keras.Input`. Inside `call()`, inside a custom training step, or when calling a model on eager data, TensorFlow ops are ordinary code under the TensorFlow backend. The rule is about *where*, not *whether*. A second subtlety: the same restriction applies to anything that tries to convert a KerasTensor — printing its values, calling `.numpy()`, passing it to NumPy, feeding it to a `tf.function`. A placeholder has no values to give, which is also why you cannot debug functional wiring by printing intermediate tensors; you inspect shapes instead, or move the logic into a layer and debug it eagerly. ## How to answer "`keras.Input` gives a symbolic KerasTensor, and Keras 3 refuses to convert it to a backend tensor so model definitions stay backend-portable. I'd either use the equivalent `keras.ops` function, or wrap the TensorFlow op in a small `Layer` subclass whose `call()` runs on real tensors — the second choice pins the model to the TensorFlow backend, which is fine if that's already the stack." That answer shows you know both the mechanism and its cost.