Pith. sign in

REVIEW 4 major objections 4 minor 52 references

NeurStore: Efficient In-database Deep Learning Model Management System

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

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

Pith's one-line read NeurStore claims that storing models as tensor deltas lets an 800-model, 361 GB collection fit in 261 GB while keeping most models' accuracy unchanged.

desk verdict NeurStore is a credible, well-engineered in-database model management system with a real implementation, but its headline storage gain rests on dense cross-model tensor similarity and the 'direct computation' claim is overstated; it still deserves a serious referee. read the letter →

arxiv 2509.03228 v2 pith:366ISEAN submitted 2025-09-03 cs.DB cs.LG

Siqi Xiang , Sheng Wang , Xiaokui Xiao , Cong Yue , Zhanhao Zhao , Beng Chin Ooi This is my paper · ORCID
classification cs.DBcs.LG
keywords in-databaseanalyticsdeeplearningmodelmanagementtensor-leveldeduplicationdeltaquantizationHNSWindexloadingcompression-awareinferencestorageengine
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

NeurStore claims that deep learning models should be stored inside a database at the level of individual tensors, not as whole-model files. Because most deployed models are fine-tuned from a shared checkpoint, nearly every tensor can be represented as a small quantized difference from a similar tensor that is already stored; the database keeps a graph-based index of base tensors and stores only the deltas. This turns a large model collection into one shared pool of components, cutting storage from 361 GB to 261 GB for an 800-model benchmark collection while keeping most models' accuracy effectively unchanged. A compression-aware loader then reconstructs tensors only when they are needed for computation, so serving a model no longer requires unpacking the entire model first. If the approach holds up, in-database AI analytics can keep many more model versions online at a fraction of the current storage cost.

What carries the argument

The load-bearing mechanism is tensor-level delta deduplication. NeurStore indexes base tensors in a hierarchical navigable small-world (HNSW) graph, one index per tensor shape, with each vertex holding an 8-bit quantized copy of a base tensor; an approximate nearest-neighbor search finds the closest base for each incoming tensor, the delta is computed against the dequantized base, and if the delta's value range is within the similarity threshold $\tau$, the delta is stored using a bit width $\lceil \log_2((\delta_{\max} - \delta_{\min})/(2p)) \rceil$. The quantized base-delta pair, together with dequantize-and-add nodes inserted into the computation graph, is what lets the system both shrink storage and avoid full reconstruction during loading.

What would settle it

Save a collection of, say, one hundred models trained independently from different architectures and random initializations, measure total storage with NeurStore, and compare against compressing each model separately with a per-model compressor; if the ratio approaches the compressor's roughly 1.3x rather than showing a widening gap as the collection grows, the cross-model deduplication claim is limited to fine-tuned families.

Watch

Extended reading notes

Core claim

On its own terms, the paper establishes a storage-and-loading design in which a model collection is compressed jointly rather than model by model. Each saved model is separated into its architecture graph and its weight tensors; the tensors are flattened by shape and matched through an HNSW approximate-nearest-neighbor index against stored base tensors. A tensor whose closest base lies within a similarity threshold is stored only as a delta, and the delta is linearly quantized at a bit width chosen from its value range and the user's precision tolerance; tensors without a close enough base become new 8-bit base-tensor vertices. Loading is compression-aware: dequantize-and-add nodes are inserted into the computation graph, base tensors with multiple references are decompressed once and reused, and the low bits of deltas can be dropped to trade accuracy for speed. The reported effect is that an 800-model, 361 GB collection fits in 261 GB, compression beats per-model compressors, and flexible loading reaches up to 2.4x the throughput of full loading with most models staying within 0.1% accuracy change.

Load-bearing premise

The load-bearing premise is that a model collection contains enough closely related tensors that most tensors land within the small delta range needed for cheap quantization; without that cross-model similarity, savings collapse to ordinary per-tensor quantization plus index overhead.

Editorial extensions

