Quantum Machine Learning: Where It Might Pay Off

The benchmark to start from

In March 2024, three researchers at Xanadu published a benchmarking study that any team should read before funding a quantum machine learning project. Joseph Bowles, Shahnawaz Ahmed and Maria Schuld took twelve quantum machine learning models from the published literature, implemented them under consistent conditions, and ran them against ordinary classical baselines on controlled datasets. Their paper, Better than classical? The subtle art of benchmarking quantum machine learning models, is on arXiv as 2403.07059. The classical baselines held up. On several tasks, removing the entanglement from the quantum models left their accuracy unchanged.

Quantum machine learning, or QML, is the attempt to run some part of a learning algorithm on quantum hardware: the similarity computation inside a classifier, the sampling step inside a generative model, the whole model as a trainable circuit. We read the Xanadu result as a statement about where the field stands today, not a verdict on where it can go. But it sets the baseline for an honest conversation, and the honest conversation is what this article is for.

Two questions follow from it. Which quantum advantages in learning are actually established, and where should a working developer or an investor expect the first real payoff? The answers are narrower than the marketing and more interesting than the dismissal.

What the promise actually says

Start with the mechanism, because most confusion about QML comes from skipping it.

A classical support vector machine separates two classes of data with a boundary. When the data isn’t separable as given, you map it into a higher-dimensional space where it is. The map is called a feature map, and the trick that makes it affordable is the kernel: a function that returns the similarity between two points in the mapped space without ever computing their coordinates there. You need the pairwise similarities, not the coordinates, so the kernel is enough.

Quantum computing enters at exactly that point. A quantum state on n qubits lives in a space of dimension 2 to the n. Encode a data point into a quantum state and you have implicitly placed it in an enormous feature space. The overlap between two such states gives you a similarity value, and a quantum processor can estimate that overlap directly. Vojtěch Havlíček and colleagues at IBM set this out in Nature in 2019, with a two-qubit hardware demonstration on data they constructed for the purpose.

That’s the promise in one sentence: a feature space too large for any classical machine to enumerate, reachable in a number of operations that grows politely with the number of qubits.

The readout problem

The promise comes with a constraint that gets left out of the elevator version. A quantum computer can hold a superposition over 2 to the n states, but measuring it returns one outcome. You don’t get 2 to the n answers. You get one sample from a distribution, and building a useful number out of it takes many repetitions.

So quantum parallelism is not free parallelism. Every real quantum algorithm has to arrange interference so that the amplitudes for wrong answers cancel and the amplitude for the answer you want grows. That arrangement is the hard part, and it’s the reason the list of algorithms with proven speedups is short rather than long. Any QML proposal that skips this step is describing a hope.

The two strongest results

Two results do more work than the rest of the literature combined, and they point in different directions.

The proof on constructed data

In 2021, Yunchao Liu, Srinivasan Arunachalam and Kristan Temme published a rigorous separation in Nature Physics. They built a classification problem out of the discrete logarithm problem, the same mathematical structure that underpins parts of today’s public-key cryptography, and proved that a quantum kernel method learns it while no classical learner can, unless that classical learner can also solve discrete logarithms efficiently. Nobody believes it can.

A quantum kernel here means a kernel whose values are estimated by preparing quantum states from the data and measuring their overlap. The result establishes something real: quantum advantage in supervised learning is not a category error. It exists.

Two qualifications travel with it, and both get dropped in summary. The dataset was engineered so that quantum structure would help, which is what a separation proof requires and also what makes it silent about natural data. And the quantum side of the comparison assumes hardware that corrects its own errors, which nobody has built. As of early 2026, no quantum kernel has shown a clear advantage on a dataset that arose from anything other than the proof.

The demonstration on quantum data

The second result is a demonstration rather than a proof, and it ran on hardware. In 2022, Hsin-Yuan Huang and colleagues at Google Quantum AI, with collaborators at Caltech and elsewhere, published work in Science on learning properties of quantum systems. The task was to determine something about an unknown quantum state or process. They compared two strategies: measure the system, convert the outcomes to classical data, then learn from that data, against holding the system quantum and processing it with a quantum memory.

The quantum-processing strategy needed exponentially fewer experiments. And it worked on a superconducting processor at a scale of tens of qubits, not only on paper.

