Introduction

Counting True values in a TensorFlow boolean tensor is a small operation that shows up everywhere: masking, metrics, thresholding, and batch statistics. The mechanics are simple, but the details that matter are axis handling, result dtype, and keeping the computation inside TensorFlow instead of bouncing back to Python too early.

Two Standard TensorFlow Patterns

There are two normal ways to do the count:

• cast booleans to integers and sum
• use tf.math.count_nonzero

Both work in eager mode and graph mode.

1import tensorflow as tf
2
3mask = tf.constant([[True, False, True], [False, True, True]])
4
5count_a = tf.reduce_sum(tf.cast(mask, tf.int32))
6count_b = tf.math.count_nonzero(mask)
7
8print(int(count_a))
9print(int(count_b))

count_nonzero is usually the most readable choice. Cast-and-sum is handy when you already need a numeric mask for later math.

Count Along Specific Axes

Global totals are not always enough. Often you need per-row, per-column, or per-batch counts.

1import tensorflow as tf
2
3mask = tf.constant([
4    [True, False, True, True],
5    [False, False, True, False],
6    [True, True, False, False],
7])
8
9per_row = tf.math.count_nonzero(mask, axis=1)
10per_col = tf.reduce_sum(tf.cast(mask, tf.int32), axis=0)
11
12print(per_row.numpy())
13print(per_col.numpy())

Being explicit about axis is important because a missing axis silently changes the meaning from "count per example" to "count across the whole tensor".

If downstream code expects dimensions to stay aligned, use keepdims=True.

per_row_keepdims = tf.math.count_nonzero(mask, axis=1, keepdims=True)
print(per_row_keepdims.shape)

Be Careful with Dtypes

Boolean counts are integers. Many metric accumulators or loss-related tensors are floats. Cast deliberately when mixing them.

1import tensorflow as tf
2
3class TrueCounter(tf.keras.metrics.Metric):
4    def __init__(self, name="true_counter", **kwargs):
5        super().__init__(name=name, **kwargs)
6        self.total = self.add_weight(name="total", initializer="zeros", dtype=tf.float32)
7
8    def update_state(self, mask):
9        count = tf.cast(tf.math.count_nonzero(mask), self.total.dtype)
10        self.total.assign_add(count)
11
12    def result(self):
13        return self.total
14
15    def reset_state(self):
16        self.total.assign(0.0)

Without the cast, you can run into dtype mismatch errors or implicit conversions that make code less obvious.

Keep the Count on the Tensor Side

A common performance mistake is converting counts to NumPy too early inside training or inference loops.

Bad pattern:

# avoid in a hot loop
# count = tf.math.count_nonzero(mask).numpy()

Better pattern:

count = tf.math.count_nonzero(mask)
ratio = tf.cast(count, tf.float32) / tf.cast(tf.size(mask), tf.float32)

Stay in TensorFlow until you actually need to log or display the value. That keeps graph execution cleaner and avoids unnecessary host synchronization.

Sparse and Ragged Inputs Need Attention

If your data is not dense, count the right thing.

For a sparse tensor, you often want to count True values in the stored values field:

1import tensorflow as tf
2
3st = tf.SparseTensor(
4    indices=[[0, 0], [1, 1], [2, 0]],
5    values=[True, True, False],
6    dense_shape=[3, 3],
7)
8
9print(int(tf.math.count_nonzero(st.values)))

For ragged tensors, axis semantics still matter:

rt = tf.ragged.constant([[True, False], [True], [False, True, True]])
print(tf.math.count_nonzero(rt, axis=1).numpy())

Do not assume that the dense-tensor mental model always transfers automatically.

Common Pitfalls

• Forgetting the axis argument and counting globally by accident.
• Ignoring keepdims when later tensor shapes depend on it.
• Mixing integer counts with float accumulators without explicit casting.
• Calling .numpy() repeatedly inside performance-sensitive loops.
• Treating sparse or ragged tensors exactly like dense tensors without checking semantics.

Summary

• Use tf.math.count_nonzero or cast-and-sum to count True values.
• Set axis explicitly when the count is per row, batch, or feature.
• Cast counts intentionally when mixing them with float metrics.
• Keep the result in TensorFlow until you really need a Python value.
• Recheck semantics for sparse and ragged inputs instead of assuming the dense case.
• Small deterministic checks help catch axis and dtype regressions early.