Pith. sign in

REVIEW 3 major objections 5 minor 55 references

A New Paradigm in Tuning Learned Indexes: A Reinforcement Learning Enhanced Approach

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

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

Pith's one-line read LITune claims that learned index parameters, which expert defaults rarely set optimally, can be tuned automatically and safely online by a deep reinforcement learning agent, reporting up to 98% lower runtime and 17-fold higher throughput…

desk verdict A genuinely useful integration of Meta-RL, safe RL, and online updating for learned-index tuning, with plausible but under-verified empirical claims; referee it, demand the artifact. read the letter →

arxiv 2502.05001 v2 pith:24MJB42B submitted 2025-02-07 cs.DB cs.AIcs.SYeess.SY

Taiyi Wang , Liang Liang , Guang Yang , Thomas Heinis , Eiko Yoneki This is my paper · ORCID
classification cs.DBcs.AIcs.SYeess.SY
keywords learnedindexparametertuningreinforcementlearningmeta-reinforcementsafeonlineALEXCARMI
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 claims that learned index parameters, which default settings rarely set optimally, can be tuned automatically online by a deep reinforcement learning agent. It introduces LITune, which combines meta-reinforcement-learning pretraining, a safety-aware RL solver that terminates dangerous exploration, and an online/offline updating system to keep the tuner current as workloads shift. On the ALEX and CARMI learned indexes over SOSD datasets, LITune reports up to 98% lower runtime and 17-fold higher throughput than default settings, outperforming random search, grid search, heuristic search, SMBO, and a vanilla DDPG tuner. The claim is that this is the first system to enable stateful, online tuning of learned indexes.

What carries the argument

The load-bearing mechanism is the Markov Decision Process formalization of tuning, where the state is a vector of empirical proxies for index condition (tree height, node counts, search distance, retrain counters), actions are full parameter configurations, and the reward is a differential function of runtime changes from the initial baseline and the previous step. Safety is enforced by modeling tuning as a Constrained MDP and converting it to an Early Terminated MDP (ET-MDP), which adds an absorbing termination state and a penalty when cumulative cost exceeds a tolerance, so the policy learns to avoid out-of-memory errors and endless runtime. The O2 system couples a pre-trained online model with an offline model that is fine-tuned on new data, using divergence checks to decide when to swap models.

What would settle it

A decisive check would be to take a trained LITune policy, apply it to a learned index not in the paper (for example, the PGM index), and then corrupt the state vector by shuffling or zeroing its metric components; if the tuning performance stays essentially unchanged, the state representation is not carrying the claimed generalization, and the observed gains must come from the action space or reward alone.

Watch

Extended reading notes

Core claim

LITune's central claim is that end-to-end tuning of learned indexes is tractable with a tailored DRL pipeline: an agent observes the index's structural and operational metrics as state, proposes simultaneous parameter adjustments as actions, and receives a reward based on runtime improvement over both the starting baseline and the previous step. Meta-training with MAML lets the policy transfer to unseen workloads and data distributions, the ET-MDP solver prevents unsafe configurations by terminating episodes that exceed cost thresholds such as memory or runtime violations, and the O2 system combines an online model for immediate tuning with an offline model that refines on new data. The paper argues that this combination, rather than any single component, is what produces fast, stable, and adaptive tuning across different index implementations.

Load-bearing premise

The load-bearing premise is that the state features LITune reads from an index (tree height, node counts, search distance, retrain counters) are a faithful and sufficient description of the index's performance-relevant state, so a policy trained on synthetic distributions transfers to real workloads and to other index implementations.

Editorial extensions

If this is right

  • If LITune is right, users of learned indexes can obtain large performance gains without manual expertise: up to 98% lower runtime and 17x higher throughput in the reported settings.
  • The same MDP formalization can be applied to different learned indexes with different parameter spaces, as demonstrated by tuning both ALEX and CARMI.
  • Online tuning becomes feasible in data-shifting workloads: the O2 system lets the tuner adapt continuously without reinitializing from scratch.
  • Safety-aware exploration prevents the kind of system failures (out-of-memory, infinite loops) that aggressive vanilla RL tuners cause, making RL tuning practical.
  • Tuning budgets can be small: at a 1% sampling rate, LITune reaches a 20% runtime reduction in about 22 seconds, compared with minutes to hours for traditional methods.

