When “Close Enough” Isn’t Enough: A Study of Autoregressive Drift in Learned Quantum Circuit Optimization on AMD Instinct™ GPUs

As quantum computing moves toward practical, fault-tolerant systems, optimizing quantum circuits has become one of the field’s most important challenges. Every unnecessary operation increases execution cost, so efficient circuit optimization is essential to getting useful performance out of future quantum hardware.

Large language models have learned to write code, prove theorems, and fold proteins. So it is natural to ask: can a neural network learn to optimize quantum circuits, the way a compiler learns to optimize a program, directly from data, instead of relying on hand-written rewrite rules?

In our recent paper accepted at the IEEE International Conference on Quantum Computing and Engineering (QCE 2026), we study exactly that question with a compact encoder–decoder transformer trained on AMD Instinct™ MI300X GPUs, and we systematically evaluate how model size, training data, and inference-time compute affect optimization quality.

The results show both the promise and the current limits of learned quantum circuit optimization. The model performs remarkably well on continuous-parameter circuits, but it consistently struggles on fully discrete Clifford+T circuits. We identify a previously uncharacterized failure mode we call autoregressive drift, and we show that adding training data has a far greater impact on correctness than simply adding more inference-time compute.

Key takeaways

1. AI models can successfully learn to optimize parameterized quantum circuits with high fidelity.
2. Fully discrete Clifford+T circuits expose a new failure mode we call autoregressive drift, where small prediction errors compound throughout sequence generation.
3. Increasing inference-time sampling improves results, but additional training data delivers significantly larger gains.
4. AMD Instinct™ MI300X GPUs enabled large-scale experimentation across model size, dataset scale, and inference strategies, helping isolate which approaches meaningfully improve exact correctness.

The problem: exact equivalence under a discrete resource budget

Fault-tolerant quantum computers can only run a restricted set of operations. The standard universal set is Clifford+T. Its non-Clifford T gates are especially expensive because they require magic-state distillation. T-count is simply the number of T and T† gates in a circuit, so reducing that count is a central compilation objective.

We frame this as sequence-to-sequence translation. Given an input circuit C_in on n qubits over the gate set G = {H, S, S^†, T, T^†,CNOT,CZ,X,Z}, we want a circuit C_out over G that is exactly equivalent: it may contain a different gate sequence, but it must perform the same quantum operation as the input, up to an unobservable global phase. We test this by comparing the two unitary matrices and accepting matches within a small floating-point tolerance, while preferring the match with the lowest T-count.

For n ≤ 6 the unitary is at most 64 × 64, so this check is inexpensive. That enables generate-and-verify: let the model propose several circuits, reject every proposal that does not implement the original operation, and keep the lowest-cost verified result.

Classical tools such as PyZX and the Qiskit transpiler already provide the reliable baseline. Our question is narrower: can a model learn their optimization behavior end-to-end, and what prevents it from producing exact results consistently?

Approach: a compact model with circuit-aware tokens

We use a deliberately compact 44.8M-parameter encoder–decoder transformer. Instead of treating a circuit as QASM text, we give each gate and qubit a typed token, so the model learns circuit operations rather than punctuation and syntax. For parameterized circuits, a small regression head also predicts rotation angles. This same model design lets us directly compare parameterized circuits, whose continuous angles can be refined after generation, with fully discrete Clifford+T circuits, which offer no such correction step.

Parameterized circuits: “close enough” is enough

For parameterized circuits we decouple the two things the model is good and bad at. The transformer predicts circuit structure (which gates, on which qubits); a separate 3-layer MLP head regresses each rotation angle as a (sin θ, cos θ) pair on the unit circle (recovered via atan2, side- stepping the 0/2π discontinuity).

The asymmetry is stark: structure is essentially perfect (100% structurally valid, correct gate counts), while raw angle predictions are only approximate (validation MAE from 77° at 2 qubits down to 6.4° at 6 qubits). Because the structure is correct, we hold it fixed and let Nelder–Mead refine the angles to maximize fidelity. That post-processing rescues the output:

Median fidelity reaches 1.000 on 3–6 qubits. Counter-intuitively, accuracy improves with qubit count because larger circuits expose more structural regularity for the model to latch onto.

Clifford+T: there is no “close enough”

Now remove the continuous escape hatch. Clifford+T circuits are entirely discrete. A single wrong gate token yields a completely different unitary, and there is nothing for a classical optimizer to refine. We train on 200K PyZX-optimized pairs (sample 10–50 gate random circuits, inject identity-equivalent redundancy, apply PyZX full_reduce + basic_optimization, decompose R_Z(kπ/4) to discrete gates, verify equivalence; average T-count drops 8.10 → 2.83, ~65%).

