TensorFlow Eager Execution
Eager execution is TensorFlow's default mode of operation since version 2.0. In eager mode, every TensorFlow operation runs immediately as you call it, just like regular Python code. You see results instantly, print intermediate values freely, and debug problems line by line. Before eager execution, TensorFlow required building an entire computation graph first and then running it in a separate session — a two-step process that made debugging extremely difficult.
The Recipe Book vs. Cooking Analogy
Old TensorFlow (graph mode without eager) was like writing a complete recipe book first, then handing it to a chef who cooks everything at once at the end. You could not taste anything mid-process. Eager execution is like cooking step by step — you chop vegetables, taste the sauce, adjust seasoning, and cook the next step only after confirming the previous one worked. You get immediate feedback at every stage.
Eager Execution Is Already On
In TensorFlow 2.x, eager execution is enabled automatically. You do not need to call any special function. Every operation you write runs immediately.
import tensorflow as tf # Eager execution: results appear instantly a = tf.constant([1, 2, 3]) b = tf.constant([4, 5, 6]) c = a + b print(c) # tf.Tensor([5 7 9], shape=(3,), dtype=int32) print(c.numpy()) # [5 7 9] — convert to NumPy array to inspect values
There is no "session.run()" or "placeholder" needed. The tensor c holds an actual value immediately after the addition.
What Eager Execution Enables
1. Immediate Value Inspection
x = tf.constant([[1.0, 2.0], [3.0, 4.0]])
y = tf.matmul(x, x)
# Print and inspect at any point
print("Intermediate result:", y)
print("Shape:", y.shape)
print("First row:", y[0].numpy())
2. Python Control Flow Works Naturally
In graph mode, Python if/for/while statements needed special TensorFlow equivalents. Eager execution lets you use plain Python control flow:
def process_tensor(x, threshold=0.5):
result = tf.nn.sigmoid(x)
# Regular Python if — works in eager mode
if tf.reduce_mean(result).numpy() > threshold:
print("High activation — applying extra scaling")
result = result * 2.0
else:
print("Low activation — keeping original")
return result
output = process_tensor(tf.random.normal([5]))
3. Python Debugging Tools Work
import tensorflow as tf
def buggy_function(x):
step1 = x * 2
print("After step1:", step1) # Works — prints immediately
step2 = tf.sqrt(step1)
print("After step2:", step2) # Works
# Set a Python breakpoint here if needed
# import pdb; pdb.set_trace()
return step2
result = buggy_function(tf.constant([4.0, 9.0, 16.0]))
# After step1: [8.0, 18.0, 32.0]
# After step2: [2.83, 4.24, 5.66]
Eager vs. Graph Mode: A Comparison
Feature Eager (TF 2.x default) Graph (TF 1.x) ───────────────────────────────────────────────────────────────────── Operations run Immediately After session.run() Print intermediate values Yes No Python if/for/while Works naturally Need tf.cond/tf.while Error messages Clear, immediate Cryptic, delayed Debugging Easy Difficult Speed (repeated calls) Slower Faster ─────────────────────────────────────────────────────────────────────
How to Check If Eager Is Enabled
print(tf.executing_eagerly()) # True in TF 2.x by default
The @tf.function Decorator: Getting Graph Speed
Eager execution is convenient for development but slower than graph execution for production and repeated training steps. The @tf.function decorator compiles a Python function into a TensorFlow graph the first time it runs, then executes the compiled graph on all future calls — giving you both developer convenience (write in eager style) and production speed (run as a graph).
import tensorflow as tf
import time
def eager_multiply(x, y):
return tf.matmul(x, y)
@tf.function
def graph_multiply(x, y):
return tf.matmul(x, y)
A = tf.random.normal([500, 500])
B = tf.random.normal([500, 500])
# Warm up
graph_multiply(A, B)
# Time eager
start = time.time()
for _ in range(100):
eager_multiply(A, B)
print(f"Eager: {time.time() - start:.3f}s")
# Time graph
start = time.time()
for _ in range(100):
graph_multiply(A, B)
print(f"Graph: {time.time() - start:.3f}s")
# Graph mode is typically 2–5× faster for repeated calls
Tracing: How @tf.function Works
When you first call a @tf.function-decorated function, TensorFlow "traces" it: it runs through the function in Python, recording every TensorFlow operation but not executing them yet. This recording becomes the graph. On the second and all subsequent calls with the same input shapes and dtypes, TensorFlow skips Python and runs the pre-built graph directly.
@tf.function
def my_func(x):
print("Python print — only appears during tracing!")
return x * 2
result1 = my_func(tf.constant(3))
# Prints: "Python print — only appears during tracing!"
result2 = my_func(tf.constant(5))
# Nothing printed — runs the compiled graph, skips Python
result3 = my_func(tf.constant([1, 2, 3]))
# Prints again! New input shape triggers re-tracing
When @tf.function Re-traces
TensorFlow re-traces a function when it encounters input shapes or dtypes it has not seen before. Each unique combination of input signatures creates a new compiled graph.
@tf.function
def square(x):
return x ** 2
square(tf.constant(2)) # Traces for scalar int32
square(tf.constant(2.0)) # Traces for scalar float32
square(tf.constant([2, 3])) # Traces for 1D int32 vector
square(tf.constant([2.0, 3.0]))# Traces for 1D float32 vector
# Four separate graphs created
Excessive re-tracing slows down your program. Use input_signature to restrict which shapes trigger tracing:
@tf.function(input_signature=[
tf.TensorSpec(shape=[None], dtype=tf.float32)
])
def normalize(x):
return (x - tf.reduce_mean(x)) / tf.math.reduce_std(x)
# Now any 1D float32 tensor uses the same graph — no re-tracing
normalize(tf.constant([1.0, 2.0, 3.0]))
normalize(tf.constant([1.0, 2.0, 3.0, 4.0, 5.0]))
Disabling Eager Execution (Rarely Needed)
Some legacy TensorFlow 1.x code requires graph mode. You can disable eager execution at the very start of your script:
import tensorflow.compat.v1 as tf tf.disable_eager_execution() # Now you are in TF 1.x graph mode # Most users should never need this
Practical Workflow: Eager for Development, Graph for Production
Development Phase: → Write all code in normal Python with TF ops → Print tensors freely to verify values and shapes → Use Python debugger to step through logic → Eager execution runs everything immediately Production/Training Phase: → Wrap hot paths (training step, inference) in @tf.function → TensorFlow compiles these to fast graphs automatically → Keep the rest of the code in eager mode for flexibility
Eager execution transformed TensorFlow from a framework that required deep expertise to debug into one that feels natural to any Python programmer. Every concept you build from here — layers, training loops, custom ops — benefits from this immediate, interactive execution model. The next topic introduces Keras, TensorFlow's high-level API that builds on eager execution to let you assemble entire neural networks in just a few lines of code.