Reading between the lines

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

  • Editorial extension: if the state proxies are sufficient, the same method should transfer to other learned indexes and possibly to classical tunable data structures, since search distance and node counts are index-agnostic.
  • Editorial extension: the reward design could be extended to multi-objective targets such as memory footprint or tail latency by changing the performance metric R, which the paper only demonstrates with runtime and throughput.
  • Editorial extension: the O2 divergence threshold could be made adaptive rather than fixed, using online change-point detection to trigger model swaps earlier in gradual shifts.
  • Editorial extension: the meta-training could be made cheaper by pretraining on a family of synthetic distributions that covers more tail shapes, since the paper's claim of generalization rests on the breadth of synthetic training data.
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 / 5 minor

Summary. The paper presents LITune, a reinforcement-learning-based framework for automatically tuning parameters of learned index structures. LITune combines a Meta-RL (MAML) pretraining stage with a safe-RL backbone based on an early-terminated MDP (ET-MDP) and an online/offline updating mechanism (O2). The authors evaluate LITune on ALEX and CARMI across SOSD datasets (OSM, books, Facebook, MIX) under static and data-shifting workloads, comparing against defaults, random/grid/heuristic search, SMBO, and a vanilla DDPG tuner. They report that LITune reduces runtime by up to 98% and increases throughput up to 17x relative to default settings, and that its O2 and safe-RL components improve adaptability and stability.

Significance. If the results hold, LITune would be a useful step toward practical end-to-end tuning of learned indexes: it addresses a real pain point, uses external benchmark data and independent baselines, and includes ablations for O2 and safe-RL. The paper's strengths include the breadth of the evaluation (two index types, four datasets, three workloads, streaming scenarios) and the explicit cost analysis in Table 3. However, the central empirical claim is currently supported by mean results without error bars, and the load-bearing reservoir-sampling and state-proxy assumptions are validated only partially. A released artifact would substantially strengthen reproducibility.

major comments (3)
  1. [Section 3.5 and Table 3] The RL reward and state used during online tuning are computed on a ~1% reservoir, yet the validation of this proxy (Table 3) covers only one workload (ALEX/OSM balanced). Since learned indexes are distribution- and workload-sensitive, a single point does not establish that reservoir-based reward rankings match full-data rankings for MIX/books/fb or read/write-heavy workloads, or for CARMI. If the reservoir misranks configurations, the policy, the O2 shift detector, and the headline gains (Figures 6-7) are optimized against a misspecified reward, so the comparison against SMBO/random/heuristic/DDPG would not support the central claim. I recommend adding per-dataset/per-workload comparisons of LITune-1% versus LITune-Full, and ideally rank correlation of candidate configurations, to validate the proxy.
  2. [Section 4.1] The state representation is acknowledged as 'empirical proxies' but never validated for sufficiency. The policy, safety model, and O2 shift detection all consume this state; if it omits performance-relevant information, the claimed generalization from synthetic training distributions to SOSD workloads and across ALEX/CARMI is unsupported. A concrete test would be an ablation that removes each metric class (structural vs. operational) or compares against a richer state set, and reports end-to-end performance; without this, the generalization claim rests on an untested representational assumption.
  3. [Section 5.2.1 and Figures 5-10] Section 5.2.1 states that five seeds are used, but Figures 5-10 report no error bars or variance information, and Section 5.4.3 explicitly contrasts methods on small margins (e.g., 10-15% for DDPG vs. LITune). Without confidence intervals or per-seed results, the reader cannot assess whether the reported differences are statistically meaningful, particularly for Random Search, whose variability is acknowledged in the text. At minimum, add error bars to all mean plots or provide a table of per-seed results.
