Pith. sign in

REVIEW 4 major objections 5 minor 57 references

Tradeoffs in Processing Queries and Supporting Updates over an ML-Enhanced R-tree

T0 review · 4 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash

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

Pith's one-line read This paper claims that adding trained leaf-node predictors to an R-tree can make high-overlap range queries up to 5.4X faster while keeping query recall near 99 percent.

desk verdict A mostly honest incremental study of ML model choice and loss design for the AI+R-tree, but the headline 5.4X speedup is computed with an unstated disk-I/O constant and needs code plus real timing before I'd trust it. read the letter →

arxiv 2502.09937 v1 pith:2UUXBQH6 submitted 2025-02-14 cs.DB cs.LG

Abdullah Al-Mamun , Ch. Md. Rakin Haider , Jianguo Wang , Walid G. Aref This is my paper · ORCID
classification cs.DBcs.LG
keywords learnedindexesR-treemulti-labelclassificationrangequeryprocessingoverlapratiospatialdatabasesmutablecustomlossfunction
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 is trying to establish that a traditional R-tree can be made faster on range queries by adding machine-learned components that predict, before any tree descent, which leaf nodes actually contain the query results. The AI+R-tree it studies routes each query through a binary overlap-ratio classifier: queries likely to waste many leaf-node accesses are sent to an AI-tree whose multi-label classifiers directly predict leaf node IDs, while low-overlap queries continue through the ordinary R-tree. On three real location datasets, the paper reports that this hybrid answers high-overlap range queries up to 5.4 times faster than the R-tree alone while preserving up to 99 percent average query recall. The paper also argues that a mutable version is feasible by performing inserts through the R-tree component, preserving leaf node IDs through link chains, and retraining models periodically rather than on every update.

What carries the argument

The central mechanism is the overlap-ratio classifier plus a grid-indexed collection of multi-label leaf-node predictors. The overlap ratio $\alpha$ is defined as true leaf-node accesses divided by visited leaf-node accesses, and the threshold $\tau$ (set to 0.75 here) separates high-overlap queries, which the AI-tree handles, from low-overlap queries, which the ordinary R-tree handles. The AI-tree partitions the query space with a coarse grid, trains a separate multi-label classifier per cell, and aggregates predictions from all cells a query touches. For neural networks, the paper introduces a custom loss that multiplies the predicted leaf-node probability vector by a sparse object-to-leaf matrix so that loss is computed over retrieved data objects rather than raw leaf-node labels. Updates are handled by inserting through the R-tree and deferring structural change: after a leaf split, the old leaf ID is kept and a linked continuation node absorbs new objects, so the learned predictors remain valid until periodic retraining.

What would settle it

A concrete test would be to run the same AI+R-tree and R-tree on a real spatial workload with naturally occurring overlap ratios, measuring end-to-end query latency on the actual storage device instead of computing time as leaf-node accesses times a fixed I/O constant; the central claim weakens if the speedup for queries with $\alpha \le 0.25$ falls below the reported range or if recall drops well below 99 percent.

Watch

Extended reading notes

Core claim

On the paper's own terms, the AI+R-tree works because answering a range query can be cast as multi-label classification: the class labels are R-tree leaf node IDs, and the query rectangle's four coordinates are the features. The overlap ratio $\alpha = TN(Q)/VN(Q)$—the number of true leaf nodes that contain results divided by the number of leaf nodes the R-tree actually visits—measures how much work is wasted, and a binary classifier decides whether $\alpha$ is below a threshold $\tau$ and therefore worth handling by the learned component. At query time, the AI-tree predicts leaf node IDs, accesses only those pages, and filters returned objects against the query rectangle so precision remains exactly one; a fallback R-tree search resolves empty predictions. The experiments show that for the most wasteful queries ($\alpha = 0.10$) a decision-tree model gives up to 5.4X lower query time than the R-tree with recall up to 99 percent, and that a custom loss function that weights leaf nodes by how many objects they contribute reduces neural-network query time substantially compared with plain binary cross-entropy.

Load-bearing premise

The load-bearing premise is that synthetic queries generated at prescribed overlap ratios are a fair stand-in for real high-overlap workloads, and that multiplying leaf-node accesses by a fixed disk-I/O time gives valid end-to-end latency.

Editorial extensions

