🔬 physics

Real-time single-shot qubit-state discrimination on FPGA with a parameter-efficient Trace–IQ fusion network

This paper introduces a parameter-efficient Trace–IQ Fusion Network (TIF-Net) deployed on an FPGA that achieves superior real-time single-shot qubit-state discrimination fidelity (0.9962) compared to traditional matched filters and larger neural networks, while maintaining robustness to low-bit quantization and hardware synthesis constraints.

Original authors: Abdalkarim Awad

Published 2026-08-19

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Abdalkarim Awad

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

In the race to build a practical quantum computer, the most fragile part of the machine is not the processor itself, but the moment we try to listen to it. Superconducting qubits, the tiny circuits that act as the brain of these computers, exist in a state of delicate superposition, holding information that vanishes if disturbed too harshly. To read what a qubit is doing, scientists shine a microwave signal at it and listen for a faint echo. This echo arrives as a stream of data points, a noisy whisper that changes over time. The challenge is to decide, in a fraction of a second, whether the qubit is in its ground state or its excited state. This decision must happen instantly, while the qubit is still alive, so the computer can correct any errors before they spread. If the listening process is too slow or too clumsy, the information is lost, and the calculation fails. For years, the standard way to listen has been a simple, rigid method that treats the signal as a static snapshot, ignoring the subtle changes that happen as the signal unfolds.

A researcher has now demonstrated a smarter way to listen, one that runs directly on the hardware controlling the quantum computer. They developed a new method for reading these signals that is not only more accurate but also incredibly efficient, requiring far less computing power than previous attempts. By training a small, specialized computer program to recognize the specific shape of the signal's evolution, they achieved a level of accuracy that surpasses the long-standing industry standard. This breakthrough is significant because it proves that complex decision-making can happen in real-time, right next to the quantum processor, without overwhelming the system's limited resources. The researcher showed that by focusing on the specific way the signal changes over time, rather than just its average value, they could distinguish between the two states with a fidelity of 0.9962, a number that represents the probability of being correct.

The core of the problem lies in the imperfections of the physical world. When a qubit is measured, it does not always stay in the state it started in. It can decay, leaking energy and changing its identity halfway through the measurement window. It can also leak into a third, unwanted state that the standard reading methods do not expect. Furthermore, the equipment itself drifts slightly over time, shifting the signal's position. The traditional method, known as a matched filter, works well when the signal is a perfect, static cloud of data points. However, it fails when the signal is a moving target that changes shape or position during the measurement. It essentially averages the whole signal together, throwing away the crucial information about how the signal changed moment by moment. This limitation meant that a significant portion of the potential accuracy was being left on the table.

To solve this, the researcher built a simulation that mimics the real-world noise and imperfections of a quantum measurement, including the decay and the drift. They used this simulation to generate a massive dataset of forty thousand individual measurement events. They then tested four traditional mathematical methods against a new approach based on neural networks, which are computer systems designed to learn patterns from data. The traditional methods, including the standard matched filter and a simple integration technique, struggled to keep up with the messy reality of the simulation. They achieved fidelities ranging from roughly 0.97 to 0.98, meaning they made mistakes in about two to three percent of cases.

The researcher then introduced a new architecture they call the Trace–IQ Fusion Network. This system is designed with two distinct pathways that work together. One pathway looks at the entire history of the signal, analyzing how the shape of the wave changes over time to catch those mid-measurement decays and leaks. The other pathway simply calculates the average position of the signal, which is what the old methods relied on. By fusing these two views, the network gets the best of both worlds: it knows the overall position but also understands the story of how it got there. Remarkably, this new network achieved a fidelity of 0.9962, outperforming the best traditional method by a clear margin. It made fewer errors than the standard approach, correctly identifying the state in nearly every single shot.

What makes this discovery particularly powerful is not just the accuracy, but the extreme efficiency of the design. The new network required only 686 adjustable numbers, or parameters, to learn the task. In contrast, a standard neural network that achieved similar accuracy needed over seven thousand parameters. This means the new system is roughly ten times more efficient, using a fraction of the memory and computing power. This efficiency is critical because the decision must be made on a field-programmable gate array, a type of chip that sits right next to the quantum processor and has very limited space for extra software. The researcher showed that their design could be shrunk down even further, working effectively with very small numbers, which allows it to run on the hardware without slowing down the rest of the system.

To ensure this design could actually be built into real hardware, the researcher had to overcome a specific technical hurdle. When translating the software design into the language that hardware chips understand, a common step called "pooling," which simplifies data, often caused the numbers to scale incorrectly, breaking the logic of the network. The researcher solved this by replacing the standard pooling step with a fixed, unchangeable calculation that performed the same job but behaved correctly in the hardware translation. This small but clever adjustment allowed the entire system to be synthesized into a working chip design without losing any of their learned intelligence. They verified this by running a digital simulation of the chip, which matched the original software model with near-perfect precision, confirming that the design would work as intended when built.

The results suggest that the future of quantum computing lies in these compact, intelligent listeners. By moving away from rigid, one-size-fits-all methods and embracing systems that can adapt to the messy, changing nature of quantum signals, scientists can extract more information from their machines. The new network proved that it is possible to achieve high-fidelity readings in real-time, even when the qubits are decaying or drifting. While the study was conducted using a highly realistic simulation rather than a physical quantum computer, the results provide a clear roadmap for the next generation of control systems. The ability to run such a sophisticated discriminator on a small chip means that quantum computers can now react to their own errors faster and more reliably than ever before, bringing the dream of a stable, large-scale quantum machine one step closer to reality.

Technical Summary: Real-time Single-Shot Qubit-State Discrimination on FPGA with a Parameter-Efficient Trace–IQ Fusion Network