minor comments (5)
  1. [References] References [44] and [45] appear to be the same paper ('Updatable learned index with precise positions' by Wu et al., 2021) and should be consolidated.
  2. [Section 4.1] The reward formula is typeset awkwardly, with the definition of Delta split across lines and no closing brace or equation number; this should be cleaned up so the two differential terms and the piecewise reward are unambiguous.
  3. [Figure 5] The caption says 'Above' and 'Below' but the figure places the runtime and throughput panels side by side; the panel labels should be made explicit, and error bars are needed in both panels.
  4. [Table 3] The 'DDPG ([24, 28])' label is confusing because [24] is the DDPG paper and [28] is RusKey; clarify that the reported training time is for the DDPG-based tuner as used in this paper, not for the RusKey system itself.
  5. [Section 5.2.3] The synthetic training distributions are named as 'uniform, beta, normal' but no distribution parameters are given; this makes the pretraining data description incomplete and impedes reproducibility.

Circularity Check

0 steps flagged · score 2.0 of 10

No significant circularity: LITune's gains are measured against external SOSD workloads and independent baselines; self-citations to the authors' prior ET-MDP and index papers are not load-bearing.

full rationale

LITune's derivation chain is not circular in any load-bearing sense. The central claim—that the RL tuner finds parameter configurations that reduce runtime and raise throughput—is validated against external SOSD datasets (OSM, books, fb, MIX) and independent baselines (random, grid, heuristic/OpenTuner, SMBO/TPE, and a vanilla DDPG tuner). The reward is defined directly as the normalized end-to-end runtime delta (Section 4.1), so the optimization objective and the evaluation metric are the same quantity; this is objective alignment, not a prediction forced by construction. The optimal configurations are not fed back into the reward or into the definition of the baselines. The main self-citation is [35] (Sun et al., including co-author Taiyi Wang) for the ET-MDP/context-model safety backbone. The paper re-derives the CMDP-to-ET-MDP transformation in Definitions 4.1–4.2 and Eq. (1), and the safety contribution is additionally supported by internal ablations (Section 5.5.2, Figures 11–12) that compare LITune with and without Safe-RL. Thus the citation, while self-referential, is not the sole or load-bearing support for the claim. Other self-citations ([23] SWIX, [46] FLIRT) are related-work context and do not carry the derivation. Two identified weaknesses are validity threats, not circularity. First, Section 4.1 states that the state features are 'empirical proxies'; if these do not capture performance-relevant state, the policy and safety model could degrade, but nothing in the paper defines the target result in terms of those proxies. Second, the 1% reservoir strategy is validated on only one workload (Table 3, ALEX/OSM balanced, 212s vs 208s full) and then used across all experiments (Section 3.5); if the sample misranks configurations on other workloads, the headline gains would be unsupported. This is an empirical generalization risk, not a circular reduction, because the final reported runtime is measured on the full dataset and the sampled reward does not define the reported outcome. Overall, no equation or fitted parameter is equivalent by construction to the claimed prediction, so the circularity score is low (2), reflecting only the presence of minor, non-load-bearing self-citations.

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

The central claim rests on several unproven modeling assumptions about state representativeness, transfer from synthetic training data, and safety generalization. The hand-set reward and sampling hyperparameters are disclosed but not justified by sensitivity analysis.

free parameters (6)
  • Reward shaping scalars ω and κ = ω=1, κ=2
    Section 4.1 chooses these values by hand: 'In our practice, ω=1 and κ=2 often strike a useful balance'. They control how the reward weights progress from baseline versus recent steps, and no sensitivity analysis is given.
  • Reservoir sampling ratio = 1% of dataset
    Section 5.4.4 selects 1% by comparing LITune-0.1%, LITune-1%, LITune-10%, and LITune-Full; 1% is chosen as the point with near-full performance (212s vs 208s).
  • RL hyperparameters (learning rates, network sizes, discount factor, LSTM dimensions) = not reported
    Section 4 describes DDPG with LSTM and MAML loops but omits the numeric settings needed to reproduce training.
  • O2 divergence threshold and update criteria = not specified
    Section 3.4.2 describes 'statistical divergence and user-defined thresholds' without concrete values; Figure 10's ablation depends on this setting.
  • Safety cost threshold C and termination reward r_e = not specified
    Definition 4.2 defines C and r_e but gives no values; the safety behavior in Figure 12 depends on them.
  • MAML inner/outer loop update counts = not reported
    Section 3.3.2 specifies a two-level MAML loop but no inner gradient steps or meta-batch sizes.