If this is right

  • For workloads dominated by high-overlap range queries, a deployed AI+R-tree can answer queries with up to 5.4X lower latency than an R-tree while returning nearly all true results.
  • The choice of ML model is a real tradeoff: the basic decision tree gave the largest speedups, while ensembles and neural networks delivered different recall/latency balances.
  • The custom object-weighted loss shows that tailoring the loss to query recall can cut false-positive leaf-node accesses for neural models without losing much recall.
  • A mutable AI+R-tree is architecturally feasible: inserts through the R-tree, logical deletes, and periodic retraining keep the learned components usable, with performance degradation concentrated in overlap-and-split cases until retraining.
  • Because the AI-tree never returns false positives, query correctness is preserved even when the learned component is wrong; only recall can suffer.

Reading between the lines

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

  • If real spatial workloads resemble the synthetic $\alpha$-stratified queries used here—many queries hitting heavily overlapped index regions—then the reported speedups should transfer; if high-overlap queries are rare, the hybrid's gains will rarely matter in practice.
  • The evaluation's latency model treats every leaf-node access as a fixed disk I/O; on storage where reads are cheap or cached, the true speedup over an R-tree would likely be smaller, a testable prediction.
  • The binary router's roughly 80 percent accuracy suggests that tuning the routing threshold or replacing the router with a calibrated model could shift the recall/latency frontier further.
  • The mutable design's dependence on retraining points toward pairing the index with workload-drift detection so that retraining is triggered by measured recall degradation rather than a fixed schedule.
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

4 major / 5 minor

Summary. The paper extends the AI+R-tree, a hybrid learned index that augments a traditional disk-based R-tree with an overlap-ratio classifier and a multi-label leaf-node classifier, to dynamic query workloads. It studies the impact of different ML models (decision trees, random forests, XGBoost, and neural networks), introduces a custom loss function for the neural network that weights leaf predictions by the number of qualifying objects, and presents qualitative design tradeoffs for supporting inserts, updates, and deletes. The empirical evaluation on three real spatio-temporal datasets reports up to 5.4X speedup for high-overlap range queries and up to 99% average query recall.

Significance. If the reported speedup were robust, the paper would offer a practical recipe for avoiding wasted R-tree leaf accesses in high-overlap workloads: route high-overlap queries to a learned leaf-node predictor and let low-overlap queries use the traditional R-tree. The paper's strengths include the breadth of the evaluation (three real datasets, three selectivities, five overlap-ratio buckets), the measurement of model sizes, and the custom-loss case study, which is genuinely tailored to the query-processing objective. However, the central quantitative claim rests on an unspecified disk-I/O time constant and on synthetic, pre-stratified query workloads, so the significance is conditional on correcting the timing methodology and on demonstrating behavior on unstratified or evolving workloads.

major comments (4)
  1. [Section VI-C] The headline speedup is not measured end-to-end. The average query processing time is synthesized as CPU time plus (number of leaf node accesses) multiplied by a "standard disk I/O access time," but the numerical value of that constant is never given, and no experiment performs actual disk I/O; all experiments run in memory in Python. The speedup ratio of AI+R-tree over R-tree is directly sensitive to this constant: when the constant is large, the reduction in leaf accesses dominates and produces the reported 5.4X; when it is small, CPU and prediction overhead dominate and the speedup can shrink or reverse. Please report the constant value, provide a sensitivity analysis over realistic I/O times, and report CPU time and leaf-access counts separately, or measure with disk-resident pages. As written, the central quantitative claim in the abstract is not reproducible.
  2. [Section VI-B and VI-D] The evaluation stratifies queries by alpha and runs each alpha bucket separately, rather than presenting an end-to-end workload with a natural mix of overlap ratios. In actual operation the AI+R-tree must first route every query with the binary overlap-ratio classifier, which is reported as only about 80% accurate (Section IV); misrouting affects both query time and recall. The per-bucket curves therefore do not show the end-to-end performance of the hybrid structure over a mixed workload. Please report results on an unstratified query workload with a defined alpha distribution, including routing accuracy and its effect on query time and recall.
  3. [Section V and Section VI] The paper claims to extend the AI+R-tree to dynamic query workloads and to support a mutable index, but Section VI contains only static, synthetic query sets with a 60/20/20 split and no temporal distribution shift, no interleaved inserts/updates/deletes, and no re-training trigger. Section V is a qualitative case analysis whose empirical consequences are explicitly deferred to future work (Section VIII-B). The abstract and introduction should either temper the dynamic/mutable claims or the evaluation should include workloads with updates and shifted query distributions.
  4. [Figure 9 and Abstract] The "up to 5.4X" speedup is reported only for the alpha=0.10 bucket; at alpha=0.25 the speedup is 3.1X, and for alpha near the threshold the query time closely follows the R-tree while recall degrades (Figure 8). The abstract's headline therefore reflects the most favorable bucket of the synthetic workload. Please report the speedup across the full alpha range, with confidence intervals or per-bucket tables, so that readers can judge the expected benefit over a realistic distribution.
