Inductor fails to compile cumsum on a 0-dim constant tensor with tuple index out of range

Compilation aborts on a graph containing a cumulative sum over a scalar constant. A post-graph optimisation recognises the pattern, asks the tensor for the length of the dimension being summed, and a scalar has no dimensions to ask about, so indexing its empty shape raises before any code is generated.

A compile-time failure in which a post-graph optimisation for cumulative sum reads a dimension length from the shape of a 0-dimensional constant tensor, whose shape tuple is empty, raising an index error before code generation.

Pattern-based rewrites match on operation and operands and then assume the shapes they usually see. A cumulative sum is almost always applied to something with at least one dimension, so reading the length of that dimension is a safe-looking step. A scalar constant satisfies the match and violates the assumption, and the guard for the degenerate case was never written because the degenerate case is not useful enough for anyone to have tried it.

• The same function runs correctly without compilation, so the model is not wrong
• The error is an index error inside the compiler, which says nothing about which operation caused it
• It depends on the tensor being a compile-time constant, so an identical shape produced at runtime does not trigger it
• A scalar cumulative sum looks pointless and is usually incidental to a larger expression nobody wrote deliberately

• Compiled graphs containing a cumulative sum over a tensor built from a literal, such as a scalar constant
• The post-graph optimisation stage, which rewrites recognised patterns after the graph is captured and before code generation
• Code where a scalar reaches an operation expecting at least one dimension through broadcasting or a generic helper
• Model code generated or templated rather than written by hand, where a degenerate shape is easy to produce unnoticed

Apply the following checklist to a small reproduction: each box below is a positive signal that you are looking at this exact failure rather than a sibling in the same taxonomy.

• ✓Compile with a graph-capture-only backend. Succeeding there while the default backend fails places the fault in code generation rather than in tracing.
• ✓Reduce the function to a cumulative sum over a single scalar constant. Reproducing on that alone identifies the pattern precisely.
• ✓Add an explicit dimension to the constant and recompile. Success confirms the empty shape tuple as the cause.

torch._inductor.exc.InductorError: IndexError: tuple index out of range
  File ".../torch/_inductor/fx_passes/post_grad.py", in pointless_cumsum_replacement
    dim_size = shape[dim]
  File ".../torch/_inductor/compile_fx.py", in _compile_fx_inner
Set TORCHDYNAMO_VERBOSE=1 for the internal stack trace

Timestamps and exact values vary across runs, but the pattern. An info-level start, an early WARN, an ERROR carrying the symptom. Is the actual fingerprint you should alert on. The Denpex platform flags this combination automatically.

Adding a dimension makes the shape tuple non-empty, so the length is readable and the rewrite proceeds normally. Removing the operation avoids the pattern entirely. Computing the constant at runtime leaves its size unknown, and the rewrite requires a compile-time size, so it declines to fire. Each removes the precondition rather than working around the symptom.

// Typical pattern:
import torch.optim as optim
optimizer = optim.AdamW(model.parameters(), lr=3e-4)
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=num_training_steps)
for step in range(num_training_steps):
    optimizer.zero_grad()
    loss = model(batch)
    loss.backward()
    optimizer.step()
    scheduler.step()

Adapt the snippet to your framework. The same pattern holds for PyTorch Lightning, Hugging Face Trainer, DeepSpeed, Megatron-LM, and vLLM training wrappers. Where the wrapper exposes a config flag (for examplelr_scheduler_type in Trainer), prefer the flag over the imperative API to keep the schedule declarative and reproducible.