Pith. sign in

REVIEW 3 major objections 6 minor 50 references

LotusFilter: Fast Diverse Nearest Neighbor Search via a Learned Cutoff Table

T0 review · 3 major / 6 minor · reviewed 2026-08-07 · deepseek-v4-flash

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

Pith's one-line read LotusFilter turns diverse nearest-neighbor search into a fast, drop-in post-filter by precomputing which vectors are too close to each other.

desk verdict A simple, practical greedy post-processor for diverse ANN search with public code, but the formal training derivation is vacuous and the diversity guarantee silently depends on an exact range search the paper never verifies. read the letter →

arxiv 2506.04790 v1 pith:TYDVZ3TE submitted 2025-06-05 cs.CV cs.IRcs.LG

Yusuke Matsui This is my paper
classification cs.CVcs.IRcs.LG
keywords diversenearestneighborsearchcutofftablepost-processinggreedyfilteringlearnedthresholdapproximateretrievalaugmentedgeneration
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

LotusFilter tries to make diverse nearest neighbor search a cheap, drop-in post-processing step rather than a slow subset-selection problem. The idea is to precompute, for every database vector, a cutoff table of the other vectors within a squared-distance threshold $\varepsilon$, then greedily scan the initial ANN results: accept the closest remaining candidate and delete everything in its cutoff list. The paper argues this reduces the filtering cost to $O(T+S+KL)$, keeps the top-1 recall of the original search, and guarantees that any two final results are at least $\sqrt{\varepsilon}$ apart. On a 900,000-vector, 1536-dimensional text-embedding set, it reports 0.02 ms/query for the filtering step and memory overhead of roughly 136 MiB, with no need to load original vectors during filtering. If correct, any modern ANN index can be diversified without touching its internals.

What carries the argument

The cutoff table $\{L_n\}_{n=1}^N$: for each database vector $x_n$, the list of all other vectors whose squared distance to $x_n$ is below $\varepsilon$. The filtering loop uses this table to prune every candidate within $\sqrt{\varepsilon}$ of an accepted vector. OrderedSet, an array combined with a hash set, lets the algorithm pop the first remaining element in $O(L)$ and delete arbitrary elements by ID in $O(1)$, so the while-loop costs $O(KL)$. The table is built once by a range search over an ANN index, which is what makes the post-process independent of dimensionality and independent of the original vectors.

What would settle it

Run the released implementation on a small dataset with two database vectors whose squared distance is below the chosen $\varepsilon$, and issue a query whose initial $S$ contains both. If both appear in the final $K$, the cutoff table missed an entry and the Section 4.4 separation guarantee is false for that build.

Watch

Extended reading notes

Core claim

The central claim is that result diversity can be enforced by a simple 'delete all near-duplicates of each accepted point' rule, provided the near-duplicate relation is tabulated beforehand. The paper shows that when every cutoff list $L_n$ is complete, Algorithm 2's greedy filtering returns a final set $K$ satisfying the separation guarantee $\lVert x_i - x_j \rVert_2^2 \ge \varepsilon$ for all distinct $i,j$, so the diversity term of the objective is bounded by $-\varepsilon$. It further claims the whole search-plus-filter loop runs in $O(T+S+KL)$ on average using an OrderedSet that supports pop and removal without scanning the whole candidate array. The threshold $\varepsilon$ is learned by a bracketing search on training queries, so the single hyperparameter does not need manual tuning.

Load-bearing premise

The whole guarantee depends on the cutoff table listing every vector within the chosen distance threshold; if the table is built with an approximate search and misses one, a pair of near-identical results can slip through.

Editorial extensions

If this is right

  • A modern ANN index can be used as a black box; diversification needs only the candidate ID list and the cutoff table, and the filter can be toggled on or off.
  • Total search-plus-filter cost is $O(T+S+KL)$; with $L$ around 20–30 in the reported settings, the filtering overhead over plain ANN search is a small constant (0.02 ms/query on the 900K set).
  • The top-1 result of the initial search always survives, so Recall@1 is unchanged by diversification.
  • Whenever the safeguard mode is not triggered, the final $K$ items are mutually at least $\sqrt{\varepsilon}$ apart, giving a user-adjustable diversity guarantee.
  • Memory overhead is exactly $64LN$ bits with 64-bit integer IDs, independent of vector dimensionality and predictable before deployment.

