Spiking neural networks for streaming qubit readout

AI summary

Overview

Research area: Superconducting-qubit readout and neuromorphic (spiking) neural network inference on FPGA hardware for quantum control.

Technical level: Intermediate. The paper assumes some familiarity with qubit readout (dispersive measurement, IQ traces, matched filtering) and with standard neural-network training; the spiking-neuron and HLS-synthesis sections are introduced from first principles.

Scope (one sentence): A five-qubit frequency-multiplexed transmon readout benchmark used to compare matched filters, a full-trace ANN and chunk-by-chunk spiking neural networks (SNNs), together with quantisation-aware training and hls4ml synthesis estimates for streaming FPGA inference.

What This Paper Is About

Conventional qubit-state assignment, such as matched filtering, must wait for the entire measurement window to be acquired before it produces a decision, so the total readout latency equals the readout-pulse duration plus inference time. The authors ask whether a spiking neural network, which keeps an internal state that evolves over time, can consume the readout trace in successive chunks and emit progressively updated qubit-state assignments while the signal is still being acquired, without giving up accuracy. They test this on a public five-qubit multiplexed-readout dataset and then check whether the networks can be quantised and synthesised for FPGA deployment fast enough to keep up with the incoming data.

Key Contributions

1. A streaming SNN discriminator for multiplexed qubit readout. The readout trace is split into T ∈ {5, 10} chunks (200 ns and 100 ns duration respectively), compressed to 10-dimensional local features (L₅) and optionally combined with cumulative features (C₅), and fed one chunk at a time to a leaky integrate-and-fire network that updates a five-bit assignment after every chunk.

2. A systematic benchmark against matched filtering and a full-trace ANN. Matched filters, an ANN with a 128-neuron hidden layer operating on the flattened time series, and SNNs with 32-, 64- and 128-neuron hidden layers are compared on the same dataset using geometric-mean single-qubit assignment fidelity (F_geom).

3. Mid-readout loss shaping. An auxiliary binary cross-entropy term applied at 600 ns, weighted equally with the final-window loss, is shown to improve intermediate-time fidelity while leaving the end-of-window fidelity essentially unchanged — giving an explicit latency-versus-fidelity tuning knob.

4. A hardware path via quantisation-aware training and hls4ml. The SNNs are fine-tuned for W-bit fixed-point arithmetic (W ∈ {8, 10, 12, 16}) and translated to HLS code with hls4ml for Vitis HLS C-synthesis estimates, targeting the requirement that each inference update completes within the 100 ns chunk period.

Main Findings

• SNNs approach ANN accuracy without full-trace access. The best SNN in the scan (128-neuron hidden layer, L₅+C₅ features, T = 10) reaches F_geom = 0.9084, against F_geom = 0.9100 for the T = 10, 128-neuron ANN on L₅ features. A 64-neuron SNN with the same features reaches F_geom = 0.9083.

• SNNs beat matched filtering. The matched-filter baseline reaches F_geom = 0.8960 in the Section 2.2 text (Table 2 lists 0.8962). The T = 5, 64-neuron SNN with L₅+C₅ features reaches F_geom = 0.9070.

• Qubit 2 dominates the residual error. Matched-filter per-qubit fidelities are 0.9688, 0.7396, 0.9007, 0.9360 and 0.9569 for q1–q5; the ANN (T = 10, 128-neuron) gives 0.9705, 0.7435, 0.9416, 0.9465, 0.9704 and the best SNN gives 0.9693, 0.7424, 0.9388, 0.9454, 0.9685. The q2 diagonal cross-fidelity improves only from the matched-filter value F^CF₂₂ = 0.479 to about 0.48–0.49, so most machine-learning gains come from the other four qubits.

• Crosstalk suppression is competitive. The largest off-diagonal cross-fidelity magnitude is 0.0159 for the ANN, 0.0210 for the 32-neuron SNN and 0.0130 for the 64-neuron SNN (all T = 10, L₅+C₅), making the 64-neuron SNN the cleanest of the three representative models on pairwise crosstalk, while the ANN retains a slightly larger diagonal contrast.

• Adding cumulative features helps mainly through capacity. C₅ improves both T = 5 and T = 10 models, but the authors attribute this largely to the increase in parameter count rather than to information the networks could not reconstruct internally from L₅ alone.

• Mid-readout loss shifts accuracy earlier in the window. With the 600 ns auxiliary loss, the T = 5 model's 600 ns fidelity rises from 0.8881 to 0.8920 while final fidelity moves from 0.9070 to 0.9063; the T = 10 model's 600 ns fidelity rises from 0.8885 to 0.8939 (largest gain at 400 ns) while final fidelity moves from 0.9083 to 0.9076.

• Qubits converge at different rates. Per-qubit mid-readout curves show q5 and q3 have plateaued by 600 ns, whereas q4, q2 and q1 keep improving to the end of the 1 μs window.

• Hardware feasibility is asserted at the chunk-period level. The stated hardware requirement is that each SNN inference update completes within 100 ns so the network state can be updated before the next chunk arrives. The provided text is truncated partway through Section 5.1 (the QAT scheduler description), so the specific post-synthesis latency, resource-utilisation (LUT/DSP/FF) and power numbers are not reported in the content available here.

Methodology in Plain English

The authors start from an existing five-qubit dataset in which the device was prepared in all 2⁵ = 32 computational basis states and the reflected multiplexed readout signal was digitised into time-resolved in-phase and quadrature (IQ) traces. They keep only the first 1 μs of each trace, sampled every 2 ns, giving 500 samples per trace, and demodulate each qubit's channel at its intermediate frequency. Traces are smoothed with a centred moving-average boxcar (W = 5 for the illustrative figures, W = 25 for the matched-filter benchmark).