assumptions (6)
  • domain assumption The selected structural and operational metrics (search distance, node counts, retrain counters) faithfully represent the internal state of a learned index.
    Section 4.1 defines states from these metrics and calls them 'empirical proxies'; the RL policy, safety model, and O2 detection all build on this representation.
  • domain assumption Synthetic training distributions (uniform, beta, normal) with write-read ratios from 1:10 to 10:1 are representative of real SOSD workloads.
    Section 5.2.3 trains on synthetic data to avoid overfitting; generalization to OSM, books, Facebook, and MIX depends on this transfer assumption.
  • domain assumption Early termination with cumulative cost constraints yields a policy that avoids unsafe states on unseen workloads.
    Section 4.2 assumes context models 'transfer policies to unseen states and avoid constraint violations'; this is a learned generalization, not a proven guarantee.
  • ad hoc to paper The differential reward function (Δ_t→0 and Δ_t→t−1) correctly encodes the tuning objective so that maximizing cumulative discounted reward improves end-to-end runtime.
    Section 4.1 designs this reward with hand-chosen scalars; there is no proof of alignment with user objectives, though R can be redefined.
  • domain assumption A 1% reservoir sample preserves the workload mix and performance characteristics of the full dataset.
    Section 3.5 asserts the sampling strategy preserves workload characteristics; no error analysis or formal guarantee is given.
  • standard math Tuning instances are drawn from a distribution over which a MAML meta-initialization can adapt quickly.
    Section 3.3.2 applies MAML; this is the standard meta-learning assumption inherited from the cited MAML literature.

how reviews work

0 comments
Cite this review

Pith. "Pith review of A New Paradigm in Tuning Learned Indexes: A Reinforcement Learning Enhanced Approach." pith.science (2026). https://pith.science/paper/24MJB42B

@misc{pith2026250205001,
  author       = {Pith},
  title        = {Pith review of: A New Paradigm in Tuning Learned Indexes: A Reinforcement Learning Enhanced Approach},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/24MJB42B}},
  note         = {Machine review of arXiv:2502.05001}
}
read the original abstract

Learned Index Structures (LIS) have significantly advanced data management by leveraging machine learning models to optimize data indexing. However, designing these structures often involves critical trade-offs, making it challenging for both designers and end-users to find an optimal balance tailored to specific workloads and scenarios. While some indexes offer adjustable parameters that demand intensive manual tuning, others rely on fixed configurations based on heuristic auto-tuners or expert knowledge, which may not consistently deliver optimal performance. This paper introduces LITune, a novel framework for end-to-end automatic tuning of Learned Index Structures. LITune employs an adaptive training pipeline equipped with a tailor-made Deep Reinforcement Learning (DRL) approach to ensure stable and efficient tuning. To accommodate long-term dynamics arising from online tuning, we further enhance LITune with an on-the-fly updating mechanism termed the O2 system. These innovations allow LITune to effectively capture state transitions in online tuning scenarios and dynamically adjust to changing data distributions and workloads, marking a significant improvement over other tuning methods. Our experimental results demonstrate that LITune achieves up to a 98% reduction in runtime and a 17-fold increase in throughput compared to default parameter settings given a selected Learned Index instance. These findings highlight LITune's effectiveness and its potential to facilitate broader adoption of LIS in real-world applications.

Figures

Figures reproduced from arXiv: 2502.05001 by the authors.

