Introduction

In TensorFlow, the phrase "assign to part of a tensor" can mean two different things: mutating a variable in place or creating a new tensor with selected values replaced. The distinction matters because plain tf.Tensor objects are immutable, while tf.Variable supports assignment APIs designed for model state.

Start with Tensor Immutability

A common mistake is trying to write NumPy-style slice assignment against a tf.Tensor:

1import tensorflow as tf
2
3x = tf.constant([1, 2, 3, 4])
4# x[1:3] = [10, 20]  # This does not work in TensorFlow

That fails because a constant tensor represents a value, not mutable storage. If you need to update values over time, use tf.Variable instead:

1import tensorflow as tf
2
3x = tf.Variable([1, 2, 3, 4], dtype=tf.int32)
4x[1].assign(10)
5x[2].assign(20)
6
7print(x.numpy())

This is the simplest approach when you are updating individual positions or small slices inside trainable state.

Updating a Slice with tf.Variable

For a mutable tensor, assigning a subset is straightforward as long as the slice and the new values have compatible shapes.

1import tensorflow as tf
2
3matrix = tf.Variable(
4    [[1.0, 2.0, 3.0],
5     [4.0, 5.0, 6.0],
6     [7.0, 8.0, 9.0]]
7)
8
9matrix[0].assign([10.0, 20.0, 30.0])
10matrix[:, 1].assign([100.0, 200.0, 300.0])
11
12print(matrix.numpy())

This pattern is useful for stateful workflows such as updating embeddings, replacing a batch slot, or patching values during iterative algorithms. The critical rule is that the assigned values must line up with the selected slice. If the slice has three elements, TensorFlow expects three replacement values.

Replacing Values in an Immutable Tensor

If the original object is a plain tensor and you want a modified result without mutating state, use a scatter update. tf.tensor_scatter_nd_update returns a new tensor with selected indices replaced.

1import tensorflow as tf
2
3tensor = tf.constant(
4    [[1, 2, 3],
5     [4, 5, 6],
6     [7, 8, 9]],
7    dtype=tf.int32,
8)
9
10updated = tf.tensor_scatter_nd_update(
11    tensor,
12    indices=[[0, 1], [2, 2]],
13    updates=[20, 99],
14)
15
16print(updated.numpy())

This is often the best answer when you are inside a functional pipeline and want to avoid side effects. It also works well inside tf.function, where immutable-style transformations are easier to reason about than step-by-step mutation.

Using Masks for Conditional Replacement

Sometimes the subset is not defined by fixed coordinates, but by a condition such as "all negative values" or "scores below threshold." In that case, tf.where is usually cleaner than indexing.

1import tensorflow as tf
2
3scores = tf.constant([0.9, -0.2, 0.4, -1.5], dtype=tf.float32)
4clipped = tf.where(scores < 0.0, 0.0, scores)
5
6print(clipped.numpy())

tf.where keeps the original shape and chooses element-by-element between two branches. That makes it a good fit for masking, sanitizing inputs, and preparing tensors before a loss calculation.

For a tensor of the same shape, you can replace only the masked entries:

1import tensorflow as tf
2
3values = tf.constant([10, 20, 30, 40], dtype=tf.int32)
4mask = tf.constant([True, False, True, False])
5
6replaced = tf.where(mask, tf.constant([1, 2, 3, 4]), values)
7print(replaced.numpy())

Choosing the Right Tool

Use tf.Variable.assign when you truly need mutation. That is common for model weights, optimizer slots, or stateful data structures.

Use tf.tensor_scatter_nd_update when you want a new tensor with selected positions changed. That is the safer fit for many data-processing pipelines and pure functions.

Use tf.where when the subset is defined by a condition rather than explicit indices.

The APIs may look interchangeable at first, but they represent different programming styles. Picking the right one makes code easier to debug and often easier for TensorFlow to optimize.

Common Pitfalls

The most common issue is trying to modify a tf.Tensor directly. If the object is immutable, slice assignment is not an option, and you need a variable or a returned copy.

Another frequent problem is shape mismatch. If your index selection refers to two positions, the updates array must contain two values. If you assign a whole row, the replacement must have the same row width.

A subtler problem appears inside graph code. Repeated scatter updates in Python loops can be slower and harder to trace than vectorized replacements. If performance matters, batch your indices and updates instead of patching one element at a time.

Summary

• Plain tf.Tensor objects are immutable, so you cannot assign into them directly.
• Use tf.Variable.assign when you need to mutate part of a tensor in place.
• Use tf.tensor_scatter_nd_update when you want a modified copy with indexed replacements.
• Use tf.where when replacement is driven by a boolean condition.
• Check shape compatibility carefully before assigning or scattering updates.