We think this is the most important QML result to date, and it’s the one least often quoted, because it doesn’t sound like a business application. What it says is that when the input is quantum, keeping it quantum wins. That’s a claim about a specific kind of data, and it holds up.

Dequantization, and why many early claims shrank

Between 2018 and 2022 a body of work grew up whose only job was to check quantum speedup claims against the best classical algorithm rather than the most obvious one. The technique came to be called dequantization: take a quantum algorithm, examine the assumptions it makes about how data is supplied, grant a classical algorithm comparable assumptions, and see whether the gap survives.

Ewin Tang started it. As an undergraduate at UT Austin, working with Scott Aaronson, she produced a classical algorithm for recommendation systems that matched the runtime of a quantum algorithm previously believed to be exponentially faster. Follow-up work by Tang, Nai-Hui Chia, András Gilyén and others extended the method to a family of quantum linear algebra routines, and a series of proposed speedups for principal component analysis, matrix inversion and related tasks came down with them.

The deeper version of the argument came in 2021, when Huang and colleagues published “Power of data in quantum machine learning” in Nature Communications. A quantum learner and a classical learner are not competing on raw computational power alone, because the classical learner also has training data. Access to data lets a classical algorithm short-circuit computations it could never perform from scratch. Once you account for that, many apparent quantum advantages narrow or disappear.

None of this closes the field. What it does is set the standard of evidence. A speedup claim measured against a naive classical baseline tells you nothing. Scott Aaronson made the same case earlier, in a 2015 Nature Physics commentary on the quantum linear systems algorithm, where he laid out the four fine-print conditions that have to hold before the advertised exponential speedup means anything.

Four bottlenecks that decide where payoff is possible

If you want to predict where QML pays off, don’t start from the algorithms. Start from the four places where quantum learning leaks value, because the applications that survive are the ones that avoid them.

Getting classical data in

To run a quantum model on your data, the data has to become a quantum state. For a single small vector, that’s cheap. For a general classical dataset, preparing a state that encodes it can require a number of operations that grows exponentially with the number of qubits, which erases whatever the algorithm was going to save.

The practical consequence is severe. A classical GPU streams training data at tens of gigabytes per second. A quantum processor prepares one state, runs one circuit, takes one measurement, resets, and does it again. If your problem has a million training examples, the encoding cost is the whole story, and no clever circuit downstream will rescue it.

This is why QML proposals that look attractive on a whiteboard tend to specify small datasets. That’s not modesty; it’s the only regime where the arithmetic works.

Getting answers out

Current hardware is noisy. Qubits lose their state over time, and every gate introduces some error. The field’s name for this period, NISQ, stands for Noisy Intermediate-Scale Quantum, and it describes machines large enough to be interesting and error-prone enough that deep circuits produce noise rather than answers.

For a kernel method, that means your estimated similarity values carry error bars. For a trainable circuit, it means your gradients do. And because every quantum output is a statistical estimate built from repeated measurement, you pay for precision in wall-clock time. Halving the error bar costs roughly four times the shots.

Barren plateaus

A variational circuit, also called a parameterized quantum circuit, is a quantum analog of a neural network: a circuit whose gate angles are trainable parameters, adjusted by a classical optimizer to minimize a loss. The training loop is hybrid by construction, with the quantum device evaluating the model and a classical computer updating the weights.

In 2018, Jarrod McClean and colleagues showed that for randomly initialized circuits of this kind, the variance of the gradient shrinks exponentially with the number of qubits. The loss surface flattens. This is the classical vanishing-gradient problem, but far worse, because you can’t see the flatness without spending measurements to look, and the measurements are what you can’t afford.

There’s a further twist that anyone evaluating this area should know about. Marco Cerezo and collaborators have argued that circuit families constructed to provably avoid barren plateaus tend to be structured enough that a classical computer can simulate them. If that argument holds in general, trainability and quantum advantage are pulling against each other rather than lining up. The question is open, and it’s the right question to ask a founder.

Inductive bias

The last bottleneck is the most instructive, because it inverts the sales pitch. Jonas Kübler, Simon Buchholz and Bernhard Schölkopf showed at NeurIPS in 2021 that a quantum kernel with a very large effective feature space generalizes badly. The reason is familiar to anyone who has fit a high-capacity model to a small dataset: a space that can separate anything gives you no reason to prefer one separation over another. Inductive bias is the set of assumptions a model brings about which patterns are plausible, and a model without it needs an enormous number of examples to learn anything.