Reading between the lines

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

  • Editorial: because the filter never reads original vectors, it should extend to billion-scale or compressed-vector databases where only IDs and distance metadata are available; the paper does not run that experiment.
  • Editorial: the global threshold $\varepsilon$ could be replaced by per-region or per-cluster thresholds for datasets with uneven density; the paper only flags the global-threshold limitation.
  • Editorial: a direct test of the completeness assumption would build the cutoff table with an exact scan and with the approximate range search, then compare whether any near pair is missing; if pairs are missing, the Section 4.4 guarantee silently becomes approximate.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

3 major / 6 minor

Summary. The paper proposes LotusFilter, a post-processing module for diverse nearest neighbor search. It precomputes a cutoff table Ln containing, for each database vector xn, all vectors whose squared distance to xn is below a threshold epsilon. At query time, the method runs an arbitrary ANNS to obtain S candidates, then greedily accepts the closest remaining candidate and deletes all of its epsilon-neighbors via the table, repeating until K items are selected. The authors claim an O(T + S + KL) filtering cost, report 0.02 ms/query on 900K 1536-dimensional OpenAI embeddings, and state a theoretical guarantee that any two output vectors have squared distance at least epsilon. The threshold epsilon is learned on a training split by bracketing. The code is publicly available.

Significance. If the claims hold, LotusFilter is an attractive drop-in diversification post-processor for RAG-style applications: it treats the ANNS index as a black box, avoids pairwise distance computations during filtering, has predictable memory usage, and is empirically very fast. The paper's strengths include public code, evaluation on standard large-scale benchmarks, a simple and novel data structure (OrderedSet), and qualitative demonstrations on text and image data. However, two load-bearing points need correction: the formal diversity guarantee silently assumes that the cutoff table is complete, which is not guaranteed by the approximate range search described in the implementation, and the training objective in Eq. (6)-(7) is formally independent of epsilon, making the derivation vacuous as written. The practical contribution is promising, but the theoretical framing must be repaired before the paper can be accepted.

major comments (3)
  1. [Sec. 4.1, Algorithm 1; Sec. 4.4] The diversity guarantee in Sec. 4.4 ('for all i,j in K, ||xi - xj||^2 >= epsilon') depends on every Lk being complete: Algorithm 2, L6 can only delete a vector if it appears in Lk. Algorithm 1 defines Ln exactly by set comprehension, but the surrounding text says the table is built by 'a range search for each xn' using the ANNS index I. An ANNS index such as HNSW performs approximate range search and may miss true neighbors within epsilon. The paper never states that the range search is exact, nor does it verify completeness of the constructed table. With an incomplete table, Algorithm 2 can return pairs with squared distance below epsilon, so the main theoretical claim does not hold for the implementation as described. The reported memory (136 MiB) and runtime (0.02 ms/query) are also computed from this approximate table and do not reflect the cost of an exact construction. This issue is load-bearing for the central contribution.
  2. [Sec. 6, Eq. (6)-(7)] Eq. (6) defines f*(epsilon, q) as argmin over K subset of NN(q,S) of f(K), where f(K) is given by Eq. (2). Since neither the feasible set NN(q,S) nor the objective f(K) depends on epsilon, f*(epsilon, q) is independent of epsilon, and Eq. (7) is formally a minimization of a constant. The bracketing procedure in Algorithm A appears to intend f* to be the cost of LotusFilter's output for a given threshold epsilon, but this function is never defined. As written, the 'learned cutoff table' training derivation is vacuous. The authors should redefine f*(epsilon, q) as the value of Eq. (2) at the output of Algorithm 2 with threshold epsilon, or otherwise explain what quantity Eq. (7) actually optimizes.
  3. [Sec. 4.5, Algorithm 2] The paper states that with the safeguard mode activated, the condition |K| = K is ensured 'in this scenario and only in this scenario, the theoretical result discussed in Sec. 4.4 does not hold.' However, it is not reported whether the experiments use the safeguard mode. If safeguard mode is used in the evaluations, the reported f values in Tables 1 and B may correspond to outputs that violate the diversity guarantee, making it unclear whether the empirical improvements are attributable to the guaranteed filtering or to the fallback behavior. The pseudocode of Algorithm 2 should explicitly show how the safeguard is activated and the experiments should state which mode is used.
