On Storage Neural Network Augmented Approximate Nearest Neighbor Search

Daisuke Miyashita; Jun Deguchi; Taiga Ikeda

REVIEW 2 major objections 6 minor 15 references

On Storage Neural Network Augmented Approximate Nearest Neighbor Search

T0 review · 2 major / 6 minor · reviewed 2026-08-10 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read The paper claims that a neural network predicting the cluster holding a query's true nearest neighbor, combined with iterative duplication, fetches 80% fewer vectors than SPANN and 58% fewer than an exhaustive k-means baseline at 90%…

desk verdict A clearly scoped empirical study: real reduction in storage reads from a neural cluster predictor plus duplication, with the latency caveat honestly stated but unmeasured at the claimed operating points. read the letter →

arxiv 2501.16375 v1 pith:6QHPNFIP submitted 2025-01-23 cs.LG cs.AIcs.IR

Taiga Ikeda , Daisuke Miyashita , Jun Deguchi This is my paper · ORCID

classification cs.LGcs.AIcs.IR

keywords approximatenearestneighborsearchstorage-residentvectorclusterpredictionneuralnetworkduplicatedassignmentrecall-latencytradeoffSIFT1Mpartitioning-basedindex

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper sets up storage-resident approximate nearest neighbor search, where the dominant cost is reading vectors from storage rather than computing distances. It argues that the limiting factor is cluster selection: the cluster whose centroid is closest to a query often does not contain the query's true nearest neighbor, and the correct cluster boundary for queries is more complex than the k-means assignment boundary. The proposed solution trains a small neural network to predict the correct cluster from the query vector, and periodically duplicates key vectors into clusters the network misses, so the boundaries become simpler as training proceeds. On SIFT1M this reaches 90% recall while fetching about 6,165 vectors on average, compared with about 14,900 for the exhaustive k-means baseline and about 30,700 for SPANN, with consistent but smaller gains on CLIP features.

What carries the argument

The load-bearing object is a three-layer MLP cluster predictor: input dimension equals the vector dimension, the hidden layer has 128 units, and output dimension equals the number of clusters. It is trained on query vectors sampled from the deployment distribution, with the correct cluster found by exhaustive search used as the label. During training, duplication runs periodically: for queries whose ground-truth key vector is not among the network's top-$k_d$ predicted clusters, the pair of top-1 cluster and ground-truth key vector is marked, and the most frequently marked $r_d\%$ of key vectors are added to another cluster; training then resumes. This mechanism matters because it lets the network fit the true query-decided cluster boundaries rather than the centroid assignment boundaries, and it lets duplication relax those boundaries enough that the network can fit them.

What would settle it

Run the three compared methods on the same SIFT1M index with an NVMe SSD and measure wall-clock latency per query at 90% recall; if the ratio of measured latencies does not roughly match the ratio of fetched vectors, for instance because small random reads cost more per vector than large sequential reads, the central claim is disproven.

Watch

Extended reading notes

Core claim

The paper's central claim is that, for approximate nearest neighbor search on data stored in storage devices rather than RAM, the right design goal is to minimize the number of vectors fetched per query at a given recall, because fetch time dominates total latency. It identifies the bottleneck as the accuracy of the cluster-selection step: in a k-means partition, the cluster nearest to a query by centroid distance frequently fails to contain the ground-truth nearest neighbor, and the true query-to-cluster boundaries follow the distribution of key vectors, not of centroids. The paper shows that a three-layer MLP trained with cross-entropy on query/correct-cluster pairs can learn these boundaries, and that periodically duplicating key vectors into the clusters the network most often misses, then retraining, further improves accuracy by simplifying the boundaries. With this method, the average number of fetched vectors at recall@1=90% on SIFT1M drops to 6,165, which is 58% less than the 14,900 of an exhaustive k-means plus linear search and 80% less than the 30,729 of SPANN; the ordering holds at 95% and 99% recall and on a CLIP feature set.

Load-bearing premise

The argument collapses if search latency is not dominated by storage-read time, because all comparisons are counts of fetched vectors rather than measured latency.

Editorial extensions

If this is right