Problem Statement
Fast, high-fidelity single-shot readout is a prerequisite for real-time feedback in superconducting-qubit processors. The current field standard, the matched filter (or weighted boxcar), assumes static Gaussian clusters with equal covariance. However, practical dispersive readout signals violate these assumptions due to mid-measurement energy decay ( $T_1$ ), leakage to the second excited state ( $|2\rangle$ ), slow IQ parameter drift, and finite signal-to-noise ratio (SNR). These non-idealities cause the matched filter to discard valuable temporal structure, degrading assignment fidelity. While machine learning classifiers can recover this fidelity, they must operate within strict latency budgets inside the real-time control loop, typically on Field-Programmable Gate Arrays (FPGAs) or RF System-on-Chips (RFSoCs). General-purpose processors are too slow due to data movement latency, necessitating the deployment of quantized neural networks directly on hardware via High-Level Synthesis (HLS).

Methodology
The author presents an end-to-end study involving simulation, model design, and FPGA synthesis:

Physically Motivated Simulation: A fully reproducible simulation of dispersive single-shot readout was constructed to generate a benchmark dataset of 40,000 shots. The model includes:
- Cavity ring-up dynamics ( $\tau_\kappa = 200$ ns).
- Mid-measurement $T_1$ decay (quantum jumps from $|1\rangle$ to $|0\rangle$ ).
- Leakage to the $|2\rangle$ state (2% probability).
- Slow IQ drift and complex white Gaussian noise (SNR = 1.0).
- The task is binary discrimination ( $|0\rangle$ vs. $|1\rangle$ ), with leakage mapped to the excited state label.
Model Architectures:
- Classical Baselines: Boxcar integration, matched filtering, Linear Discriminant Analysis (LDA), and a Gaussian Mixture Model (GMM).
- Floating-Point CNN: A standard 1D CNN (7,194 parameters) serving as a floating-point reference.
- Quantization-Aware CNN (QKeras): The same CNN topology retrained with QKeras quantizers (8-bit weights/activations, 12-bit input) to model fixed-point arithmetic during training.
- Trace–IQ Fusion Network (TIF-Net): A novel, compact two-branch architecture designed for parameter efficiency:
  - Trace Branch: A strided-convolution temporal feature extractor (downsampling 100 samples to 25, then to 4 bins) to capture trajectory shape.
  - Integrated-IQ Skip Branch: A fixed-weight global average convolution that computes a matched-filter-like statistic (integrated IQ position) with minimal parameters.
  - Fusion Head: Concatenates the two branches and projects to output logits.
  - TIF-Net utilizes only 686 trainable parameters (1,470 total including fixed kernels).
FPGA Implementation & HLS Optimization:
- Models were compiled to RTL using the hls4ml workflow for a Xilinx Zynq-7020 device (200 MHz clock).
- Synthesis-Safe Pooling: The author identified a scaling pathology in the hls4ml toolchain where standard average-pooling primitives rescaled activations incorrectly. They resolved this by replacing pooling operations with fixed-weight convolutions (mathematically identical but handled correctly by the convolution code path).
- Precision Configuration: Per-layer fixed-point precision was applied to match observed activation magnitudes, ensuring branch scales aligned correctly at concatenation to prevent quantization to zero.

Key Results

Fidelity: TIF-Net achieved the highest assignment fidelity of 0.9962, outperforming the matched filter (0.9732) by 2.3 percentage points and the floating-point CNN (0.9937) by 0.25 points.
Parameter Efficiency: TIF-Net achieved this performance with 686 trainable parameters, roughly 10.5 times fewer than the standard CNN (7,194 parameters). This represents a fidelity-per-parameter gain of roughly 10x.
Quantization Robustness: Both networks retained near-peak fidelity with weights quantized down to 4 bits. The QKeras CNN showed no degradation below 8 bits, and TIF-Net reached its peak at 12 bits but remained strong at 4 bits (0.9957).
Bit-Accuracy: hls4ml C-simulations of the synthesized RTL matched the trained software models within $3 \times 10^{-4}$ fidelity and agreed on >99.8% of individual shots, confirming the correctness of the fixed-weight pooling and scale-matching strategies.
Error Analysis: Residual errors were dominated by $|1\rangle \to |0\rangle$ transitions caused by mid-window decay and leakage. TIF-Net reduced these specific errors compared to the CNN, demonstrating its ability to utilize temporal trajectory information that the matched filter misses.

Significance and Claims
The paper claims that TIF-Net offers a highly efficient solution for real-time qubit readout by explicitly fusing learned temporal features with the physically motivated integrated-IQ statistic. The primary contributions are:

Architecture: A compact, two-branch network that achieves state-of-the-art fidelity with an order of magnitude fewer trainable parameters than standard CNNs, making it ideal for resource-constrained FPGAs.
Synthesis Technique: The substitution of pooling primitives with fixed-weight convolutions to avoid HLS scaling pathologies, a construction claimed to be broadly useful for synthesizing pooling-heavy networks.
Deployment Viability: The demonstration that quantization-aware training acts as a regularizer (slightly improving floating-point performance) and that 4-bit weights are sufficient for near-peak fidelity, significantly reducing the DSP and LUT cost for on-board deployment.

The author notes that while the study relies on simulated data capturing key non-idealities, it does not yet include full place-and-route latency measurements or hardware-in-the-loop validation on actual quantum devices. The work establishes a functional, bit-accurate foundation for in-the-loop readout classifiers.

Technical Summary: Real-time Single-Shot Qubit-State Discrimination on FPGA with a Parameter-Efficient Trace–IQ Fusion Network

More like this