minor comments (6)
  1. [Sec. 4.1] The sentence 'Assuming that the cost of the range search is also O(T), the total cost becomes O(NT)' is inconsistent with the exact set definition in Algorithm 1 L3, since an exact range search does not in general have the same cost as an approximate ANNS query. Please clarify what kind of range search is assumed.
  2. [Algorithm 2] The pseudocode returns K with |K| = K, but if S becomes empty before the while loop terminates, L7 can return fewer than K elements. The safeguard described in Sec. 4.5 should be reflected in the pseudocode or the return statement should be qualified.
  3. [Sec. 4.3] The memory expression 64LN [bit] uses the average L, but the worst-case memory can be as large as 64N^2 bits (when every vector is within epsilon of every other). A sentence noting the worst case would help readers judge scalability.
  4. [Table 1] For the LotusFilter row, the memory column for the original vectors {xn} is marked '-', but the HNSW index I used in Algorithm 1 also stores vectors internally. Please clarify what is included in the reported memory overhead and what is excluded.
  5. [Sec. 6] The line 'Since S is the search result of q, we can write S = NN(q, S)' is confusing because S appears on both sides and NN is not formally defined. Please introduce notation such as S = ANNS(q, S) or S = Search(q) to avoid ambiguity.
  6. [Sec. 5.2] In the POP operation, Step 1 ('Repeat c <- c+1 until v[c] in V') assumes that V is nonempty. If the OrderedSet becomes empty before the loop terminates, this step is undefined; an edge-case check would make the pseudocode robust.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the diversity guarantee follows by construction from Algorithm 1's cutoff-table definition, epsilon is fitted on a separate training split, and no load-bearing self-citation is used.

full rationale

LotusFilter's derivation is self-contained. The Sec. 4.4 diversity bound is a direct correctness property of Algorithm 2: Algorithm 1 defines Lk = {i : ||xk - xi||^2 < epsilon, i != k}, and Algorithm 2 deletes Lk whenever k is accepted, so any pair in K has squared distance at least epsilon. This is a proof about the algorithm's own definitions, not a prediction that reduces to a fitted input. The threshold epsilon is selected on Qtrain via Eq. (7) and evaluated on held-out queries, which is standard hyperparameter fitting rather than a forced prediction. The evaluation objective Eq. (2) is the same as the training objective, which creates a mild selection-pressure caveat, but that is not circularity. The paper cites prior work (e.g., [3, 22] for the diversity term and HNSW [28] as the ANN backbone), but none of these citations carries the central claim; the cutoff-table mechanism and its guarantee are established within the paper. A genuine correctness concern is that the cutoff table is built with an approximate ANNS range search, so completeness of Lk is not verified; if Lk misses close vectors, the Sec. 4.4 guarantee can fail. That is an implementation gap, not a circular-reasoning defect.

Assumptions & free parameters 1 free parameters · 4 assumptions · 0 invented entities

One fitted epsilon per dataset is the only free parameter. The core assumptions are exact range search for the cutoff table, train/test query distribution match, and the greedy heuristic's near-optimality. No new physical or conceptual entities are introduced.

free parameters (1)
  • epsilon (cutoff threshold) = 0.277 for OpenAI dataset; 18.5 for MS MARCO; 1.14 for Revisited Paris; 5869 for SpaceV
    Learned via Eq (7) using bracketing on a training query set (first 1000 database vectors). Controls cutoff table size L and the diversity level; this is the central free parameter.
assumptions (4)
  • domain assumption The cutoff table L_n contains every database vector x_i with ||x_n - x_i||^2 < epsilon for every n.
    Algorithm 1 L3 defines L_n this way and Sec 4.4 uses it to prove pairwise separation. The paper does not state whether the ANNS range search used to build the table is exact.
  • domain assumption Training queries Qtrain are drawn from a distribution similar to test queries.
    Sec 6 states 'Assuming that this training query data is drawn from a distribution similar to the test query data.' This is needed for the learned epsilon to transfer.
  • ad hoc to paper The greedy filtering output approximates the optimal subset solution of Eq (1) closely enough to be useful.
    Sec 4.4 only bounds the diversity term; Sec 7.7 admits there is no theoretical guarantee for total cost. The empirical claim rests on this unproven heuristic quality.
  • domain assumption Eq (2) with lambda = 0.3 is an appropriate measure of retrieval quality for RAG.
    Both training and evaluation use Eq (2), and the paper's limitations state that end-to-end RAG quality is not measured.