At every measured recall level on both datasets, the proposed method fetches fewer vectors than either baseline, so it should translate into lower mean latency whenever storage-read time dominates.
Using SPANN's fast partitioning instead of k-means does not break the method: the fetched-vector count at 90% recall becomes 7,372, still far below SPANN's 30,729, so the approach can be paired with a scalable index builder.
The neural network's memory overhead at 1,000 clusters is comparable to the baseline's centroid table, since the output layer has 128×1000 parameters, so the gains are not bought by extra memory-heavy state.
Each ingredient contributes independently: neural prediction alone and duplication alone each beat the exhaustive baseline, and alternating duplication with training outperforms a single duplication step applied after training.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

A wall-clock latency study on actual NAND or NVMe hardware would directly test whether the fetched-vector reductions appear as latency reductions; the paper reports only the proxy metric.
Because the method trains on queries from the deployment distribution, it should transfer most easily to retrieval workloads with concentrated query distributions, such as question answering or retrieval-augmented language modeling, and least to uniform query streams.
The same idea of learning the true query-determined cluster boundaries could extend to choosing which nodes to fetch in graph-based storage indexes, or to learned page prefetching, though the paper evaluates only partitioning-based indexes.
The duplication schedule and hyperparameters could be made adaptive to validation recall instead of fixed epochs, which might improve robustness across datasets.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

What should you know? The paper's actual contribution is narrower and cleaner than its abstract suggests: it trains a small MLP to predict which cluster contains the true nearest neighbor, then iteratively duplicates cluster membership based on training-query misses. That is a genuine departure from DSI, BLISS, and NeuralLSH, which either predict vector indices or learn a partitioning rule but still use the same rule for query routing. The 2D toy visualization makes the intuition clear, and the ablations show both the neural predictor and duplication matter, with CE loss performing best. They also report ten repeated runs with standard deviations, which is more than many ANN papers do.

The paper is honest about what it measures. It does not claim measured latency improvements; it claims fewer fetched vectors, and it explicitly states in Section 5 that the discussion is invalid if the storage-latency-dominance condition does not hold. The fetched-vector metric is a reasonable controlled proxy, and the SPANN comparison at 1000 clusters is defensible given their argument that VQ is not a fair metric across different cluster counts. That said, the 80% reduction versus SPANN is partly a comparison at a constrained setting—SPANN's preferred regime is many more clusters, and the paper does not explore that.

The stress-test concern about T≈Tb is fair but not fatal. Table 1 gives coarse upper bounds that do not cover the method's own low-fetch operating points (e.g., 2114 vectors on CLIP), and random-access penalties or small-read effects are not modeled. So the latency interpretation is a plausible extrapolation, not a measured result. The paper's own caveat covers much of this, but the headline "less data fetched" will likely be read as "faster search," and the paper could do more to police that boundary. The CLIP gains are marginal, the evaluation is in-distribution, and no code or data are provided. Those are real limitations, but they are stated clearly, not hidden.

The math is simple and correct; there is no circularity. The citation pattern is fine, including the authors' own prior work on KNN classification, which is relevant to the setting. The central empirical claim—fewer fetched vectors at matched recall on million-scale data under the stated assumptions—holds up as a conditional improvement.

Recommendation: send this to peer review. A serious referee should push for either end-to-end latency measurements or a stronger validation of T≈Tb at the method's actual operating points, and should ask for code/data release. But the core idea and the measured fetch reduction are solid and worth refereeing. I would bring it to a reading group if storage ANN is on the agenda.

Referee Report

2 major / 6 minor

Summary. The paper addresses approximate nearest neighbor search when the vector store resides in storage rather than memory. It argues that search latency is dominated by the time to fetch vectors from storage, and therefore proposes to minimize the number of fetched vectors at a given recall. The proposed method trains a small three-layer MLP to predict which clusters (posting lists) are likely to contain the ground-truth nearest neighbor of a query, and augments this with an iterative duplication process that copies frequently missed key vectors into additional clusters. Experiments on SIFT1M and a CLIP feature dataset compare the method against an exhaustive k-means baseline and SPANN at a fixed 1,000-cluster configuration, reporting reductions in fetched vectors at 90/95/99% recall. The paper includes ablations isolating the contributions of the neural predictor, duplication, and the loss function.