If this is right

  • A fleet of fine-tuned derivatives of the same checkpoint can be stored at roughly the cost of one checkpoint plus small deltas per variant, rather than one full copy per model.
  • Loading can begin inference before the full model exists in memory: fetching only the most significant bits of each delta gives up to a 2.4x loading throughput gain and drops peak loading memory, while keeping most tested models within 0.1% accuracy change.
  • The more models a database already contains, the more likely a new tensor matches an existing base, so incremental model addition becomes cheaper over time rather than requiring recompression.
  • The storage engine is portable: beyond the main database extension, the paper reports working integrations with two analytical databases, both reaching 78% of baseline storage.
  • Users control the accuracy/storage trade-off with a per-model precision tolerance, and the paper reports the tolerances at which each task family starts to lose accuracy.

Reading between the lines

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

  • A testable consequence the paper does not run: if the same collection is saved repeatedly as it grows, the marginal storage per newly fine-tuned version should approach the delta size once the HNSW index has seen all base tensors; measuring marginal bytes per version would quantify the incremental-compression claim.
  • The flexible-loading bit-width parameter could plausibly become a per-query accuracy knob in the database, letting the optimizer choose lower inference precision for latency-critical requests; NeurStore supplies the mechanism but stops short of an optimizer policy.
  • Because matching is by tensor similarity rather than by declared model lineage, the same machinery might compress collections of models that share only some modules, such as embedding tables or adapter layers, even with different overall architectures; the paper's workload does not isolate that scenario.
  • One limit implied by the design is that storage savings concentrate in collections with many close tensors; a catalog of one-off, independently trained models would fall back to the quantization-only compression ratio, and the index overhead could erode that gain.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 4 minor

Summary. The paper presents NeurStore, a tensor-level storage engine for in-database deep learning model management. It decouples model architectures from weight tensors, indexes 8-bit quantized base tensors with a per-shape HNSW index, stores quantized deltas for tensors within a similarity threshold, and augments the model computation graph with dequantize-and-add nodes so that tensors are reconstructed lazily during inference. The evaluation compares NeurStore with PostgresML, ELF*, ZSTD, and ZFP on 800 HuggingFace models totaling 361 GB, reporting a 1.38x compression ratio, up to 2.4x loading-throughput gains under flexible 8-bit delta loading, and accuracy changes mostly below 0.1%. The paper also reports integrations of the storage engine into DuckDB and ClickHouse.

Significance. If its storage advantages hold broadly, NeurStore's tensor-deduplication approach would be a practical addition to in-database model management. The paper's concrete strengths are a full PostgreSQL implementation with released source code, an extension to DuckDB and ClickHouse, evaluation across six analytic tasks, and explicit accuracy-loss measurements. Two caveats temper the significance. First, the reported compression advantage over ELF is modest (1.38x versus 1.32x) and rests on an unquantified assumption that many tensors find a close base within the similarity threshold. Second, the most novel claimed mechanism, 'direct computation on compressed tensors,' is not actually what Algorithm 2 implements; the system performs on-demand dequantization and graph-level pipelining. The central ideas are defensible, but the paper overstates its evidence and one of its headline claims.

