Is quantum machine learning useful? When it makes sense, and when it does not
For most problems on classical data today, no: in one of the largest systematic benchmarks so far, run on simulated circuits of modest size, standard classical models beat popular quantum classifiers overall, and taking the entanglement out of the quantum models often did not make them worse. Quantum machine learning makes sense as research, on data that comes from quantum systems, and on problems with a structure that a quantum computer is proven to exploit. If you are deciding whether to invest, the cheapest answer backed by evidence is a benchmark on your own data: the quantum model next to tuned classical baselines on the same split, and again with its quantum part removed.
Updated
The short answer
- On ordinary tabular or image data
- Classical models usually win. Out-of-the-box classical models beat 12[1] popular quantum models overall in one of the largest systematic benchmarks so far.
- Should we invest in it?
- Benchmark it on your own data first: it is the cheapest answer backed by evidence. Run the quantum model and tuned classical baselines on the same split with several seeds, then remove the quantum part and run it again.
- Proven quantum speed-ups in learning
- They exist for constructed problems, such as one built on the discrete logarithm[4], and need fault-tolerant hardware.
- Exponential speed-ups in linear algebra
- Several were matched by classical algorithms that sample the same way (dequantization)[3].
- Where it is worth trying
- Data produced by quantum systems, research on model design, and problems that map onto a known quantum structure.
What the evidence says
One of the most careful tests so far is a benchmark by Bowles, Ahmed and Schuld, researchers at Xanadu, the company behind PennyLane. They took 12[1] quantum classifiers from the literature, quantum neural networks, quantum kernel methods and quantum convolutional networks among them, and ran them on 160[1] datasets drawn from 6[1] binary classification tasks, next to standard classical models with the same hyperparameter search. The classical models won overall. Removing the entanglement from a quantum model often gave results as good or better, which suggests that what helped on these tasks was not the quantum part.
The same paper looked at how the field reports results. Of 55[1] arXiv papers with quantum machine learning and outperform in the title or abstract, about 40%[1] claimed that a quantum model beat a classical one, and 4%[1] reported that it did not. Positive results are published; negative ones mostly are not.
There are limits to what this proves. The largest circuit simulated in the benchmark had 18 qubits[1], so it says little about models at a scale no simulator reaches. It does say that small-scale wins on classical data, the kind most papers and vendor demos show, are not evidence of an advantage.
Theory points the same way for a different reason. Huang and colleagues showed that a classical model trained on data can predict some functions that are hard to compute classically, which is why classical learners can match quantum models that seemed out of their reach[2]. They also gave a test for when a quantum model can have an edge: it has to see something in the data that the classical kernel cannot.
Quantum machine learning vs classical machine learning, case by case
Where each stands in late 2026, by kind of problem. A row is a reading of published results, not a forecast.
| Problem | What the evidence says | Verdict today |
|---|---|---|
| Classification or regression on tabular data | Classical models won the independent benchmark; quantum kernels on many qubits can flatten towards one value and stop separating classes[8]. | Use classical ML. Treat a quantum model as an experiment. |
| Data from quantum experiments or simulations | The data already lives in quantum states, and the test of Huang et al. can come out in the quantum model's favour[2]. | The most credible place to look. |
| Constructed problems with a proven speed-up | A quantum kernel learns a class built on the discrete logarithm that no classical learner can, if that problem is hard classically[4]. | Real, but the problem is built for the proof and needs fault-tolerant hardware. |
| Recommendation, low-rank linear algebra | The quantum recommendation algorithm was matched by a classical one that is only polynomially slower[3]. | Mostly dequantized. Check before you rely on a speed-up. |
| Large linear systems (HHL and descendants) | Fast only under strict conditions on loading the input and reading the output. See the HHL page. | Not shown end to end on a real application. |
| Deep variational circuits on many qubits | Gradients vanish exponentially with qubit count for random deep circuits[6]. See barren plateaus. | Untrainable at scale without structure, and structure can make it classically simulable. |
Why promised speed-ups shrink
Dequantization. Many early quantum machine learning algorithms assumed the data could be loaded and sampled in a special way. Tang showed that a classical algorithm given the same kind of sampling access produces recommendations only polynomially slower than the quantum algorithm it was compared with[3]. The exponential gap came from the input model, not from the quantum computer. A later framework extended this to principal component analysis, support vector machines, low-rank regression and other low-rank tasks[5], so an exponential speed-up on a linear-algebra task is a claim to check, not to assume.
Training. A variational circuit is trained by gradient descent, and for random deep circuits the gradients become exponentially small as qubits are added[6]. Estimating an exponentially small gradient takes exponentially many shots. The circuits that provably avoid this tend to have enough structure that their outputs can be computed classically from data collected once on the device[7]. The barren plateaus page goes through the causes and the fixes.
Resources. Resource estimates turn a speed-up on paper into qubits and run time. No end-to-end estimate exists for a quantum machine learning task on real data, but the one for a neighbouring problem shows the scale: pricing a derivative with amplitude estimation was estimated to need 8k logical qubits[9] and a T-depth of 54 million[9], executed in about a second[9] to beat classical Monte Carlo. Logical qubits are error-corrected ones, each built from many physical qubits. Any quantum learning method that relies on amplitude estimation or phase estimation inherits costs of this kind.
What would change this verdict
The verdict describes today's evidence, and each part of it rests on a condition that can change. Three are concrete enough to watch, and each can be tested rather than assumed.
Scale. The benchmark simulated circuits of up to 18 qubits[1], so a model that only pays off at a width no simulator reaches would not have shown up in it. For such a model to count, it has to stay trainable as it grows, which random deep circuits do not[6] and kernels on many qubits often do not[8], and it has to resist cheap classical simulation, which the structures that keep gradients large often fail to do[7]. The scaling step of the checklist below tests both.
Data. On data produced by quantum systems, the test of Huang et al. can come out in the quantum model's favour[2]. If your data comes from quantum sensors, chemistry simulations or quantum experiments, that is where a quantum model has the strongest case, and a benchmark on that data is the way to find out.
Hardware. The proven speed-ups in learning need fault-tolerant hardware[4], and the resource estimate for a neighbouring task runs to 8k logical qubits[9]. Progress there would first show as error rates low enough to run deeper circuits within a device's error budget. The Benchmarks link near the end of this page shows which of today's QPUs are inside that budget for a circuit like the ones in the code below.
When it is worth trying anyway
A negative answer for production today is not a reason to ignore the field. Quantum machine learning is worth time when the data comes from quantum systems, when you are studying which circuit structures learn well, or when you want a team ready for fault-tolerant hardware.
It is also worth a benchmark whenever someone asks "should we invest in this?" A comparison on your own data, the quantum model next to tuned classical baselines on the same split, is the cheapest way to answer that question with evidence rather than opinion, and either outcome is an answer. The checklist below is that benchmark step by step, and the code after it runs the comparison.
In each case, decide in advance what result would make you stop. A quantum model that ties a classical one at a thousand times the training cost is a result, and a useful one.
A checklist before you build a quantum model
Each step can end the project, and an early stop with evidence is a useful result.
Ask whether the problem has a quantum formulation at all
Some problems map onto a known quantum algorithm or a QUBO, and many do not. EigenOrbit Adviser takes a plain-language description of the problem, breaks it into parts and flags which of them have a credible quantum formulation, before you write any code.
Look at where the data comes from
Classical tabular, text or image data gives a quantum model no head start, and has to be encoded into rotation angles first. Data from quantum sensors, chemistry simulations or quantum experiments is the case with the most theoretical support.
Set the classical baselines first
A tuned gradient-boosted tree, an RBF support vector machine, logistic regression and k-nearest neighbours, on the same features. If one of them already meets the business need, stop here.
Compare on the same split, with several seeds
Same training and test data, same preprocessing, the same hyperparameter budget for every model, and the spread across seeds. A gap smaller than that spread is noise.
Remove the quantum part and run it again
Replace the entangling gates, or the whole circuit, with a classical layer of the same size. If the score does not drop, the circuit was not what helped, as in most models of the benchmark[1].
Check how it scales
A result on 4 or 8 qubits says little about 50. Plot the gradient size and the score as the qubit count grows, and check that the model is not one a classical simulator can reproduce cheaply at the size you need.
Validate on hardware last
Train on a simulator, then run the trained circuit on a QPU with the same test set, and read the drop caused by noise and finite shots. A model that only works on an exact simulator is not ready. Training on hardware instead multiplies every circuit by the shots and the gradient evaluations, and what QPU time costs shows how fast that adds up.
Test it on your own data with eigenkit
import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.decomposition import PCA
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import MinMaxScaler, StandardScaler
from eigenkit import HQNC, QSVC
from eigenkit.benchmark import compare, quick_baselines
# Your data goes here: any X of shape (n_samples, n_features) and labels y.
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, stratify=y, random_state=0)
# Four features, one per qubit, scaled to rotation angles in [0, pi].
prep = make_pipeline(StandardScaler(), PCA(n_components=4), MinMaxScaler((0, np.pi)))
X_train = prep.fit_transform(X_train)
X_test = np.clip(prep.transform(X_test), 0, np.pi)
result = compare(
models=[
QSVC(feature_map="Angle", reps=2),
HQNC(in_features=4, depth=2, epochs=30, show_progress=False),
*quick_baselines(), # RBF SVC, random forest, logistic regression, k-NN
],
dataset={"X_train": X_train, "y_train": y_train, "X_test": X_test, "y_test": y_test},
metrics=["accuracy", "f1", "fit_time"],
n_seeds=3,
)
print(result.table()) # mean ± std over the seeds, one row per modelNeeds pip install "eigenkit[qml,torch,benchmark]" and runs in a few seconds on the built-in simulator. In the run behind this page all six models landed within a few points of each other, with the RBF support vector machine and k-nearest neighbours on top and the two quantum models in the middle. The classical models were also limited to four PCA features here; on all features they do better still, so give them those in your own comparison. The split is fixed, so the seeds vary only each model's own randomness.
Run it on a real QPU with EigenOrbit RouterThe model trained above, evaluated on a real QPU with the same test set, to measure what noise and finite shots cost it.In eigenkit: pip install "eigenkit[router]", then provider=RouterConfig(device=...) (docs).
Questions
Is quantum machine learning useful today?
For production work on classical data, rarely. In one of the largest systematic benchmarks, standard classical models overall beat twelve popular quantum classifiers, and removing entanglement from the quantum models often did not hurt them. It is useful for research, for data that comes from quantum systems, and for learning how your problem would behave on future hardware. If you are deciding whether to invest, a benchmark on your own data against tuned classical models is the cheapest evidence you can get.
Is quantum machine learning better than classical machine learning?
Not on the problems where it has been tested fairly. Proven advantages exist for constructed problems, such as one built on the discrete logarithm, and they need error-corrected hardware. On ordinary datasets, a tuned classical model is the one to beat, and it usually wins.
Has quantum advantage in machine learning been demonstrated?
Not on a practical task with classical data. There are proofs of advantage for specially built learning problems and experiments where quantum models do well on data from quantum systems. Claimed wins on standard datasets usually disappear when the classical baselines get the same tuning and the same data.
What is dequantization?
A classical algorithm that matches a quantum one by using the same kind of access to the data. Ewin Tang's 2018 algorithm for recommendation systems is the best-known case: given sampling access to the data, it runs only polynomially slower than the quantum algorithm that was thought to be exponentially faster.
How do I test whether quantum machine learning helps on my data?
Train the quantum model and several tuned classical baselines on the same split, with the same preprocessing and several random seeds, and compare the mean and spread. Then remove the quantum part of the model and run it again. eigenkit's compare() and quick_baselines() do the first part in one call.
Can I run quantum machine learning on a real quantum computer?
Yes, but train on a simulator first and use the QPU to evaluate the trained model, because gradients on hardware cost many circuit runs. Expect the score to drop from noise and finite shots, and compare it with the simulator on the same test set.
Sources
- J. Bowles, S. Ahmed, M. Schuld. Better than classical? The subtle art of benchmarking quantum machine learning models. arXiv preprint, 2024. arXiv:2403.07059.
- H.-Y. Huang, M. Broughton, M. Mohseni, R. Babbush, S. Boixo, H. Neven, J. R. McClean. Power of data in quantum machine learning. Nature Communications 12, 2631, 2021. arXiv:2011.01938.
- E. Tang. A quantum-inspired classical algorithm for recommendation systems. Proceedings of the 51st Annual ACM Symposium on Theory of Computing (STOC 2019), 2019. arXiv:1807.04271.
- Y. Liu, S. Arunachalam, K. Temme. A rigorous and robust quantum speed-up in supervised machine learning. Nature Physics 17, 2021. arXiv:2010.02174.
- N.-H. Chia, A. Gilyén, T. Li, H.-H. Lin, E. Tang, C. Wang. Sampling-based sublinear low-rank matrix arithmetic framework for dequantizing quantum machine learning. Proceedings of the 52nd Annual ACM Symposium on Theory of Computing (STOC 2020), 2020. arXiv:1910.06151.
- J. R. McClean, S. Boixo, V. N. Smelyanskiy, R. Babbush, H. Neven. Barren plateaus in quantum neural network training landscapes. Nature Communications 9, 4812, 2018. arXiv:1803.11173.
- M. Cerezo, M. Larocca, D. García-Martín, N. L. Diaz, P. Braccia, E. Fontana, M. S. Rudolph, P. Bermejo, A. Ijaz, S. Thanasilp, E. R. Anschuetz, Z. Holmes. Does provable absence of barren plateaus imply classical simulability? Nature Communications 16, 7907, 2025. arXiv:2312.09121.
- S. Thanasilp, S. Wang, M. Cerezo, Z. Holmes. Exponential concentration in quantum kernel methods. Nature Communications 15, 5200, 2024. arXiv:2208.11060.
- S. Chakrabarti, R. Krishnakumar, G. Mazzola, N. Stamatopoulos, S. Woerner, W. J. Zeng. A threshold for quantum advantage in derivative pricing. Quantum 5, 463, 2021. arXiv:2012.03819.
Run it yourself with eigenkit
eigenkit is EigenOrbit's open-source Python library: write a circuit once, run it on any simulator or QPU, and test it against a classical baseline on your own data before you invest in it or rule it out.
$ pip install eigenkit