Significance. If the results hold, the paper offers a simple and orthogonal idea: instead of using the same rule for partitioning keys and for choosing clusters at query time, train a neural network directly on query-to-ground-truth-cluster pairs. This is a plausible way to improve the storage-fetch/recall tradeoff and could potentially be combined with other index structures. The experimental presentation is careful in several respects: results are repeated 10 times with standard deviations, the ablation study isolates the neural network and duplication ingredients, and the paper explicitly acknowledges the main limitation of its latency proxy. However, the significance is moderated by the constrained comparison with SPANN and by the absence of any direct latency validation at the method's actual operating points.

major comments (2)

[Section 4.1 (Comparison with conventional methods)] SPANN is evaluated with 1,000 clusters and its default ReplicaCount=8, but SPANN is designed to operate with a much larger number of posting lists; the paper's own Figure 1(a) shows that SPANN at 100K clusters achieves a substantially better fetch/recall tradeoff than at 1K clusters. The abstract's unqualified statement that the proposed method reads 80% less data than SPANN is therefore not representative of SPANN's preferred configuration. Please either include SPANN at additional cluster counts with memory usage reported, or qualify the headline claim as holding at 1,000 clusters.
[Section 3.2.1 (Eq. (1), Table 1)] The paper approximates mean latency as T ≈ Tb and uses the number of fetched vectors as the evaluation metric, but it never reports measured Tb or end-to-end latency for the proposed method at its actual operating points (e.g., 2,114 fetched vectors at R@1=90% on CLIP in Table 3). Table 1 provides only coarse bounds for 1k/10k/100k vectors and for SPANN's Ta; it does not cover the small-read regime where the proposed method operates, nor does it account for random-access penalties or page granularity. Since the first stated contribution is that storage fetch time dominates search latency, the paper should validate the proxy at the reported operating points, or explicitly limit the claim to the number of fetched vectors.

minor comments (6)

[Section 3.2.1, Table 1] The entries such as "Ta < 0.24 < 0.27 < 0.29" are hard to read; re-format the table to clearly report the three cluster-count conditions and the measured upper bounds for each.
[Section 4.1] The procedure for varying the number of fetched vectors to produce the recall-versus-fetched-vectors curves is not described; specify how many clusters are selected for each method and how the number of fetched vectors is controlled.
[Section 4.1] The phrase "we use the first 128 dimension" should be "we use the first 128 dimensions."
[Section 5] The word "foundings" in the final paragraph should be "findings."
[Figure 4] The figure does not show error bars or confidence bands despite the text reporting 10 trials; consider adding them to support the reported variability.
[Section 4.1] The training hyperparameters, including learning rate, noise standard deviation, and weight decay, are not reported; add a training details paragraph for reproducibility.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the reported fetched-vector reductions are measured outcomes of a supervised training/evaluation pipeline, not fitted quantities or self-citational derivations.

full rationale

The claimed contributions are empirical: Tables 2 and 3 report measured numbers of vectors fetched from storage under fixed recall and a fixed cluster count (1000). These quantities are not predictions derived from fitted parameters. The neural network is trained in a standard supervised manner using ground-truth cluster labels obtained by exhaustive search over training queries (Section 4), and the duplication step modifies the index using training-query statistics; both procedures are then evaluated on separate test queries. The evaluation therefore does not reduce to the training objective by construction. The main modeling premise translating fetched-vector counts into latency is the approximation T ≈ Tb in Section 3.2.1, which the paper explicitly states as an assumption supported by order-of-magnitude arguments and Table 1, and Section 5 openly notes that the discussion is invalid if storage access time is not dominant. This is an acknowledged modeling assumption, not a circular step. The only author-overlapping citation (Nakata et al., 2022) appears as motivational related work in Section 1 and is not load-bearing for the central claim. No self-citation chain, uniqueness theorem, or ansatz-by-citation was found. The paper is self-contained in its empirical comparisons, so I find no significant circularity.

Assumptions & free parameters 9 free parameters · 6 assumptions · 0 invented entities

The central claim rests on the storage-latency proxy, the in-distribution query assumption, and the learned-boundary approximation. Free parameters are mostly hand-chosen hyperparameters; no new physical or conceptual entities are introduced.

free parameters (9)

