Decoding quantum errors with NVIDIA Ising Decoding on AWS

Quantum computers today are fragile: they lose their quantum state to noise and decoherence faster than a useful algorithm completes. Quantum error correction (QEC) makes longer computations possible by encoding each logical qubit across many physical qubits, so that errors can be detected and removed without disturbing the encoded information. In practice, QEC runs as a repeating cycle (see Fig. 1): in each round, the hardware measures a set of parity checks, called stabilizers, whose outcomes (the syndrome) reveal where errors have occurred without collapsing the logical state. A classical decoder then reads the syndrome, infers the most likely errors, and either records a correction to apply later or triggers a physical recovery.

Figure 1 – The quantum error correction cycle. On the quantum hardware, (1) a logical qubit is stored across many physical qubits, and (2) each round of stabilizer (parity-check) measurements produces a syndrome. The syndrome passes to classical processing, where (3) a decoder infers the likely error and (4) issues a recovery command that is fed back to the hardware. The cycle repeats every round.

The challenge is latency [1] (see our earlier post, A framework for quantum-classical integration decisions). On today’s superconducting hardware, for instance, one round takes on the order of one microsecond. If the decoder cannot keep up with that rate, a processing backlog builds and stalls the computation. Popular decoders such as minimum-weight perfect matching (MWPM) [2], which infers the most likely errors by pairing up syndrome signals in a graph, grow more expensive as the quantum error-correcting code size gets larger. A pre-decoder eases this bottleneck with a fast first pass that clears the easy, high-confidence errors, leaving the full decoder a much smaller problem. This is where AI-based pre-decoders [3,4] come in, such as NVIDIA Ising Decoding.

In this post we show how we trained NVIDIA Ising Decoding on AWS, how a range of accelerated compute instances compare in terms of performance and pricing, and how you can get started running similar workloads yourself.

AWS offers a broad and flexible range of accelerated compute instances, which makes it well suited for training machine learning (ML) models for QEC decoding. For this work we used Amazon EC2 P4d, P5, P5en, and P6 instances, accelerated by NVIDIA A100, H100, H200, and Blackwell B200 GPUs respectively, as well as G6e instances, accelerated by NVIDIA L40S GPUs. Every instance in this comparison provides eight GPUs, letting the pre-decoder train in a data-parallel fashion across all eight accelerators.

We ran every benchmark with the same containerized workflow on AWS Parallel Computing Service (AWS PCS), and every run used the same container image, so hardware was the only variable across instance types. The image holds the full training stack. NVIDIA CUDA and PyTorch run the neural-network training on the GPUs, Stim [5] simulates noisy quantum circuits to generate the syndromes used as training data, and the Ising Decoding repository implements the pre-decoder model and its training workflow. Each training sample is one shot of a distance-9 surface code memory experiment, in which a logical qubit is encoded in a 9-by-9 grid of data qubits and its stabilizers are measured over 9 consecutive rounds (step 2 in Fig. 1), under a circuit-level depolarizing noise model at a physical error rate of p = 0.006 per operation. Each epoch consists of about 67 million such shots, spread across all eight GPUs. We measured the average time to train one epoch once training reached a steady state. Fig. 2 shows the results.

Figure 2 – Average training time per epoch for Ising Decoding across accelerated compute instances (distance-9 surface code, circuit-level depolarizing noise at p = 0.006, 8 GPUs). Instances are ordered along the x-axis by NVIDIA GPU generation. Error bars show the standard deviation across steady-state epochs.

Ordered by GPU generation, the instances train progressively faster, cutting the average epoch time by up to about 39% from the A100-based P4d to the B200-based P6. The improvement is uneven and flattens at the top, where P5en and P6 finish within about 1 to 2% of each other, and the L40S in G6e keeps pace with the H100 in P5 to within about 6%. Based on Amazon EC2 On-Demand pricing in the US East (N. Virginia) Region as of October 2026, G6e is about 45% cheaper per hour than P5 while only about 6% slower, and P5en is about 44% cheaper per hour than P6 while only 1 to 2% slower. This lets you match the instance to the stage of the work, using G6e for high-volume early exploration and hyperparameter sweeps, and P5en or P6 when you want a trained model sooner or need the extra GPU memory for larger code distances. Ultimately, the most suitable instance depends on how you weight training time against budget for your workload.

Although the latency budget of a fault-tolerant machine requires decoding to run on classical hardware co-located with the QPU (as shown in Fig. 1), much of the decoder development that precedes deployment needs no quantum hardware and fits naturally in the cloud. Before a pre-decoder is deployed, its accuracy and speed must be characterized, and doing so at scale takes considerable compute. On AWS you can run these validation sweeps across accelerator generations and iterate on the pre-decoder’s neural network freely. Fig. 3 shows one such validation run on a single B200 GPU on a P6 instance: logical error rate versus decoding latency at physical error rate p = 0.006, comparing the MWPM decoder alone against the two Ising Decoding variants (“Fast” and “Accurate”), each followed by MWPM. We varied the code distance d from 5 to 31 by enlarging the surface-code patch. At small code distances the fixed runtime overhead of running the network dominates, so MWPM alone is faster. As the code distance grows, the MWPM decoder must process a larger syndrome volume, and the pre-decoder pays off: at distance 31 it reduces latency per round by roughly 2.4x (Fast) to 2.9x (Accurate) relative to MWPM alone, while improving the logical error rate. These results are consistent with what NVIDIA reports for Ising Decoding [3].

Figure 3 – Inference validation on a single B200 GPU (P6) for varying code distances (d): logical error rate versus decoding latency per QEC round at p = 0.006, comparing MWPM alone with the Ising Decoding Fast and Accurate variants, each followed by MWPM.

Quantum error correction depends on decoders that are both accurate and fast enough to keep up with a quantum processor, and pre-decoding is one promising way to speed up the decoding pipeline. In this post we trained Ising Decoding on AWS across five accelerated compute instance types, spanning four NVIDIA GPU generations, using a single containerized workflow on AWS PCS. We found that each newer GPU generation delivers faster training, and that cost varies just as much across instances, so the right instance depends on the stage of your work and your budget. We also validated the trained pre-decoder on AWS, where it reduced decoding latency at large code distances while improving the logical error rate. To get started, you can find the code in the NVIDIA Ising Decoding GitHub repository, and an AWS sample for PCS setup. Together they let you reproduce these benchmarks and adapt the workflow to your own QEC models.

[1] Rao, Pooja, et al. “Performance Model for Hybrid Quantum-Classical Workflows.” arXiv:2607.15426 (2026).

[2] Fowler, Austin G. “Minimum weight perfect matching of fault-tolerant topological quantum error correction in average O(1) parallel time.” arXiv:1307.1740 (2013).

[3] Chamberland, Christopher, et al. “Fast and accurate AI-based pre-decoders for surface codes.” arXiv:2604.12841 (2026).

[4] Olle, Jan, et al. “Fast and accurate AI-based pre-decoders for color codes.” arXiv:2607.10058 (2026).

[5] Gidney, Craig. “Stim: a fast stabilizer circuit simulator.” Quantum 5, 497 (2021).