how reviews work

0 comments
Cite this review

Pith. "Pith review of LotusFilter: Fast Diverse Nearest Neighbor Search via a Learned Cutoff Table." pith.science (2026). https://pith.science/paper/TYDVZ3TE

@misc{pith2026250604790,
  author       = {Pith},
  title        = {Pith review of: LotusFilter: Fast Diverse Nearest Neighbor Search via a Learned Cutoff Table},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/TYDVZ3TE}},
  note         = {Machine review of arXiv:2506.04790}
}
read the original abstract

Approximate nearest neighbor search (ANNS) is an essential building block for applications like RAG but can sometimes yield results that are overly similar to each other. In certain scenarios, search results should be similar to the query and yet diverse. We propose LotusFilter, a post-processing module to diversify ANNS results. We precompute a cutoff table summarizing vectors that are close to each other. During the filtering, LotusFilter greedily looks up the table to delete redundant vectors from the candidates. We demonstrated that the LotusFilter operates fast (0.02 [ms/query]) in settings resembling real-world RAG applications, utilizing features such as OpenAI embeddings. Our code is publicly available at https://github.com/matsui528/lotf.

Figures

Figures reproduced from arXiv: 2506.04790 by the authors.

Figure 1
Figure 1. (a) Usual ANNS. The search results are close to the [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Overview of the proposed LotusFilter (D = 2, N = 14, S = 6, K = 2) safeguard ensures that the final result meets the condition |K| = K. In this scenario and only in this scenario, the theoretical result discussed in Sec. 4.4 does not hold. 5. Complexity Analysis We prove that the computational complexity of Algorithm 2 is O(T + S + KL) on average. This is fast because just accessing the used variables requires the s… view at source ↗
Figure 3
Figure 3. Fix K, vary S 0.2 0.3 0.4 0.5 ε 0.33 0.34 f From test query ε ∗ by Eq. 7 [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (1 more)
Figure 5
Figure 5. Figure 5: Qualitative evaluation on image data using Revisited Paris. [PITH_FULL_IMAGE:figures/full_fig_p008_5.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

50 extracted references · 47 canonical work pages

  1. [1]

    Optuna: A next-generation hy- perparameter optimization framework

    Takuya Akiba, Shotaro Sano, Toshihiko Yanase, Takeru Ohta, and Masanori Koyama. Optuna: A next-generation hy- perparameter optimization framework. In Proc. ACM KDD,

    work page

  2. [2]

    Optuna: A next-generation hyperparameter optimization framework

    Takuya Akiba, Shotaro Sano, Toshihiko Yanase, Takeru Ohta, and Masanori Koyama. Optuna: A next-generation hyperparameter optimization framework. In Proceedings of the 25th ACM SIGKDD International Conference on Knowl- edge Discovery and Data Mining, 2019. 1

    work page 2019

  3. [3]

    Diversity maximization in the presence of outliers

    Daichi Amagata. Diversity maximization in the presence of outliers. In Proc. AAAI, 2023. 2, 6

    work page 2023

  4. [4]

    Quicker adc: Unlocking the hidden potential of product quantization with simd

    Fabien Andr ´e, Anne-Marie Kermarrec, and Nicolas Le Scouarnec. Quicker adc: Unlocking the hidden potential of product quantization with simd. IEEE TPAMI, 43(5):1666– 1677, 2021. 2

    work page 2021

  5. [5]

    Acl2023 tutorial on retrieval-based language models and ap- plications, 2023

    Akari Asai, Sewon Min, Zexuan Zhong, and Danqi Chen. Acl2023 tutorial on retrieval-based language models and ap- plications, 2023. 1

    work page 2023

  6. [6]

    Ms marco: A human generated machine reading comprehension dataset

    Payal Bajaj, Daniel Campos, Nick Craswell, Li Deng, Jian- feng Gao, Xiaodong Liu, Rangan Majumder, Andrew McNa- mara, Bhaskar Mitra, Tri Nguyen, Mir Rosenberg, Xia Song, Alina Stoica, Saurabh Tiwary, and Tong Wang. Ms marco: A human generated machine reading comprehension dataset. arXiv, 1611.09268, 2016. 5

    arXiv 2016

  7. [7]

    Re- visiting the inverted indices for billion-scale approximate nearest neighbors

    Dmitry Baranchuk, Artem Babenko, and Yury Malkov. Re- visiting the inverted indices for billion-scale approximate nearest neighbors. In Proc. ECCV, 2018. 2

    work page 2018

  8. [8]

    Foundations of Vector Retrieval

    Sebastian Bruch. Foundations of Vector Retrieval. Springer,

    work page

Show all 50 references
  1. [9]

    The use of mmr, diversity-based reranking for reordering documents and pro- ducing summaries

    Jaime Carbonell and Jade Goldstein. The use of mmr, diversity-based reranking for reordering documents and pro- ducing summaries. In Proc. SIGIR, 1998. 2, 6

    1998

  2. [10]

    Learned index with dy- namic ϵ

    Daoyuan Chen, Wuchao Li, Yaliang Li, Bolin Ding, Kai Zeng, Defu Lian, and Jingren Zhou. Learned index with dy- namic ϵ. In Proc. ICLR, 2023. 2

    2023

  3. [11]

    Bert: Pre-training of deep bidirectional trans- formers for language understanding

    Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional trans- formers for language understanding. In Proc. NAACL-HLT,

  4. [12]

    Tsunami: A learned multi-dimensional index for correlated data and skewed workloads

    Jialin Ding, Vikram Nathan, Mohammad Alizadeh, and Tim Kraska. Tsunami: A learned multi-dimensional index for correlated data and skewed workloads. InProc. VLDB, 2020. 2

    2020

  5. [13]

    Link and code: Fast indexing with graphs and compact re- gression codes

    Matthijs Douze, Alexandre Sablayrolles, and Herv ´e J ´egou. Link and code: Fast indexing with graphs and compact re- gression codes. In Proc. IEEE CVPR, 2018. 2

    2018

  6. [14]

    The faiss library

    Matthijs Douze, Alexandr Guzhva, Chengqi Deng, Jeff Johnson, Gergely Szilvasy, Pierre-Emmanuel Mazar´e, Maria Lomeli, Lucas Hosseini, and Herv´e J´egou. The faiss library. arXiv, 2401.08281, 2024. 2, 5

    2024 arXiv

  7. [15]

    Search result diversi- fication

    Marina Drosou and Evaggelia Pitoura. Search result diversi- fication. In Proc. SIGMOD, 2010. 1, 2

    2010

  8. [16]

    Disc diversity: Result diversification based on dissimilarity and coverage

    Marina Drosou and Evaggelia Pitoura. Disc diversity: Result diversification based on dissimilarity and coverage. In Proc. VLDB, 2012. 2

    2012

  9. [17]

    Learned Data Structures

    Paolo Ferragina and Giorgio Vinciguerra. Learned Data Structures. Springer International Publishing, 2020. 2

    2020

  10. [18]

    The pgmindex: a fully dynamic compressed learned index with provable worst-case bounds

    Paolo Ferragina and Giorgio Vinciguerra. The pgmindex: a fully dynamic compressed learned index with provable worst-case bounds. In Proc. VLDB, 2020. 2

    2020

  11. [19]

    Why are learned indexes so effective? In Proc

    Paolo Ferragina, Fabrizio Lillo, and Giorgio Vinciguerra. Why are learned indexes so effective? In Proc. ICML, 2020. 2

    2020

  12. [20]

    Fast approximate nearest neighbor search with the navigating spreading-out graph

    Cong Fu, Chao Xiang, Changxu Wang, and Deng Cai. Fast approximate nearest neighbor search with the navigating spreading-out graph. In Proc. VLDB, 2019. 2

    2019

  13. [21]

    Flexflood: Efficiently up- datable learned multi-dimensional index

    Fuma Hidaka and Yusuke Matsui. Flexflood: Efficiently up- datable learned multi-dimensional index. In Proc. NeurIPS Workshop on ML for Systems, 2024. 2

    2024

  14. [22]

    Solving diversity-aware maximum inner product search efficiently and effectively

    Kohei Hirata, Daichi Amagata, Sumio Fujita, and Takahiro Hara. Solving diversity-aware maximum inner product search efficiently and effectively. In Proc. RecSys, 2022. 2

    2022

  15. [23]

    nanobind: tiny and efficient c++/python bind- ings, 2022

    Wenzel Jakob. nanobind: tiny and efficient c++/python bind- ings, 2022. https://github.com/wjakob/nanobind. 5

    2022

  16. [24]

    Prod- uct quantization for nearest neighbor search

    Herv ´e J´egou, Matthijis Douze, and Cordelia Schmid. Prod- uct quantization for nearest neighbor search. IEEE TPAMI, 33(1):117–128, 2011. 2

    2011

  17. [25]

    Kochenderfer and Tim A

    Mykel J. Kochenderfer and Tim A. Wheeler. Algorithms for Optimization. The MIT Press, 2019. 5, 1

    2019

  18. [26]

    Chi, Jeffrey Dean, and Neoklis Polyzotis

    Tim Kraska, Alex Beutel, Ed H. Chi, Jeffrey Dean, and Neoklis Polyzotis. The case for learned index structures. In Proc. SIGMOD, 2018. 2

    2018

  19. [27]

    Stable learned bloom filters for data streams

    Qiyu Liu, Libin Zheng, Yanyan Shen, and Lei Chen. Stable learned bloom filters for data streams. In Proc. VLDB, 2020. 2

    2020

  20. [28]

    Malkov and Dmitry A

    Yury A. Malkov and Dmitry A. Yashunin. Efficient and ro- bust approximate nearest neighbor search using hierarchical navigable small world graphs. IEEE TPAMI, 42(4):824–836,

  21. [29]

    Cvpr2020 tutorial on image retrieval in the wild, 2020

    Yusuke Matsui, Takuma Yamaguchi, and Zheng Wang. Cvpr2020 tutorial on image retrieval in the wild, 2020. 1

    2020

  22. [30]

    Arm 4-bit pq: Simd-based acceleration for approximate nearest neighbor search on arm

    Yusuke Matsui, Yoshiki Imaizumi, Naoya Miyamoto, and Naoki Yoshifuji. Arm 4-bit pq: Simd-based acceleration for approximate nearest neighbor search on arm. In Proc. IEEE ICASSP, 2022. 2

    2022

  23. [31]

    Cvpr2023 tutorial on neural search in action, 2023

    Yusuke Matsui, Martin Aum ¨uller, and Han Xiao. Cvpr2023 tutorial on neural search in action, 2023. 1

    2023

  24. [32]

    A model for learned bloom filters, and optimizing by sandwiching

    Michael Mitzenmacher. A model for learned bloom filters, and optimizing by sandwiching. In Proc. NeurIPS, 2018. 2

    2018

  25. [33]

    Learning multi-dimensional indexes

    Vikram Nathan, Jialin Ding, Mohammad Alizadeh, and Tim Kraska. Learning multi-dimensional indexes. In Proc. SIG- MOD, 2020. 2

    2020

  26. [34]

    General and practical tun- ing method for off-the-shelf graph-based index: Sisap index- ing challenge report by team utokyo

    Yutaro Oguri and Yusuke Matsui. General and practical tun- ing method for off-the-shelf graph-based index: Sisap index- ing challenge report by team utokyo. In Proc. SISAP, 2023. 2

    2023

  27. [35]

    Theoretical and empiri- cal analysis of adaptive entry point selection for graph-based approximate nearest neighbor search

    Yutaro Oguri and Yusuke Matsui. Theoretical and empiri- cal analysis of adaptive entry point selection for graph-based approximate nearest neighbor search. arXiv, 2402.04713,

    arXiv

  28. [36]

    Relative nn-descent: A fast index construction for graph-based approximate nearest neighbor search

    Naoki Ono and Yusuke Matsui. Relative nn-descent: A fast index construction for graph-based approximate nearest neighbor search. In Proc. MM, 2023. 2

    2023

  29. [37]

    Revisiting oxford and paris: Large-scale image retrieval benchmarking

    Filip Radenovi ´c, Ahmet Iscen, Giorgos Tolias, Yannis Avrithis, and Ond ˇrej Chum. Revisiting oxford and paris: Large-scale image retrieval benchmarking. In Proc. IEEE CVPR, 2018. 5

    2018

  30. [38]

    Fine- tuning cnn image retrieval with no human annotation

    Filip Radenovi ´c, Giorgos Tolias, and Ond ˇrej Chum. Fine- tuning cnn image retrieval with no human annotation. IEEE TPAMI, 41(7):1655–1668, 2018. 5

    2018

  31. [39]

    Vidyadhar Rao, Prateek Jain, and C.V . Jawahar. Diverse yet efficient retrieval using locality sensitive hashing. In Proc. ICMR, 2016. 2

    2016

  32. [40]

    Ravi, Daniel J

    Sekharipuram S. Ravi, Daniel J. Rosenkrantz, and Giri Ku- mar Tayi. Heuristic and special case algorithms for disper- sion problems. Operations Research, 542(2):299–310, 1994. 2, 6, 3

    1994

  33. [41]

    Rodrygo L. T. Santos, Craig Macdonald, and Iadh Ounis. Search result diversification. Foundations and Trends in In- formation Retrieval, 9(1):1–90, 2015. 1, 2

    2015

  34. [42]

    Fast partitioned learned bloom filter

    Atsuki Sato and Yusuke Matsui. Fast partitioned learned bloom filter. In Proc. NeurIPS, 2023. 2

    2023

  35. [43]

    Glow: Global weighted self-attention network for web search

    Xuan Shan, Chuanjie Liu, Yiqian Xia, Qi Chen, Yusi Zhang, Kaize Ding, Yaobo Liang, Angen Luo, and Yuxiang Luo. Glow: Global weighted self-attention network for web search. In Proc. IEEE Big Data, 2021. 2

    2021

  36. [44]

    Results of the neurips’21 challenge on billion-scale approximate nearest neighbor search

    Harsha Vardhan Simhadri, George Williams, Martin Aum¨uller, Matthijs Douze, Artem Babenko, Dmitry Baranchuk, Qi Chen, Lucas Hosseini, Ravishankar Krish- naswamny, Gopal Srinivasa, Suhas Jayaram Subramanya, and Jingdong Wang. Results of the neurips’21 challenge on billion-scale...

    2022

  37. [45]

    Results of the big ann: Neurips’23 competition

    Harsha Vardhan Simhadri, Martin Aum ¨uller, Amir Ing- ber, Matthijs Douze, George Williams, Magdalen Dobson Manohar, Dmitry Baranchuk, Edo Liberty, Frank Liu, Ben Landrum, Mazin Karjikar, Laxman Dhulipala, Meng Chen, Yue Chen, Rui Ma, Kai Zhang, Yuzheng Cai, Jiayang Shi, Yizhu...

    2024 arXiv

  38. [46]

    Diskann: Fast accurate billion-point nearest neighbor search on a single node

    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 Proc. NeurIPS, 2019. 2

    2019

  39. [47]

    Partitioned learned bloom filters

    Kapil Vaidya, Eric Knorr, Michael Mitzenmacher, and Tim Kraska. Partitioned learned bloom filters. In Proc. ICLR,

  40. [48]

    A comprehensive survey and experimental compari- son of graph-based approximate nearest neighbor search

    Mengzhao Wang, Xiaoliang Xu, Qiang Yue, and Yuxiang Wang. A comprehensive survey and experimental compari- son of graph-based approximate nearest neighbor search. In Proc. VLDB, 2021. 2

    2021

  41. [49]

    Updatable learned index with precise positions

    Jiacheng Wu, Yong Zhang, Shimin Chen, Jin Wang, Yu Chen, and Chunxiao Xing. Updatable learned index with precise positions. In Proc. VLDB, 2021. 2

    2021

  42. [50]

    This condition

    Kaiping Zheng, Hongzhi Wang, Zhixin Qi, Jianzhong Li, and Hong Gao. A survey of query result diversification. Knowledge and Information Systems, 51:1–36, 2017. 1, 2 LotusFilter: Fast Diverse Nearest Neighbor Search via a Learned Cutoff Table Supplementary Material A. Selection...

    2017

Pith tools

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