kd = 4 (default; also tested 1)
Number of top predicted clusters checked in duplication; chosen by hand. Ablation (Table 4g) shows kd=1 is worse.
rd = 20
Percentage of most frequently marked pairs applied in duplication; chosen by hand and not ablated.
duplication interval = 50 epochs
Duplication is executed every 50 epochs; one-shot duplication after training (Table 4h) is worse.
hidden layer size = 128
Set equal to vector dimension so the output layer parameter count matches centroid memory usage.
number of clusters = 1000
Chosen for fair comparison across methods; recall-fetched tradeoff depends strongly on it (Figure 1).
training epochs = 150
Training duration chosen by hand; not ablated.
batch size = 1000
Used for neural network training; chosen by hand.
noise standard deviation for training augmentation
Noise is added to avoid overfitting, but its standard deviation is not reported, which also hurts reproducibility.
AdamW learning rate and weight decay
Optimizer is specified but hyperparameters are not reported.

assumptions (6)

domain assumption Mean search latency is dominated by storage fetch time (T approximately equal to Tb), with computation times Ta and Tc negligible.
Section 3.2.1; the entire evaluation uses number of fetched vectors as a proxy for latency.
domain assumption The number of vectors fetched from storage is proportional to storage read latency.
Section 3.2.1; no model of random versus sequential reads, page boundaries, or device-specific behavior.
domain assumption Queries encountered at deployment follow the same distribution as the training query sample.
Section 4.1 samples training queries from the same source as test queries; Section 5 notes the method may fail if query distribution is uniform and unpredictable.
standard math Ground truth cluster labels for training queries are obtained by exhaustive search over key vectors.
Section 4; this is computationally exact but expensive, and its cost is not counted in the index-build budget.
domain assumption A three-layer MLP with 128 hidden units can approximate the true cluster-boundary function for the query-to-nearest-cluster mapping.
The method's effectiveness depends on this approximation; no capacity or generalization guarantee is given.
domain assumption Duplicated cluster assignment relaxes boundary complexity and improves recall without negating the benefit of neural prediction.
Ablation supports this empirically, but the interaction is not analyzed.

how reviews work

0 comments

Cite this review

Pith. "Pith review of On Storage Neural Network Augmented Approximate Nearest Neighbor Search." pith.science (2026). https://pith.science/paper/6QHPNFIP

@misc{pith2026250116375,
  author       = {Pith},
  title        = {Pith review of: On Storage Neural Network Augmented Approximate Nearest Neighbor Search},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/6QHPNFIP}},
  note         = {Machine review of arXiv:2501.16375}
}

read the original abstract

Large-scale approximate nearest neighbor search (ANN) has been gaining attention along with the latest machine learning researches employing ANNs. If the data is too large to fit in memory, it is necessary to search for the most similar vectors to a given query vector from the data stored in storage devices, not from that in memory. The storage device such as NAND flash memory has larger capacity than the memory device such as DRAM, but they also have larger latency to read data. Therefore, ANN methods for storage require completely different approaches from conventional in-memory ANN methods. Since the approximation that the time required for search is determined only by the amount of data fetched from storage holds under reasonable assumptions, our goal is to minimize it while maximizing recall. For partitioning-based ANNs, vectors are partitioned into clusters in the index building phase. In the search phase, some of the clusters are chosen, the vectors in the chosen clusters are fetched from storage, and the nearest vector is retrieved from the fetched vectors. Thus, the key point is to accurately select the clusters containing the ground truth nearest neighbor vectors. We accomplish this by proposing a method to predict the correct clusters by means of a neural network that is gradually refined by alternating supervised learning and duplicated cluster assignment. Compared to state-of-the-art SPANN and an exhaustive method using k-means clustering and linear search, the proposed method achieves 90% recall on SIFT1M with 80% and 58% less data fetched from storage, respectively.

Figures

Figures reproduced from arXiv: 2501.16375 by the authors.