Figure 1
Figure 1. (a) shows the performance surface of a learned index (ALEX) under a wild exploration of the parameter space. (b) [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 3
Figure 3. The architecture of LITune. Part A illustrates the training phase, where RL-based models are trained. Once the training is complete, these models are deployed as online tuners in Part B. The operational details of the O2 system are explained in Part C. The O2 system routinely assesses the necessity for model up￾dates by comparing the online model’s performance against new data and predefined criteria, including stat… view at source ↗
Figure 4
Figure 4. (a) Running example of LITune. This example demonstrates how LITune’s tuner components respond to changes in performance metrics and adjust to workload shifts. (b) The safe-RL approach prevents aggressive tuning by learning from instabilities encountered during training. runtime. To address this, we propose a minimalist approach by employing an Early Terminated Markov Decision Process (ET-MDP) solver that triggers a… view at source ↗
Figures from the paper (6 more)
Figure 5
Figure 5. Figure 5: Tuning efficiency–Performance as tuning steps in [PITH_FULL_IMAGE:figures/full_fig_p010_5.png]
Figure 6
Figure 6. Figure 6: Runtime performance (average on operation tuples) with extensive tuning. Performance improvements relative to [PITH_FULL_IMAGE:figures/full_fig_p011_6.png]
Figure 7
Figure 7. Figure 7: Throughput performance (ops/sec) with extensive [PITH_FULL_IMAGE:figures/full_fig_p011_7.png]
Figure 9
Figure 9. Figure 9: Online and continuous tuning performance (aver [PITH_FULL_IMAGE:figures/full_fig_p013_9.png]
Figure 10
Figure 10. Figure 10: Benefits of the O2 system in online and continuous [PITH_FULL_IMAGE:figures/full_fig_p013_10.png]
Figure 11
Figure 11. Figure 11: Exploring Parameter Spaces Across Tuning Meth [PITH_FULL_IMAGE:figures/full_fig_p013_11.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

55 extracted references · 38 canonical work pages

  1. [1]

    Jason Ansel, Shoaib Kamil, Kalyan Veeramachaneni, Jonathan Ragan-Kelley, Jeffrey Bosboom, Una-May O’Reilly, and Saman Amarasinghe. 2014. Opentuner: An extensible framework for program autotuning. In Proceedings of the 23rd international conference on Parallel architectures and compilation . 303–316

    work page 2014

  2. [2]

    James Bergstra, Dan Yamins, David D Cox, et al . 2013. Hyperopt: A python library for optimizing the hyperparameters of machine learning algorithms. In Proceedings of the 12th Python in science conference , Vol. 13. Citeseer, 20

    2013

  3. [3]

    Surajit Chaudhuri and Vivek Narasayya. 1997. An Efficient Cost-Driven Index Selection Tool for Microsoft SQL Server. In Proceedings of the 23rd International Conference on Very Large Data Bases (VLDB) . 146–155

    work page 1997

  4. [4]

    Supawit Chockchowwat, Wenjie Liu, and Yongjoo Park. 2023. Airindex: versatile index tuning through data and storage. Proceedings of the ACM on Management of Data 1, 3 (2023), 1–26

    work page 2023

  5. [5]

    Yinlam Chow, Ofir Nachum, Edgar Duenez-Guzman, and Mohammad Ghavamzadeh. 2018. A lyapunov-based approach to safe reinforcement learning. Advances in neural information processing systems 31 (2018)

    work page 2018

  6. [6]

    Kurtland Chua, Roberto Calandra, Rowan McAllister, and Sergey Levine. 2018. Deep reinforcement learning in a handful of trials using probabilistic dynamics models. Advances in neural information processing systems 31 (2018)

    work page 2018

  7. [7]

    Douglas Comer. 1979. Ubiquitous B-tree. ACM Computing Surveys (CSUR) 11, 2 (1979), 121–137

    work page 1979

  8. [8]

    Niv Dayan and Stratos Idreos. 2018. Dostoevsky: Better space-time trade-offs for LSM-tree based key-value stores via adaptive removal of superfluous merging. In Proceedings of the 2018 International Conference on Management of Data . 505–520

    work page 2018

Show all 55 references
  1. [9]

    Jialin Ding, Ryan Marcus, Andreas Kipf, Vikram Nathan, Aniruddha Nrusimha, Kapil Vaidya, Alexander van Renen, and Tim Kraska. 2022. Sagedb: An instance- optimized data analytics system. Proceedings of the VLDB Endowment 15, 13 (2022)

    2022

  2. [10]

    Jialin Ding, Umar Farooq Minhas, Jia Yu, Chi Wang, Jaeyoung Do, Yinan Li, Hantian Zhang, Badrish Chandramouli, Johannes Gehrke, Donald Kossmann, et al. 2020. ALEX: an updatable adaptive learned index. In Proceedings of the 2020 ACM SIGMOD International Conference on Management...

    2020

  3. [11]

    Paolo Ferragina and Giorgio Vinciguerra. 2020. The PGM-index: a fully-dynamic compressed learned index with provable worst-case bounds. Proceedings of the VLDB Endowment 13, 8 (2020), 1162–1175

    2020

  4. [12]

    Matthias Feurer, Jost Springenberg, and Frank Hutter. 2015. Initializing bayesian hyperparameter optimization via meta-learning. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 29

    2015

  5. [13]

    Qiming Fu, Zhechao Wang, Nengwei Fang, Bin Xing, Xiao Zhang, and Jianping Chen. 2023. MAML2: meta reinforcement learning via meta-learning for task categories. Frontiers of Computer Science 17, 4 (2023), 174325

    2023

  6. [14]

    Alex Galakatos, Michael Markovitch, Carsten Binnig, Rodrigo Fonseca, and Tim Kraska. 2019. Fiting-tree: A data-aware index structure. In Proceedings of the 2019 international conference on management of data . 1189–1206

    2019

  7. [15]

    Sanket Kamthe and Marc Deisenroth. 2018. Data-efficient reinforcement learning with probabilistic model predictive control. InInternational conference on artificial intelligence and statistics. PMLR, 1701–1710

    2018

  8. [16]

    Elias Khalil, Hanjun Dai, Yuyu Zhang, Bistra Dilkina, and Le Song. 2017. Learn- ing combinatorial optimization algorithms over graphs. Advances in neural information processing systems 30 (2017)

    2017

  9. [17]

    Minsu Kim, Jinwoo Hwang, Guseul Heo, Seiyeon Cho, Divya Mahajan, and Jongse Park. 2024. Accelerating String-key Learned Index Structures via Memoization- based Incremental Training. arXiv preprint arXiv:2403.11472 (2024)

    2024 arXiv

  10. [18]

    Andreas Kipf, Ryan Marcus, Alexander van Renen, Mihail Stoian, Alfons Kemper, Tim Kraska, and Thomas Neumann. 2019. SOSD: A benchmark for learned indexes. arXiv preprint arXiv:1911.13014 (2019)

    2019 arXiv

  11. [19]

    Andreas Kipf, Ryan Marcus, Alexander van Renen, Mihail Stoian, Alfons Kemper, Tim Kraska, and Thomas Neumann. 2020. RadixSpline: a single-pass learned index. In Proceedings of the third international workshop on exploiting artificial intelligence techniques for data management . 1–5

    2020

  12. [20]

    Jan Kossmann, Onur Mutlu, Scott Posner, and Felix Nöth. 2022. SWIRL: Selection of Workload-aware Indexes via Reinforcement Learning. In Proceedings of the 2022 International Conference on Management of Data (SIGMOD) . 1570–1583

    2022

  13. [21]

    Tim Kraska, Alex Beutel, Ed H Chi, Jeffrey Dean, and Neoklis Polyzotis. 2018. The case for learned index structures. In Proceedings of the 2018 international conference on management of data . 489–504

    2018

  14. [22]

    Pengfei Li, Yu Hua, Jingnan Jia, and Pengfei Zuo. 2021. FINEdex: a fine-grained learned index scheme for scalable and concurrent memory systems. Proceedings of the VLDB Endowment 15, 2 (2021), 321–334

    2021

  15. [23]

    Liang Liang, Guang Yang, Ali Hadian, Luis Alberto Croquevielle, and Thomas Hei- nis. 2024. SWIX: A Memory-efficient Sliding Window Learned Index. Proceedings of the ACM on Management of Data 2, 1 (2024), 1–26

    2024

  16. [24]

    TP Lillicrap. 2015. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971 (2015)

    2015 arXiv

  17. [25]

    Yang Liu, Wissam M Sid-Lakhdar, Osni Marques, Xinran Zhu, Chang Meng, James W Demmel, and Xiaoye S Li. 2021. Gptune: Multitask learning for autotun- ing exascale applications. In Proceedings of the 26th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming . 234–246

    2021

  18. [26]

    Baotong Lu, Jialin Ding, Eric Lo, Umar Farooq Minhas, and Tianzheng Wang

  19. [27]

    Ryan Marcus, Emily Zhang, and Tim Kraska. 2020. Cdfshop: Exploring and optimizing learned index structures. In Proceedings of the 2020 ACM SIGMOD International Conference on Management of Data . 2789–2792

    2020

  20. [28]

    Dingheng Mo, Fanchao Chen, Siqiang Luo, and Caihua Shan. 2023. Learning to Optimize LSM-trees: Towards A Reinforcement Learning based Key-Value Store for Dynamic Workloads. arXiv preprint arXiv:2308.07013 (2023)

    2023 arXiv

  21. [29]

    Yoshihiko Ozaki, Yuki Tanigaki, Shuhei Watanabe, and Masaki Onishi. 2020. Multiobjective tree-structured parzen estimator for computationally expensive optimization problems. In Proceedings of the 2020 genetic and evolutionary com- putation conference. 533–541

    2020

  22. [30]

    Kostas Patroumpas and Timos Sellis. 2006. Window specification over data streams. In International Conference on Extending Database Technology . Springer, A New Paradigm in Tuning Learned Indexes: A Reinforcement Learning Enhanced Approach SIGMOD ’25, June 22-27, 2025, Berlin,...

    2006

  23. [31]

    John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov

  24. [32]

    Tarique Siddiqui and Wentao Wu. 2024. ML-Powered Index Tuning: An Overview of Recent Progress and Open Challenges. ACM SIGMOD Record 52, 4 (2024), 19–30

    2024

  25. [33]

    Jasper Snoek, Hugo Larochelle, and Ryan P Adams. 2012. Practical bayesian optimization of machine learning algorithms. Advances in neural information processing systems 25 (2012)

    2012

  26. [34]

    Mihail Stoian, Andreas Kipf, Ryan Marcus, and Tim Kraska. 2021. Towards Practical Learned Indexing. arXiv preprint arXiv:2108.05117 (2021)

    2021 arXiv

  27. [35]

    Hao Sun, Ziping Xu, Zhenghao Peng, Meng Fang, Taiyi Wang, Bo Dai, and Bolei Zhou. 2022. Constrained MDPs can be Solved by Eearly-Termination with Recurrent Models. In NeurIPS 2022 Foundation Models for Decision Making Workshop

    2022

  28. [36]

    Zhaoyan Sun, Xuanhe Zhou, and Guoliang Li. 2023. Learned Index: A Com- prehensive Experimental Evaluation. Proceedings of the VLDB Endowment 16, 8 (2023), 1992–2004

    2023

  29. [37]

    Richard S Sutton and Andrew G Barto. 2018. Reinforcement learning: An intro- duction. MIT press

    2018

  30. [38]

    Chuzhe Tang, Youyun Wang, Zhiyuan Dong, Gansen Hu, Zhaoguo Wang, Minjie Wang, and Haibo Chen. 2020. XIndex: a scalable learned index for multicore data storage. In Proceedings of the 25th ACM SIGPLAN symposium on principles and practice of parallel programming . 308–320

    2020

  31. [39]

    Lohman, and Alan Skelley

    Grubb Valentin, Michael Zuliani, Diego Zilio, Guy M. Lohman, and Alan Skelley

  32. [40]

    Dana Van Aken, Andrew Pavlo, Geoffrey J Gordon, and Bohan Zhang. 2017. Automatic database management system tuning through large-scale machine learning. In Proceedings of the 2017 ACM international conference on management of data. 1009–1024

    2017

  33. [41]

    Linnan Wang, Yiyang Zhao, Yuu Jinnai, Yuandong Tian, and Rodrigo Fonseca

  34. [42]

    Tingwu Wang, Xuchan Bao, Ignasi Clavera, Jerrick Hoang, Yeming Wen, Eric Lan- glois, Shunshi Zhang, Guodong Zhang, Pieter Abbeel, and Jimmy Ba. 2019. Bench- marking Model-Based Reinforcement Learning. arXiv preprint arXiv:1907.02057 (2019)

    2019 arXiv

  35. [43]

    Zijia Wang, Haoran Liu, Chen Lin, Zhifeng Bao, Guoliang Li, and Tianqing Wang

  36. [45]

    Jiacheng Wu, Yong Zhang, Shimin Chen, Jin Wang, Yu Chen, and Chunxiao Xing. 2021. Updatable learned index with precise positions. arXiv preprint arXiv:2104.05520 (2021)

    2021 arXiv

  37. [46]

    Guang Yang, Liang Liang, Ali Hadian, and Thomas Heinis. 2023. FLIRT: A Fast Learned Index for Rolling Time frames.. In EDBT. 234–246

    2023

  38. [47]

    Wei Ying, Yu Zhang, Junzhou Huang, and Qiang Yang. 2018. Transfer learning via learning to transfer. In International Conference on Machine Learning . PMLR, 5085–5094

    2018

  39. [48]

    Jiaoyi Zhang and Yihan Gao. 2021. Carmi: A cache-aware learned index with a cost-based construction algorithm. arXiv preprint arXiv:2103.00858 (2021)

    2021 arXiv

  40. [49]

    Ji Zhang, Yu Liu, Ke Zhou, Guoliang Li, Zhili Xiao, Bin Cheng, Jiashu Xing, Yangtao Wang, Tianheng Cheng, Li Liu, et al. 2019. An end-to-end automatic cloud database tuning system using deep reinforcement learning. In Proceedings of the 2019 International Conference on Managem...

    2019

  41. [50]

    Xinyang Zhao, Xuanhe Zhou, and Guoliang Li. 2023. Automatic database knob tuning: a survey. IEEE Transactions on Knowledge and Data Engineering 35, 12 (2023), 12470–12490

    2023

  42. [51]

    Wei Zhou, Chen Lin, Xuanhe Zhou, and Guoliang Li. 2024. Breaking It Down: An In-Depth Study of Index Advisors. Proceedings of the VLDB Endowment 17, 10 (2024), 2405–2418

    2024

  43. [2000]

    In Proceedings of the 16th International Conference on Data Engineering (ICDE)

    DB2 Advisor: An Optimizer Smart Enough to Recommend Its Own Indexes. In Proceedings of the 16th International Conference on Data Engineering (ICDE) . 101–110

  44. [2017]

    arXiv preprint arXiv:1707.06347 (2017)

    Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347 (2017)

    2017 arXiv

  45. [2020]

    In Proceedings of the AAAI Conference on Artificial Intelligence, Vol

    Neural architecture search using deep neural networks and monte carlo tree search. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 34. 9983–9991

  46. [2021]

    arXiv preprint arXiv:2105.00683 (2021)

    APEX: a high-performance learned index on persistent memory. arXiv preprint arXiv:2105.00683 (2021)

    2021 arXiv

  47. [2024]

    Proceedings of the VLDB Endowment 17, 7 (2024), 1642–1654

    Leveraging Dynamic and Heterogeneous Workload Knowledge to Boost the Performance of Index Advisors. Proceedings of the VLDB Endowment 17, 7 (2024), 1642–1654

    2024

Pith tools

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