major comments (4)
  1. [Section 4.3.2, Algorithm 2] The abstract and Section 4.3 claim 'direct computation on compressed tensors,' but Algorithm 2 creates DequantizeLinear nodes for the quantized base tensor and the (possibly truncated) delta tensor, then inserts an element-wise Add node, and only after this floating-point reconstruction wires the result to the original consumer node. The system therefore performs on-demand decompression with graph-level pipelining, not direct computation on compressed representations. The text should either be revised to describe on-demand reconstruction, or the authors should provide kernels that actually operate on quantized data; as written, this headline claim is overstated.
  2. [Sections 6.1.1, 6.3.1, and 6.4.1] The evidence for the central storage claim is workload-specific in an unquantified way. The 800-model HuggingFace corpus is never characterized by architecture diversity, lineage, or per-tensor matched-base statistics, and the three analytics workloads in Table 1 are fine-tuned derivatives of DistilBERT, ViT, and an MLP. With the default tau=0.16 and p=2^-24, Eq. (2) implies that a tensor that becomes a new base costs roughly 8 + 15-21 bits per value, i.e., a compression of about 1.1-1.4x before HNSW vertex and edge overhead; only dense deduplication lifts NeurStore above ELF's 1.32x. The paper should report the fraction of tensors that delta-match, the delta bit-width distribution, and the HNSW index overhead on the full corpus, and should evaluate on a held-out collection of independently trained models to support the claimed generality.
  3. [Sections 4.1 and 4.2] The stated storage format is internally inconsistent. Section 4.1 says each delta tensor stores 'a 4-bit scale' and 'a 4-bit zero-point,' but Eq. (3) and Algorithm 1 compute zero_point = floor(-delta_min/(2p)); with the default p=2^-24 and tau=0.16, this value can be as large as about 1.34e6 and requires roughly 21 bits, the same order as the quantized payload. The authors should clarify the actual metadata encoding and account for its cost in the reported storage numbers.
  4. [Section 6.4.1] The default threshold tau=0.16 is selected on 50 BERT models fine-tuned from a single checkpoint, and the main workload is dominated by the same kind of fine-tuned derivatives. This is parameter tuning rather than circular reasoning, but the sensitivity analysis should be repeated on a heterogeneous subset and reported together with matched-tensor ratios, so that readers can see how much of the 1.38x result depends on tuning tau to the evaluation distribution.
minor comments (4)
  1. [Table 2] The system name is written 'NeuralStore' in the table, which is inconsistent with 'NeurStore' elsewhere in the paper.
  2. [Equation (2)] Equation (2) is undefined when delta_max equals delta_min; please add a degenerate-case rule for zero-range delta tensors.
  3. [Section 4.2] The sentence 'For a tensor with normalization, the range of the new delta falls within 1−(−1)/2^8 ≈ 0.0078' has a typesetting error; it should read (1 - (-1))/2^8.
  4. [Section 6.4.2] The sentence 'These tensors mainly originate from the same base tensor as their corresponding delta tensors' is unclear and should be rephrased to explain why a delta can be identical to its base.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: NeurStore's storage and throughput claims are measured system results, and its bit-width formula is a design equation rather than a fitted prediction.

full rationale

NeurStore's central claims are empirical system results rather than derivations from fitted parameters. The delta bit-width formula (Eq. 2) computes n_bit from the user-supplied precision bound p and the observed delta range; it is a construction that guarantees the quantized reconstruction error stays below p, and the paper separately measures model accuracy impact (Section 6.4.4). The reported storage compression ratios (e.g., 1.38x for 800 models), loading throughput, and accuracy changes are measured against PostgresML, ELF*, ZSTD, ZFP, and ELF on a 361 GB corpus (Sections 6.2-6.4). The similarity threshold tau is tuned on a 50-model BERT subset (Section 6.4.1) and then used as the default in the main evaluation; this is standard hyperparameter selection and does not make the reported compression ratio equal to the tuning objective by construction. The only self-references, such as 'NeurStore is a component of NeurDB [33, 52]', are identity/integration statements and are not load-bearing evidence for any technical claim. No self-citation chain, imported uniqueness theorem, or ansatz-via-citation carries the argument. The legitimate concern that the modest 1.38x advantage over ELF's 1.32x depends on dense cross-model tensor similarity is a robustness and workload representativeness issue, not a circularity issue.

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

The central design rests on two fitted knobs (tau, p) and on the empirical premise that fine-tuned model collections contain many similar tensors. No new physical entities are introduced. The bit-width formula itself is standard uniform quantization, so the main scientific content is the system design and its workload-dependent evaluation.

free parameters (3)
  • Similarity threshold tau = 0.16
    Decides whether a tensor is stored as a delta or as a new base tensor. Tuned on 50 BERT fine-tuned models in Section 6.4.1; the default is used in all main experiments and directly affects the reported compression ratio.
  • Precision tolerance p = 5.96e-8 (2^-24)
    User-defined bound on per-element quantization error; default chosen by the authors as smaller than single-precision machine epsilon. It sets the quantization bin width (2p) and hence the bit width in Equation (2).
  • Flexible loading bit width b = 8 bits
    Default number of most-significant delta bits loaded during inference; used in the default configuration and in the flexible-loading experiments.