**Figure 2.** Visualization with 2-dimensional toy data. (a) [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗

**Figure 3.** Effect of our proposed method. The upper figures show the [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗

Figures from the paper (2 more)

**Figure 4.** Figure 4: Recall@1 vs the number of vectors fetched from storage. [PITH_FULL_IMAGE:figures/full_fig_p008_4.png]

**Figure 4.** Figure 4: The difference of the amount of improvement between SIFT and CLIP may come from [PITH_FULL_IMAGE:figures/full_fig_p009_4.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

15 extracted references · 5 canonical work pages

[3]

Imagenet: A large-scale hier- archical image database

Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hier- archical image database. In 2009 IEEE Conference on Computer Vision and Pattern Recognition, pp. 248–255,

2009
[6]

URL http://www.vldb.org/pvldb/vol12/p461-fu.pdf

doi: 10.14778/ 3303753.3303754. URL http://www.vldb.org/pvldb/vol12/p461-fu.pdf. Anirudh Goyal, Abram Friesen, Andrea Banino, Theophane Weber, Nan Rosemary Ke, Adri`a Puig- dom`enech Badia, Arthur Guez, Mehdi Mirza, Peter C Humphreys, Ksenia Konyushova, Michal Valko, Simon Osindero, Timothy Lillicrap, Nicolas Heess, and Charles Blundell. Retrieval- augmen...

arXiv
[8]

Product quantization for nearest neighbor search

10 Herve J ´egou, Matthijs Douze, and Cordelia Schmid. Product quantization for nearest neighbor search. IEEE Transactions on Pattern Analysis and Machine Intelligence, 33(1):117–128, 2011a. doi: 10.1109/TPAMI.2010.57. Herv´e J´egou, Romain Tavenard, Matthijs Douze, and Laurent Amsaleg. Searching in one billion vec- tors: Re-rank with source coding. In 20...

arXiv 2010
[9]

Dense passage retrieval for open-domain question answering

Vladimir Karpukhin, Barlas Oguz, Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, and Wen-tau Yih. Dense passage retrieval for open-domain question answering. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pp. 6769–6781, Online, November

work page 2020
[11]

Revisiting a kNN-based Image Classification System with High-capacity Storage

URL https://arxiv.org/abs/2204.01186. Alexander Pritzel, Benigno Uria, Sriram Srinivasan, Adri `a Puigdom `enech Badia, Oriol Vinyals, Demis Hassabis, Daan Wierstra, and Charles Blundell. Neural episodic control. In Doina Precup and Yee Whye Teh (eds.), Proceedings of the 34th International Conference on Machine Learn- ing, volume 70 of Proceedings of Mac...

work page Pith review arXiv
[13]

Minjia Zhang and Yuxiong He

URL https://arxiv.org/abs/ 2202.06991. Minjia Zhang and Yuxiong He. Grip: Multi-store capacity-optimized high-performance nearest neighbor search for vector search engine. In Proceedings of the 28th ACM International Confer- ence on Information and Knowledge Management , CIKM ’19, pp. 1673–1682,

arXiv
[14]

Song: Approximate nearest neighbor search on gpu

Weijie Zhao, Shulong Tan, and Ping Li. Song: Approximate nearest neighbor search on gpu. In 2020 IEEE 36th International Conference on Data Engineering (ICDE) , pp. 1033–1044,

work page 2020
[15]

doi: 10.1109/ICDE48307.2020.00094. 11

arXiv 2020

Show all 15 references

[2009]

Yihe Dong, Piotr Indyk, Ilya P

doi: 10.1109/CVPR.2009.5206848. Yihe Dong, Piotr Indyk, Ilya P. Razenshteyn, and Tal Wagner. Learning sublinear-time indexing for nearest neighbor search. arXiv preprint, arXiv:1901.08544,

2009
[2016]

URLhttps: //arxiv.org/abs/1606.04460. Sebastian Borgeaud, Arthur Mensch, Jordan Hoffmann, Trevor Cai, Eliza Rutherford, Katie Mil- lican, George van den Driessche, Jean-Baptiste Lespiau, Bogdan Damoc, Aidan Clark, Diego de Las Casas, Aurelia Guy, Jacob Menick, Roman Ring, Tom ...

arXiv
[2017]

URL https://proceedings.mlr.press/v70/pritzel17a.html. Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agar- wal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, Gretchen Krueger, and Ilya Sutskever. Learning transferable visual model...

2021
[2019]

URL http://arxiv.org/ abs/1901.08544. Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, Jakob Uszko- reit, and Neil Houlsby. An image is worth 16x16 word...

1901 arXiv
[2020]

doi: 10.18653/v1/2020.emnlp-main.550

Association for Computational Linguis- tics. doi: 10.18653/v1/2020.emnlp-main.550. URL https://aclanthology.org/2020. emnlp-main.550. Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. In International Confer- ence on Learning Representations ,

2020 doi
[2021]

Qi Chen, Bing Zhao, Haidong Wang, Mingqin Li, Chuanjie Liu, Zengzhong Li, Mao Yang, and Jingdong Wang

URL https://arxiv.org/abs/2112.04426. Qi Chen, Bing Zhao, Haidong Wang, Mingqin Li, Chuanjie Liu, Zengzhong Li, Mao Yang, and Jingdong Wang. Spann: Highly-efficient billion-scale approximate nearest neighborhood search. In Advances in Neural Information Processing Systems , vo...

arXiv
[2022]

Suhas Jayaram Subramanya, Fnu Devvrit, Harsha Vardhan Simhadri, Ravishankar Krishnawamy, and Rohan Kadekodi

URLhttps://arxiv.org/ abs/2206.05314. Suhas Jayaram Subramanya, Fnu Devvrit, Harsha Vardhan Simhadri, Ravishankar Krishnawamy, and Rohan Kadekodi. Diskann: Fast accurate billion-point nearest neighbor search on a single node. In Advances in Neural Information Processing System...

arXiv

Pith tools

Reviewed August 10, 2026 · model on record in the stance chip above.

[1] [3]

Imagenet: A large-scale hier- archical image database

Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hier- archical image database. In 2009 IEEE Conference on Computer Vision and Pattern Recognition, pp. 248–255,

2009

[2] [6]

URL http://www.vldb.org/pvldb/vol12/p461-fu.pdf

doi: 10.14778/ 3303753.3303754. URL http://www.vldb.org/pvldb/vol12/p461-fu.pdf. Anirudh Goyal, Abram Friesen, Andrea Banino, Theophane Weber, Nan Rosemary Ke, Adri`a Puig- dom`enech Badia, Arthur Guez, Mehdi Mirza, Peter C Humphreys, Ksenia Konyushova, Michal Valko, Simon Osindero, Timothy Lillicrap, Nicolas Heess, and Charles Blundell. Retrieval- augmen...

arXiv

[3] [8]

Product quantization for nearest neighbor search

10 Herve J ´egou, Matthijs Douze, and Cordelia Schmid. Product quantization for nearest neighbor search. IEEE Transactions on Pattern Analysis and Machine Intelligence, 33(1):117–128, 2011a. doi: 10.1109/TPAMI.2010.57. Herv´e J´egou, Romain Tavenard, Matthijs Douze, and Laurent Amsaleg. Searching in one billion vec- tors: Re-rank with source coding. In 20...

arXiv 2010

[4] [9]

Dense passage retrieval for open-domain question answering

Vladimir Karpukhin, Barlas Oguz, Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, and Wen-tau Yih. Dense passage retrieval for open-domain question answering. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), pp. 6769–6781, Online, November

work page 2020

[5] [11]

Revisiting a kNN-based Image Classification System with High-capacity Storage

URL https://arxiv.org/abs/2204.01186. Alexander Pritzel, Benigno Uria, Sriram Srinivasan, Adri `a Puigdom `enech Badia, Oriol Vinyals, Demis Hassabis, Daan Wierstra, and Charles Blundell. Neural episodic control. In Doina Precup and Yee Whye Teh (eds.), Proceedings of the 34th International Conference on Machine Learn- ing, volume 70 of Proceedings of Mac...

work page Pith review arXiv

[6] [13]

Minjia Zhang and Yuxiong He

URL https://arxiv.org/abs/ 2202.06991. Minjia Zhang and Yuxiong He. Grip: Multi-store capacity-optimized high-performance nearest neighbor search for vector search engine. In Proceedings of the 28th ACM International Confer- ence on Information and Knowledge Management , CIKM ’19, pp. 1673–1682,

arXiv

[7] [14]

Song: Approximate nearest neighbor search on gpu

Weijie Zhao, Shulong Tan, and Ping Li. Song: Approximate nearest neighbor search on gpu. In 2020 IEEE 36th International Conference on Data Engineering (ICDE) , pp. 1033–1044,

work page 2020

[8] [15]

doi: 10.1109/ICDE48307.2020.00094. 11

arXiv 2020