acceptodds
Under review as a conference paper at ICLR 2027

LoomKV: Structured Low-Rank KV Caches for Video LLMs

Abstract

Among the most accurate ways to compress a video language model’s KV cache, a low-rank factorization shared across a group of layers must first hold the very cache it compresses. We compute it per input during prefill, keeping a fixed-rank representation rather than a fixed fraction of tokens. Which structure to keep is itself a result: a matched-storage control rejected our first, grid-preserving Tucker design in favour of sharing across layers (47.97 against 59.12), and the grid does not pay for itself after that extraction either. The offline cross-layer factorization, however, consumes the completed prompt cache, which is exactly what cannot be held. LoomKV removes that dependence. As visual blocks arrive it maintains compact coefficients, a shared channel basis and the Gram matrix needed to refresh that basis, and a refresh from r + Sb rows is exact for the whole history the state represents, so the dense multi-layer cache is never materialized. On a 24 GB card the offline factorization fails at 128 frames and a chunked dense control at 160; LoomKV completes 224, per-session resident state is 5.7 to 7.7× smaller, and nine prefilled sessions stay resident against one. At a matched answer-time cache it outperforms InfiniPot-V by 7.46 points on Qwen2-VL and 13.56 on Qwen2.5-VL on MME-VideoOCR, stays within 3.6 points of the offline ceiling across three model families, and on long Video-MME is indistinguishable from dense while retaining 11.9% of the visual cache. Controlled ablations attribute the gain to cross-layer sharing; refresh frequency, coefficient transport and causal feedback have no additional cost this sample resolves. All primary comparisons are paired, and negative results are reported.

Primary area:
foundation or frontier models, including LLMs
Keywords:
KV cache compression, video language models, low-rank factorization, memory-efficient inference, long-context inference, prefill, multimodal large language models

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_LUdHOpenReview ↗
Rating
3
Confidence
3
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes LoomKV, an online low-rank KV cache compression method for Video LLMs. Unlike previous methods such as xKV, which require the full KV cache before compression, LoomKV constructs the compressed KV cache incrementally during prefill. The method combines cross-layer sharing with incremental SVD and Gram Matrix Refresh to update the low-rank representation without storing the full historical KV cache. Experiments show that LoomKV significantly reduces memory usage and supports longer video inputs while maintaining competitive accuracy under 8x compression. The paper also provides ablation studies on cross-layer sharing and refresh frequency. However, the method introduces additional prefill and decoding latency, and its algorithmic novelty is relatively limited compared with existing low-rank compression methods.

Critical strengths
  1. The method uses incremental SVD and Gram Matrix Refresh, with solid mathematical support. Simple and reasonable design.

  2. Good memory reduction without storing full KV cache. Also maintains good accuracy under high compression ratio.

Critical weaknesses
  1. Limited novelty. The method mainly combines cross-layer low-rank compression from xKV with existing incremental SVD techniques. The main algorithmic contribution is relatively limited.

  2. Efficiency concerns. The method introduces higher prefill and decoding latency (1.51x prefill time and around 30% decoding overhead). The paper also lacks real serving throughput experiments, so it is unclear whether the memory savings can bring practical benefits.

Questions for authors

No

1 comment

Response to Reviewer LUdH

Thank you for the review.

W1: limited novelty (xKV plus incremental SVD). The algebra is classical, and we say so (Sec. 2, Lemma 1); the contribution is not a new factorization. xKV horizontally concatenates every layer's completed cache and factorizes it. In the regime that motivates compression, that completed cache is exactly what cannot be held. Our contribution is removing that construction dependency: we build the cross-layer low-rank cache incrementally during chunked prefill, keeping a compact sufficient statistic (A, Q, G) and a periodic refresh that Lemma 1 makes exact for the represented history.

The empirical claim is specific to video caches. The frame×space×channel grid one would expect a video cache to reward does not pay for itself: three-mode Tucker scores 47.97 vs 59.12 for cross-layer, −11.15 [−15.64, −6.73], p<1e-3. Cross-layer redundancy is the structure worth keeping. Offline xKV is the ceiling we measure against, not a baseline. On one card, our gap to it on Qwen2-VL is −2.71 [−6.09, +0.66]. Under the in-process 24 GB allocator cap, offline xKV cannot form its own input at 128 frames, while LoomKV runs to 224.

