Introduction

In TensorFlow 1 style code, optimizer.compute_gradients() and tf.gradients() both produce gradients, but they operate at different abstraction levels. tf.gradients() is the low-level graph function for differentiating tensors, while optimizer.compute_gradients() is an optimizer-oriented helper that usually calls into gradient computation and packages the results as (gradient, variable) pairs for training.

tf.gradients() Is the Raw Gradient API

tf.gradients() asks TensorFlow to differentiate one tensor with respect to one or more other tensors.

1import tensorflow as tf
2
3tf.compat.v1.disable_eager_execution()
4
5x = tf.Variable(3.0)
6y = x * x + 2 * x
7grads = tf.gradients(y, [x])

Here, grads is a list of symbolic gradient tensors. The function does not know anything about optimizers, learning rates, or parameter updates. It only builds the gradient expressions.

This makes it useful for:

• custom math
• analysis and debugging
• manual update rules
• gradients with respect to arbitrary tensors, not just trainable variables

optimizer.compute_gradients() Is Training-Focused

An optimizer method such as GradientDescentOptimizer.compute_gradients() is a higher-level API designed for parameter updates.

optimizer = tf.compat.v1.train.GradientDescentOptimizer(learning_rate=0.1)
loss = x * x + 2 * x
grad_var_pairs = optimizer.compute_gradients(loss, var_list=[x])

This returns (gradient, variable) tuples instead of bare gradient tensors. That format is useful because the next step is usually:

train_op = optimizer.apply_gradients(grad_var_pairs)

So the optimizer API is not just about computing derivatives. It is about integrating gradient computation into the optimization workflow.

The Return Types Are Different on Purpose

This is one of the clearest distinctions.

tf.gradients() returns something like:

• '[grad_x, grad_y, ...]'

optimizer.compute_gradients() returns something like:

• '[(grad_x, x), (grad_y, y), ...]'

That second form is convenient when you want to inspect, clip, filter, or transform gradients before applying them.

Optimizer Methods Understand Variables Naturally

Because the optimizer method is meant for training, it works naturally with trainable variables and optimizer-specific options such as gradient aggregation and gating.

For example, clipping before application is straightforward:

1grad_var_pairs = optimizer.compute_gradients(loss)
2clipped = [(tf.clip_by_norm(grad, 5.0), var)
3           for grad, var in grad_var_pairs
4           if grad is not None]
5train_op = optimizer.apply_gradients(clipped)

You could do something similar with tf.gradients(), but you would have to manually pair gradients back with the correct variables.

tf.gradients() Is More General

A key strength of tf.gradients() is that it is not limited to optimizer use cases. You can differentiate with respect to intermediate tensors or inputs.

1x = tf.constant(2.0)
2y = x * x
3z = y * 3.0
4grad = tf.gradients(z, [x, y])

This is useful for sensitivity analysis, research experiments, or custom graph construction where no optimizer is involved.

The Optimizer API Often Wraps Gradient Logic

In practice, optimizer.compute_gradients() relies on TensorFlow's gradient machinery underneath. It is not a completely different differentiation engine. The difference is the abstraction level and the optimizer-specific behavior layered around that engine.

A good way to think about it is:

• 'tf.gradients(): raw graph differentiation primitive'
• 'optimizer.compute_gradients(): training helper built on top of gradient computation'

TensorFlow 2 Changed the Recommended API

For modern TensorFlow, both of these are largely historical in everyday code. TensorFlow 2 prefers tf.GradientTape.

1import tensorflow as tf
2
3x = tf.Variable(3.0)
4with tf.GradientTape() as tape:
5    y = x * x + 2 * x
6
7grad = tape.gradient(y, x)
8print(grad.numpy())

So if you are writing new TensorFlow 2 code, the practical comparison matters mostly when reading TensorFlow 1 tutorials or maintaining older graph-based training loops.

When to Use Which in Legacy Code

In TensorFlow 1 style code:

• use optimizer.compute_gradients() when you are building a training step
• use tf.gradients() when you need raw derivatives for custom logic

That is the usual rule of thumb.

If you also plan to apply the gradients with the same optimizer, the optimizer API is typically clearer and less error-prone.

Common Pitfalls

• Expecting tf.gradients() to return variable pairs ready for apply_gradients().
• Using optimizer.compute_gradients() for arbitrary tensor analysis when the optimizer context is unnecessary.
• Forgetting that both APIs are mainly TensorFlow 1 style and not the preferred TensorFlow 2 pattern.
• Not handling None gradients before clipping or applying updates.
• Treating the two functions as different differentiation engines rather than different abstraction layers.

Summary

• 'tf.gradients() is the low-level TensorFlow 1 graph API for differentiating tensors.'
• 'optimizer.compute_gradients() is a higher-level training API that returns (gradient, variable) pairs.'
• The optimizer method is better suited to building update steps with apply_gradients().
• 'tf.gradients() is more general for custom derivative logic.'
• In modern TensorFlow 2, tf.GradientTape is the preferred API instead of either of these older patterns.