TL;DR
This paper investigates the trade-off between accuracy and latency in neural decoders for quantum error correction (QEC). The authors demonstrate that for near-term quantum computers, decoding performance is primarily driven by the scale of training data and the presence of appropriate architectural "inductive biases," rather than complex model architectures. Crucially, they show that aggressive INT4 quantization, achieved through quantization-aware training, is essential for meeting the microsecond-scale latency requirements needed for practical QEC on FPGAs.
What Problem Does This Paper Address?
Quantum computers are highly susceptible to errors. Quantum Error Correction (QEC) is a crucial technique to protect quantum information from these errors, enabling the development of fault-tolerant quantum computers. A key component of QEC is the "decoder," which analyzes error syndromes to determine and correct the errors. However, decoding is computationally challenging, with theoretical limits suggesting it's NP-hard. This creates a fundamental tension: achieving high decoding accuracy often requires complex computations, leading to high latency, which is incompatible with the real-time feedback needed for quantum operations. Neural decoders have emerged as a promising data-driven approach, but their practical deployment is hindered by this accuracy-latency trade-off, especially for surface codes, which are a leading candidate for QEC. This paper aims to reconcile this trade-off by systematically evaluating neural decoders for surface codes, focusing on their performance under strict accuracy and microsecond-scale latency constraints.
Methods
The authors unify and redesign five representative neural decoder architectures: Multilayer Perceptrons (MLPs), 3D Convolutional Neural Networks (CNNs), Temporal Convolutional Networks (TCNs), Transformers, and Graph Neural Networks (GNNs). They evaluate these architectures on surface codes with code distances up to $d=9$ (161 physical qubits). To address the latency challenge, they develop an end-to-end model compression pipeline that combines weight pruning and aggressive INT4 quantization (using Quantization-Aware Training, QAT). This pipeline aims to create lightweight neural decoders suitable for deployment on Field-Programmable Gate Arrays (FPGAs). They also develop an analytical model for FPGA resource estimation to assess deployability.
Datasets
The primary datasets used are synthetically generated using the Stim library, simulating a rotated surface code with a depolarizing noise model. For code distances $d \in \{3,5\}$, training set sizes range from $10^5$ to $5 \times 10^6$ samples. For $d \in \{7,9\}$, training set sizes go up to $2.5 \times 10^7$ samples. A test set of $5 \times 10^4$ samples is used for evaluation. Additionally, the authors validate their findings on real quantum hardware data from the Google Sycamore processor for $d=3$ and $d=5$.
Key Insights and Ideas
- Data Scale is King (with a caveat): For near-term QEC, the scale of training data is a more significant driver of decoding accuracy than architectural complexity, provided the architecture has appropriate inductive biases.
- Inductive Bias is Non-Negotiable: Architectures need "inductive biases" that align with the problem's structure (e.g., spatial locality for CNNs, temporal dependencies for TCNs). MLPs (lacking bias) and GNNs (misaligned bias for surface codes) fail to scale effectively.
- INT4 Quantization is a Prerequisite, Not an Option: Achieving microsecond-scale latency on FPGAs necessitates aggressive INT4 quantization. This is only reliably achievable through Quantization-Aware Training (QAT), not just post-training quantization.
- Hardware-Algorithm Co-design is Crucial: To meet real-time constraints, hardware limitations (like FPGA resource availability and latency budgets) must be explicitly considered during model design and training.
Key Results
- Scalability: Structure-aware architectures (CNN, TCN, Transformer) consistently outperform MWPM and maintain performance margins as code distance increases. MLPs degrade significantly at higher code distances.
- Data-First Regime: A simple neural decoder trained on a large dataset ($10^7$ samples) outperformed more complex architectures trained on smaller datasets.
- INT4 QAT for Latency: QAT with INT4 quantization was essential to recover accuracy lost during compression and meet the microsecond latency target on FPGAs. Without QAT, models suffered catastrophic degradation.
- FPGA Feasibility: Lightweight, INT4-quantized neural decoders (specifically TCN) can be deployed on FPGAs and meet the strict 1 µs latency requirement even for $d=9$ code distances.
- Real-World Validation: Neural decoders, when informed by device-specific noise models, can outperform classical decoders even on real quantum hardware.
Limitations and Future Work
- FPGA Resource Estimation: The resource estimation model uses a conservative 50% derating factor for LUTs, which might not perfectly reflect actual hardware synthesis outcomes.
- Model Complexity vs. Accuracy: While the paper focuses on accuracy-latency trade-offs, there's still a desire to push accuracy further, potentially requiring more complex architectures or larger datasets.
- Generalization to Other Codes: The study primarily focuses on surface codes. Extending these findings to other QEC codes, particularly those with irregular structures like quantum LDPC codes, would be valuable.
- Hardware-Specific Optimizations: While the INT4 approach is general, further hardware-specific optimizations for different FPGA architectures could yield additional gains.
Summary updated