W2: efficiency (1.51× prefill, ~30% slower decode) and no serving throughput. Both costs are stated in the paper.

  • Single-session decode. As in the paper's decode table (Qwen2-VL-7B, 23,040 visual tokens), dense takes 32.2 ms/token. LoomKV takes 41.8 ms with dense reconstruction (1.30×) and 53.5 ms with attention on the factors (1.66×). We make no per-request speed claim.
  • What we added on throughput. We added the same-device byte frontier (see GqWy, Q2) and a matched-cap aggregate decode throughput measurement. On Qwen2-VL-7B, one A6000, 256 frames, with a 48 GB cap:
    • LoomKV fits 41 sessions at 171.1–171.4 tok/s.
    • Dense fits 5 sessions at 79.1–79.3 tok/s.
    • That is 2.162× (timing range 2.160-2.164×), and a second run gives 2.163× (range 2.160-2.166×).
  • What the 2.16× means. The gain comes from capacity. At batch 1, LoomKV is still about 15% slower per step. This is decode-only, not a queued end-to-end serving study. Details are in our response to GqWy.
Reviewer_GqWyOpenReview ↗
Rating
2
Confidence
3
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

LoomKV makes xKV-style cross-layer low-rank KV caches constructible during causal blockwise prefill for video LLMs, rather than first materializing the full dense prompt cache. It appends block projections, maintains a Gram state, and periodically refreshes the low-rank basis. The paper evaluates Qwen2-VL, Qwen2.5-VL, and InternVL2.5 on video understanding tasks, reporting 5.7–7.7× resident-state reduction, support for more frames under an emulated 24 GB cap, and moderate prefill/decode overhead.

Critical strengths

Constructible low-memory low-rank caching is a meaningful target. The blockwise state update and refresh procedure address an important gap in offline low-rank compression: avoiding dense prompt-KV materialization during construction. Lemma 1 is also stated with an appropriately limited scope, namely exact refresh of the represented approximated state rather than exact recovery of the original dense history.

The empirical study is careful and transparent. The paper includes matched-element comparisons, width/refresh/transport controls, causal-feedback checks, uncertainty estimates, negative findings, and explicit discussion of underpowered analyses. This makes the technical tradeoffs more informative than a single best-configuration table would.

Critical weaknesses

The decisive quality–memory comparison is assembled under non-uniform settings. Table 1 largely matches retained elements and uses float32 LoomKV factors, while memory and width studies use deployed BF16 storage; several headline comparisons also cross hardware. The InternVL accuracy path uses a shim without the bounded-memory guarantee, while memory is measured on a different implementation. As a result, the paper does not yet establish one consistent quality, physical-byte, peak-memory, and device frontier.

The deployment advantage over practical alternatives remains uncertain. InfiniPot-V is the main bounded-memory competitor, while StreamKV is cited but not run. LoomKV reports 11.72 s ready-cache time versus 6.97 s for dense and 7.74 s for offline xKV at 64 frames, and dense reconstruction increases decode time from 32.2 to 41.8 ms/token. The new feasible-regime probe is only n=58 and has wide intervals, so the serving benefit beyond a single-process resident-cache proxy is not yet established.

Questions for authors

