# Machine learning algorithms for big data: how they scale, and what is new

> Machine learning algorithms scale to big data by sampling, approximating and splitting the work. How SGD, XGBoost and Spark do it, and how to judge a new one.

- URL: https://computese.com/a-revolutionary-machine-learning-algorithm/
- Author: Duong Quan Nguyen, CEO, Computese
- Published: 2024-07-28
- Updated: 2026-09-25
- Topics: AI & automation

## In short
- No single algorithm made machine learning work on big data. A handful of techniques did: learning from small random samples, approximating the expensive step, splitting the work across machines and keeping data close to the processor.
- Stochastic gradient descent updates a model from one example or a small batch at a time. Léon Bottou showed in 2010 that when computing time is the limit, it reaches a given accuracy sooner than exact methods.
- Gradient-boosted trees such as XGBoost and LightGBM scale by binning values into histograms, and a NeurIPS 2022 benchmark found tree models still ahead of deep learning on medium-sized tables.
- Quantum machine learning is not a shortcut for business data yet: a 2018 classical algorithm removed a leading quantum speedup, and a 2024 benchmark found classical models ahead of quantum classifiers.
- Judge any revolutionary algorithm headline by its paper: what was measured, against which tuned baseline, on what data and hardware, and whether the code is out for others to reproduce.

Machine learning algorithms keep up with big data through a few ideas rather than one breakthrough: they update the model from small random samples (stochastic gradient descent), approximate the expensive step (histograms, sketches, approximate indexes), split the work across processors and machines, and read data in blocks that fit in memory. Which one matters depends on your data.

This page first ran in July 2024 as a news item about an unnamed "revolutionary" machine learning algorithm, said to make data processing faster, more accurate and more scalable. It named no paper, lab or result, and its only link was to a blog post about quantum machine learning that cited no study either, so this rewrite reports no single breakthrough. Instead it explains the techniques that made machine learning scale, with the papers that measured them, what quantum machine learning has and has not shown, and how to judge the next "revolutionary algorithm" headline.

## What scaling to big data means for a machine learning algorithm

