Applications / AI

AI quantum computing use cases

Quantum AI and QML, measured on QPUs and classical baselines

Quantum machine learning (QML) puts a parameterised circuit where a model layer would sit, and the rotation angles are the weights: a quantum circuit Born machine (QCBM), a QGAN, quantum image generation, a variational policy for quantum reinforcement learning, quantum kernels and variational classifiers, and quantum reservoir computing.

AI for quantum points the other way, with neural network quantum states (NNQS) finding a ground state and neural network tomography reconstructing the state a device prepared. Every case below is a billed run against the production API with its criterion fixed in advance, and five of the eight were then submitted to a quantum processor.

Single circuits below run from the console or a phone, and batches of circuits from the console. Training loops run through the SDK. Get the Android app

One worked example before the cases below, chosen because it is the case that reaches the most of the platform: the generator from QGAN and synthetic data. One model across both simulator tiers, two superconducting processors from different vendors, and a photonic pair, which is three modalities in one table. It is the same table that page carries.

Run on our engines

A two-qubit generator of four rotations against a two-layer classical discriminator, 40 alternating steps, targeting 0.4 / 0.1 / 0.1 / 0.4. Submitted to each kind of compute we offer, on 18 September 2026. Every figure below is a real job on the service, priced as any customer would be priced.

Engine	Kind	Qubits	Result	Cost
exact.cpu	CPU	2	TVD 0.269 to 0.146, discriminator gap 0.0069 to -0.0006	$0.0722
exact.gpu	GPU	2	TVD 0.278, the same converged generator at 1,000 shots certificate	$0.0001
qpu.rigetti	QPU	2	TVD 0.286, the converged generator re-run at 1,000 shots	$0.7250
qpu.iqm.garnet	QPU	2	TVD 0.240, the same generator and shot count on a second superconducting device certificate	$1.7500
photonic.slos.cpu	CPU	3	generator half, P(target) 1.000, 0.989, 0.932, 0.875 and 0.766 across five seeded starts	$0.1096
qpu.quandela.belenos	QPU	3	2,686 coincidences in 100,000 attempts, P(target) 0.974 with the two bunched outcomes returning 4 to 1 certificate	$0.4584

A note on the hardware certificates: they state Hellinger fidelity against the exact distribution. For an optimisation circuit that distribution is spread across many outcomes rather than concentrated on one, so the figure is low by construction and is not a measure of whether the device found a good answer. The result column above is.

The same problem is yours to run: every instance here is seeded, so it rebuilds exactly. Open the console and a cost estimate is free before anything executes.

Run on a quantum processor

Five cases where the trained circuit was submitted to real hardware rather than to a simulator. Training stays on a simulator because every gradient evaluation is its own task; the converged circuit is one task.

QCBM and quantum generative models

Sampling from a distribution learned from scratch

QCBM against its own untrained start

Generative modelling research, synthetic data programmes

QGAN and synthetic data

Adversarial generation against a learning discriminator

QGAN with a classical discriminator

Teams whose training data is scarce, regulated or expensive to collect

Quantum AI image generation

Writing an image into a circuit and reading it back

Patch GAN and NTQIP, both on Rigetti

Imaging research, quantum image processing

Quantum RL and control policies

Choosing an action from an observed state

Variational quantum policy trained by REINFORCE

Control systems, scheduling, operations research

NNQS for materials and chemistry

Ground states where tensor networks stop

Neural network quantum states on a Google TPU

Condensed matter, quantum chemistry, materials research

Run on the production simulators

Three cases measured on the same service and the same billing, on exact and neural engines. Each runs unchanged on the gate QPUs by naming a different engine.

QML and classification

Labelling data through a quantum feature map

Quantum kernel and variational classifier against classical baselines

Applied ML teams evaluating quantum feature maps

QRC, quantum reservoir computing

Features from a circuit that trains nothing

Quantum reservoir computing with a classical readout

Time-series and signal processing teams

NNQS tomography

Reconstructing the state a device prepared

Neural network tomography from measurement records

Hardware teams, metrology, anyone certifying a device

Where each method stops

Every figure below follows from the encoding or from the shot budget rather than from a timing, so unlike an accuracy it does not move when a benchmark is re-run. The measured results sit on each case page.

Use case	Direction	Classical baseline	Where the method runs out
QCBM and quantum generative models	Quantum for AI	The untrained circuit, at TVD 0.459	2^n outcomes against a fixed shot budget: at 20 qubits most outcomes are never sampled once
QGAN and synthetic data	Quantum for AI	The discriminator gap, which starts at 0.0069	Mode collapse onto a subset of outcomes, the same failure mode as a classical GAN
Quantum AI image generation	Quantum for AI	The target image itself, pixel by pixel	One qubit per pixel: a 108-qubit processor holds about a 10x10 image in a single job
Quantum RL and control policies	Quantum for AI	A random policy, at 0.533 mean return	One circuit per decision: an episode of 1,000 steps is 1,000 jobs
NNQS for materials and chemistry	AI for quantum	Exact diagonalisation, where the system still fits in memory	40 spins on the neural tier; exact diagonalisation stops near 30
QML and classification	Quantum for AI	Logistic regression, k-NN, an MLP and an RBF kernel	A kernel needs one circuit per pair: 1,111 circuits for 62 points
QRC, quantum reservoir computing	Quantum for AI	The raw coordinates, at 0.850	A bitstring readout needs 2^n features from a fixed shot budget; local observables need n^2
NNQS tomography	AI for quantum	Held-out measurement records the fit never saw	Refused outright when the measured bases cannot determine a state

Every criterion was fixed before the run

Each case above had its success condition written down before it was submitted, and the result is published against that condition whichever way it came out. Where a run on hardware returned a worse figure than its simulator, the hardware figure is the one printed.

Every number is from a job billed on the production service at the price any customer pays, and the approximate ones carry a certified error bound. You can load the same circuits into the console, change the instance to your own data, and export a certificate for your own run.

Read the benchmark methodology The full QML write-up

Working on a model shape not covered here? Tell us the problem and we will benchmark it.