1.Please expand the related-work discussion to include EAKV (https://openreview.net/forum?id=wyT47sv2o8), MadaKV (https://arxiv.org/abs/2506.15724), Ada-KV (https://arxiv.org/abs/2407.11550), FastGen (https://openreview.net/forum?id=uNrFpDPMyo), MiKV (https://arxiv.org/abs/2402.18096). Please explain what LoomKV adds beyond these mechanisms. Where a method can be applied under the same bounded-prefill constraint, please add a matched physical-byte comparison.

2.Can you report one same-device, same-dtype frontier using actual GPU bytes for persistent cache, peak construction memory, and transient reconstruction workspace? Please include BF16 and INT8 factor variants, and clarify how the allocator-enforced 24 GB cap differs from a physical 24 GB GPU.

3.How sensitive is the method to the assumed total span length and ranks rK/rV chosen before processing? Please evaluate abrupt scene cuts, rapid subspace changes, and longer native-resolution inputs with tasks that demonstrably require the added frames, rather than only the small n=58 probe.

Can you compare directly with StreamKV and other bounded-memory baselines under identical memory caps? An end-to-end serving study with batching, queueing, decode/output lengths, and concurrent session counts would help determine whether the resident-state reduction offsets the observed prefill and reconstruction overhead.

5 comments

Response to Reviewer GqWy (1/5)

Thank you for a detailed review. Most of what you asked for is now measured rather than argued.

W1: "the decisive comparison is assembled under non-uniform settings (float32 vs BF16, cross-hardware, InternVL shim)."

  • Cross-hardware. We re-ran the Qwen2-VL LoomKV arm on the A6000, which already held every reference arm, with Table 1's settings and the deployed storage (BF16 coefficients, FP32 basis). An in-process dense check matched the stored A6000 dense results on 295/295 questions, so the reference arms were already same-card. A rule fixed before the run required every comparison to be replaced, whichever way it moved:

    comparisonsubmitted (cross-card)same card
    LoomKV − InfiniPot-V+7.46 [+2.23, +12.69]+8.16 [+3.08, +13.24], p=0.003, n=294
    LoomKV − xKV (W=1)+7.46 [+2.23, +12.69]+8.14 [+3.63, +12.64], p=0.001
    LoomKV − offline xKV (W=4)−3.39 [−6.78, −0.002]−2.71 [−6.09, +0.66], p=0.169
    LoomKV − dense−2.71 [−6.59, +1.16]−3.73 [−7.52, +0.06], p=0.080
    • Three comparisons moved in LoomKV's favour. The gap to dense widened by about one point: dense itself moved from 58.64 to 60.34, which is the hardware term Appendix G already disclosed.
    • The advantage over the bounded-memory baselines remains significant on one card. At n=295, the gaps to the uncompressed and offline ceilings are not resolved from zero.
    • We therefore withdraw the Sec. 5 sentence stating that both ceiling gaps exclude zero.
    • Table 1 and Appendix G will carry all four same-card numbers.
    • The InfiniPot-V cell pairs rows by video and question stem, which loses one pair to two questions sharing a stem prefix on one video (n=294); pairing by loader order instead gives n=295, +8.14 [+2.99, +13.28], p=0.003.
  • dtype (corrected). The same-card arm uses the deployed storage, BF16 coefficients with an FP32 basis and Gram matrix, which is the storage of every memory, byte and throughput number below; the same-card Table 1 is therefore one device and one storage policy. The submitted cross-card row used FP32 coefficients (165/295, 55.93%); against it, the same-card arm (167/295, 56.61%) differs by +0.68 pp [−1.81, +3.16], not resolved, with identical predictions on 278/295 questions, a difference that mixes the dtype and the card. The revision labels Table 1's row accordingly and reports this pair in its caption, and the Q2 frontier below reports BF16- and INT8-coefficient bytes (INT8: 1.26 bits per dense-cache element; its accuracy was measured on 395 MME-VideoOCR items at 64 frames).

  • InternVL shim. The submitted InternVL accuracy path uses a compatibility shim without the bounded-memory guarantee, while InternVL memory was measured on the guaranteed implementation. We have now also run accuracy on the guaranteed implementation, on a prespecified subset (the first 100 MME-VideoOCR items in archive order; one local video copy was unreadable, so n=99), in the same process as the shim on identical frames. The two paths produced identical letter logits on all 99 readable items (maximum absolute difference 0.0), and therefore identical predictions and accuracy (40/99), while the guaranteed path peaked at 18.68 GB. This prespecified subset tests agreement between the two implementations; the full-set result remains 206/394 (52.28%), measured through the shim.

(continued, 2/5)

Q2: one same-device, same-dtype GPU-byte frontier. Added. All numbers are actual bytes on one A6000; model weights and computation are BF16 in every arm, and "INT8" refers only to LoomKV's factor storage.

quantitydenseLoomKV BF16LoomKV INT8
persistent cache per session1260 MB157.4 MB (8.00×)99.2 MB (12.70×)
transient per decode step23.8 MB11.2 MB (attention on the factors)—

During construction, LoomKV's resident factors grow to the 157.4 MB above and its transient workspace peaks at 22.5 MB (one layer's reconstructed history), whereas dense and offline construction must hold the full multi-layer prompt KV, at least 1260 MB per session before any offline-SVD workspace, which we did not instrument separately. The INT8 decode-step transient was not measured separately. On the cap: it is an allocator ceiling enforced in-process, which is a fair single-process resident proxy but not a physical 24 GB device. The caption will say so.

