Marin Ivezic
In 2024, Joseph Bowles (University of Geneva), Shahnawaz Ahmed (Xanadu) and Maria Schuld (Xanadu) benchmarked twelve widely cited quantum machine learning models against ordinary classical baselines across a set of standard datasets. The classical models generally won. In several of the quantum models, stripping out the entangling gates left performance unchanged or slightly better, which is an uncomfortable finding for a field whose central promise rests on entanglement. Their paper is called Better than classical? The subtle art of benchmarking quantum machine learning models, and they mean the question mark.
That is the honest place to begin, and it isn’t an argument for ignoring the subject. Quantum machine learning is a live research programme with a mathematically proven separation from classical learning on at least one constructed problem, a software base that any Python developer can install this afternoon, and a set of open questions that will take another decade to settle. What it doesn’t have yet is a demonstrated advantage on the kind of natural, messy data you work with.
Most of the confusion in this field comes from collapsing three different claims into one: what has been proved in theory, what has been shown on hardware, and what a vendor deck asserts. We keep those separate throughout.
This article covers the concepts. What quantum machine learning is, the four model families you’ll encounter, how classical data gets into a quantum computer, why training is harder than it looks, and what current hardware can and cannot do. It assumes you know classical ML. It assumes nothing about quantum physics, and every term of art gets defined the first time it does any work.
What Counts as Quantum Machine Learning
The label covers four different things, and sorting them out early saves a lot of arguing. Vedran Dunjko and Hans Briegel proposed a useful grid in their 2018 review: split the data into classical or quantum, split the algorithm into classical or quantum, and you get four quadrants.
Classical data with a classical algorithm is ordinary machine learning, and it stays in the picture because some quantum-inspired classical algorithms were invented by studying quantum ones. Quantum data with a quantum algorithm covers learning tasks where the input is itself a quantum state, such as classifying phases of matter or characterising a noisy device. Quantum data with a classical algorithm is how most experimental physics already works. The quadrant this article is about is the third one: classical data, quantum algorithm. You have a table of numbers, and you want a quantum computer to help you fit a model to it.
Almost everything you can run today in that quadrant is a hybrid. A classical optimiser sits in a loop around a quantum circuit, sending it parameters, receiving numbers back, and updating. The quantum part is a parameterised quantum circuit, sometimes called a variational circuit or PQC. It’s a fixed sequence of quantum gates where some of the gates take a numeric argument, typically a rotation angle. Those angles are the trainable weights. Everything else about the training loop looks familiar: a cost function, a gradient, an optimiser step.
One structural difference is worth internalising now. A quantum circuit does not return a number. It returns a sample. To get an expectation value out of a circuit, you run it many times and average the measurement outcomes, and each of those runs is called a shot. A thousand shots gives you an estimate with sampling noise attached, in the same way a Monte Carlo estimate carries noise. Every gradient you compute inherits that noise, and every hyperparameter sweep multiplies the number of circuit executions you need. Shot budgets are the quantum equivalent of GPU hours, and they’re the reason a QML experiment that looks small on paper can take a weekend of queue time.
The Three Properties and What They Buy
A qubit is a two-state quantum system whose state is described by two complex numbers, called amplitudes, one for the outcome 0 and one for the outcome 1. The squared magnitudes of those amplitudes give the probabilities of measuring each outcome, so they sum to one.
Superposition means a qubit’s state is a weighted combination of 0 and 1 before you measure it. Put n qubits together and the joint state needs 2ⁿ amplitudes to describe it, one for every bit string of length n. That complex vector space of dimension 2ⁿ is the Hilbert space the computation happens in. Fifty qubits already need more amplitudes than a classical machine can store, which is the origin of every “exponentially large feature space” claim you’ll read.
Entanglement means the joint state of several qubits can’t be factored into independent single-qubit states. Measuring one tells you something about the others. In modelling terms, entangling gates are how a circuit represents interactions between features rather than treating them independently.
Interference is the part that does the actual work. Amplitudes are complex numbers, so they can cancel. A well-designed algorithm arranges for the amplitudes on wrong answers to cancel and the amplitudes on right answers to reinforce, so that when you finally measure, the right answer is the likely one.
Most introductions bury the qualification. Yes, n qubits carry 2ⁿ amplitudes, and yes, a single gate operates on all of them at once. But measurement returns exactly n classical bits, drawn from a distribution. You cannot read out 2ⁿ answers. The exponential lives inside the machine and stays there, and the entire craft of quantum algorithm design is finding cases where interference can concentrate the useful information into the few bits you’re allowed to see. Shor’s algorithm does this. Grover’s does a weaker version of it. For machine learning, whether it can be done on real data is still an open question, not a settled one.
Getting Data Into the Machine
Now, this is the part that decides whether a QML project is worth funding: how your data gets from a CSV file into a quantum state. Three schemes are common, and they trade off against each other in ways that determine what’s possible.
Basis encoding writes each data point as a bit string and prepares the matching computational basis state. It’s simple and wasteful. A 32-bit float needs 32 qubits.
Angle encoding uses each feature value as a rotation angle on its own qubit. One feature, one qubit, cheap to prepare. It’s the workhorse of nearly every variational demo you’ll see, and it caps your feature count at your qubit count unless you re-upload features across multiple circuit layers.
Amplitude encoding is the one that generates the excitement. Normalise your feature vector, then load its components directly as the amplitudes of an n-qubit state. Now 2ⁿ features fit into n qubits, so a million-dimensional vector needs twenty qubits. The catch is preparation cost. For an arbitrary vector with no exploitable structure, building that state takes a number of gates that scales with the number of amplitudes, which is 2ⁿ again. You’ve moved the exponential from storage to state preparation and gained nothing.
The standard escape is QRAM, a hypothetical quantum memory that would prepare such states in time proportional to n rather than 2ⁿ. No one has built one at any useful scale, and the engineering requirements are severe. Scott Aaronson’s 2015 essay “Read the Fine Print” laid out the caveat clearly: several celebrated exponential speedups in quantum linear algebra, including the HHL algorithm for solving linear systems published by Harrow, Hassidim and Lloyd in 2009, assume both fast state preparation on the way in and a limited kind of readout on the way out. Drop either assumption and the speedup goes with it.
There’s a symmetric problem on the output side. If your model produces a quantum state encoding a million predictions, reading all of them out costs a million measurements. Quantum advantage in machine learning has to come from tasks where the answer you want is small: a label, a probability, an expectation value, a single scalar risk figure. Any pipeline that needs to stream a large output back into classical memory loses whatever it gained.
When you’re evaluating a QML paper or a vendor claim, encoding is the first thing to check. Ask what the input state preparation costs, and ask what gets measured at the end.
The Four Model Families
Quantum Kernels and the Quantum Support Vector Machine (QSVM)
This family is the closest thing to a natural fit, and it’s where the strongest theoretical results live.
A feature map takes a data point x and produces a quantum state, written |φ(x)⟩, by running x through a fixed circuit. The kernel between two data points is then the squared overlap of their two states, |⟨φ(xᵢ)|φ(xⱼ)⟩|². That’s an inner product in a 2ⁿ-dimensional space, and a quantum computer can estimate it directly by preparing both states and measuring their overlap, without ever writing down a 2ⁿ-dimensional vector.
Everything after that is classical. You build the full kernel matrix on the quantum device, hand it to a standard SVM solver, and get support vectors and a decision boundary back exactly as you would with an RBF kernel. Maria Schuld and Nathan Killoran made the framing explicit in 2019: a quantum feature map is a kernel method, and most variational models can be read that way too.
Vojtěch Havlíček and colleagues at IBM published the practical version in Nature in the same year, in Supervised learning with quantum-enhanced feature spaces. Their feature maps use Hadamard gates and entangling controlled-Z rotations whose angles depend on products of input features, producing kernels that expand into high-order feature combinations.
Two practical limits apply. Building an N × N kernel matrix means running on the order of N² circuits, each with enough shots to beat the sampling noise, so quantum kernels suit datasets of hundreds of points rather than millions. And a feature map that’s easy to simulate classically buys you nothing, while one that’s hard to simulate tends to produce kernel matrices close to the identity as the qubit count grows, which teaches an SVM nothing at all. Designing a map that lands between those failures is the open research problem.
Variational Circuits and Quantum Neural Networks
A quantum neural network is a parameterised circuit trained to fit labels. The word “neural” is a loose analogy and the mapping to neurons is not tight, so don’t push it.
The structure is: encode the input, apply a stack of parameterised layers, measure an observable, treat the resulting expectation value as the model output. Each layer typically alternates single-qubit rotations, which carry the trainable parameters, with entangling gates such as CNOTs, which mix information between qubits. That fixed circuit template is called the ansatz, and choosing one is the quantum equivalent of choosing an architecture.
Nonlinearity is the subtle part. Quantum evolution is linear and unitary, so the circuit itself can’t apply anything like a ReLU. Nonlinearity enters through measurement, and also through the encoding, since a feature loaded as a rotation angle appears inside a sine or cosine. Data re-uploading, where you interleave encoding layers between parameterised layers, is a common way to get a richer function class out of a shallow circuit.
Quantum convolutional networks are a variant worth knowing. They mimic pooling by measuring some qubits partway through and conditioning later gates on the results, shrinking the register layer by layer.
The recurring finding in this family is that expressivity isn’t the bottleneck. Small circuits can represent complicated decision boundaries. Training them reliably, and getting them to generalise better than a modest classical model on the same data, is where the results have not yet arrived.
Quantum Generative Adversarial Networks
A QGAN keeps the adversarial setup and replaces the generator with a quantum circuit. The generator produces a quantum state; you measure it to get samples; a classical discriminator, usually a small neural network, tries to tell those samples from real ones. Training alternates as usual.
The interesting motivation isn’t better image generation. It’s the encoding problem from the previous section. Christa Zoufal, Aurélien Lucchi and Stefan Woerner showed in 2019 that a QGAN can learn to prepare a quantum state approximating a target probability distribution, using a circuit with a number of parameters that grows polynomially rather than exponentially with qubit count. Instead of loading a distribution exactly, which is expensive, you train a circuit to produce it approximately, which may not be.
That has a specific downstream use. Several quantum algorithms for risk and pricing need a distribution loaded into a register before they can run, and quantum amplitude estimation offers a quadratic improvement over classical Monte Carlo for computing expectations once it is. A learned loader plus amplitude estimation is a plausible pipeline. It’s also a pipeline that needs error-corrected hardware to be worth running, so treat it as a design for later rather than a technique for now.
Training difficulties compound here. GANs are unstable classically, and every discriminator evaluation on a generated sample carries quantum sampling noise on top.
Quantum Boltzmann Machines
A classical Boltzmann machine assigns an energy to every configuration of its units and defines a probability distribution in which low-energy configurations are more likely. Training means adjusting the weights until the model distribution matches the data. The expensive step is estimating expectations under the model, which classically means Markov chain Monte Carlo, and MCMC mixes slowly when the energy surface has many separated minima.
There are two quantum approaches. Mohammad Amin and colleagues at D-Wave defined a genuinely quantum version in 2018, where the energy function becomes a quantum Hamiltonian containing non-commuting terms such as a transverse field. The resulting distribution can express correlations a classical Boltzmann machine cannot, at the cost of making the gradients harder to define and compute.
The other approach uses quantum annealing hardware as a sampler for an otherwise classical model. Quantum annealers are special-purpose machines that encode an energy function into a network of coupled qubits and relax toward low-energy configurations. Steven Adachi and Maxwell Henderson reported in 2015 that using a D-Wave device to draw samples during restricted Boltzmann machine training reached comparable accuracy in fewer iterations than classical Gibbs sampling. The result was suggestive rather than conclusive, since the improvement could not be isolated to a quantum cause.
This family gets less attention than the other three, partly because Boltzmann machines themselves fell out of fashion in classical deep learning. It’s still the most direct link between machine learning and annealing hardware, which is the most widely deployed quantum hardware by qubit count.
Proved, Demonstrated, and Claimed
Keeping these three apart is the single most useful discipline in this field.
Proved. In 2021, Yunchao Liu, Srinivasan Arunachalam and Kristan Temme published a rigorous and robust quantum speed-up in supervised machine learning. They constructed a classification problem based on the discrete logarithm problem and showed that a quantum kernel SVM learns it efficiently, while no classical learner can unless discrete log is classically easy, which essentially nobody believes. The separation is exponential and it’s a theorem, not an experiment. Two conditions travel with it. The dataset is engineered from a problem quantum computers are known to be good at, and the quantum side assumes a fault-tolerant machine that doesn’t exist. What the result establishes is that quantum advantage in supervised learning is possible in principle.
Demonstrated. On real data, on real hardware, nothing yet clears the bar. The benchmark from the opening is the most careful negative result available, and it’s negative in an instructive way: the quantum models tested were not merely slower, they were often no better than the same circuits with entanglement removed.
Dequantized. This is the category most people have never heard of, and it’s the one that should shape your priors. In 2018, Ewin Tang, then an undergraduate, published a quantum-inspired classical algorithm for recommendation systems that matched the exponential speedup of a well-known quantum algorithm. The technique generalised. Over the following years, similar classical algorithms were found for quantum principal component analysis, quantum linear systems solving under sampling assumptions, and several other proposed speedups. The pattern is consistent: when a quantum algorithm assumes fast structured access to its input, a classical algorithm given comparable sampling access can often match it. Any exponential speedup that rests on QRAM-style assumptions deserves scepticism until someone checks whether it survives dequantization.
Hsin-Yuan Huang and co-authors made the theoretical version of that point in 2021 in Power of data in quantum machine learning. Once a classical learner is given training data rather than only query access, many apparent quantum advantages shrink or disappear, because the data itself carries information the classical model can exploit.
Claimed. Vendor marketing in this field routinely elides the distinction between a theorem about a constructed dataset and a result on customer data. When a deck says quantum machine learning has been shown to outperform classical methods, ask which of the four categories above the claim belongs in. Most of the time the honest answer is the first one.
Why Training a Quantum Model Is Harder Than It Looks
Gradients come from the parameter-shift rule. For the rotation gates used in most circuits, the exact derivative with respect to a parameter equals a scaled difference between two circuit evaluations at shifted parameter values. It’s exact rather than a finite-difference approximation, which is elegant, and it costs two full circuit evaluations per parameter. A hundred-parameter circuit needs two hundred evaluations for one gradient, each with enough shots to see through the sampling noise. Compare that with backpropagation, which computes all gradients in roughly one backward pass, and the cost asymmetry becomes obvious.
Then there’s the barren plateau. Jarrod McClean, Sergio Boixo, Vadim Smelyanskiy, Ryan Babbush and Hartmut Neven showed in 2018, in Barren plateaus in quantum neural network training landscapes, that for randomly initialised circuits of sufficient depth the gradient variance shrinks exponentially with qubit count. The cost surface flattens almost everywhere. Since your gradient estimate already carries shot noise, an exponentially small true gradient gets buried in it, and no amount of optimiser tuning recovers a signal that isn’t there.
Later work by Marco Cerezo and colleagues showed the effect also depends on the cost function: global observables, which look at all qubits at once, induce plateaus even in shallow circuits, while local observables can avoid them at shallow depth. Mitigations exist. Structured rather than random initialisation, layer-by-layer training, shallow problem-informed ansätze, local cost functions. None of them is a general solution, and the phenomenon is the main reason QML circuits stay small even on hardware that could run larger ones.
The Hardware as It Stands
John Preskill named the current period the NISQ era in 2018, for noisy intermediate-scale quantum. Devices with tens to hundreds of qubits, no error correction, and circuit depths limited by how fast errors accumulate.
Be precise about which qubits are being counted. A physical qubit is a piece of hardware. A logical qubit is an error-corrected abstraction built from many physical qubits, using a scheme such as the surface code, where a larger code distance means more physical qubits per logical one and a lower logical error rate. Press releases quote physical qubits. Algorithm resource estimates assume logical ones. The ratio between them is currently in the hundreds to thousands, depending on the physical error rate.
On physical counts, IBM’s Heron processors have 133 qubits, and its Condor chip reached 1,121 in 2023. Google’s Willow chip has 105. Quantinuum’s trapped-ion H2 system has 56, with notably better gate fidelities and full connectivity between qubits. Two-qubit gate error rates on the best publicly documented systems sit somewhere between one error in a few hundred operations and one in a few thousand.
Error correction has started to work. Google reported in Nature in 2023 that increasing the surface-code distance on a Sycamore-class superconducting processor decreased the logical error rate, which is the crossing point the whole field had been waiting for. It’s a genuine milestone and it’s also a demonstration of one logical qubit being kept alive, not a machine that runs algorithms on logical qubits.
For a developer, the practical consequence is straightforward. Anything you build now runs either on a simulator, where you’re limited to roughly 25 to 30 qubits on a laptop before the state vector exhausts memory, or on noisy hardware with shallow circuits and a queue. Both are fine for learning. Neither is a production target.
Where Classical Methods Still Win
For almost every problem you’ll be handed at work, the answer is a gradient-boosted tree or a transformer, and it will stay that way for years.
Classical training pipelines stream gigabytes per second through hardware built for exactly that. Quantum devices reload state per data point and measure repeatedly to extract one number, so any dataset with millions of rows loses on input handling before the algorithm is reached. Classical results are reproducible to numerical precision, while quantum devices drift between calibrations. Classical tooling has twenty years of optimisation behind it. And a large fraction of ML tasks are already solved by algorithms with near-linear cost, which leaves no exponential for a quantum method to remove.
The place to watch is the opposite corner: small datasets with genuinely intricate structure, problems where the data comes from a quantum process to begin with, and subroutines inside a larger classical pipeline where a specific expectation value is expensive to compute. That’s where a hybrid design has a plausible shape.
How to Learn This Without Wasting Six Months
A workable order, based on what our learners actually get stuck on.
Start with linear algebra over the complex numbers, since a quantum state is a unit vector and a gate is a unitary matrix. If you can multiply matrices and reason about inner products and eigenvalues, you have most of what’s needed. The physics is genuinely optional at this level.
Next, learn the circuit model properly before touching a QML library. Gates, measurement, the Bloch sphere, what a CNOT does to a superposition. People who skip this write circuits they can’t debug, because a QML framework will happily run a circuit that does nothing useful and return plausible numbers.
Then pick one framework and go deep rather than sampling three. Qiskit suits quantum kernels and integrates with scikit-learn. PennyLane handles automatic differentiation across quantum and classical components and connects to PyTorch. Both are fine starting points, and switching later is cheap once the concepts are solid.
Build in this order: a quantum kernel SVM on a two-dimensional toy dataset first, since the workflow maps directly onto classical SVM practice, then a variational classifier, then something generative. Compare every quantum result against a properly tuned classical baseline on the same data. Doing that honestly is the most valuable habit in the field, and it’s the one the benchmarking literature keeps finding absent.
Finally, read the negative results alongside the positive ones. The Bowles, Ahmed and Schuld benchmark, the dequantization literature, and the barren plateau papers will calibrate you faster than any survey article.
Where to Go From Here
Quantum machine learning is worth learning now for a specific reason: the concepts are stable even though the hardware isn’t. Feature maps, encoding costs, ansatz design, shot budgets and the difference between a proved separation and a demonstrated one will still be the right vocabulary in ten years, whatever the qubit counts look like by then. Learning it later doesn’t get easier, and the people who understand where the bottlenecks sit are the ones who will recognise a real application when it appears.
Quantum Academy’s quantum computing programs cover this material properly, from the linear algebra through circuit construction and into hybrid model design, with the assessment work built around comparing quantum models against classical baselines rather than around demonstrations that only run on toy data. You can review the full program catalogue and enrolment options at quantumacademy.com/. For deeper technical background on quantum computing principles and algorithm design, PostQuantum.com carries longer reference material.