So the exponentially large feature space isn’t the advantage by itself. The advantage, if it exists, comes from choosing a feature map whose structure matches the structure of the problem. Marco Caro and colleagues made the quantitative version of this point in Nature Communications in 2022, deriving generalization bounds that scale with the number of trainable gates against the number of training examples. Fewer gates, better generalization, same as in classical learning theory.

Which means the design question in QML is not how big a space you can reach. It’s whether you know something about your data that a particular quantum encoding expresses well. That’s a domain question before it’s a quantum question.

Where the payoff is most likely

Run the four bottlenecks as filters and a short list survives. We’ve ordered it by how much evidence sits behind each item.

Quantum data

The strongest case is the one the Google result demonstrated. When the data is already quantum, the encoding bottleneck disappears, because there is nothing to encode. Quantum data means measurement records or states produced by a quantum process: the output of a quantum sensor, the state of a molecule under simulation, the characterization data from a quantum processor’s own calibration run.

Classical machine learning has a structural disadvantage here. To learn from a quantum state classically, you first have to describe it classically, and a full description takes a number of measurements that grows exponentially with system size. A quantum learner can work with the state directly.

Concrete places this shows up now, not in a decade:

• Device characterization. Every quantum computing company has to learn the error behavior of its own hardware. Learning algorithms that consume quantum data are being applied to this problem because the alternative is prohibitively expensive.
• Quantum sensing and metrology. Sensors that exploit quantum effects produce data whose structure is quantum. Classifying or denoising that data is a native fit.
• Chemistry and materials simulation pipelines. When a quantum processor is already producing the states, a learning step that keeps them quantum avoids a costly round trip.

None of these look like the applications in a QML deck. All of them are real work with a defensible reason to be quantum.

Small datasets with structure you understand

The second candidate follows from the inductive bias result rather than around it. If your dataset is small, high-value, and you have a principled reason to think a specific quantum encoding captures its structure, the regime is at least coherent. Small data avoids the encoding bottleneck. Domain knowledge supplies the bias.

We’d treat this as a research program rather than a plan. The honest status is that nobody has demonstrated it convincingly on natural data, and the Xanadu benchmark is evidence against the casual version of the claim. But it’s the only route by which QML reaches conventional tabular or scientific datasets, and it’s a legitimate thing to fund at research scale with research-scale expectations.

Distribution loading inside a quantum pipeline

The third candidate is narrower and clearer. Christa Zoufal, Aurélien Lucchi and Stefan Woerner published work in npj Quantum Information in 2019 on quantum generative adversarial networks, where a trainable quantum circuit learns to produce a target probability distribution and a classical network judges its samples. Their result addressed the encoding problem directly: rather than exactly loading a distribution, which can take exponentially many gates, the generator learns an approximation using a gate count that grows polynomially.

What makes this useful is what comes next in the pipeline. Amplitude estimation is a quantum routine that computes the expected value of a quantity to a given precision using roughly the square root of the samples a classical Monte Carlo simulation would need. It requires the distribution to already be in a quantum state, and loading is exactly the step that has historically eaten the advantage. Zoufal and colleagues connected the two, training a generator and then using the resulting state in an option pricing calculation.

The payoff here is a quadratic speedup on a well-defined and commercially valuable calculation: pricing derivatives, estimating tail risk. The condition is that the quadratic advantage only survives on hardware that corrects its own errors, because amplitude estimation needs circuit depth. This is a fault-tolerance application with a plausible path, not a near-term product.

A boundary marker on optimization

One correction is worth making because it recurs in QML material. Quantum annealing and the variational optimization algorithms are not machine learning, even when they appear in machine learning pipelines. Volkswagen’s route optimization work on annealing hardware, and the various portfolio-selection demonstrations, are combinatorial optimization problems. They belong to a different evidence base with its own disputes about whether the observed speedups come from quantum effects or from analog hardware behaving well.

The one genuine crossover is the Boltzmann machine, a probabilistic model whose training requires sampling from a complicated distribution. Steven Adachi and Maxwell Henderson reported in 2015 that using an annealer to supply those samples reduced the number of training iterations needed on downsampled handwritten digit data, and they were careful to say they could not attribute the improvement to quantum effects specifically. That caveat is still the right summary a decade on. Mohammad Amin and colleagues at D-Wave developed the more ambitious version, a model whose energy function is itself quantum, in Physical Review X in 2018. It’s live research.

