Applications / AI / Quantum for AI
Quantum AI image generation
Writing an image into a circuit and reading it back
There are two ways to get a picture out of a quantum computer and they are opposites. The first trains: several small sub-generators each learn one patch of the image, entangled within a patch and independent across patches, which is what keeps the circuits small enough to run. The second trains nothing at all: one qubit per pixel, the pixel value written as a rotation angle, measured and read straight back.
The untrained method carries no model and no learning, so what it measures is the device. Its error per pixel is the device's readout error, which makes it a clean hardware benchmark as well as an image. The trained method is a generative model and is scored against the target distribution the same way a Born machine is.
Run on our engines
An 8x8 target for the trained generator, and a 32x32 letterform written one pixel to a qubit. 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.
| Device | Engine | Kind | Qubits | Result | Cost |
|---|---|---|---|---|---|
 | exact.cpu | CPU | 4 | patch GAN, TVD 0.828 untrained to 0.2326 trained, 3,224 circuits | $0.3224 |
 | qpu.rigetti | QPU | 4 | patch GAN, TVD 0.4129 for the converged generator | $0.7250 |
| qpu.rigetti | QPU | 32 | one qubit per pixel, 32x32 image in 11 circuits, 0.0525 mean error per pixel | $3.4683 |
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.
The trained generator reached 0.2326 on the simulator and 0.4129 when the converged circuit was run on Rigetti.
The untrained method returned a 32x32 image across 11 circuits with a mean absolute error of 0.0525 per pixel against the target, at 36 shots a circuit. Nothing is entangled between pixels, so a pixel's position in the image is its qubit's position in the circuit and an image larger than the device is split across circuits.
Where this stops
- One circuit holds as many pixels as the device has qubits, so a larger image is several jobs and has to be stitched back together in submission order
- The untrained method carries no model: it reproduces an image you already have rather than generating a new one
- Shot noise sets the floor on per-pixel accuracy, so error falls as 1/sqrt(shots) and a sharper image costs linearly more
The classical baseline for this case is the target image itself, pixel by pixel. The structural limit, which does not move when a benchmark is re-run, is One qubit per pixel: a 108-qubit processor holds about a 10x10 image in a single job.
Run it yourself
Every figure above is from a job billed on the production service. Load the same circuits into the console, change the instance to your own data, and export a certificate for your own run rather than citing ours.
The argument behind these numbers, at length: Quantum machine learning on simulators and real quantum hardware.
Other AI use cases
QCBM and quantum generative models
Sampling from a distribution learned from scratch
QCBM against its own untrained start
QGAN and synthetic data
Adversarial generation against a learning discriminator
QGAN with a classical discriminator
Quantum RL and control policies
Choosing an action from an observed state
Variational quantum policy trained by REINFORCE