minor comments (5)
  1. [Abstract] There is a duplicated conjunction in the abstract: "dynamic query workloads and and in supporting updates."
  2. [Section VI-D] The text contains typos such as "accors" for "across" and "classifer" for "classifier"; a careful proofreading pass is needed.
  3. [Section VI-B] The procedure for generating synthetic queries with a prescribed alpha value is not described; please explain how queries are constructed so that the workload generation is reproducible.
  4. [Section VI-D] All timing figures are point estimates without error bars or statistical significance tests; with 1000 queries per bucket, reporting variance or confidence intervals would strengthen the claims.
  5. [Section IV] The threshold tau=0.75 and the binary classifier's roughly 80% accuracy are stated without sensitivity analysis; since the hybrid design depends on this routing decision, a study of tau and misclassification cost would improve the paper.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the AI+R-tree evaluation is a standard supervised-learning measurement, and the quoted 5.4X speedup is an experimental result, not a reduction to the paper's definitions or fitted values.

full rationale

I walked the derivation chain and found no circular step. The system is trained on queries from the same synthetic workload distribution used for evaluation, but with an explicit 60/20/20 train/validation/test split, which is standard supervised ML evaluation rather than a fitted parameter being renamed as a prediction. The overlap ratio alpha = TN(Q)/VN(Q) is a workload characterization used to bin queries and to train the binary router; it does not by itself determine the measured speedup, because the multi-label classifier can mispredict leaf nodes and the binary router can misroute queries, as acknowledged by the reported ~80% router accuracy and recall below 1 for some alpha values. The custom loss function takes the R-tree as an input to build a sparse object-to-leaf matrix and reweights leaf predictions by object counts; this is a training-time objective that aligns the model with the recall metric, but it does not inject the test answer, and the paper independently reports recall for both the BCE and custom-loss variants. The timing model (CPU time plus leaf accesses times a standard disk I/O time) is a modeling choice rather than a circular reduction: the same model is applied to both the R-tree and the AI+R-tree, so the ratio is an empirical outcome of measured leaf accesses and CPU time. The unspecified disk-I/O constant is a reproducibility and external-validity concern, but it is not an equivalence between a prediction and its input. Self-citations to [18] supply the base architecture and the leaf-capacity parameter (M=1000), but the new tradeoffs, model comparisons, custom-loss study, and speedup measurements are generated in this paper, so the self-citations are not load-bearing for the central empirical claims.

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

The central claim rests on workload-generation and I/O-modeling assumptions, plus validation-tuned parameters such as grid size, threshold tau, and leaf capacity. No new entities are introduced beyond the AI+R-tree structure described in the prior paper [18].

free parameters (7)
  • Overlap-ratio threshold tau = 0.75
    Hand-set in Section VI-B3 to define high-overlap queries; directly controls which queries are routed to the learned component.
  • Grid size for local ML models = 20x20 for DCT, 4x4 for RF and XG, single model for NN
    Selected by validation-set search in Section VI-B3; affects model accuracy, model count, and reported model size.
  • Random forest n_estimators = best value on validation set
    Tuned on validation data in Section VI-C1; contributes to the reported RF query time and recall.
  • R-tree leaf capacity M = 1000
    Fixed in Section VI-B1 based on an observed advantage in the prior paper [18]; changes R-tree shape and overlap behavior.
  • NN architecture and training hyperparameters = 3 hidden layers, ReLU, Adam lr=1e-3, 30 epochs
    Chosen without grid search in Section VI-C1; directly affects the NN recall and latency comparison.
  • Standard disk I/O access time constant = unspecified
    Section VI-C computes query time as CPU time plus leaf-node accesses times this constant; the value drives all reported latency numbers.
  • Synthetic workload parameters = selectivities 0.00005, 0.0001, 0.0002; alpha values 0.1, 0.25, 0.5, 0.75, 1.0
    Chosen in Section VI-B2 to control query difficulty; the 5.4X speedup claim is specifically for the alpha = 0.10 bucket.