What this means if you’re building

If you write code for a living and you’re deciding whether to spend six months here, we’d give you three practical positions.

Learn the encoding question first. Most developers coming from classical ML start with circuit design and treat data encoding as plumbing. It’s the opposite. How your data becomes a quantum state determines the kernel you get, which determines whether the model can generalize at all. A team fluent in encoding strategies and their inductive biases is doing the part of the work that’s still open.

Build the benchmarking discipline before the model. The lesson of the dequantization literature is that a quantum result without a well-tuned classical baseline is not a result. That means running the boring comparison: a gradient-boosted tree, a properly tuned support vector machine with a radial basis kernel, a small neural network. If you can’t beat those, you have a research artifact, and knowing which one you have is the professional skill.

Notice what transfers. Hybrid quantum-classical training loops, parameter-shift gradients, sampling-limited optimization, working with noisy objective evaluations: these are transferable skills, and several of them apply to classical problems where evaluations are expensive and stochastic. The tooling is also genuinely usable now. Qiskit, PennyLane and Cirq are mature enough that the barrier to a first experiment is an afternoon, not a semester.

Where we’d steer you away: don’t build a QML startup around beating classical models on a conventional dataset. The Xanadu benchmark is the paper your first technical due diligence call will cite.

What this means if you’re funding

For investors, the useful move is to convert the science above into questions that separate a real technical position from a rebranded one.

Is the data quantum? If the answer is yes, the strongest published evidence is on the company’s side. If the answer is no, ask what avoids the encoding bottleneck, and expect a specific answer about dataset size and state preparation cost rather than a description of feature space dimension.

What is the classical baseline, and who tuned it? A fairly tuned classical comparison is cheap to run and expensive to fake. Its absence is informative.

Does the advantage require fault tolerance? Many of the more credible QML pipelines, including the amplitude estimation route, do. Requiring fault tolerance doesn’t disqualify a company, but it changes the investment from a product timeline to a research position, and the two deserve different terms.

How does the model avoid barren plateaus, and does that structure make it classically simulable? This is the single question most likely to distinguish a team that has read the recent literature from one that has read the 2019 literature.

What was dequantized nearby? If a company’s core claim descends from quantum linear algebra, someone has probably already produced a classical algorithm with comparable scaling. Ask which results they’ve checked against.

The market judgment we’d offer: capital in this area is currently priced on the size of the promise, and the promise has been narrowing under fair comparison since 2018 while the two solid results have held. That’s an asymmetry, and it favors anyone who can read the papers.

Where this sits on the timeline

Fault tolerance is the dividing line. A fault-tolerant quantum computer uses many physical qubits to encode one logical qubit whose errors are actively corrected, and it’s what lets you run circuits deep enough for amplitude estimation or a proven kernel separation. Logical qubits have been demonstrated with error rates below their constituent physical qubits, which is the necessary first step. The number of logical qubits needed for the QML applications above hasn’t been built.

So the reasonable expectation splits. Work on quantum data can proceed on current hardware, because the tasks are small and the advantage doesn’t depend on depth. Work on classical data at commercial scale waits for machines that don’t exist, and the intervening years are for building the encoding theory and the benchmarking practice that will make those machines worth using.

Neither half of that is a reason to look away. The field has produced two durable results and a rigorous method for discarding weak ones in under a decade. That’s a healthy science, and it’s a bad match for a hype cycle.

Building the judgment

Everything above is a judgment call rather than a fact to memorize: whether a baseline was fair, whether an encoding matches a problem, whether a speedup claim survives a careful classical comparison. Reading one paper won’t produce that judgment. Understanding what quantum states can and can’t do, how circuits behave under noise, and where the measured evidence sits will.

Quantum Academy builds its programs around exactly that gap between knowing the vocabulary and being able to assess a claim. Developers should look for the program that starts with quantum states, circuits and encoding rather than with algorithm names, because encoding is where the open work is. Investors and technical diligence teams should look for the program that covers hardware constraints and how published results are benchmarked, because that is what turns a deck into a set of answerable questions. Both paths are listed at quantumacademy.com/, and if the question underneath is which role to aim at rather than which topic to study, QuantumCareers.com maps the roles this work actually creates.