Why is .grad None on a PyTorch tensor after calling backward()?

## Leaves and non-leaves Autograd divides tensors into two classes. A **leaf** is a tensor you created directly — `torch.randn(3, requires_grad=True)`, an `nn.Parameter`, an input batch. Its `is_leaf` is `True` and its `grad_fn` is `None`, because no recorded operation produced it. A **non-leaf** is anything that came out of an op on a grad-requiring tensor; it carries a `grad_fn` and `is_leaf` is `False`. When you call `.backward()`, autograd computes a gradient for *every* node it walks through — it has to, that is how the chain rule composes. But it only **stores** the result on leaves that require grad. The intermediate gradients are passed to the next node and released, because keeping them would multiply memory for no benefit in the normal training case, where only parameter gradients are consumed by the optimizer. So this is expected behaviour, not a bug: ``` a = torch.tensor([2.0], requires_grad=True) b = a * 3 # non-leaf c = (b ** 2).sum() c.backward() a.grad # tensor([36.]) b.grad # None, plus a UserWarning ``` Modern PyTorch emits a warning when you access `.grad` on a non-leaf precisely because this trips people up. The fix, when you genuinely want the intermediate gradient (probing activations, visualizing saliency, debugging a layer), is `b.retain_grad()` *before* the backward call. An alternative that avoids storing anything is `torch.autograd.grad(c, b)`, which returns the gradient as a value instead of writing it into `.grad`. ## Cause two: the tensor never required grad `.grad` stays `None` forever on a tensor whose `requires_grad` is `False`, because no backward node referencing it was ever created. This bites in two situations. One is a freshly created tensor where you forgot the flag. The other is a parameter you froze earlier — `p.requires_grad_(False)` — and then wondered why the optimizer is not moving it. A related trap: `.grad` is `None`, not zeros, before the first backward pass. Code like `if p.grad.norm() > 1:` crashes with `AttributeError: 'NoneType' object has no attribute 'norm'` on the very first iteration. Modern `zero_grad()` also sets gradients back to `None` rather than to zero tensors by default, so `None` is a normal steady state between steps, not evidence of a broken graph. ## Cause three: the graph is severed The most interesting failure. The tensor is a leaf, it requires grad, and `.grad` is still `None` — which means the loss you called `backward()` on genuinely does not depend on it, through a *recorded* path. Ways that happens: - **An explicit `.detach()`** somewhere in the forward path. Detach returns a tensor sharing the same storage with `requires_grad=False`, so numerics are unchanged and nothing raises — the gradient just stops there. - **A `torch.no_grad()` block** wrapping part of the model. Everything computed inside is untracked. - **A round trip through NumPy or Python scalars** — `.numpy()`, `.item()`, `.tolist()`, or `int(...)`. Autograd cannot follow numbers out of the framework and back. - **Rebinding instead of mutating.** Writing `layer.weight = layer.weight - lr * g` replaces the `nn.Parameter` object with a plain non-leaf tensor; the optimizer still points at the old object. In-place updates under `no_grad`, or just using an optimizer, avoid this. - **A branch that was never taken.** With a dynamic graph, a parameter used only inside an `if` that was false this iteration gets no gradient at all. That is correct, and it is why some sparse or mixture models legitimately show `None` for some parameters on some steps. ## The diagnostic sequence When a gradient is missing, do this in order: 1. Print `t.is_leaf`, `t.requires_grad`, `t.grad_fn`. That immediately separates "non-leaf", "not tracked" and "severed". 2. Print `loss.grad_fn` and walk `loss.grad_fn.next_functions` a level or two, or simply check `loss.requires_grad` — if the loss itself does not require grad, the whole forward pass was untracked. 3. Sweep the model: `[n for n, p in model.named_parameters() if p.grad is None]` after a backward pass names exactly which subtree is disconnected, which usually points straight at the offending line. 4. Distinguish `None` from **zero**. A gradient of `0.0` means the path exists but the derivative vanished — a saturated activation, a dead ReLU, a multiplication by a zeroed mask. That is a modelling problem, not a wiring problem, and the fix is completely different. That last distinction is the one interviewers listen for. `None` means autograd never got there; zero means it got there and the math said zero.