assumptions (4)
  • domain assumption The number of disk I/Os is equivalent to the number of leaf-node accesses.
    Section VI-C states this equivalence explicitly; the entire latency comparison depends on this simplification.
  • ad hoc to paper Synthetic queries generated to hit target overlap ratios are representative of dynamic query workloads.
    Section VI-B2 describes evaluating each alpha bucket separately instead of using a naturally occurring mixed workload, so the reported gains are conditioned on this synthetic design.
  • domain assumption The overlap-ratio binary classifier with around 80% accuracy is sufficient for routing queries without harming end-to-end performance.
    Section IV reports roughly 80% accuracy but provides no sensitivity analysis showing how routing errors affect the final query time and recall.
  • domain assumption A model trained on one static R-tree leaf assignment remains valid for the static test R-tree.
    All experiments use a fixed R-tree; Section V acknowledges that model retraining is needed after structural changes, but no dynamic experiment is run.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Tradeoffs in Processing Queries and Supporting Updates over an ML-Enhanced R-tree." pith.science (2026). https://pith.science/paper/2UUXBQH6

@misc{pith2026250209937,
  author       = {Pith},
  title        = {Pith review of: Tradeoffs in Processing Queries and Supporting Updates over an ML-Enhanced R-tree},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/2UUXBQH6}},
  note         = {Machine review of arXiv:2502.09937}
}
read the original abstract

Machine Learning (ML) techniques have been successfully applied to design various learned database index structures for both the one- and multi-dimensional spaces. Particularly, a class of traditional multi-dimensional indexes has been augmented with ML models to design ML-enhanced variants of their traditional counterparts. This paper focuses on the R-tree multi-dimensional index structure as it is widely used for indexing multi-dimensional data. The R-tree has been augmented with machine learning models to enhance the R-tree performance. The AI+R-tree is an ML-enhanced R-tree index structure that augments a traditional disk-based R-tree with an ML model to enhance the R-tree's query processing performance, mainly, to avoid navigating the overlapping branches of the R-tree that do not yield query results, e.g., in the presence of high-overlap among the rectangles of the R-tree nodes. We investigate the empirical tradeoffs in processing dynamic query workloads and in supporting updates over the AI+R-tree. Particularly, we investigate the impact of the choice of ML models over the AI+R-tree query processing performance. Moreover, we present a case study of designing a custom loss function for a neural network model tailored to the query processing requirements of the AI+R-tree. Furthermore, we present the design tradeoffs for adopting various strategies for supporting dynamic inserts, updates, and deletes with the vision of realizing a mutable AI+R-tree. Experiments on real datasets demonstrate that the AI+R-tree can enhance the query processing performance of a traditional R-tree for high-overlap range queries by up to 5.4X while achieving up to 99% average query recall.

Figures

Figures reproduced from arXiv: 2502.09937 by the authors.