assumptions (4)
  • domain assumption HNSW approximate nearest neighbor search returns a base tensor close enough that the resulting delta range is below tau for a substantial fraction of tensors
    The storage gains require ANN to find good matches. The paper does not report HNSW recall or the distribution of distances, so this remains an unverified premise. See Section 4.1 and Algorithm 1.
  • domain assumption The model collection used in evaluation is representative of real deployments, with high inter-model tensor similarity
    The workload is dominated by fine-tuned variants of a few base checkpoints (Section 6.1.1). If real collections have more heterogeneous independent models, the dedup benefit shrinks.
  • standard math Uniform scalar quantization with bin width 2p bounds each element's reconstruction error by p
    Used implicitly in Equation (2) and Section 4.2 to justify controllable accuracy loss. The bound holds for nearest-neighbor rounding of a single value, but accumulation across layers and downstream tasks is not guaranteed.
  • domain assumption Delta tensors have smaller value ranges than original tensors, so quantizing deltas is more accurate than quantizing weights directly
    Stated in Section 2.4 and used to motivate the design. It holds when the matched base tensor is close; when it is not, NeurStore creates a new base instead.

how reviews work

0 comments
Cite this review

Pith. "Pith review of NeurStore: Efficient In-database Deep Learning Model Management System." pith.science (2026). https://pith.science/paper/366ISEAN

@misc{pith2026250903228,
  author       = {Pith},
  title        = {Pith review of: NeurStore: Efficient In-database Deep Learning Model Management System},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/366ISEAN}},
  note         = {Machine review of arXiv:2509.03228}
}
read the original abstract

With the prevalence of in-database AI-powered analytics, there is an increasing demand for database systems to efficiently manage the ever-expanding number and size of deep learning models. However, existing database systems typically store entire models as monolithic files or apply compression techniques that overlook the structural characteristics of deep learning models, resulting in suboptimal model storage overhead. This paper presents NeurStore, a novel in-database model management system that enables efficient storage and utilization of deep learning models. First, NeurStore employs a tensor-based model storage engine to enable fine-grained model storage within databases. In particular, we enhance the hierarchical navigable small world (HNSW) graph to index tensors, and only store additional deltas for tensors within a predefined similarity threshold to ensure tensor-level deduplication. Second, we propose a delta quantization algorithm that effectively compresses delta tensors, thus achieving a superior compression ratio with controllable model accuracy loss. Finally, we devise a compression-aware model loading mechanism, which improves model utilization performance by enabling direct computation on compressed tensors. Experimental evaluations demonstrate that NeurStore achieves superior compression ratios and competitive model loading throughput compared to state-of-the-art approaches.

Figures

Figures reproduced from arXiv: 2509.03228 by the authors.