The model learns the distribution well: 100% of outputs are valid Clifford+T sequences, and predicted T-count (2.89) closely matches the PyZX target (2.83). But exact functional equivalence degrades sharply with target length:

Exact-equivalence rate (%) by target gate-count bin, 200 test samples.

Notably, qubit count is a much weaker predictor than length: under greedy decoding, per-qubit rates span only 7.2% (4q) to 15.2% (5q). The bottleneck is sequence length, not problem dimensionality.

That strength on short circuits suggests a possible deployment path: a peephole-style optimization pass within a production compiler. The compiler could divide a larger circuit into small windows, ask the model for a cheaper replacement, and accept it only after confirming equivalence. When verification fails, it would retain the original window or fall back to PyZX. In this role, the model would complement classical tooling rather than replace it.

Autoregressive drift: the mechanism

Why does the model succeed on parameterized circuits but struggle on discrete Clifford+T circuits?

The answer is a failure mode we call autoregressive drift. During sequence generation, each predicted gate is conditioned on all previous predictions. When the model makes an early mistake, even within the first one or two gates, that error propagates through the remainder of the sequence, causing subsequent predictions to drift farther from the correct solution.

Unlike parameterized circuits, where continuous rotation angles can be refined after generation, discrete Clifford+T circuits offer no opportunity for correction. A single incorrect gate changes the circuit’s functionality entirely, leaving no notion of “almost correct.” The result is the sharp drop in exact equivalence as circuit length increases that we saw above.

Per-sample diagnostics make the mechanism concrete. Token-position accuracy under greedy decoding shows the very first content token is correct only 56.2% of the time, falling to ~16% by position 30. The median first-error position is at just 3.1% of the target sequence, within the first one or two gates. Once a wrong token is emitted, every subsequent token is conditioned on that error, which cascades irrecoverably.

Three intertwined symptoms accompany it: (i) 87% of failures have the wrong output length (average deviation ~3 gates); (ii) early divergence, as above; and (iii) bimodal fidelity. Clifford+T outputs cluster at F ≈ 1 or F ≈ 0 with almost nothing in between, unlike the smooth parameterized distribution that Nelder–Mead can rescue.

This is the discrete-output cousin of exposure bias in neural machine translation, but it is far less forgiving. In translation a slip degrades quality smoothly; here one wrong gate corrupts the unitary entirely, with no partial credit. It is architectural, not a capacity limit: a 133.6M-parameter variant improves greedy only to 9.5%, and the position-accuracy curve keeps the same shape.

Two levers: inference-time compute and data

Drift explains why generate-and-verify works. For per-sample success probability p, drawing N independent samples and keeping any verified success yields 1 − (1 − p)^N, which saturates once Np ≫ 1. Simply sampling more candidates and letting the verifier keep the best can therefore rescue circuits with p > 0.

Temperature sampling (τ=0.8, top-p=0.95) with verifier-first reranking lifts exact equivalence from 7.0% with greedy decoding to 22.5% with 200 candidates, a greater than 3× gain. Returns clearly diminish beyond N=100: doubling candidate generation from 100 to 200 adds only 1.5 percentage points, the same pass@k behavior seen in code generation.

The table makes the quality–latency tradeoff explicit: additional decoding compute helps, but it remains far from closing the correctness gap. PyZX is both fully reliable on this benchmark and much faster. These results therefore diagnose the learned model’s behavior; they do not yet argue for replacing the classical optimizer.

The bigger lever, though, is training data. Holding the 44.8M architecture fixed and going 200K → 500K pairs (2.5×) raises Temp N=100 from 21.0% to 39.5% and lifts every length bin. The largest gain appears in the 10–14 gate range, but the drift signature persists: circuits with 26+ gates remain near zero.

Critically, we tested five interventions and only data scaling helped materially. Long-circuit finetuning (22.5%), weighted sampling (20.0%), hybrid pooled search (21.5%), and ensembling the 44.8M + 133.6M models (24.5%) all land within the confidence interval of the 21.0% baseline; the ensemble result suggests errors are correlated across architectures trained on the same data. Data scaling (39.5%) is the outlier.

Enabling large-scale AI research with AMD Instinct™ MI300X GPUs

This work required more than training a single model. It demanded systematic experimentation across model architectures, dataset sizes, and inference strategies to understand which factors genuinely improve correctness.

AMD Instinct™ MI300X GPUs provided the memory capacity and compute needed to evaluate these variables at scale. The platform let us compare multiple model sizes, expand training datasets, and generate hundreds of candidate solutions per circuit during inference, making it possible to distinguish improvements driven by model capacity, additional data, and inference-time compute. Concretely, the 44.8M-parameter Clifford+T model trains for 40 epochs in about 3.7 hours,