Figure 1
Figure 1. An example of an R-tree with overlapping nodes [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Spectrum of the overlap ratio α with Threshold τ to identify high￾and low-overlap queries the number of true leaf nodes by the total number of visited leaf nodes to estimate α, e.g., in [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗
Figure 5
Figure 5. Indexing the learned models For example, in [PITH_FULL_IMAGE:figures/full_fig_p003_5.png] view at source ↗
Figures from the paper (15 more)
Figure 4
Figure 4. Figure 4: Workflow of ML model training and testing [PITH_FULL_IMAGE:figures/full_fig_p003_4.png]
Figure 6
Figure 6. Figure 6: Designing a custom loss function for the NN model [PITH_FULL_IMAGE:figures/full_fig_p004_6.png]
Figure 7
Figure 7. Figure 7: In-place vs. Out-of-place insertion strategies [PITH_FULL_IMAGE:figures/full_fig_p005_7.png]
Figure 8
Figure 8. Figure 8: Average query recall of DT based classifiers for the Tweets location dataset. The R-tree recall is always 1, hence is omitted in the figures. [PITH_FULL_IMAGE:figures/full_fig_p008_8.png]
Figure 9
Figure 9. Figure 9: Average query time of DT based classifiers for the Tweets dataset [PITH_FULL_IMAGE:figures/full_fig_p009_9.png]
Figure 10
Figure 10. Figure 10: Average query recall of NN based classifiers for the tweet locations dataset [PITH_FULL_IMAGE:figures/full_fig_p009_10.png]
Figure 11
Figure 11. Figure 11: Average query time of NN based classifiers for the tweet locations dataset [PITH_FULL_IMAGE:figures/full_fig_p009_11.png]
Figure 12
Figure 12. Figure 12: Average query recall of DT based classifiers for the gowalla dataset. The R-tree recall is always 1 and is not shown in the figures. [PITH_FULL_IMAGE:figures/full_fig_p010_12.png]
Figure 13
Figure 13. Figure 13: Average query processing time of DT-based classifiers for the Gowalla dataset [PITH_FULL_IMAGE:figures/full_fig_p010_13.png]
Figure 14
Figure 14. Figure 14: Average query recall of NN based classifiers for the Gowalla dataset [PITH_FULL_IMAGE:figures/full_fig_p010_14.png]
Figure 15
Figure 15. Figure 15: Average query time of NN based classifiers for the Gowalla dataset [PITH_FULL_IMAGE:figures/full_fig_p011_15.png]
Figure 16
Figure 16. Figure 16: Average query recall of DT-based classifiers for the Chicago Crimes dataset. The R-tree recall is always 1 and is not shown in the figures. [PITH_FULL_IMAGE:figures/full_fig_p011_16.png]
Figure 17
Figure 17. Figure 17: Average query time of DT-based classifiers for the Chicago Crimes dataset [PITH_FULL_IMAGE:figures/full_fig_p012_17.png]
Figure 18
Figure 18. Figure 18: Average query recall of NN based classifiers for the Chicago Crimes dataset [PITH_FULL_IMAGE:figures/full_fig_p012_18.png]
Figure 19
Figure 19. Figure 19: Average query time of NN based classifiers for the chicago crimes dataset [PITH_FULL_IMAGE:figures/full_fig_p012_19.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

57 extracted references · 49 canonical work pages

  1. [1]

    Machine learning for databases: Foundations, paradigms, and open problems,

    G. Cong, J. Yang, and Y . Zhao, “Machine learning for databases: Foundations, paradigms, and open problems,” in Companion of the 2024 International Conference on Management of Data , 2024, pp. 622–629

    work page 2024

  2. [2]

    The case for learned index structures,

    T. Kraska, A. Beutel, E. H. Chi, J. Dean, and N. Polyzotis, “The case for learned index structures,” in Proceedings of the ACM SIGMOD International Conference on Management of Data , 2018, pp. 489–504

    work page 2018

  3. [3]

    The pgm-index,

    P. Ferragina and G. Vinciguerra, “The pgm-index,” in Proceedings of the VLDB Endowment , 2020, p. 1162–1175

    work page 2020

  4. [4]

    Alex: an updatable adaptive learned index,

    J. Ding, U. F. Minhas, J. Yu, C. Wang, J. Do, Y . Li, H. Zhang, B. Chan- dramouli, J. Gehrke, D. Kossmann et al., “Alex: an updatable adaptive learned index,” in Proceedings of the ACM SIGMOD International Conference on Management of Data , 2020, pp. 969–984

    work page 2020

  5. [5]

    Updatable learned index with precise positions,

    J. Wu, Y . Zhang, S. Chen, J. Wang, Y . Chen, and C. Xing, “Updatable learned index with precise positions,”Proc. VLDB Endow., vol. 14, no. 8, p. 1276–1288, apr 2021

    work page 2021

  6. [6]

    Sagedb: A learned database system,

    T. Kraska, M. Alizadeh, A. Beutel, E. H. Chi, J. Ding, A. Kristo, G. Leclerc, S. Madden, H. Mao, and V . Nathan, “Sagedb: A learned database system,” in 9th Biennial Conference on Innovative Data Systems Research, 2019

    work page 2019

  7. [7]

    A tutorial on learned multi- dimensional indexes,

    A. Al-Mamun, H. Wu, and W. G. Aref, “A tutorial on learned multi- dimensional indexes,” in Proceedings of the 28th ACM SIGSPATIAL International Conference on Advances in Geographic Information Sys- tems, 2020, pp. 1–4

    work page 2020

  8. [8]

    How Good Are Multi-dimensional Learned Indices? An Experimental Survey

    Q. Liu, M. Li, Y . Zeng, Y . Shen, and L. Chen, “How good are multi- dimensional learned indices? an experimental survey,” arXiv preprint arXiv:2405.05536, 2024

    work page Pith review arXiv 2024

Show all 57 references
  1. [9]

    A survey of multi-dimensional indexes: Past and future trends,

    M. Li, H. Wang, H. Dai, M. Li, R. Gu, F. Chen, Z. Chen, S. Li, Q. Liu, and G. Chen, “A survey of multi-dimensional indexes: Past and future trends,” IEEE Transactions on Knowledge and Data Engineering , 2024. 14

    2024

  2. [10]

    A survey of learned indexes for the multi-dimensional space,

    A. Al-Mamun, H. Wu, Q. He, J. Wang, and W. G. Aref, “A survey of learned indexes for the multi-dimensional space,” arXiv preprint arXiv:2403.06456, 2024

    2024 arXiv

  3. [11]

    Accelerating b+ tree search by using simple machine learning techniques,

    A. Llavesh, U. Sirin, R. West, and A. Ailamaki, “Accelerating b+ tree search by using simple machine learning techniques,” in Proceedings of the 1st International Workshop on Applied AI for Database Systems and Applications, 2019

    2019

  4. [12]

    From wisckey to bourbon: A learned index for log-structured merge trees,

    Y . Dai, Y . Xu, A. Ganesan, R. Alagappan, B. Kroth, A. Arpaci-Dusseau, and R. Arpaci-Dusseau, “From wisckey to bourbon: A learned index for log-structured merge trees,” in 14th Symposium on Operating Systems Design and Implementation , 2020, pp. 155–171

    2020

  5. [13]

    R-trees: A dynamic index structure for spatial searching,

    A. Guttman, “R-trees: A dynamic index structure for spatial searching,” in Proceedings of the ACM SIGMOD international conference on Management of data , 1984, pp. 47–57

    1984

  6. [14]

    Ubiquitous b-tree,

    D. Comer, “Ubiquitous b-tree,” ACM Computing Surveys (CSUR) , vol. 11, no. 2, pp. 121–137, 1979

    1979

  7. [15]

    Manolopoulos, A

    Y . Manolopoulos, A. Nanopoulos, A. N. Papadopoulos, and Y . Theodor- idis, R-trees: Theory and Applications . Springer Science & Business Media, 2010

    2010

  8. [16]

    Lisa: A learned index structure for spatial data,

    P. Li, H. Lu, Q. Zheng, L. Yang, and G. Pan, “Lisa: A learned index structure for spatial data,” Proceedings of the ACM SIGMOD International Conference on Management of Data , 2020

    2020

  9. [17]

    Multilabel classification,

    F. Herrera, F. Charte, A. J. Rivera, and M. J. Del Jesus, “Multilabel classification,” in Multilabel Classification. Springer, 2016, pp. 17–31

    2016

  10. [18]

    The “ai + r

    A. Al-Mamun, C. M. R. Haider, J. Wang, and W. G. Aref, “The “ai + r” - tree: An instance-optimized r - tree,” in 2022 23rd IEEE International Conference on Mobile Data Management (MDM) , 2022, pp. 9–18

    2022

  11. [19]

    Data classification,

    C. C. Aggarwal, “Data classification,” in Data Mining. Springer, 2015, pp. 285–344

    2015

  12. [20]

    The handwritten trie: Indexing electronic ink,

    W. Aref, D. Barbar ´a, and P. Vallabhaneni, “The handwritten trie: Indexing electronic ink,” in SIGMOD Rec., 1995, p. 151–162

    1995

  13. [21]

    C. M. Bishop and H. Bishop, Deep learning: Foundations and concepts. Springer Nature, 2023

    2023

  14. [22]

    Algorithms for hyper- parameter optimization,

    J. Bergstra, R. Bardenet, Y . Bengio, and B. K ´egl, “Algorithms for hyper- parameter optimization,” Advances in neural information processing systems, vol. 24, 2011

    2011

  15. [23]

    Random forests,

    L. Breiman, “Random forests,” Machine learning , vol. 45, no. 1, pp. 5–32, 2001

    2001

  16. [24]

    A tutorial on multilabel learning,

    E. Gibaja and S. Ventura, “A tutorial on multilabel learning,” ACM Computing Surveys (CSUR) , vol. 47, no. 3, pp. 1–38, 2015

    2015

  17. [25]

    Induction of decision trees,

    J. R. Quinlan, “Induction of decision trees,” Machine learning, vol. 1, no. 1, pp. 81–106, 1986

    1986

  18. [26]

    Scikit-multilearn: a scikit-based python environment for performing multi-label classification,

    P. Szymanski and T. Kajdanowicz, “Scikit-multilearn: a scikit-based python environment for performing multi-label classification,” The Jour- nal of Machine Learning Research , vol. 20, no. 1, pp. 209–230, 2019

    2019

  19. [27]

    Scikit-learn: Machine learning in Python,

    F. Pedregosa, G. Varoquaux, A. Gramfort, V . Michel, B. Thirion, O. Grisel, M. Blondel, P. Prettenhofer, R. Weiss, V . Dubourg, J. Vander- plas, A. Passos, D. Cournapeau, M. Brucher, M. Perrot, and E. Duch- esnay, “Scikit-learn: Machine learning in Python,” Journal of Machine ...

    2011

  20. [28]

    Xgboost: A scalable tree boosting system,

    T. Chen and C. Guestrin, “Xgboost: A scalable tree boosting system,” in Proceedings of the 22nd acm sigkdd international conference on knowledge discovery and data mining , 2016, pp. 785–794

    2016

  21. [29]

    A tailored regression for learned indexes: Logarithmic error regression,

    M. Eppert, P. Fent, and T. Neumann, “A tailored regression for learned indexes: Logarithmic error regression,” inFourth Workshop in Exploiting AI Techniques for Data Management , 2021, pp. 9–15

    2021

  22. [30]

    On the suitability of neural networks as building blocks for the design of efficient learned indexes,

    D. Amato, G. L. Bosco, and R. Giancarlo, “On the suitability of neural networks as building blocks for the design of efficient learned indexes,” in International Conference on Engineering Applications of Neural Networks. Springer, 2022, pp. 115–127

    2022

  23. [31]

    Neural networks as building blocks for the design of efficient learned indexes,

    D. Amato, G. Lo Bosco, and R. Giancarlo, “Neural networks as building blocks for the design of efficient learned indexes,” Neural Computing and Applications, vol. 35, no. 29, pp. 21 399–21 414, 2023

    2023

  24. [32]

    On nonlinear learned string indexing,

    P. Ferragina, M. Frasca, G. C. Marin `o, and G. Vinciguerra, “On nonlinear learned string indexing,” IEEE Access, 2023

    2023

  25. [33]

    Pytorch module for loss functions,

    “Pytorch module for loss functions,” Accessed in 2024. [Online]. Available: https://pytorch.org/docs/stable/generated/torch.nn.BCELoss. html

    2024

  26. [34]

    Learning multi- dimensional indexes,

    V . Nathan, J. Ding, M. Alizadeh, and T. Kraska, “Learning multi- dimensional indexes,” in Proceedings of the ACM SIGMOD Interna- tional Conference on Management of Data , 2020, pp. 985–1000

    2020

  27. [35]

    Learning over sets for databases,

    A. Davitkova, D. Gjurovski, and S. Michel, “Learning over sets for databases,” International Conference on Extending Database Technology (EDBT), 2024

    2024

  28. [36]

    Ucr-star: The ucr spatio-temporal active repository,

    S. Ghosh, T. Vu, M. A. Eskandari, and A. Eldawy, “Ucr-star: The ucr spatio-temporal active repository,” SIGSPATIAL Special, vol. 11, no. 2, pp. 34–40, 2019

    2019

  29. [37]

    Indexing recent trajectories of moving objects,

    A. R. Mahmood, W. G. Aref, A. M. Aly, and S. Basalamah, “Indexing recent trajectories of moving objects,” in Proceedings of the 22nd ACM SIGSPATIAL International Conference on Advances in Geographic Information Systems, 2014, pp. 393–396

    2014

  30. [38]

    Pytorch: An imperative style, high-performance deep learning library,

    A. Paszke, S. Gross, F. Massa, A. Lerer, J. Bradbury, G. Chanan, T. Killeen, Z. Lin, N. Gimelshein, L. Antiga et al. , “Pytorch: An imperative style, high-performance deep learning library,” Advances in neural information processing systems , vol. 32, 2019

    2019

  31. [39]

    Adam: A method for stochastic optimization,

    D. P. Kingma, “Adam: A method for stochastic optimization,” arXiv preprint arXiv:1412.6980, 2014

    2014 arXiv

  32. [40]

    The r+-tree: A dynamic index for multi-dimensional objects

    T. Sellis, N. Roussopoulos, and C. Faloutsos, “The r+-tree: A dynamic index for multi-dimensional objects.” Tech. Rep., 1987

    1987

  33. [41]

    The r*- tree: an efficient and robust access method for points and rectangles,

    N. Beckmann, H.-P. Kriegel, R. Schneider, and B. Seeger, “The r*- tree: an efficient and robust access method for points and rectangles,” in Proceedings of the ACM SIGMOD international conference on Management of data , 1990, pp. 322–331

    1990

  34. [42]

    A revised r*-tree in comparison with related index structures,

    N. Beckmann and B. Seeger, “A revised r*-tree in comparison with related index structures,” in Proceedings of the ACM SIGMOD Interna- tional Conference on Management of data , 2009, pp. 799–812

    2009

  35. [43]

    Samet, Foundations of multidimensional and metric data structures

    H. Samet, Foundations of multidimensional and metric data structures . Morgan Kaufmann, 2006

    2006

  36. [44]

    Improv- ing spatial data processing by clipping minimum bounding boxes,

    D. Sidlauskas, S. Chester, E. T. Zacharatou, and A. Ailamaki, “Improv- ing spatial data processing by clipping minimum bounding boxes,” in 34th International Conference on Data Engineering (ICDE) . IEEE, 2018, pp. 425–436

    2018

  37. [45]

    The priority r-tree: A practically efficient and worst-case optimal r-tree,

    L. Arge, M. D. Berg, H. Haverkort, and K. Yi, “The priority r-tree: A practically efficient and worst-case optimal r-tree,” ACM Transactions on Algorithms (TALG) , vol. 4, no. 1, pp. 1–30, 2008

    2008

  38. [46]

    Hilbert r-tree: An improved r-tree using fractals,

    I. Kamel and C. Faloutsos, “Hilbert r-tree: An improved r-tree using fractals,” in Proceedings of the 20th International Conference on Very Large Data Bases , 1994, p. 500–509

    1994

  39. [47]

    The rlr-tree: A reinforcement learning based r-tree for spatial data,

    T. Gu, K. Feng, G. Cong, C. Long, Z. Wang, and S. Wang, “The rlr-tree: A reinforcement learning based r-tree for spatial data,” arXiv preprint arXiv:2103.04541, 2021

    2021 arXiv

  40. [48]

    Platon: Top-down r-tree packing with learned partition policy,

    J. Yang and G. Cong, “Platon: Top-down r-tree packing with learned partition policy,” Proceedings of the ACM on Management of Data , vol. 1, no. 4, pp. 1–26, 2023

    2023

  41. [49]

    Acr-tree: Constructing r-trees using deep reinforcement learning,

    S. Huang, Y . Wang, and G. Li, “Acr-tree: Constructing r-trees using deep reinforcement learning,” in International Conference on Database Systems for Advanced Applications . Springer, 2023, pp. 80–96

    2023

  42. [50]

    Hands-off model integration in spatial index structures,

    A. Hadian, A. Kumar, and T. Heinis, “Hands-off model integration in spatial index structures,” in Proceedings of the 2nd International Workshop on Applied AI for Database Systems and Applications , 2020

    2020

  43. [51]

    The case for learned spatial indexes,

    V . Pandey, A. van Renen, A. Kipf, I. Sabek, J. Ding, and A. Kemper, “The case for learned spatial indexes,” arXiv preprint arXiv:2008.10349, 2020

    2008 arXiv

  44. [52]

    The case for ml- enhanced high-dimensional indexes,

    R. Kang, W. Wu, C. Wang, C. Zhang, and J. Wang, “The case for ml- enhanced high-dimensional indexes,” in Proceedings of the 3rd Interna- tional Workshop on Applied AI for Database Systems and Applications , 2021

    2021

  45. [53]

    Limou- sine: Blending learned and classical indexes to self-design larger-than- memory cloud storage engines,

    S. Chatterjee, M. F. Pekala, L. Kruglyak, and S. Idreos, “Limou- sine: Blending learned and classical indexes to self-design larger-than- memory cloud storage engines,” Proceedings of the ACM on Manage- ment of Data , vol. 2, no. 1, pp. 1–28, 2024

    2024

  46. [54]

    Unsupervised space partition- ing for nearest neighbor search,

    A. Fahim, M. E. Ali, and M. A. Cheema, “Unsupervised space partition- ing for nearest neighbor search,” International Conference on Extending Database Technology (EDBT), 2023

    2023

  47. [55]

    Two is better than one: The case for 2-tree for skewed data sets,

    X. Zhou, X. Yu, G. Graefe, and M. Stonebraker, “Two is better than one: The case for 2-tree for skewed data sets,” CIDR, vol. 11, p. 13, 2023

    2023

  48. [56]

    Similarity indexing with the ss-tree,

    D. A. White and R. Jain, “Similarity indexing with the ss-tree,” in Pro- ceedings of the Twelfth International Conference on Data Engineering . IEEE, 1996, pp. 516–523

    1996

  49. [57]

    Machine unlearning in learned databases: An experimental analysis,

    M. Kurmanji, E. Triantafillou, and P. Triantafillou, “Machine unlearning in learned databases: An experimental analysis,” Proceedings of the ACM on Management of Data , vol. 2, no. 1, pp. 1–26, 2024. X. B IOGRAPHY SECTION Abdullah-Al-Mamun is a PhD candidate at the Department ...

    2024

Pith tools

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