Figure 1
Figure 1. In-database AI-powered Analytics Workflow [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. System Architecture of NeurStore – The system sup￾ports two main workflows: (1) model saving (red), where models are compressed before being stored, and (2) model loading (blue), where models are retrieved by the model loader. model architectures. NeurStore persists HNSW on disk, which are loaded into memory at runtime and used by the model compressor for efficient similarity search. To reduce the size of HNSW, we s… view at source ↗
Figure 3
Figure 3. Tensor-based Storage Engine – The engine consists of three components: index storage for HNSW-based indexes, delta tensor storage, and metadata storage for model architectures. before they are invoked in the computation. NeurStore then follows the modified computation graph to compute the results. Running Example. Let us continue the CTR prediction example shown in [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (9 more)
Figure 4
Figure 4. Figure 4: Delta Quantization Algorithm – NeurStore com￾presses tensors in four steps: (1) decouple the weights from model architecture, (2) search for the closest base tensor with ANN, (3) perform delta-encoding, and (4) apply quantization to deltas. independent optimization of …
Figure 5
Figure 5. Figure 5: Compression-aware Model Inference – NeurStore adopts flexible tensor loading with partial delta tensor bits and on￾demand decompression to streamline the model loading process. 4.3.1 Model Loading. When a Load Model request is received, NeurStore first looks up the ref…
Figure 6
Figure 6. Figure 6: Pipelining – NeurStore pipelines tensor loading, decom￾pression, and computation during model loading. addition nodes directly into the model graph. The output of this re￾construction subgraph is then wired to the corresponding original node that consumed the tensor (L…
Figure 7
Figure 7. Figure 7: End-to-end Time Breakdown for In-database AI [PITH_FULL_IMAGE:figures/full_fig_p010_7.png]
Figure 8
Figure 8. Figure 8: Overall Performance of NeurStore. 6.1.3 Default configuration. We configure PostgreSQL with a 32GB shared buffer. Other PostgreSQL parameters remain at their default values unless specified. We choose 𝜏 = 0.16 as the default similarity threshold in NeurStore, and enabl…
Figure 11
Figure 11. Figure 11: Performance Impact of Flexible Model Loading. [PITH_FULL_IMAGE:figures/full_fig_p011_11.png]
Figure 12
Figure 12. Figure 12: Model Accuracy and Storage Change under Differ [PITH_FULL_IMAGE:figures/full_fig_p012_12.png]
Figure 13
Figure 13. Figure 13: Model Performance of Compared Compression Algorithms under Different Tasks [PITH_FULL_IMAGE:figures/full_fig_p013_13.png]
Figure 14
Figure 14. Figure 14: Performance of NeurStore on DuckDB and Click￾House 6.5 Extensibility of NeurStore We now extend NeurStore to DuckDB [36], denoted as DuckDB+NeurStore, and to ClickHouse [40], denoted as ClickHouse+NeurStore. For comparison, the baseline DuckDB and ClickHouse systems s…

Review history (2 revisions) →

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

52 extracted references · 41 canonical work pages

  1. [2]

    2024. zlib. https://zlib.net

    work page 2024

  2. [4]

    Azure SQL

    2025. Azure SQL. https://azure.microsoft.com

    work page 2025

  3. [5]

    Hugging Face

    2025. Hugging Face. https://huggingface.co

    work page 2025

  4. [6]

    Oracle Machine Learning

    2025. Oracle Machine Learning. https://docs.oracle.com/en/database/oracle/ machine-learning

    work page 2025

  5. [7]

    PostgresML

    2025. PostgresML. https://postgresml.org

    work page 2025

  6. [8]

    Zstandard

    2025. Zstandard. https://github.com/facebook/zstd

    work page 2025

  7. [9]

    Christoph Brücke, Philipp Härtling, Rodrigo Escobar Palacios, Hamesh Patel, and Tilmann Rabl. 2023. TPCx-AI - An Industry Standard Benchmark for Artificial Intelligence and Machine Learning Systems.Proc. VLDB Endow.16, 12 (2023), 3649–3661

    work page 2023

  8. [10]

    Deng Cai. 2021. A Revisit of Hashing Algorithms for Approximate Nearest Neighbor Search.IEEE Trans. Knowl. Data Eng.33, 6 (2021), 2337–2348

    work page 2021

Show all 52 references
  1. [11]

    Mengzhao Chen, Wenqi Shao, Peng Xu, Jiahao Wang, Peng Gao, Kaipeng Zhang, Yu Qiao, and Ping Luo. 2024. EfficientQAT: Efficient Quantization-Aware Training for Large Language Models.CoRRabs/2407.11062 (2024)

    2024 arXiv

  2. [12]

    Matthijs Douze, Alexandr Guzhva, Chengqi Deng, Jeff Johnson, Gergely Szilvasy, Pierre-Emmanuel Mazaré, Maria Lomeli, Lucas Hosseini, and Hervé Jégou. 2024. The Faiss library.CoRRabs/2401.08281 (2024)

    2024 arXiv

  3. [13]

    Arash Fard, Anh Le, George Larionov, Waqas Dhillon, and Chuck Bear. 2020. Vertica-ML: Distributed Machine Learning in Vertica Database. InSIGMOD Conference. 755–768

    2020

  4. [14]

    Xixuan Feng, Arun Kumar, Benjamin Recht, and Christopher Ré. 2012. Towards a unified architecture for in-RDBMS analytics. InSIGMOD Conference. 325–336

    2012

  5. [15]

    Cong Fu, Chao Xiang, Changxu Wang, and Deng Cai. 2019. Fast Approximate Nearest Neighbor Search With The Navigating Spreading-out Graph.Proc. VLDB Endow.12, 5 (2019), 461–474

    2019

  6. [16]

    Haotian Gao, Cong Yue, Tien Tuan Anh Dinh, Zhiyong Huang, and Beng Chin Ooi. 2023. Enabling secure and efficient data analytics pipeline evolution with trusted execution environment.Proc. VLDB Endow.16, 10 (2023), 2485–2498

    2023

  7. [17]

    Mahoney, and Kurt Keutzer

    Amir Gholami, Sehoon Kim, Zhen Dong, Zhewei Yao, Michael W. Mahoney, and Kurt Keutzer. 2021. A Survey of Quantization Methods for Efficient Neural Network Inference.CoRRabs/2103.13630 (2021)

    2021 arXiv

  8. [18]

    Song Han, Huizi Mao, and William J. Dally. 2016. Deep Compression: Compress- ing Deep Neural Network with Pruning, Trained Quantization and Huffman Coding. InICLR

    2016

  9. [19]

    Hellerstein, Christopher Ré, Florian Schoppmann, Daisy Zhe Wang, Eugene Fratkin, Aleksander Gorajek, Kee Siong Ng, Caleb Welton, Xixuan Feng, Kun Li, and Arun Kumar

    Joseph M. Hellerstein, Christopher Ré, Florian Schoppmann, Daisy Zhe Wang, Eugene Fratkin, Aleksander Gorajek, Kee Siong Ng, Caleb Welton, Xixuan Feng, Kun Li, and Arun Kumar. 2012. The MADlib Analytics Library or MAD Skills, the SQL.Proc. VLDB Endow.5, 12 (2012), 1700–1711

    2012

  10. [20]

    Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen

    Edward J. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. 2022. LoRA: Low-Rank Adaptation of Large Language Models. InICLR

    2022

  11. [21]

    Piotr Indyk and Rajeev Motwani. 1998. Approximate Nearest Neighbors: Towards Removing the Curse of Dimensionality. InSTOC. 604–613

    1998

  12. [22]

    Howard, Hartwig Adam, and Dmitry Kalenichenko

    Benoit Jacob, Skirmantas Kligys, Bo Chen, Menglong Zhu, Matthew Tang, An- drew G. Howard, Hartwig Adam, and Dmitry Kalenichenko. 2018. Quantization and Training of Neural Networks for Efficient Integer-Arithmetic-Only Inference. InCVPR. 2704–2713

    2018

  13. [23]

    Hervé Jégou, Matthijs Douze, and Cordelia Schmid. 2011. Product Quantization for Nearest Neighbor Search.IEEE Trans. Pattern Anal. Mach. Intell.33, 1 (2011), 117–128

    2011

  14. [24]

    Raghuraman Krishnamoorthi. 2018. Quantizing deep convolutional networks for efficient inference: A whitepaper.CoRRabs/1806.08342 (2018)

    2018 arXiv

  15. [25]

    Peter Lindstrom. 2014. Fixed-Rate Compressed Floating-Point Arrays.IEEE Trans. Vis. Comput. Graph.20, 12 (2014), 2674–2683

    2014

  16. [26]

    Zhenhua Liu, Yunhe Wang, Kai Han, Wei Zhang, Siwei Ma, and Wen Gao. 2021. Post-Training Quantization for Vision Transformer. InNeurIPS. 28092–28103

    2021

  17. [27]

    Zhaojing Luo, Sai Ho Yeung, Meihui Zhang, Kaiping Zheng, Lei Zhu, Gang Chen, Feiyi Fan, Qian Lin, Kee Yuan Ngiam, and Beng Chin Ooi. 2021. MLCask: Efficient management of component evolution in collaborative data analytics pipelines. InICDE. 1655–1666

    2021

  18. [28]

    Maas, Raymond E

    Andrew L. Maas, Raymond E. Daly, Peter T. Pham, Dan Huang, Andrew Y. Ng, and Christopher Potts. 2011. Learning Word Vectors for Sentiment Analysis. In ACL-HLT. 142–150

    2011

  19. [29]

    Malkov and Dmitry A

    Yury A. Malkov and Dmitry A. Yashunin. 2020. Efficient and Robust Approximate Nearest Neighbor Search Using Hierarchical Navigable Small World Graphs.IEEE Trans. Pattern Anal. Mach. Intell.42, 4 (2020), 824–836

    2020

  20. [30]

    Davis, and Amol Deshpande

    Hui Miao, Ang Li, Larry S. Davis, and Amol Deshpande. 2017. Towards Unified Data and Lifecycle Management for Deep Learning. InICDE. 571–582

    2017

  21. [31]

    Markus Nagel, Rana Ali Amjad, Mart van Baalen, Christos Louizos, and Tij- men Blankevoort. 2020. Up or Down? Adaptive Rounding for Post-Training Quantization. InICML, Vol. 119. 7197–7206

    2020

  22. [32]

    2025.NeurStore Implementation

    NeurStore. 2025.NeurStore Implementation. https://github.com/neurdb/neurstore

    2025

  23. [33]

    Beng Chin Ooi, Shaofeng Cai, Gang Chen, Yanyan Shen, Kian-Lee Tan, Yuncheng Wu, Xiaokui Xiao, Naili Xing, Cong Yue, Lingze Zeng, et al. 2024. NeurDB: an AI-powered autonomous data system.Science China Information Sciences67, 10 (2024), 200901

    2024

  24. [34]

    Beng Chin Ooi, Kian-Lee Tan, Sheng Wang, Wei Wang, Qingchao Cai, Gang Chen, Jinyang Gao, Zhaojing Luo, Anthony KH Tung, Yuan Wang, et al. 2015. SINGA: A distributed deep learning platform. InProceedings of the 23rd ACM international conference on Multimedia. 685–688

    2015

  25. [35]

    Kwanghyun Park, Karla Saur, Dalitso Banda, Rathijit Sen, Matteo Interlandi, and Konstantinos Karanasos. 2022. End-to-end Optimization of Machine Learning Prediction Queries. InSIGMOD Conference. 587–601

    2022

  26. [36]

    Mark Raasveldt and Hannes Mühleisen. 2019. DuckDB: an Embeddable Analytical Database. InSIGMOD Conference, Peter A. Boncz, Stefan Manegold, Anastasia Ailamaki, Amol Deshpande, and Tim Kraska (Eds.). ACM, 1981–1984

    2019

  27. [37]

    Parikshit Ram and Kaushik Sinha. 2019. Revisiting kd-tree for Nearest Neighbor Search. InKDD. 1378–1388

    2019

  28. [38]

    Francisco Romero, Johann Hauswald, Aditi Partap, Daniel Kang, Matei Zaharia, and Christos Kozyrakis. 2022. Optimizing Video Analytics with Declarative Model Relationships.Proc. VLDB Endow.16, 3 (2022), 447–460

    2022

  29. [39]

    Ricardo Salazar-Díaz, Boris Glavic, and Tilmann Rabl. 2024. InferDB: In-Database Machine Learning Inference Using Indexes.Proc. VLDB Endow.17, 8 (2024), 1830– 1842

    2024

  30. [40]

    Robert Schulze, Tom Schreiber, Ilya Yatsishin, Ryadh Dahimene, and Alexey Milovidov. 2024. ClickHouse - Lightning Fast Analytics for Everyone.Proc. VLDB Endow.17, 12 (2024), 3731–3744. https://doi.org/10.14778/3685800.3685802

    2024

  31. [41]

    Zhaoyuan Su, Ammar Ahmed, Zirui Wang, Ali Anwar, and Yue Cheng. 2024. Everything You Always Wanted to Know About Storage Compressibility of Pre-Trained ML Models but Were Afraid to Ask.Proc. VLDB Endow.17, 8 (2024), 2036–2049

    2024

  32. [42]

    Manasi Vartak. 2017. MODELDB: A System for Machine Learning Model Man- agement. InCIDR

    2017

  33. [43]

    Mengzhao Wang, Xiaoliang Xu, Qiang Yue, and Yuxiang Wang. 2021. A Com- prehensive Survey and Experimental Comparison of Graph-Based Approximate Nearest Neighbor Search.Proc. VLDB Endow.14, 11 (2021), 1964–1978

    2021

  34. [44]

    Naili Xing, Shaofeng Cai, Gang Chen, Zhaojing Luo, Beng Chin Ooi, and Jian Pei. 2024. Database Native Model Selection: Harnessing Deep Neural Networks in Database Systems.Proc. VLDB Endow.17, 5 (2024), 1020–1033

    2024

  35. [45]

    Lijie Xu, Shuang Qiu, Binhang Yuan, Jiawei Jiang, Cédric Renggli, Shaoduo Gan, Kaan Kara, Guoliang Li, Ji Liu, Wentao Wu, Jieping Ye, and Ce Zhang. 2022. In- Database Machine Learning with CorgiPile: Stochastic Gradient Descent without Full Data Shuffle. InSIGMOD Conference. 1286–1300

    2022

  36. [46]

    Zhuangdi Xu, Gaurav Tarlok Kakkar, Joy Arulraj, and Umakishore Ramachan- dran. 2022. EVA: A Symbolic Approach to Accelerating Exploratory Video Analytics with Materialized Views. InSIGMOD Conference. 602–616

    2022

  37. [47]

    Ali Hadi Zadeh, Isak Edo, Omar Mohamed Awad, and Andreas Moshovos. 2020. GOBO: Quantizing Attention-Based NLP Models for Low Latency and Energy Efficient Inference. InMICRO. 811–824

    2020

  38. [48]

    Lingze Zeng, Naili Xing, Shaofeng Cai, Gang Chen, Beng Chin Ooi, Jian Pei, and Yuncheng Wu. 2024. Powering In-Database Dynamic Model Slicing for Structured Data Analytics.Proc. VLDB Endow.17, 13 (2024), 4813–4826

    2024

  39. [50]

    Chenyang Zhang, Junxiong Peng, Chen Xu, Quanqing Xu, and Chuanhui Yang

  40. [51]

    Ting Zhang, Chao Du, and Jingdong Wang. 2014. Composite Quantization for Approximate Nearest Neighbor Search. InICML, Vol. 32. 838–846

    2014

  41. [52]

    Zhanhao Zhao, Shaofeng Cai, Haotian Gao, Hexiang Pan, Siqi Xiang, Naili Xing, Gang Chen, Beng Chin Ooi, Yanyan Shen, Yuncheng Wu, and Meihui Zhang. 2025. NeurDB: On the Design and Implementation of an AI-powered Autonomous Database.CIDR(2025)

    2025

  42. [53]

    Lixi Zhou, Jiaqing Chen, Amitabh Das, Hong Min, Lei Yu, Ming Zhao, and Jia Zou. 2022. Serving Deep Learning Models with Deduplication from Relational Databases.Proc. VLDB Endow.15, 10 (2022), 2230–2243. 15

    2022

  43. [2024]

    InSIGMOD Conference Companion

    IMBridge: Impedance Mismatch Mitigation between Database Engine and Prediction Query Execution. InSIGMOD Conference Companion. ACM, 456–459

  44. [2025]

    ACM Manag

    Mitigating the Impedance Mismatch between Prediction Query Execution and Database Engine.Proc. ACM Manag. Data3, 3 (2025), 189:1–189:28. 14 NeurStore: Efficient In-database Deep Learning Model Management System

    2025

Pith tools

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