A machine learning algorithm fits a model to examples so that it can make predictions or find structure in data it has not seen. [Google's introduction to machine learning](https://developers.google.com/machine-learning/intro-to-ml/what-is-ml) groups the systems into supervised learning (labelled examples, used for regression and classification), unsupervised learning (patterns in unlabelled data, such as clusters), reinforcement learning (a policy learned from rewards and penalties) and generative AI.

"Big data" has a working definition too. [NIST's Big Data Interoperability Framework](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.1500-1r2.pdf) (October 2019) describes it as extensive datasets, mainly in volume, velocity, variety or variability, that need a scalable architecture to store, manipulate and analyze efficiently. For a learning algorithm, scaling comes down to three questions: does the cost of one update grow with the size of the dataset, does the work fit in one machine's memory, and can it be split across processors?

In 2010 Léon Bottou, then at NEC Labs America, [set out why this changes which algorithm wins](https://leon.bottou.org/papers/bottou-2010). Data had grown faster than processor speed, so for large problems the limit on learning is computing time, not the number of examples. In that regime, an algorithm that optimizes less precisely but gets through more examples in the time available ends up with the better model. The techniques below make the same trade: a little exactness for a lot of throughput.

| Bottleneck                                    | Technique that removes it                   | Where you meet it                                    |
| --------------------------------------------- | ------------------------------------------- | ---------------------------------------------------- |
| Every update reads the whole dataset          | Stochastic and mini-batch gradient descent  | Neural networks, linear models                       |
| Finding a tree split looks at every value     | Histograms and quantile sketches            | XGBoost, LightGBM, scikit-learn HistGradientBoosting |
| The data is larger than memory                | Out-of-core blocks, streamed mini-batches   | XGBoost external memory, data loaders                |
| One machine is too slow                       | Data parallelism, in-memory cluster compute | Spark MLlib, distributed XGBoost, multi-GPU training |
| Similarity search compares against every item | Approximate nearest neighbor indexes        | FAISS, HNSW, pgvector                                |

## Learn from a sample at a time: stochastic gradient descent

Training most models means lowering an error measured on the training data. The gradient says which way to change each parameter to lower it, and gradient descent takes a step in that direction, over and over. Plain, or full-batch, gradient descent computes the gradient over every example before each step. [Google's Machine Learning Crash Course](https://developers.google.com/machine-learning/crash-course/linear-regression/hyperparameters) puts the problem plainly: with hundreds of thousands or millions of examples, using the full batch is not practical.

Stochastic gradient descent (SGD) estimates the gradient from a single randomly picked example and takes a step at once. Each step is noisy, but it costs the same whether the dataset has a thousand rows or a billion. Mini-batch SGD sits in between: pick a small random batch, average its gradients, update, repeat. Bottou's paper adds two properties that matter for big data. SGD does not need to remember which examples it has already seen, so it can learn from data as it arrives. And although it is a poor optimizer by the classical measure, it needs less time than exact methods to reach a given expected error when computing time is the constraint. In theory, a single pass of averaged SGD over the training data gives a model as good, asymptotically, as fully optimizing on all of it, although Bottou notes that reaching that regime can take a long time in practice.

![A small orange handful of rows travels from a tall stack of data to a gear, which nudges the needle of a dial; a dashed arrow loops back to the stack for the next handful.](https://computese.com/images/blog/a-revolutionary-machine-learning-algorithm/minibatch.f8a94ffe7f-1536.webp)

*Each step reads a handful of rows, so its cost stays the same however large the dataset grows.*

Batch size is a setting to tune, not a fixed rule. Google's course notes that small batches behave like pure SGD and large ones like full-batch descent, and that some of the noise even helps a model generalize.

## Approximate the expensive step: histograms in gradient boosting

For tabular data, the rows and columns of transactions, CRM records and sensor logs, gradient-boosted trees are the method to beat. Boosting adds decision trees one at a time, each fitted to the errors the earlier trees left. The expensive step is choosing where each tree splits: the exact method sorts every value of every feature and tries every candidate split.

[XGBoost](https://arxiv.org/abs/1603.02754), by Tianqi Chen and Carlos Guestrin of the University of Washington (KDD, August 2016), made three changes that let boosting scale:

- **Approximate splits.** A weighted quantile sketch proposes a short list of candidate split points from the percentiles of each feature, and the algorithm only evaluates those. The paper found this matched the exact method's accuracy at a reasonable level of approximation.
- **Sparsity-aware splits.** Each tree node learns a default direction for missing values, so the algorithm only visits entries that are present. On a sparse insurance dataset it ran 50 times faster than a naive implementation.
- **Out-of-core learning.** Data is stored in compressed, sorted column blocks that can be read from disk. The system trained on 1.7 billion examples on a single machine, and on all of them with only four machines in a cluster.

The paper reports that XGBoost ran more than ten times faster than popular existing solutions on one machine, and that 17 of the 29 winning solutions published on Kaggle's blog during 2015 used it. [LightGBM](https://papers.nips.cc/paper_files/paper/2017/hash/6449f44a102fde848669bdd9eb6b76fa-Abstract.html) (NIPS 2017), from Microsoft Research and Peking University, went further on the same bottleneck. Gradient-based one-side sampling drops a large share of the rows with small gradients, which say little about where to split, and exclusive feature bundling merges features that are rarely non-zero at the same time. Its authors report training up to more than 20 times faster than conventional gradient boosting with almost the same accuracy.

Histogram-based split finding is easiest to see in [scikit-learn's documentation](https://scikit-learn.org/stable/modules/ensemble.html). Its HistGradientBoosting estimators, added in version 0.21 and inspired by LightGBM, sort each feature once at the start and bin it into integer buckets, typically 256; from then on, each split considers only the bucket boundaries. The documentation says they can be orders of magnitude faster than the classic implementation once a dataset passes tens of thousands of samples.

![Many scattered dots are gathered into a short row of bars, and an orange vertical cut between two bars becomes the split of a small decision tree on the right.](https://computese.com/images/blog/a-revolutionary-machine-learning-algorithm/histogram.63a5f134f0-1536.webp)

*Binning trades a little precision in where a split falls for a large cut in the work of finding it.*

The approximation won. As of September 2026, [XGBoost's documentation](https://xgboost.readthedocs.io/en/stable/treemethod.html) describes the exact method as slow and hard to scale, and its [default tree method](https://xgboost.readthedocs.io/en/stable/parameter.html), `auto`, is the same as `hist`, the histogram method it describes as close to LightGBM's.

Tree models have also held their ground against deep learning on this kind of data. A [NeurIPS 2022 benchmark](https://papers.nips.cc/paper_files/paper/2022/hash/0378c7692da36807bdec87ab043cdadc-Abstract-Datasets_and_Benchmarks.html) by Léo Grinsztajn, Edouard Oyallon and Gaël Varoquaux compared them across 45 tabular datasets and found tree-based models still state of the art on medium-sized data, around 10,000 samples, even before counting their speed. Our [comparison of AI frameworks](https://computese.com/latest-ai-tools-and-frameworks-a-comparative-analysis/) covers the libraries themselves.

## Split the work: in-memory clusters and data parallelism

Many learning algorithms are iterative: k-means clustering and logistic regression pass over the same data again and again. The [Resilient Distributed Datasets paper](https://www.usenix.org/system/files/conference/nsdi12/nsdi12-final138.pdf) from UC Berkeley (NSDI 2012) pointed out that in most frameworks of the time, the only way to reuse data between two MapReduce jobs was to write it to a distributed file system, paying for replication, disk I/O and serialization on every pass. Its answer, Spark, keeps working data in memory across the cluster and rebuilds lost pieces from their lineage. The paper measured Spark at up to 20 times faster than Hadoop on iterative machine learning and graph applications.

MLlib is the distributed machine learning library that grew on top. As of September 2026, the [Spark documentation](https://spark.apache.org/docs/latest/ml-guide.html) names the DataFrame-based API (`spark.ml`) as MLlib's primary API; the older RDD-based `spark.mllib` has been in maintenance mode since Spark 2.0.

Deep learning, whose layers and training are explained in [deep learning and NLP explained](https://computese.com/the-ai-and-machine-learning-revolution/), parallelizes differently. In data parallelism, every worker holds a copy of the same model, takes its share of each mini-batch, computes gradients, and an allreduce operation combines the gradients so every copy applies the same update. The difficulty is that more workers means a larger total batch, and large batches are harder to optimize. In June 2017, a [Facebook team with Priya Goyal as first author](https://arxiv.org/abs/1706.02677) showed two simple fixes: scale the learning rate in proportion to the batch size (their linear scaling rule), and warm it up gradually at the start. With them, a ResNet-50 image classifier trained on ImageNet with a batch of 8,192 images across 256 GPUs in one hour, matched the accuracy of small-batch training, and reached about 90% scaling efficiency going from 8 to 256 GPUs.

![Four servers each take a slice of a data stack and hold the same model; their gradients meet in an orange ring that combines them, and the same update returns to every server.](https://computese.com/images/blog/a-revolutionary-machine-learning-algorithm/data-parallel.bb7fc954be-1536.webp)

*More machines mean a bigger combined batch, which only pays off if the model still learns as well as it did on one.*

Training frontier-scale models raises a different set of limits; our post on [the path to AGI and AI supercomputers](https://computese.com/the-path-to-agi-how-a-new-ai-supercomputer-network/) covers that end of the scale.

## Search instead of scanning: approximate nearest neighbor indexes

Modern systems turn documents, images and products into embeddings, lists of numbers where similar items sit close together. Finding the most similar items to a query exactly means comparing it with every stored vector, which grows with the collection. Approximate nearest neighbor (ANN) search gives up a little recall to avoid that scan.

Two papers set the pattern. [FAISS](https://arxiv.org/abs/1702.08734), from Facebook AI Research (February 2017, later in IEEE Transactions on Big Data), rebuilt similarity search for GPUs: its nearest neighbor search ran 8.5 times faster than the previous GPU state of the art, and it built a graph linking 1 billion vectors in under 12 hours on four GPUs. [HNSW](https://arxiv.org/abs/1603.09320), by Malkov and Yashunin (first posted in 2016, published in IEEE TPAMI in 2020), stacks several proximity graphs in layers; a search starts in the sparse top layer and descends, which gives logarithmic scaling of search complexity.

Both ideas are now ordinary database features. As of September 2026, [pgvector](https://github.com/pgvector/pgvector), the PostgreSQL extension, does exact search by default, with perfect recall, and offers HNSW and IVFFlat indexes for approximate search. Its documentation notes that HNSW has the better speed-recall trade-off but builds more slowly and uses more memory, and that queries can return different results once an approximate index is added. Vector search of this kind is also the retrieval step in retrieval-augmented generation (RAG), where an assistant looks up passages from a company's documents before it answers. How vector search and text-to-SQL work inside a database is covered in [generative AI for databases](https://computese.com/generative-ai-for-databases/).

## Is quantum machine learning the next revolution?

The article the 2024 page linked to was about quantum machine learning, the promise that quantum computers will process big data exponentially faster. The promise has a real origin: [HHL](https://arxiv.org/abs/0811.3171), published by Aram Harrow, Avinatan Hassidim and Seth Lloyd in Physical Review Letters in 2009, handles sparse systems of linear equations in time polynomial in the logarithm of the system's size (and in its condition number), exponentially faster than the best classical method for the task as they defined it. Many quantum machine learning algorithms build on it.

In 2015, Scott Aaronson set out the [fine print](https://www.scottaaronson.com/papers/qml.pdf) in Nature Physics. The speedup holds only if the input can be loaded into quantum memory quickly, if the matrix is sparse or has other special structure, and if it is well-conditioned. And the output is a quantum state that encodes the solution, not the solution itself: reading out individual entries means running the algorithm about as many times as there are entries, which cancels the gain. With big data, those are exactly the expensive steps: getting the data in and the answer out.

Then the best-known example fell. [Kerenidis and Prakash's 2016 quantum recommendation algorithm](https://arxiv.org/abs/1603.08675) ran in time polylogarithmic in the size of the ratings matrix, and was regarded as one of the strongest candidates for a provable exponential speedup. In July 2018, Ewin Tang posted a [classical algorithm](https://arxiv.org/abs/1807.04271), presented at STOC in June 2019, that is only polynomially slower when the data sits in a structure that supports the same kind of sampling. The quantum algorithm's exponential advantage was gone.

Parameterized quantum circuits, trained by a classical optimizer, have a different problem. [Jarrod McClean and colleagues](https://arxiv.org/abs/1803.11173) showed in 2018 that for a wide class of these circuits the gradient vanishes exponentially as qubits are added: a barren plateau, with no slope to follow. An August 2025 [Nature Communications perspective](https://www.nature.com/articles/s41467-025-63099-6) by M. Cerezo of Los Alamos National Laboratory and colleagues gathered evidence that many models built to avoid barren plateaus can then be simulated classically, once some data has been collected from a quantum device, with caveats the authors list.

Benchmarks point the same way. In March 2024, [Bowles, Ahmed and Schuld](https://arxiv.org/abs/2403.07059) tested 12 popular quantum machine learning models on 6 binary classification tasks, 160 datasets in all. Out-of-the-box classical models outperformed the quantum classifiers, and removing entanglement from a quantum model often did as well or better.

> [!NOTE]
> A demonstrated advantage does exist for a different kind of data: data that comes from quantum systems. In [Science in June 2022](https://arxiv.org/abs/2112.00778), Hsin-Yuan Huang and colleagues proved that quantum machines can learn some properties of physical systems from exponentially fewer experiments, and demonstrated it with up to 40 superconducting qubits. That is a result about physics experiments, not spreadsheets.

None of the results above shows a quantum speedup on ordinary business data such as tables, text or images. For that data, the techniques in the earlier sections are where the gains are today.

## How to judge a "revolutionary algorithm" headline

The 2024 story this page began as could not be checked, because it gave nothing to check. When the next one arrives, work through the claim in this order:

1. **Find the paper.** A real result has authors, a date and usually a venue: a journal, a conference or at least an arXiv preprint. A story without one is not evidence.
2. **Find what was measured.** Accuracy on which benchmark, speed on which hardware, compared with what. LightGBM's speedup of up to more than 20 times is measured against conventional gradient boosting, at almost the same accuracy; that is a specific, testable claim.
3. **Check that the baseline was tuned.** In a [2017 study](https://arxiv.org/abs/1707.05589), Gábor Melis, Chris Dyer and Phil Blunsom re-ran popular language model architectures with large-scale automatic hyperparameter tuning and found that standard LSTMs, properly regularized, outperformed more recent models. The earlier results had been measured with different code bases and limited computing budgets.
4. **Check for leakage.** Sayash Kapoor and Arvind Narayanan [surveyed leakage](https://pmc.ncbi.nlm.nih.gov/articles/PMC10499856/), information from the test data reaching the model during training, and found it in 17 fields, affecting 294 papers (Patterns, 2023). In their reproduction of civil war prediction studies, complex models did not perform substantively better than decades-old logistic regression once the errors were fixed. Our [first Python machine learning project](https://computese.com/artificial-intelligence-with-python/) shows how leakage creeps into an ordinary train and test split.
5. **Check that it fits your data.** A method that wins on images may lose on tables, as the NeurIPS 2022 tabular benchmark showed.
6. **Look for code.** XGBoost, LightGBM and FAISS all shipped with their code, so anyone could rerun the comparisons. A result nobody can run stays a claim.

> [!TIP]
> The fastest check is the abstract. Read each number next to the baseline and the dataset it was measured against. An abstract with no numbers is a warning sign.

The same habits apply to AI research news in general; our look at [AI scientific discoveries and what held up](https://computese.com/ai-enabled-scientific-discoveries/) applies them to protein folding, materials and weather forecasting.

## Which technique fits your data

Start from the shape of the data, not from the newest paper:

| Your data                                            | Start with                                                     | Why                                                                                                             |
| ---------------------------------------------------- | -------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
| A table that fits in memory                          | Histogram gradient boosting: XGBoost, LightGBM or scikit-learn | Tree models led deep learning on medium-sized tables in the NeurIPS 2022 benchmark, and binning keeps them fast |
| A table larger than one machine's memory             | XGBoost reading from disk, or distributed training on Spark    | XGBoost's paper trained on 1.7 billion rows on one machine, and on four in a cluster                            |
| Images, audio or free text                           | Neural networks trained with mini-batch SGD on GPUs            | Mini-batches keep each update cheap, and data parallelism spreads them across GPUs                              |
| Data that arrives continuously                       | Online learning with SGD                                       | SGD needs no memory of past examples, so it can learn as the data arrives                                       |
| Millions of documents or images to search by meaning | An ANN index: HNSW in pgvector, or FAISS                       | A little recall buys search that does not scan every vector                                                     |

Whatever the algorithm, the test is the same: a held-out set from your own data, and a simple baseline it has to beat. If the harder question is where a model belongs in a business process at all, our [AI and automation service](https://computese.com/services/ai-automation/) starts from one real workflow, uses a model only at the steps that need judgment, and runs an evaluation set built from your real cases before any model, prompt or source change goes live.

## Key terms
- **Machine learning algorithm**: A procedure that fits a model's parameters to examples so the model can predict, group or act on new data. Supervised, unsupervised and reinforcement learning are the classic families.
- **Big data**: In NIST's definition, datasets whose volume, velocity, variety or variability require a scalable architecture to store, manipulate and analyze them efficiently.
- **Stochastic gradient descent (SGD)**: Gradient descent that estimates the direction to improve from one random example, or a small random mini-batch, instead of the whole dataset, so each update costs the same however large the data grows.
- **Gradient boosting**: An ensemble method that adds decision trees one at a time, each fitted to the errors the earlier trees left. XGBoost and LightGBM are the best-known implementations.
- **Histogram-based split finding**: Binning each feature's values into a few hundred buckets once, then choosing tree splits from bucket boundaries instead of every sorted value.
- **Out-of-core learning**: Training on data larger than memory by reading it from disk in blocks, so one machine can process a dataset it could never load at once.
- **Data parallelism**: Splitting each batch of training data across several processors or machines that hold copies of the same model, then combining their gradients so all copies take the same step.
- **Approximate nearest neighbor (ANN) search**: Finding the vectors most similar to a query through an index such as HNSW, accepting a small loss of recall to avoid comparing the query with every stored vector.
- **Quantum machine learning (QML)**: Machine learning algorithms designed to run partly on quantum computers, from HHL-based linear algebra to parameterized quantum circuits trained by a classical optimizer.
- **Barren plateau**: A training landscape in which the gradient of a parameterized quantum circuit becomes exponentially small as qubits are added, leaving the classical optimizer no slope to follow.

## Common questions

### Is there a new revolutionary machine learning algorithm?

Not one that the July 2024 story this page began as could name: it cited no paper, lab or result. The gains in speed and scale that machine learning has made came from several techniques published over many years, among them stochastic gradient descent, histogram-based boosting, in-memory cluster computing and approximate nearest neighbor indexes. When a headline announces a breakthrough, look for the paper behind it.

### Which machine learning algorithms work best for big data?

It depends on the shape of the data. For tables, start with histogram-based gradient boosting (XGBoost, LightGBM or scikit-learn's HistGradientBoosting). For images, audio and free text, neural networks trained with mini-batch SGD on GPUs. For similarity search over millions of items, an approximate nearest neighbor index such as HNSW.

### Why is stochastic gradient descent used on large datasets?

Because the cost of each update does not depend on how many examples you have. Full gradient descent reads every example before every step, which stops being practical at millions of rows. SGD and mini-batch SGD take a cheap, noisy step from a small random sample, and when computing time is the limit they reach a given accuracy sooner.

### Can machine learning handle data that does not fit in memory?

Yes. Algorithms can stream mini-batches from disk, and some libraries read data in compressed blocks: XGBoost's 2016 paper trained on 1.7 billion examples on a single machine this way, and on four machines in a cluster. Beyond that, Spark MLlib and distributed XGBoost spread the data across a cluster.

### Will quantum computers speed up machine learning?

Not for ordinary business data on current evidence. The best-known exponential speedups rely on assumptions about loading and reading data that can erase the gain in practice, one was matched classically in 2018, and a 2024 study of 12 quantum models found classical models ahead. The strongest demonstrated advantage is for learning from quantum experiments.

### What is the difference between XGBoost and LightGBM?

Both are gradient-boosted tree libraries. XGBoost (2016) introduced sparsity-aware splits, a weighted quantile sketch and out-of-core blocks; LightGBM (2017) added gradient-based sampling and feature bundling to skip work. XGBoost's default tree method is now a histogram method like LightGBM's, so the practical difference depends on your data: test both.

## Sources
1. [What is Machine Learning?](https://developers.google.com/machine-learning/intro-to-ml/what-is-ml), Google for Developers
2. [NIST Big Data Interoperability Framework: Volume 1, Definitions (SP 1500-1r2)](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.1500-1r2.pdf), NIST
3. [Large-Scale Machine Learning with Stochastic Gradient Descent (COMPSTAT 2010)](https://leon.bottou.org/papers/bottou-2010), Léon Bottou
4. [Linear regression: Hyperparameters](https://developers.google.com/machine-learning/crash-course/linear-regression/hyperparameters), Google for Developers
5. [XGBoost: A Scalable Tree Boosting System (KDD 2016)](https://arxiv.org/abs/1603.02754), arXiv
6. [LightGBM: A Highly Efficient Gradient Boosting Decision Tree (NIPS 2017)](https://papers.nips.cc/paper_files/paper/2017/hash/6449f44a102fde848669bdd9eb6b76fa-Abstract.html), NeurIPS Proceedings
7. [Ensembles: Histogram-Based Gradient Boosting](https://scikit-learn.org/stable/modules/ensemble.html), scikit-learn
8. [Tree Methods](https://xgboost.readthedocs.io/en/stable/treemethod.html), XGBoost documentation
9. [XGBoost Parameters](https://xgboost.readthedocs.io/en/stable/parameter.html), XGBoost documentation
10. [Why do tree-based models still outperform deep learning on typical tabular data? (NeurIPS 2022)](https://papers.nips.cc/paper_files/paper/2022/hash/0378c7692da36807bdec87ab043cdadc-Abstract-Datasets_and_Benchmarks.html), NeurIPS Proceedings
11. [Resilient Distributed Datasets: A Fault-Tolerant Abstraction for In-Memory Cluster Computing (NSDI 2012)](https://www.usenix.org/system/files/conference/nsdi12/nsdi12-final138.pdf), USENIX
12. [MLlib: Main Guide](https://spark.apache.org/docs/latest/ml-guide.html), Apache Spark
13. [Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour](https://arxiv.org/abs/1706.02677), arXiv
14. [Billion-scale similarity search with GPUs](https://arxiv.org/abs/1702.08734), arXiv
15. [Efficient and robust approximate nearest neighbor search using Hierarchical Navigable Small World graphs](https://arxiv.org/abs/1603.09320), arXiv
16. [pgvector: Open-source vector similarity search for Postgres](https://github.com/pgvector/pgvector), GitHub
17. [Quantum algorithm for solving linear systems of equations (Physical Review Letters, 2009)](https://arxiv.org/abs/0811.3171), arXiv
18. [Quantum Machine Learning Algorithms: Read the Fine Print (Nature Physics, 2015)](https://www.scottaaronson.com/papers/qml.pdf), Scott Aaronson
19. [Quantum Recommendation Systems](https://arxiv.org/abs/1603.08675), arXiv
20. [A quantum-inspired classical algorithm for recommendation systems (STOC 2019)](https://arxiv.org/abs/1807.04271), arXiv
21. [Barren plateaus in quantum neural network training landscapes (Nature Communications, 2018)](https://arxiv.org/abs/1803.11173), arXiv
22. [Does provable absence of barren plateaus imply classical simulability?](https://www.nature.com/articles/s41467-025-63099-6), Nature Communications
23. [Better than classical? The subtle art of benchmarking quantum machine learning models](https://arxiv.org/abs/2403.07059), arXiv
24. [Quantum advantage in learning from experiments (Science, 2022)](https://arxiv.org/abs/2112.00778), arXiv
25. [On the State of the Art of Evaluation in Neural Language Models](https://arxiv.org/abs/1707.05589), arXiv
26. [Leakage and the reproducibility crisis in machine-learning-based science](https://pmc.ncbi.nlm.nih.gov/articles/PMC10499856/), Patterns (PMC)