{"id":"24ede598-f282-4d33-9d4d-434e8299b15d","arxiv_id":"2509.03228","paper_version":2,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":3,"one_line_summary":"A database model-management system that deduplicates tensors across models and uses delta quantization to cut storage and speed loading.","lead":"NeurStore is a database extension that stores deep learning models as shared tensor pieces plus small differences, cutting storage while keeping models ready for fast loading. It targets databases that run AI analytics over many fine-tuned models, where the same base layers appear over and over.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The storage advantage rests on dense cross-model tensor similarity; on diverse, independently trained model collections the residual-quantization floor plus HNSW overhead may erase the advantage over ELF.","rationale":"The reader's conditional verdict already identifies the workload dependence as the weakest assumption. My reading sharpens that concern: it is not merely that the test collection is favorable, but that the algorithm's own residual-quantization floor is close to or below the ELF baseline. For a tensor that becomes a new base, the cost is the 8-bit base plus a dynamically sized delta to its own quantized version. With the default precision tolerance, this floor is about 23-24 bits per value for normalized weights, giving roughly 1.3-1.4x compression before HNSW overhead; for tensors with wider value ranges the floor drops below ELF's 1.32x. Therefore the reported 1.38x aggregate advantage depends on most tensors being matched to shared bases, which the evaluation's fine-tuned HuggingFace workload guarantees. This is not an internal inconsistency or a fraudulent claim; the system does what it says on the tested workload. It is a scope limitation. The missing evidence is a controlled comparison on a heterogeneous, independently trained model collection and a storage breakdown separating HNSW index cost from delta cost. Because that evidence is absent, the current conditional verdict is appropriate. The 'direct computation on compressed tensors' phrasing in the abstract is also overbroad relative to Algorithm 2, which inserts DequantizeLinear and Add nodes before each consuming operation, but that is a presentation issue rather than the main load-bearing risk.","tokens_in":22997,"tokens_out":9528,"duration_ms":92409,"concrete_test":"Construct two matched 800-model collections with identical total size: (A) fine-tuned descendants of a few shared checkpoints, as in the paper; (B) independently trained models from random initialization across diverse architectures, with no shared lineage. Run NeurStore with default tau=0.16 and p=5.96e-8, plus ELF, on both collections. Report total storage, compression ratio, HNSW index size, delta storage, and per-tensor delta-range distribution. If on collection B NeurStore's compression ratio is at or below ELF's 1.32x, or its total storage exceeds ELF's, the paper's central storage claim is specific to fine-tuned model families and should be restated as such.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The load-bearing premise is that most tensors in a stored collection find an existing base tensor within tau=0.16, so that the dominant cost is a small quantized delta rather than a new 8-bit base plus its self-reconstruction delta. The paper's own arithmetic (Section 4.2, Eq. 2) shows what happens when this premise fails. For a tensor with value range R that becomes a new base, its delta to its own 8-bit quantized version has range about R/256; with default p=2^-24, Eq. (2) gives n_bit about 15 + ceil(log2 R) bits for R in [1,2), so the tensor costs roughly 8 + 15-21 bits per value, i.e., a compression of about 1.1-1.39x before any HNSW vertex, edge, or metadata overhead. ELF reaches 1.32x on the same corpus with no index. Thus NeurStore's reported 1.38x (Section 6.3.1) is only meaningful if deduplication is dense. The evaluation maximizes this density: the three analytics workloads are fine-tuned DistilBERT/ViT/MLP derivatives (Section 6.1.1), the threshold study uses 50 fine-tuned BERT models (Section 6.4.1), and the 800-model HuggingFace corpus is not characterized by lineage, architecture diversity, or per-tensor similarity statistics. No HNSW recall or index-versus-delta storage breakdown is reported for the full corpus. If a deployment stores many independently trained, architecturally diverse models, most tensors may become new bases; NeurStore's compression then falls to the residual floor, and HNSW overhead can make it worse than ELF. The central storage claim is therefore workload-bound rather than a property of the compression scheme alone.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","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.","tokens_in":23278,"tokens_out":7364,"duration_ms":62346,"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":[{"comment":"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.","section":"Section 4.3.2, Algorithm 2"},{"comment":"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.","section":"Sections 6.1.1, 6.3.1, and 6.4.1"},{"comment":"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.","section":"Sections 4.1 and 4.2"},{"comment":"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.","section":"Section 6.4.1"}],"minor_comments":[{"comment":"The system name is written 'NeuralStore' in the table, which is inconsistent with 'NeurStore' elsewhere in the paper.","section":"Table 2"},{"comment":"Equation (2) is undefined when delta_max equals delta_min; please add a degenerate-case rule for zero-range delta tensors.","section":"Equation (2)"},{"comment":"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.","section":"Section 4.2"},{"comment":"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.","section":"Section 6.4.2"}],"recommendation":"major_revision","confidential_remarks":"This is a solid systems paper with a substantial implementation, and the core delta-deduplication idea is reasonable for model repositories dominated by fine-tuned variants. The main risk is that the evaluation is heavily tilted toward such collections without quantifying the dependency. The reported compression advantage over ELF is small (1.38x versus 1.32x) and could vanish in less favorable workloads, so the authors should be required to disclose the dedup density and index overhead. No concerns about citation practice or novelty disclosure; the related-work discussion is adequate."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"NeurStore is worth a serious look. The authors built an actual system, not a simulation: a PostgreSQL extension, DuckDB and ClickHouse ports, 5000 lines of C/C++, and the code is public. The core idea—tensor-level deduplication via HNSW with adaptive delta quantization—is new in the model-management context, and the engineering is substantial. On the tested workloads they get 1.38x compression versus 1.32x for ELF, up to 2.4x faster loading with partial-bit deltas, and halved memory during load. Those numbers are real on the experiments they ran.\n\nThe soft spots are real but addressable. First, the abstract and Section 4.3 say \"direct computation on compressed tensors,\" but Algorithm 2 inserts DequantizeLinear and Add nodes before the compute graph runs. That is lazy reconstruction, not compute-on-compressed-data. The paper should say \"on-demand decompression,\" which is still a useful mechanism but not the advertised one. Second, the storage advantage is workload-bound. The 800-model corpus is dominated by fine-tuned derivatives of a few base checkpoints, and the paper does not report lineage, architecture diversity, or per-tensor similarity statistics. The stress-test analysis checks out: for a tensor that becomes a new base, the delta to its own 8-bit quantized version needs roughly 15–21 bits per value plus the 8-bit base, so the per-tensor compression is about 1.1–1.39x before HNSW overhead. ELF already gets 1.32x with no index. On a heterogeneous collection with many independent base tensors, NeurStore could fall to the residual floor and the HNSW overhead could erase its advantage. The paper's own Eq. (2) makes this clear, so it is not a hidden contradiction, but the claims in the abstract are too strong without qualification. Third, the evaluation has no error bars, and HNSW recall and index-size-versus-delta-storage breakdown are missing. Those are easy fixes.\n\nThe math in Section 4.2 is correct, the implementation is substantial, and the baselines are handled fairly—they reimplemented ELF and made it open. The threshold tuning on a BERT subset is standard parameter selection, not curve fitting. This is honest progress in a niche subfield, not a breakthrough. The paper deserves a rigorous peer review; the authors need to fix the overclaim about direct computation and add experiments on a truly diverse model collection, reporting similarity density and HNSW overhead. I would send it to a competent referee and ask for a major revision, not a desk reject.","headline":"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.","tokens_in":23913,"tokens_out":2068,"would_cite":true,"duration_ms":20995,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"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.","keywords":["in-database analytics","deep learning model management","tensor-level deduplication","delta quantization","HNSW index","model loading","compression-aware inference","storage engine"],"falsifier":"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.","tokens_in":22723,"feed_emoji":"🗜️","tokens_out":10857,"duration_ms":92626,"temperature":0.7,"pith_summary":"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.","feed_headline":"Tensor sharing shrinks 800 AI models from 361 GB to 261 GB","feed_subtitle":"Fine-tuned models share most weights; storing only the differences lets databases hold many models at near-original accuracy.","key_machinery":"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.","core_discovery":"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.","pith_inferences":["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."],"forward_implications":["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."],"supporting_citations":[{"why":"Supplies the graph-based approximate nearest-neighbor search that NeurStore adapts into a per-shape tensor index. Removing it removes the deduplication mechanism.","marker":"[29]"},{"why":"Defines the per-model compression baseline whose roughly 1.33x ceiling motivates cross-model tensor deduplication; NeurStore's 1.38x result is measured against it.","marker":"[41]"},{"why":"Earlier model-management system that stores differences between models; NeurStore generalizes this from pairwise model lineage to tensor-level similarity across a collection.","marker":"[30]"},{"why":"In-database baseline that stores each model as a serialized blob; this is the storage convention NeurStore replaces with tensor pages.","marker":"[7]"},{"why":"Floating-point array compressor used as a lossy baseline; its weaker result on model weights motivates delta quantization rather than generic float compression.","marker":"[25]"},{"why":"General-purpose lossless compressor used as a baseline; shows that exact-duplicate removal alone misses the redundancy across fine-tuned weights.","marker":"[8]"}],"fun_headline_variants":["DB stores 800 AI models 28% smaller via tensor deltas","NeurStore: delta tensors cut model storage to 72%","In-database AI: 800 models, 361GB->261GB via shared tensors","Tensor-level dedup packs 800 models into 261GB","NeurStore: fine-grained model storage with HNSW-indexed tensors"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"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.","fun_headline_variants_meta":{"raw":{"variants":["DB stores 800 AI models 28% smaller via tensor deltas","NeurStore: delta tensors cut model storage to 72%","In-database AI: 800 models, 361GB->261GB via shared tensors","Tensor-level dedup packs 800 models into 261GB","NeurStore: fine-grained model storage with HNSW-indexed tensors"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000145,"raw_usage":{"total_tokens":1196,"prompt_tokens":978,"completion_tokens":218,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":594,"completion_tokens_details":{"reasoning_tokens":117}},"tokens_in":594,"tokens_out":218,"duration_ms":2578,"temperature":1.0,"reasoning_tokens":117,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-15T16:33:18.850352+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"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.","supporting_citations":[{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Defines the per-model compression baseline whose roughly 1.33x ceiling motivates cross-model tensor deduplication; NeurStore's 1.38x result is measured against it."},{"cited_title":"Davis, and Amol Deshpande","cited_arxiv_id":null,"evidence_quote":"Earlier model-management system that stores differences between models; NeurStore generalizes this from pairwise model lineage to tensor-level similarity across a collection."},{"cited_title":"PostgresML","cited_arxiv_id":null,"evidence_quote":"In-database baseline that stores each model as a serialized blob; this is the storage convention NeurStore replaces with tensor pages."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Floating-point array compressor used as a lossy baseline; its weaker result on model weights motivates delta quantization rather than generic float compression."},{"cited_title":"Zstandard","cited_arxiv_id":null,"evidence_quote":"General-purpose lossless compressor used as a baseline; shows that exact-duplicate removal alone misses the redundancy across fine-tuned weights."}],"review_version":2}