Introduction

In TensorFlow 2, printing tensor values is usually straightforward because eager execution is enabled by default. Confusion appears when code runs inside tf.function, where Python print does not behave like normal step-by-step execution. This guide shows reliable ways to inspect tensor values in both modes and explains when to use .numpy() versus tf.print.

Eager Mode Basics

In eager mode, tensors already hold concrete values. You can print the tensor object directly or convert to NumPy.

1import tensorflow as tf
2
3x = tf.constant([1.0, 2.0, 3.0])
4print(x)           # Tensor object with dtype and values
5print(x.numpy())   # NumPy array with raw values

If your code runs in notebooks or scripts with eager mode, .numpy() is usually the simplest way to inspect exact numeric content.

Why ops.Tensor Name Appears

You may see type strings like tensorflow.python.framework.ops.Tensor. That name reflects TensorFlow internals, not an error by itself.

Use this quick check:

1import tensorflow as tf
2
3x = tf.constant([[1, 2], [3, 4]])
4print(type(x))
5print(tf.is_tensor(x))

If tf.is_tensor is true, you can inspect it with the methods in this article.

Use tf.print Inside Graph-Compiled Functions

Inside tf.function, Python print runs at trace time, not each execution step. For runtime tensor values, use tf.print.

1import tensorflow as tf
2
3@tf.function
4def compute(a, b):
5    c = a * b + 1.0
6    tf.print("a:", a, "b:", b, "c:", c)
7    return c
8
9result = compute(tf.constant(2.0), tf.constant(5.0))
10print("result:", result.numpy())

tf.print is part of the graph and executes during function calls.

Printing During Training Loops

In custom training loops, print selectively to avoid slowing execution. Use conditional logging every fixed number of steps.

1import tensorflow as tf
2
3w = tf.Variable(0.0)
4opt = tf.keras.optimizers.SGD(learning_rate=0.1)
5
6for step in range(1, 21):
7    with tf.GradientTape() as tape:
8        loss = (w - 3.0) ** 2
9    grads = tape.gradient(loss, [w])
10    opt.apply_gradients(zip(grads, [w]))
11
12    if step % 5 == 0:
13        print("step", step, "w", float(w.numpy()), "loss", float(loss.numpy()))

This pattern keeps logs readable while still exposing model behavior.

Debugging Shapes and Dtypes

Many TensorFlow bugs are shape or dtype issues, not value issues. Print both metadata and sample values.

1import tensorflow as tf
2
3x = tf.random.normal((4, 10))
4print("shape:", x.shape)
5print("dtype:", x.dtype)
6print("first row:", x[0].numpy())

Inside tf.function, replace value print with tf.print and keep shape checks using tf.shape when dynamic dimensions matter.

1@tf.function
2def debug_tensor(t):
3    tf.print("dynamic shape:", tf.shape(t), "dtype:", t.dtype)
4    tf.print("slice:", t[0, :3])

Printing in Keras Layers

If you need introspection inside a custom layer, use tf.print in call.

1import tensorflow as tf
2
3class DebugDense(tf.keras.layers.Layer):
4    def __init__(self, units):
5        super().__init__()
6        self.dense = tf.keras.layers.Dense(units)
7
8    def call(self, inputs):
9        tf.print("inputs shape:", tf.shape(inputs))
10        outputs = self.dense(inputs)
11        tf.print("outputs shape:", tf.shape(outputs))
12        return outputs
13
14x = tf.random.normal((2, 5))
15layer = DebugDense(3)
16_ = layer(x)

This works in eager and graph contexts and is safer than relying on Python print behavior.

Common Logging Patterns That Scale

For larger models, avoid dumping entire tensors. Prefer summaries:

• shape and dtype
• min and max
• mean and standard deviation
• a small slice

1@tf.function
2def summarize(t):
3    tf.print(
4        "shape", tf.shape(t),
5        "min", tf.reduce_min(t),
6        "max", tf.reduce_max(t),
7        "mean", tf.reduce_mean(t)
8    )

Summaries reduce noise and help identify exploding or vanishing values quickly.

When .numpy() Is Not Available

.numpy() requires eager context. If called inside traced graph code, it may fail or be unsupported. In those contexts:

• use tf.print
• return values from function and inspect after call in eager code
• disable tf.function temporarily during debugging if needed

This avoids mixing eager-only debugging calls into graph execution paths.

Common Pitfalls

• Using Python print inside tf.function and expecting runtime values.
• Calling .numpy() in graph-compiled code paths.
• Printing entire large tensors every step, causing severe slowdown.
• Focusing only on values and ignoring shape or dtype mismatches.
• Interpreting internal class names as errors rather than implementation detail.

Summary

• In eager mode, print tensor objects or call .numpy() for raw values.
• In tf.function, use tf.print for runtime tensor inspection.
• Log selectively in training loops to keep performance acceptable.
• Debug metadata, such as shape and dtype, along with sample values.
• Treat ops.Tensor type names as normal internal representation in TensorFlow.