Because 2 ns is far too fast for a network to consume point by point, they average the stream into T chunks of 200 ns (T = 5) or 100 ns (T = 10). Two feature sets are formed per chunk: a local vector L₅ containing the average I and Q of that chunk for all five qubits (10 numbers), and a cumulative vector C₅ containing the running average from the start of the window (another 10 numbers). Features are standardised with training-split statistics.

The classifier is a spiking network: a dense layer, one leaky integrate-and-fire hidden layer, dropout (0.02) and a dense five-logit readout that is thresholded at zero to give the five bits. The leaky neurons use a learnable leak parameter initialised at β = 0.75, a threshold of 1.0 and a subtractive reset; the readout accumulates membrane potential without decay (β_ro = 1.0). Networks are trained in snnTorch with surrogate gradients and bitwise binary cross-entropy, with loss applied only at the final chunk by default. The ANN baseline flattens the whole sequence into one vector, uses a single 128-neuron ReLU hidden layer and is trained with the same loss. Splits are 432,000 training traces, 48,000 validation traces and a 1,120,000-trace test set, balanced across the 32 states. Models are trained with minibatch size 1024, early stopping after 30 epochs without improvement greater than 10⁻⁵, a 250-epoch cap, and the best checkpoint chosen on validation F_geom; results come from a single fixed-seed run, with seed-to-seed fluctuation noted at the order of 10⁻⁴.

Finally, the trained SNNs are fine-tuned with quantisation-aware training for fixed-point weights and neuron potentials (W ∈ {8, 10, 12, 16} bits with 4 integer bits; 16 total bits with 8 integer bits for the readout membrane; 18 total bits with 8 integer bits for the accumulator, which uses truncation and wrapping for latency reasons while everything else uses rounding and saturation) and passed through hls4ml to Vitis HLS for C-synthesis estimates.

Why This Matters

Qubit readout is not a final diagnostic step but a component of every error-correction cycle, calibration routine and feedback protocol, so shaving latency off the measurement-to-decision path directly extends what feedback protocols are feasible. This paper's distinctive claim is not raw accuracy — an ANN on the full trace remains marginally better — but that a stateful spiking network delivers a continuously updated, time-resolved estimate at essentially the same fidelity, with an architecture that maps onto resource-constrained FPGA logic.

Applications:

• Quantum error correction and feedback: faster, mid-window state assignments give controllers more time to act before encoded information changes.
• Processor calibration: repeated high-fidelity readout underlies routine device characterisation across many qubits.
• Real-time scientific inference on FPGAs: the paper situates SNN readout alongside existing SNN work in radiation detection, temporal scientific-data classification and collider triggers, all of which share the same streaming, latency-bound structure.
• Multiplexed multi-qubit architectures: time-resolved classifiers can in principle flag transient events such as relaxation mid-window and correlated crosstalk that single integrated scores wash out.

Industry relevance: The work sits at the intersection of quantum-control hardware vendors (the readout, demodulation and FPGA control stack), FPGA/HLS tooling providers, and neuromorphic computing efforts. Because it uses quantisation-aware training and an open HLS toolchain, the deployment path is the same one already used for conventional neural-network inference in real-time instrumentation, which lowers the barrier to adoption in quantum control electronics.

Future Directions

• Complete the hardware picture. The reported results are C-synthesis estimates; the authors state that future work will cover full demodulation, feature construction, data transfer and FPGA place-and-route for a complete readout pipeline. Whether the 100 ns per-update requirement survives a full placed-and-routed design is the central open question.
• Rescue qubit 2. q2 remains the dominant error source for every classifier, with diagonal cross-fidelity improving only from 0.479 to roughly 0.48–0.49 under machine learning; targeted architectures or features for weakly separated channels are an obvious next step.
• Push decisions earlier. Since the 600 ns auxiliary-loss experiment improved mid-window fidelity at negligible final cost, more aggressive or multi-point loss schedules, and a systematic latency–fidelity trade-off study, are natural extensions.
• Go beyond the five-qubit benchmark. The dataset is a five-qubit, 32-state benchmark; scaling to larger multiplexed arrays and to real feedback loops with live hardware would test whether the approach holds under production conditions.

Target Audience

Quantum-computing experimentalists and control engineers working on superconducting-qubit readout and FPGA-based control stacks; neuromorphic and embedded-ML researchers interested in streaming, latency-critical inference; and graduate students or tool developers working with hls4ml, snnTorch or quantisation-aware training who want a concrete, well-benchmarked application outside the usual particle-physics setting.

Authors’ abstract

Fast and accurate qubit-state assignment is essential for feedback, calibration, and error correction in quantum processors. In superconducting platforms, frequency-multiplexed readout makes this task intrinsically multivariate as measured traces can encode crosstalk, qubit-state relaxation events, and other transient nonidealities that are not fully captured by conventional matched filtering. Here, we introduce spiking neural network (SNN) discriminators for superconducting qubit readout. By processing the measurement window in successive time chunks, the networks exploit temporal structure and update classification scores as data arrive, rather than waiting until the end of the readout window. The spiking networks outperform matched-filter discrimination and approach the accuracy of a full-trace artificial neural network. Beyond reaching the performance of artificial neural networks, the key advantage of SNNs is that they provide a streaming, time-resolved estimate of the qubit state that evolves as the readout signal is acquired. Using quantisation-aware training and hls4ml synthesis, we further demonstrate that each FPGA inference update can be completed before the next readout chunk arrives. These results establish spiking neural networks as a promising route to low-latency, real-time qubit readout on FPGA hardware, with broader implications for time-critical quantum-control and scientific-inference applications.