Q1: related work + matched-byte comparison (EAKV, MadaKV, Ada-KV, FastGen, MiKV). We expand related work to separate LoomKV from the five methods. EAKV allocates per-head budgets from attention entropy and merges the remainder into contextual anchors; MadaKV is modality-aware eviction for multimodal long context; Ada-KV adaptively allocates an eviction budget across heads; FastGen profiles each head to pick a per-head discard policy; MiKV keeps important K/V at higher precision and quantizes the rest. Ada-KV, FastGen, MadaKV and MiKV compress a cache that has already been formed, so they do not meet our bounded-prefill constraint; EAKV is the one applicable bounded-prefill comparator, and it is the dimension LoomKV differs on — LoomKV builds a dense, cross-layer low-rank cache during chunked prefill and never materializes the full-prompt KV.

Because EAKV has no public code, we implemented its published core mechanisms (entropy head-allocation, fast-attack/slow-decay saliency, contextual anchors, center-of-mass positions) and call this EAKV-core; we do not claim it reproduces an unavailable reference. At a matched stored visual-K/V payload, LoomKV uses 12.5% of the dense cache and scores 167/295 (56.61%); EAKV-core at 12.6% physical (8.28% logical) scores 159/295 (53.90%). LoomKV − EAKV-core is +2.71 pp (95% paired-bootstrap CI [−2.0, +7.5], exact McNemar p=0.33; not significant at equal bytes). At matched logical entries instead (EAKV-core then costs ~1.51× the physical bytes, a padding overhead of our batched implementation, not intrinsic to EAKV), EAKV-core scores 158/295. InfiniPot-V, the same-family baseline already in the paper, scores 143/295. The two caches also differ in reuse: LoomKV's cache is query-agnostic and can be reused across questions on the same video, whereas our reimplementation of EAKV-core is question-conditioned and rebuilds its cache for each question.

Appendix ablation: made query-agnostic (the same information access as LoomKV and InfiniPot-V), EAKV-core scores 101/295 (34.24%); question-conditioned retrieval contributes substantially to EAKV-core's score (101/295 query-agnostic vs 159/295 question-conditioned).

(continued, 3/5)

