Fast and accurate AI-based pre-decoders for surface codes

1. Problem Statement

Quantum Error Correction (QEC) is essential for fault-tolerant quantum computing (FTQC). However, a major bottleneck is the decoding latency.

• Runtime Constraints: To prevent an exponential backlog of unprocessed syndrome data during quantum algorithm execution, decoders must operate within strict time limits (typically $O(1\mu s)$ per syndrome measurement round).
• Scalability Issues: Traditional algorithmic decoders like Minimum-Weight Perfect Matching (MWPM/PyMatching) have runtimes that scale with syndrome density ($O(s^3)$ for MWPM). As code distances ($d$) increase to meet fault-tolerance requirements, the syndrome density and decoding time grow, making real-time decoding challenging.
• Scalability of AI Decoders: Pure AI-based decoders often struggle with scalability (training data requirements) and compatibility with parallel block-wise decoding architectures required for large-scale lattice surgery operations.
• Noise Model Uncertainty: In practice, circuit-level noise models are often unknown or time-varying, making it difficult to derive optimal decoding weights for global decoders.

2. Methodology

The authors propose a modular, hybrid decoding framework consisting of an AI-based pre-decoder followed by a global algorithmic decoder (PyMatching).

A. AI-Based Pre-Decoder Architecture

• Structure: A fully convolutional 3D neural network (CNN) that processes the space-time volume of syndrome data ($d \times d \times d_m$).
• Inputs: Encoded syndrome data including detector events (changes in stabilizer measurements) and geometric information (stabilizer weights and locations).
• Outputs: Four channels predicting:
  1. Spacelike corrections for $X$-type data qubits.
  2. Spacelike corrections for $Z$-type data qubits.
  3. Timelike corrections for $X$-type stabilizer measurements.
  4. Timelike corrections for $Z$-type stabilizer measurements.
• Key Innovations in Data Processing:
  • Timelike Failure Isolation: A protocol to separate pure timelike errors (measurement faults) from spacelike errors.
  • Fault Deferral: Prevents artificial timelike detection events caused by the temporal ordering of faults and measurements.
  • Homological Equivalence: A protocol to simplify training labels by identifying physically equivalent error configurations, reducing label complexity and improving training convergence.
• Training: Trained on labeled data generated from a circuit-level noise model. The architecture is backend-agnostic and can generalize to code distances larger than those used in training.

B. Noise-Learning Architecture

• Goal: To infer optimal edge and hyperedge weights for PyMatching directly from syndrome statistics without an explicit noise model.
• Mechanism: A 2D CNN with global average pooling extracts features from two consecutive syndrome rounds. It predicts 25 noise parameters (covering state prep, measurement, idle, and CNOT errors).
• Distance Independence: The probability formulas for edge/hyperedge types are independent of code distance, allowing a model trained at one distance (e.g., $d=21$) to generalize to others.
• Loss Function: Combines Mean Squared Error (MSE) for edge probabilities and hyperedge conditional probabilities, weighted by instance counts and variance-stabilizing factors.

C. Parallel Decoding Strategy

The system is designed for block-wise parallel decoding across space and time. The pre-decoder reduces the syndrome density, allowing the global decoder to run faster. Multiple GPUs can process different blocks (commit/cleanup windows) concurrently.

3. Key Contributions

1. Scalable Pre-Decoder Architecture: Introduced a 3D CNN that jointly predicts spacelike and timelike corrections, achieving backend-agnostic compatibility with any surface code global decoder.
2. Simultaneous LER and Runtime Improvement: Demonstrated for the first time that an AI pre-decoder can simultaneously reduce Logical Error Rates (LER) and total decoding runtime compared to a state-of-the-art global decoder alone.
3. GPU Deployment & Benchmarks: Benchmarked on NVIDIA GB300 GPUs using FP8 precision. Achieved end-to-end decoding runtimes of $O(1\mu s)$ per round at large code distances ($d=31$).
4. Noise-Learning Framework: Developed a method to learn decoding weights directly from experimental syndrome statistics, enabling optimized decoding even when the underlying noise model is unknown or drifting.
5. Resource Optimization: Showed that increasing batch sizes in parallel decoding schemes can reduce the number of required GPUs by up to 12.5x, critical for scaling to massive merged patches in lattice surgery.

4. Key Results

• Performance vs. PyMatching:
  • Uncorrelated PyMatching: The pipeline (Pre-decoder + Uncorrelated PyMatching) achieved lower LERs and lower runtimes than PyMatching alone for code distances $d \ge 21$ at physical error rates near the threshold ($p \approx 0.006$).
  • Correlated PyMatching: Using a larger, deeper residual network (Model 6), the pipeline outperformed correlated PyMatching alone up to $d=13$.
  • Speedups: Total decoding speedups reached 3.4x over uncorrelated PyMatching and 3.5x over correlated PyMatching at $d=31$.
• Syndrome Density Reduction: The pre-decoder reduced effective syndrome density by factors of 40x to 180x, significantly accelerating the global decoder.
• Latency:
  • Single-shot inference on a GB300 GPU: ~2–9 $\mu s$ (depending on model size and $d$).
  • With temporal parallelism (multiple GPUs/batch processing): Per-round runtime drops to well below 1 $\mu s$.
• Noise Learning:
  • Learned weights from raw syndrome data nearly matched the performance of weights derived from the known ground-truth noise model for uncorrelated matching.
  • For correlated matching, learned weights actually improved LERs compared to the known model, likely due to better handling of the heuristic reweighting process.
  • When applied to pre-decoder outputs, noise learning did not yield further gains, as the residual errors were already structured in a way that limited the benefit of weight re-optimization.

5. Significance

• Real-Time FTQC: This work provides a practical pathway to meeting the stringent latency requirements of real-time fault-tolerant quantum computing, specifically for large-distance surface codes.
• Modularity: The "pre-decoder + global decoder" approach allows hardware vendors to deploy fast, local AI corrections while retaining the robustness of established algorithmic decoders for the final correction step.
• Hardware Agnosticism: The noise-learning component allows the system to adapt to real-world hardware noise without requiring precise calibration or simulation, a critical feature for near-term quantum devices.
• Scalability: By enabling parallel block-wise decoding and reducing the classical resource footprint (via batching), this framework addresses the "classical bottleneck" that often limits the scaling of quantum error correction.

In summary, the paper establishes a high-throughput, modular decoding framework that leverages AI for local error suppression and noise adaptation, successfully overcoming the latency and accuracy trade-offs that have historically hindered large-scale surface code implementations.