Introduction

In TensorFlow 2, eager execution is enabled by default, which means operations run immediately and return concrete values instead of building a deferred graph first. This makes TensorFlow code feel much closer to ordinary Python, especially during debugging and experimentation.

What Eager Execution Changes

Under eager execution, TensorFlow expressions evaluate as soon as they are executed.

1import tensorflow as tf
2
3x = tf.constant([1.0, 2.0, 3.0])
4y = tf.constant([10.0, 20.0, 30.0])
5z = x + y
6
7print(z)
8print(z.numpy())

This is a major usability improvement over old graph-first workflows because you can inspect intermediate values directly.

It also means standard Python debugging techniques, such as print, breakpoints, and step-through debugging, work naturally during model development.

Gradient Computation Still Works

Eager mode does not remove automatic differentiation. You compute gradients with tf.GradientTape.

1import tensorflow as tf
2
3w = tf.Variable(3.0)
4
5with tf.GradientTape() as tape:
6    loss = w * w + 2.0 * w
7
8grad = tape.gradient(loss, w)
9print("loss:", loss.numpy())
10print("grad:", grad.numpy())

This is one of the reasons TensorFlow 2 feels much more approachable than old placeholder-and-session code. You still get autograd, but the surrounding execution model is much simpler.

Use tf.function When You Need Graph Speed

Eager execution is great for clarity, but it is not always the fastest runtime mode. When the code path stabilizes, TensorFlow can trace the function into a graph with tf.function.

1import tensorflow as tf
2
3@tf.function
4def add_and_square(x, y):
5    result = x + y
6    return result * result
7
8value = add_and_square(tf.constant(2.0), tf.constant(5.0))
9print(value.numpy())

The practical model in TensorFlow 2 is:

• eager for development clarity
• 'tf.function for optimized repeated execution'

That hybrid approach is one of the biggest design improvements in the TensorFlow 2 API.

Model Training Feels More Like Normal Python

Keras integrates naturally with eager execution, so even custom training loops are easier to reason about.

1import tensorflow as tf
2
3model = tf.keras.Sequential([
4    tf.keras.layers.Dense(8, activation="relu"),
5    tf.keras.layers.Dense(1),
6])
7
8optimizer = tf.keras.optimizers.Adam(learning_rate=0.01)
9loss_fn = tf.keras.losses.MeanSquaredError()
10
11x = tf.random.normal((16, 4))
12y = tf.random.normal((16, 1))
13
14with tf.GradientTape() as tape:
15    preds = model(x, training=True)
16    loss = loss_fn(y, preds)
17
18grads = tape.gradient(loss, model.trainable_variables)
19optimizer.apply_gradients(zip(grads, model.trainable_variables))
20
21print(float(loss.numpy()))

This is still TensorFlow, but it reads like ordinary imperative Python code.

Be Aware of the Tradeoffs

Eager execution makes development nicer, but it also changes how some optimizations work. Python-side loops, dynamic branching, and small repeated operations can be slower than a traced graph if you leave everything in eager mode for production-scale workloads.

That does not mean eager is bad. It means you should pick the execution style based on the stage of development:

• prototype and debug eagerly
• optimize stable paths with tf.function

It is also worth remembering that not every TensorFlow program needs a custom training loop. In many cases, high-level Keras APIs already give you good performance with less code.

Common Pitfalls

• Expecting TensorFlow 2 code to require manual session management leads to unnecessarily old design patterns.
• Forgetting that eager mode executes immediately can make repeated Python-side loops slower than expected.
• Wrapping everything in tf.function too early makes debugging harder before the logic is stable.
• Mixing .numpy() calls deep inside performance-critical training code can force unnecessary host-device synchronization.
• Assuming eager execution removes the need to understand graph tracing misses how tf.function still matters for optimized production paths.

Summary

• TensorFlow 2 enables eager execution by default, so operations run immediately.
• Eager mode makes debugging and experimentation much closer to ordinary Python.
• Gradient computation still works through tf.GradientTape.
• Use tf.function when you need graph-style optimization for stable execution paths.
• The best TensorFlow 2 workflow usually combines eager development with selective graph tracing.