W2 / Q4: bounded-memory baselines, StreamKV, and serving.

  • More eviction baselines at a matched cache. On MME-VideoOCR, at an answer-time cache matched by construction, we added two more eviction baselines: uniform and SWA. The three eviction methods derive the retained-token count from the same line of the baseline authors' code, and only the compression method changes. Everything runs on one A6000, using the same-card LoomKV arm from W1. On the same 295 questions, LoomKV beats:

    • uniform by +14.24 [+8.00, +20.47]
    • SWA by +15.93 [+9.66, +22.20]

    Both have McNemar p < 0.001. InfiniPot-V (+8.16, see W1) is the strongest of the three baselines. This agrees with a separate MVBench measurement on Qwen2-VL and Qwen2.5-VL, where it leads the other two by 6–8 pp.

  • StreamKV (supplementary, same-model comparison). StreamKV's public code supports LLaVA-OneVision only and uses a host-offload retrieval memory model (full local window GPU-resident, segment caches paged to host), different from our GPU-resident bounded cache, so we did not port it to Qwen2-VL. We instead ran a supplementary same-model comparison on LLaVA-OneVision-7B (299 aligned MME-VideoOCR questions; 64 frames, BF16, single-session A6000). LoomKV scored 142/299 (47.49%) and StreamKV 139/299 (46.49%); exact paired McNemar p=0.78 does not establish a difference, and dense scored 163/299 (54.52%), leaving both compressors 7-8 pp below dense. On the same card, LoomKV and StreamKV used 0.090 vs 0.787 GB of persistent GPU-resident KV tensor payload (8.75x), computed from logged resident lengths and exact tensor shapes (StreamKV range 0.739-0.864 GB). Their incremental end-to-end allocated peaks were 0.464 vs 10.65 GB (22.9x), including transient attention workspace (StreamKV range 4.97-16.57 GB). Host-offloaded KV was 0 vs 0.48 GB. Under StreamKV's configured n_local~15000 the 64-frame context stays resident and only segment summaries offload; n_local is a configuration choice, not an algorithmic lower bound. Same-cap concurrency, now measured: on the same model and card, we retained sessions until the first OOM under an in-process cap that includes the model weights, one fresh process per run. At a 24 GB cap, across three session orders, LoomKV retained 34 sessions in every run, whereas StreamKV retained 0, 0 and 1; at 40 GB, in the single tested order, LoomKV retained 179 sessions and StreamKV 4 (44.8x). Every retained session subsequently reproduced its original answer, and whenever at least one session fit, the first session reproduced that method's earlier single-session prediction. The observed limits coincide with StreamKV's larger construction transient (9.72 GB above the weights at the median, 11.98 GB at the maximum, versus 4.08 GB for LoomKV) and its 3.76–3.80 GB of total allocator-resident state per retained session, versus a median of 0.106 GB for LoomKV; these totals are broader than the 0.787 and 0.090 GB KV tensor payloads above. StreamKV's retained state included 0.791 GB of local KV and 2.881 GB of attention workspace, with smaller components; releasing the workspace between sessions did not change the counts. The cap included model weights (16.06 GB for LoomKV, 16.53 GB for StreamKV); this 0.47 GB difference does not explain the 24 GB result, since 16.06 + 9.72 = 25.78 GB already exceeds the cap. This is a single-process measurement on LLaVA-OV with sessions answered one at a time, not a queued serving study.

  • LongVU, MadaKV. For EAKV we report the EAKV-core reimplementation and matched-byte comparison in our reply to Q1 above; we found no public code for MadaKV. LongVU is a separately trained model with its own token reduction, not a cache policy we can apply to Qwen2-VL at a matched cache. We state this as scope.

Reviewer_xKUhOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper builds a cross-layer low-rank KV cache incrementally during chunked video prefill, avoiding the need to store the full cache before compression. Experiments show lower peak and resident memory usage at the cost of increased inference latency.

Critical strengths
  1. The method addresses a clear memory bottleneck during cache construction. Section 3 uses compact statistics to update the cross-layer representation without materializing the full cache across layers.
  2. An uncompressed chunked control supports the memory gains: under a 24 GB cap, the control fails at 160 frames, while LoomKV completes 224 frames (Table 2). Per-session resident state is reduced by a factor of 5.7–7.7 (Table 3).
Critical weaknesses
  1. The magnitude of the improvement over the baseline needs confirmation. Table 1 reports higher accuracy for LoomKV than InfiniPot-V, but the two methods were evaluated on different GPUs. Appendix G also shows that hardware differences can change some predictions. Repeating the comparison on the same GPU would help establish the size of the improvement.
  2. Evidence on long-video accuracy remains limited. The paper demonstrates memory savings and the ability to process longer videos, but accuracy retention in this regime is less clear. Appendix B covers only 58 questions, while the long-video experiments in Table 8 use a lower resolution. More evidence is needed for long, high-resolution videos.
  3. Figure 1 should not be drawn using AI. In its current form, I find it cluttered, with an unclear structure and no clear visual hierarchy.
Questions for authors
  1. Baseline comparison: The two methods in Table 1 were evaluated on different GPUs. Could you repeat the comparison on the same GPU to check whether LoomKV's accuracy advantage over InfiniPot-V remains close to 7.46 percentage points?
  2. Long-video accuracy: Appendix B evaluated only 58 questions due to time constraints. Are there additional results under the same conditions—224 frames at native resolution—that could provide a more precise estimate of the accuracy change after compression?
  3. Data clarification: How many questions were evaluated in each row of Table 10? If all rows use 306 questions, how were the accuracies of 57.22% and 56.46% calculated?
1 comment

Response to Reviewer xKUh

Thank you. Each request is answered below.

Q1: same-GPU repeat of the 7.46 pp Table 1 advantage. Done. On the A6000 alone, the Qwen2-VL advantage over InfiniPot-V is +8.16 [+3.08, +13.24], p=0.003, n=294 (pairing by loader order instead: n=295, +8.14), up from +7.46 when measured across cards. The advantage grew slightly and the lower bound rose from +2.23 to +3.08. Table 1 and Appendix G will carry the same-card numbers.

