A Computer Architect’s Musings on enabling run-time AI for fast quantum modalities
By Kevin D. Kissell, Alice & Bob
Quantum computing is perhaps today’s biggest challenge in computer architecture. Quantum algorithms can solve otherwise impossible problems, but quantum information is fragile. Bits of quantum information, or qubits, spontaneously “decohere” or decay. A variety of underlying technologies, or modalities, to implement qubits have been proposed, – and quite a few have been demonstrated as non-error-corrected (“NISQ”) quantum processors – but they all have the same problem. The useful lifetime of a qubit is too short to demonstrate a practical quantum advantage over “classical” processors. These limits on physical qubits imply that error corrected, fault-tolerant quantum computing (FTQC) is the most likely path to meaningful advantage over classical digital computation.
Confronting the Cost of Error Correction
In classical computing, we are already familiar with fault-tolerance and error-correcting codes, from ECC in RAM to forward error correction in high-speed networks. There is overhead to pay, typically a fractional cost in redundant information and hard-wired logic. In the example of DDR4 DRAM with SEC-DED, it’s 12.5% more RAM cells or chips. Quantum information is fussier. Quantum mechanics forbids things like making direct copies of quantum state. Quantum error correction (QEC) is thus subtle and expensive. As a percentage, the overheads have been realistically estimated to be as high as 1,000x – a thousand fragile physical qubits to contain a single, robust, “logical” qubit capable of general quantum computation. About half of those qubits contain the quantum state of interest, while the other half acts as “syndrome” qubits to detect both phase and bit-flip errors. As we expect useful beyond-classical quantum computations to require hundreds of logical qubits, large numbers of physical qubits will be required, which is to say large and expensive numbers of chips, wires, lasers, beam-guides, etc. In the past decade, we have advanced from “Can a quantum processor exist?” to “How can I practically build and operate one?”.
Reducing costs and complexities of error correction is thus a major target of research and corporate investment. The whole Alice & Bob architecture is based around the premise that a more subtle physical qubit modality, the cat qubit, can exponentially reduce the qubit overhead required and simplifies the remaining error correction – see this white paper for details. Other teams working with more conventional modalities, such as superconducting transmon/Xmon qubits or neutral atoms, lack this self-redundancy, and are even more highly motivated to find more efficient quantum error correction schemes. This has resulted in new and dramatically improved families of error codes. Surface codes which might have required thousands of physical qubits per logical qubit are giving way in newer designs to quantum low-density parity check (qLDPC) codes, which should be able to do the job with “merely” hundreds of physical qubits per logical. But, just as Alice & Bob pay a price in processor complexity to take advantage of the scaling of cat qubits, quantum LDPC codes impose a price in connectivity – chips and packages require a new dimension of connection for dispersed syndrome qubits – and the classical qLDPC decoding algorithms are more complex, taking far more time and resources to compute. This is where AI comes into the picture.
Appealing to Artificial Intelligence
Machine learning techniques have revolutionized quite a few technologies, and quantum computing is one of them. Proposals and experiments range across a spectrum, from the use of generative AI to optimize quantum device hardware structures, to the use of ML classifiers to interpret experimental results.
It thus comes as little surprise that NVIDIA, industry leader in hardware subsystems for AI learning and inference, offers a platform for supporting quantum computing – NVIDIA CUDA-Q. CUDA-Q makes GPU-powered AI for quantum computing straightforward across the spectrum, but it is the use of ML at run time as part of the operation of the machine, not just as part of the design and engineering process that I’d like to focus on here. This corresponds to the yellow and green areas of the diagram above.
Both Good Enough and Fast Enough
The use of AI in QEC decoding has been a research topic for the past decade, and a range of ML approaches have been experimentally applied to a range of QEC codes, with interesting and sometimes impressive results, in terms of reduced quantum resources and improved performance. But this comes at the cost of additional classical computation and data movement. Moving data and control between control interfaces, sequencers, FPGAs/ASICs, and levels of CPU/GPU computation isn’t free. Data movement consumes cycles and the scheduling of threads of control across domains imposes further, difficult-to-predict, latencies. The practical significance of this additional overhead depends on the quantum information modality. For “fast” superconducting modalities, like Alice & Bob’s cat qubits, we seek to maintain an error decode time of roughly 1 μs. That constrains how far measurement data can be propagated and distributed in processing. As depicted in Fig. 1 below, it leaves enough time for processing close to the syndrome readout hardware (green arc), and perhaps for relatively simple processing by directly connected embedded cores (yellow arc), but the time it would take for a thread of control to propagate out to accelerators and networked resources for processing is likely far too long.
The constraints are easier for slower modalities, which have orders-of-magnitude longer coherence times and slower operations. Naively, one might suppose that the speed and coherence times of superconducting qubits would make the run-time use of GPUs and ML/AI impractical for a fault-tolerant cat qubit quantum computer. But that would be a mistaken supposition.
NVQLink Changes the Topology
Firstly, to make it easier to use GPU supercomputing in the quantum stack, NVIDIA has produced NVIDIA NVQLink, an open collection of FPGA IP, firmware, and partner support, which expands the processing schema in an interesting way, allowing quantum measurement devices to interact directly with GPUs. Measurements are passed directly from data acquisition circuits to GPU memory using HPC networking technology, eliminating data copies and context switching latencies. See Figure 2, below.
NVQLink brings GPU processing within a few microseconds of measurement, which is a huge improvement. Once the data is in a GPU, other CUDA-Q libraries can be brought directly to bear to accelerate decoding. That brings a broader collection of quantum modalities into the realm of control via accelerated computing. But for those where the machine’s cycle time is only a microsecond, it’s still worryingly tight. If the AI processing is non-trivial, it may not be realistic to have AI in the loop on a cycle-by-cycle, measurement-by-measurement basis, for a superconducting cat qubit device, even with NVQLink.
Decoupled Processing: Separating Real-time from “Policy”
But there is another way to bring run-time CUDA-Q and AI, into play at Alice & Bob – and for other fast superconducting modalities. It involves decoupling real-time mechanisms from longer term “policy”, changing operational parameters at run-time based on integrated feedback from previous operations. Measurements are collected, and the cycle-by-cycle operations that must keep pace will do so, limiting the computation to what can be accomplished within the time budget. But, in parallel with that, copies of the measurements are also independently queued for decoupled processing by higher-level software. Quantum information cannot be replicated, but classical measurements easily can. The higher-level software, in turn, can modify the operational parameters of the real-time firmware based on AI or other relatively “heavyweight” software, identifying trends and patterns in the data, and the potential optimizations that they imply. See Figure 3 below. The broken green arc represents decoupled execution that starts in parallel with the solid arc, but continues, possibly for much longer.
Live Calibration Comes First
The initial motivation for exploring this approach was to resolve the conflict between a desire to apply AI techniques to quantum error decoding and the short decoding cycle time required by bosonic cat qubits as a modality, but current work at Alice & Bob is more focused on decoupled live calibration than on error decoding per se. By their nature, cat qubits require less redundancy than other modalities to achieve a similar level of reliability, and they can take advantage of simpler error codes, like repetition codes and “classical LDPC”. However, they require complex and subtle calibration to operate correctly. Decoupled calibration can be fundamentally simpler than decoupled error decoding. There is no hard requirement to make calibration adjustments at the full cycle rate, so there’s no need for an inner/outer, coupled/decoupled loop structure for calibration. Whatever else is done synchronously with measurements in error decoding and logical operation cycles, a decoupled outer loop can identify calibration trends and generate correction factors in parallel.
This technique is independent of NVQLink, and Alice & Bob prototyping does not assume GPUs. Measurement data goes from instruments into scalar processors which queue up copies as time series for general decoupled parallel processing and analysis. We would, however, like to take advantage of the CUDA-Q platform, and to work with NVIDIA on further synthesis methods to allow NVQLink FPGAs/GPUs, as well as CPUs, to queue up events for decoupled processing, either directly, or indirectly (by providing access to CPUs sharing the GPU memory). See Figure 4.
NVQLink and decoupled processing
By augmenting and exploiting NVQlLink’s data movement capabilities, we can bring the rest of CUDA-Q into play in new and different ways, making it more relevant to fast quantum modalities, and there are various opportunities to do this. The most efficient generation of decoupled duplicate data would likely be done at a very low level, at the time of RDMA transfers into GPU memory, though this would be very hardware-specific and brittle as a design. A simpler approach to prototype, using the cudaq-realtime API for direct access to NVQLink connected hardware, would be to register a decoupling relay as a CUDA-Q calibration agent. Another approach, of intermediary performance and complexity, could be to modify, or create an alias, for the cudaq_qec.enqueue_syndromes() method to silently replicate the enqueued measurements to a decoupled side-channel. The technology is very young, and there are still fundamental experiments to be performed, but there are exciting opportunities to take the broadest possible advantage of the NVIDIA platform for AI and GPU-accelerated methods across the broadest number of quantum modalities and architectures, including Alice & Bob superconducting cat qubits. We’re even now planning and building the experiments.