Q2: long-video accuracy at 224 frames and native resolution, with more than 58 questions. Done, at n=150.

  • A sampling issue we found and fixed. The original probe drew frames by linspace independently for each frame count. As a result, arms at different counts saw nearly disjoint frames (64 and 224 frames shared 3.1% of indices), so the across-row contrasts mixed frame count with frame identity. We re-measured on a nested ladder, where F56 = F224[::4] and F112 = F224[::2], over 150 questions. The submitted 58 are a contiguous prefix of these 150 in a frozen order, so they were not a selected subset.

  • Results on the nested ladder. LoomKV and dense run in the same process on identical frames. The dense predictions reproduce a separately run dense ladder on 150/150 questions at every frame count.

    framesLoomKVdenseΔ (pp)95% CI
    5654.6752.67+2.00[−2.32, +6.32]
    11254.6752.67+2.00[−1.91, +5.91]
    22455.3352.00+3.33[−0.97, +7.63]
  • What we conclude. At 224 frames and native resolution we resolve no difference between compressed and uncompressed (95% CI [−0.97, +7.63]), and we claim no gain. Neither curve shows a resolved frame-count effect. On this benchmark, shifting which frames are sampled at a fixed 224 frames moves dense accuracy by −4.67 pp, more than doubling the frame count does. We will replace the affected text and state the confound wherever the original numbers appear.

Q3: how many questions per row of Table 10, and how 57.22% and 56.46% were computed. You are right that they are not on 306 questions. Each sweep row is paired against the every-4 arm under its own decomposition route, and the two routes have different common sets:

  • eigh pair: n=306, with 57.19% = 175/306 and 55.88% = 171/306
  • gesvd pair: n=395, with 57.22% = 226/395 and 56.46% = 223/395

The Δ column and McNemar p were each computed on the row's own n and are unaffected; only the caption's single "306" was wrong. We will correct the caption to give the per-route n. Thank you for catching this.

Presentation: Figure 1 is AI-drawn. Agreed, and done. The top schematic is redrawn as a hand-authored vector (TikZ) figure with an explicit left-to-right construction flow, and the AI-generated image is removed. The labelled three-panel comparison below it was already LaTeX and stays.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Response to All Reviewers

General Response to All Reviewers

We thank all three reviewers. The reviews converge on one shared concern — that the quality, memory, and device comparisons were assembled under non-uniform settings (cross-GPU, mixed dtype), and that the practical serving benefit was not yet established. We address the first directly and add a decode-capacity measurement for the second; detailed per-reviewer replies follow in each thread.

One same-card comparison and actual-byte accounting.

  • Table 1 is re-run on a single A6000 that already held every reference arm (an in-process dense check matches the stored dense on 295/295). The Qwen2-VL advantage over InfiniPot-V is +8.16 [+3.08, +13.24], p=0.003 (was +7.46 cross-card); three of four comparisons moved in LoomKV's favour, and we withdraw the one sentence that claimed both ceiling gaps exclude zero.
  • Same-device GPU-byte accounting on one A6000: persistent cache for dense, LoomKV with BF16 factors and with INT8 factor storage, plus LoomKV's construction and per-decode-step workspace, in actual bytes.

Bounded-prefill comparators the reviewers named. A matched-byte comparison to an EAKV-core reimplementation (LoomKV 167/295 vs 159/295, p=0.33 — no established difference at equal bytes), and a supplementary same-model StreamKV comparison on LLaVA-OneVision (an observed 1.0 pp accuracy difference that is not statistically resolved, p=0.78; 8.75× less persistent GPU-resident KV payload and no host offload; at the same 40 GB GPU cap, 179 vs 4 concurrent sessions).

Decode capacity. Under a matched 48 GB cap, batched decode reaches 2.16× dense aggregate throughput (41 vs 5 resident sessions). This is a decode-only capacity result, not a queued end-to-end serving study or a per-request speedup.

Scope and honesty. The feasible-regime probe is extended to n=150 with a corrected nested frame ladder; Figure 1 is redrawn by hand; all negative results and underpowered analyses are retained.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.