acceptodds
Under review as a conference paper at ICLR 2027

Temporal Delta Activation Sparsity for Diffusion Language Model

Abstract

Diffusion language models repeatedly process a sequence to generate text, making inference expensive. Existing activation-sparsity methods reduce this inference cost by discarding small activations. We instead exploit the fact that activations often change little between denoising steps. Thus, we propose Temporal Delta Sparsity (TDS), a training-free method that updates each linear layer using the selected changes to a stored reference input. A shared budget across tokens and channels assigns computation to the changes with the largest weight-informed scores. We show that the accumulator remains consistent with its reference in exact arithmetic and that this selection minimises a one-step output-error bound. Moreover, unprocessed changes remain in the residual for later steps. On GSM8K, MATH500, HumanEval and MBPP, TDS skips – of linear-layer multiply–accumulates. Its average score is versus for dense LLaDA-8B, and versus for dense Dream-7B. On the separate GSM8K evaluation, a whole-row variant achieves and end-to-end speedups, respectively, with equal or higher observed accuracy.

Primary area:
generative models
Keywords:
Diffusion Language Model, Activation Sparsity, Inference Acceleration

Reviews

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

This paper proposes Temporal Delta Sparsity (TDS), a training-free inference acceleration method for diffusion language models. Rather than sparsifying activation magnitudes, TDS maintains reference activations and incrementally updates their most influential temporal differences. A weight-informed selection criterion allocates computation across tokens and channels, while an adaptive threshold controls sparsity over denoising steps. The paper establishes accumulator consistency and one-step error-bound minimization. Experiments on LLaDA-8B and Dream-7B show approximately 89% linear-layer MAC savings with near-dense average benchmark performance. Structured implementations additionally achieve 1.46–1.90× end-to-end speedups on a GSM8K subset.

Critical strengths
  • Strong empirical motivation for temporal sparsity. Figure 1 demonstrates substantially lower output approximation errors when sparsifying temporal changes rather than activation magnitudes.

  • Practical acceleration. Beyond MAC accounting, the paper demonstrates measurable end-to-end acceleration onLLaDA and Dream.

Critical weaknesses
  • The last-refresh reference and sparse output-update mechanism follow Delta Networks [1], while Eventful Transformers [2] and Chipmunk [3] establish related selective temporal recomputation in Transformers and diffusion models. WINA [4] supplies the weight-informed scoring principle. The conceptual contribution of global token–channel allocation requires clearer differentiation.
  • The adaptive controller fixes α=0.4\alpha=0.4 and γ=0.7\gamma=0.7. Their influence on threshold dynamics and the robustness of the reported accuracy–compute trade-off requires ablations.
  • The strongest accuracy–sparsity results come from unstructured TDS, whereas measured speedups rely on structured variants. At 10% density, row selection underperforms unstructured TDS by 1.9 and 3.5 average points on LLaDA and Dream.
  • The adaptive controller uses more MACs than fixed-budget selection at equal target density. As acknowledged by the authors, these comparisons do not isolate the benefits of adaptive allocation at matched realised compute.
  • Evaluation focuses on one-token-per-step decoding. The two-token experiment reports 79.3% accuracy for fixed-budget TDS versus 84.0% for dense decoding at approximately 89% sparsity, leaving its effectiveness under more parallel decoding insufficiently characterized.

[1] D. Neil et al., “Delta Networks for Optimized Recurrent Network Computation”.

[2] M. Dutson et al., “Eventful Transformers: Leveraging Temporal Redundancy in Vision Transformers”.

[3] A. Silveria et al., “Chipmunk: Training-Free Acceleration of Diffusion Transformers with Dynamic Column-Sparse Deltas”.

[4] S. Chen et al., “WINA: Weight Informed Neuron Activation for Accelerating Large Language Model Inference”.

Questions for authors
  • Could the authors provide end-to-end accuracy–latency trade-offs for TDS-row and TDS-chunk on mathematical reasoning and code-generation benchmarks beyond the 200-example GSM8K subset?
  • How do end-to-end latency, additional reference-state memory, and accuracy scale with larger batch sizes and longer real generation contexts?
1 comment

Thank you for the precise review.

1. What is new (W1)

We take the delta update from Delta Networks, the score from WINA (Sec. 3.2, Remark 1) and the chunk layout from Chipmunk; our row variant is close to Eventful Transformers' token gating, which we do not claim. Our contribution is a study of how to allocate delta computation in masked DLMs, with GPU variants. Each row swaps one choice inside TDS for the closest prior rule (GSM8K dev, ρ = 0.10 / 0.05; dense: LLaDA 81.6, Dream 87.9):

Choice (closest prior work)LLaDADream
Per-token budget (WINA)53.1 / 8.63.9 / 1.2
Whole tokens (Eventful)84.4 / 82.086.3 / 80.5
Tokens × channels84.8 / 82.484.0 / 74.6
Contiguous 64-token chunks (Chipmunk-style)*77.7 / 28.531.6 / 0.8
Re-sorted 64-token chunks (ours)*80.9 / 76.676.6 / 15.6

Fixed per-step budget; *with controller. A zero reference gives 0.0% (LLaDA) and 0.4% (Dream).

  • Sharing the budget across tokens is decisive. The new token is 0.3% of positions but takes ~10× that share (LLaDA, Fig. 2b), so per-token budgets fail.
  • Re-sorting chunks by change each step is what makes chunked kernels usable.
  • Channels within tokens are not cleanly separated. On dev they tie whole tokens on LLaDA and trail on Dream. On the four test tasks, default TDS beats rows by 1.9 / 3.5 points at ρ = 0.1 (your W3 gap) and 5.1 / 6.1 at ρ = 0.05, winning 14 of 16 cells (Table 1), but it also uses the controller, so this gap mixes both. We will say so.

2. Controller hyperparameters (W2)

  • α weights the current density against the running mean; γ bounds the threshold change to 0.38–2.64× per step (Eq. 6).
  • The row variant behind our headline speedups (1.90× / 1.46×) has no controller (fixed ρn rows, App. D).
  • Without the controller (fixed budget, no α, γ), dev accuracy at ρ = 0.1 stays within the 2–2.5-point standard error (84.4 vs 84.8; 86.3 vs 84.0). At ρ = 0.05 the controller adds 1.6 / 7.0 points, with more MACs.

There is no α–γ sweep; we will state this as a limitation.

3. Structured vs unstructured (W3)

Agreed. The abstract will pair the row variant's speed with its own accuracy and drop "equal or higher accuracy": 89% sparsity, 45.9 vs 47.4 (LLaDA) and 56.3 vs 60.6 (Dream) on the four-task mean, and 1.90× / 1.46× end to end on 200 GSM8K test problems at batch 1. On the four-task mean it beats all six baselines on Dream (best: top-p, 54.8 at 21% sparsity) and is 0.6 / 0.2 points below TEAL (50%) / top-p (17%) on LLaDA.

4. Controller at matched compute (W4)

Agreed for equal target density, but Table 8 allows matched comparisons. At equal accuracy (82.4%) the controller needs about 18% fewer MACs (97.2% vs 96.6% sparsity); at 97.8% vs 97.6% it scores 82.4% vs 77.7%. Up to 97.6%, every fixed-budget point is matched or beaten by a controller point with at least as much sparsity. So the controller is never worse there, but beyond one standard error only near 98%. We will state exactly this.

5. Parallel decoding (W5)

The evidence is one point: 79.3% for TDS vs 84.0% for dense, both at two tokens per step (LLaDA dev, 89% sparsity, fixed budget). Prop. 3 suggests why: with a fixed threshold, refresh work is bounded by total activation change, which k tokens per step pack into about k times fewer steps, so per-step work would grow with k. TDS suits decoders that commit few tokens per step; the abstract and conclusion will state the evaluated setting (answers up to 256 tokens, blocks of 32, one token per step, runtime at batch 1).

Questions

Q1. Row accuracy on all four tasks is in Table 1: ρ = 0.1 gives 45.9 / 56.3 (four tasks) at 1.90× / 1.46× (GSM8K-200); ρ = 0.05 gives 41.7 / 48.7 for only 1.99× on LLaDA, so ρ = 0.1 is the operating point. Row per-step work depends only on n and ρ, and our sequences have n ≈ 350–440 (Sec. 3.2), so per-step speedups should carry over (inferred, not timed). Chunk results beyond GSM8K are not in the paper.

Q2. Memory (Sec. 4.4 formula, public configs): LLaDA 7.3 MB per token (row 4.5 MB), so 3.8 GB (2.3 GB) per sequence at n = 512 and 7.5 GB (4.6 GB) at n = 1024, linear in batch; Dream is similar. Beside 16 GB of weights and ~2 GB of activations, about six row sequences of length 512 fit on a 32 GB GPU, so TDS targets small-batch latency. Latency: per-step row speedup at ρ = 0.1 grows from n = 512 to 1024 (LLaDA 1.98→2.23×, Dream 1.71→2.33×; synthetic inputs, Fig. 3). Accuracy: reference, budget and threshold are per sequence, so batching changes only BF16 rounding, which already flips the correctness of 5–6.5% of dense answers (App. C.1). On LLaDA the error stays roughly flat over 256 teacher-forced steps (Fig. 2a). Not measured: free-running behaviour beyond 256 tokens, and runtime and peak memory at batch > 1.

We hope these answers address your concerns.

Reviewer_aLCWOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper proposes Temporal Delta Sparsity (TDS), a method that updates cached outputs in linear attention layers with weight-informed activation differences, motivated by the observation that diffusion language models suffer from repeated computation with multiple denoising steps. TDS achieves better performance on LLaDA-8B and Dream-7B with improvement on the inference speed.

Critical strengths

Motivation

  • The paper observes that significant temporal redundancy in dLLMs and shares an insight that temporal differences are more consistent with sparsification than original activations. This insight provides an interesting foundation for TDS.

Method

  • TDS is simple and is training free. The empirical results also support its claims.
Critical weaknesses
  • It might be better if the authors can differentiate TDS more clearly with some previous works such as Chipmunk. The weight-informed selection seems to have an overlap with it.
  • It seems weird to me that the core experiments rely on a one-token-per-step basis during the inference. Parallel decoding is a critical advantage of dLLMs but the paper seems to choose effectiveness over dLLM's parallel decoding nature.
Questions for authors

N/A

1 comment

Thank you for the focused review. We answer point 1 with a closer comparison and existing ablations. Point 2 is partly a limitation, which we state plainly.

1. How TDS differs from Chipmunk and other prior work

Both TDS and Chipmunk reuse cached activations and recompute what changed. We credit Chipmunk for column-sparse deltas in which a chunk of tokens shares selected channels; our chunk variant follows this (Sec. 2.2, 4.4).

ChipmunkTDS
SettingImage/video diffusion transformers: every latent token is updated each stepMasked DLMs: only newly committed tokens change at the input (one per step here)
What is sparsifiedMLP hidden neurons; attention keys/valuesInput entries of all four linear operators
Selection scoreActivation change or attention mass; no weight normsChange × weight-column norm
BudgetFixed top-k per token chunkOne threshold per operator over all tokens × channels (row variant: top ρn tokens)
Token groupingStatic voxel orderRe-sorted by change at every step (chunk variant)
Dense stepsPeriodicFirst step only

Weight norms are not our main difference. Chipmunk does not use them; our score follows WINA (Remark 1), applied to the change. Their effect is small and mixed in sign: +1.2 / +1.5 points on LLaDA and −3.1 / +1.6 on Dream at ρ = 0.1 / 0.05 (Tables 3, 7). We will credit weighting to WINA in Sec. 2.2 and 4.1.

What matters in DLMs (GSM8K dev accuracy, LLaDA / Dream; dense 81.6 / 87.9; ρ = 0.1 unless noted):

  • A temporal reference (shared with delta networks). With a zero reference: 0.0 / 0.4%.
  • One budget shared across tokens (new vs Chipmunk). The newly decoded token is about 0.3% of positions but carries 12–23% of the squared activation change (Fig. 1c) and gets about ten times its share of the budget (LLaDA, Fig. 2b). A per-token budget, our closest test of a fixed per-group budget, gives 53.1 / 3.9% vs 84.8 / 84.0% (Tables 3a–b, 7a–b); we did not run Chipmunk's per-chunk top-k. Our row variant shares the budget over whole tokens (84.4 / 86.3%), close to Eventful Transformers' token gating, which we do not claim.
  • Per-step sorting (new vs Chipmunk). At the same chunk size (64 tokens, with control), sorting by change lifts LLaDA from 77.7 to 80.9% (ρ = 0.1) and from 28.5 to 76.6% (ρ = 0.05), and Dream from 31.6 to 76.6% and from 0.8 to 15.6%, still a failure at ρ = 0.05 (Tables 3c, 7c).

DLM caches (dLLM-Cache, Fast-dLLM) reuse cached token features or KV states between refreshes; TDS selects entries in every linear layer at every step. We will add this table and summary to the paper (in the appendix if space requires).

2. One token per step

We agree that parallel decoding is a key strength of DLMs. TDS targets decoding that commits one or a few tokens per step, and we will say so explicitly.

  • Why this setting. We follow LLaDA's recommended protocol (as many sampling steps as answer tokens), and all baselines use it. It is a protocol choice, not an accuracy requirement: on our dev split, two-token dense decoding scores 84.0% vs 81.6% for one token (within noise).
  • Per-pass speed is unchanged at a fixed ρ. The row kernel refreshes a fixed ρn rows per pass, however many tokens the pass commits (App. D; LLaDA: 1.98× at n = 512, ρ = 0.1, Table 4). Keeping accuracy at larger k needs a larger ρ, which is slower (1.65× at ρ = 0.2), and we have no row-variant accuracy for k > 1.
  • Accuracy is the cost. Committing k tokens puts more change into each pass. Prop. 3 (fixed threshold) bounds refresh work by the total activation change, not the number of passes, which suggests the per-pass budget must grow with k. Our two-token test kept the budget fixed (89% sparsity) and scored 79.3% for TDS vs 84.0% for dense, both at two tokens per step (LLaDA dev).

So TDS and parallel decoding exploit the same redundancy between passes, and their gains partly overlap. The abstract and conclusion will state the evaluated setting (answers up to 256 tokens, blocks of 32, one token per step, runtime at batch 1), and Sec. 5.6 will include this analysis.

We hope this clarifies both points.

Reviewer_FNbGOpenReview ↗
Rating
1
Confidence
2
Informativeness
2
Presentation
1
Soundness
1
Read review
Paper summary

The paper proposes a training-free temporal delta sparsity method for the linear layers of masked diffusion language models. Under a 10% entry budget, sparsifying step-to-step changes leaves 3-4% relative output error while sparsifying activations leaves 41-43%. Each linear operator stores a reference input and its projected output, refreshes only the entries with the largest cj∣Dt,ij∣c_j|D_{t,ij}| and accumulates their contribution, so skipped changes stay in the residual for later steps; the budget is shared globally across tokens and channels under an integral threshold controller. Accuracy is measured with an unstructured entry-level mask, which at ρ=0.1\rho=0.1 skips about 89% of linear-layer MACs for mean scores 47.8 and 59.8 against dense 47.4 and 60.6; speedups come from the row and sorted-chunk variants, with the row variant reaching 1.90x and 1.46x end-to-end on 200 GSM8K problems.

Critical strengths

The key controls are decisive in my view. Setting the reference to zero, which reduces the method to ordinary magnitude sparsity, drops accuracy to 0.0%, and a per-token budget gives 53.1% and 8.6% against 84.8% and 82.4% for the global budget. These attribute the gain to the reference and the shared budget rather than to tuning. The accounting is cleaner than usual for efficiency submissions: the dense first step and every method's mask-forming projections are counted, the paper states plainly that this is an arithmetic count rather than runtime, and the appendix quantifies how BF16 batch shape changes greedy outputs and declines to read two-point differences on the 200-problem subset as improvement. The structured variants report measured kernel time rather than paper MACs.

Critical weaknesses
  1. The experimental coverage is thin, and two key axes are never swept. Block size is fixed at 32, maximum length at 256, with single-token commitment and batch size 1; no curve anywhere varies block size or generation length. Those are exactly the axes that set how much temporal redundancy exists: a block boundary admits 32 new masks at once, the largest activation jump on the trajectory, while the controller is clipped to a factor of 4 per step, and longer generation removes the basis for the error-accumulation claim, since Figure 2(a) covers 256 steps under dense teacher-forced inputs. The n=512n=512 and n=1024n=1024 points in Table 4 and Figure 3 are synthetic-sequence timings without accuracy and cannot stand in for long real generations. The authors' own 79.3% at 89% sparsity against 84.0% dense when committing two tokens per step shows this family of axes matters.
  2. Accuracy and speed come from two different configurations. Every accuracy result uses the unstructured entry-level mask, which has no GPU implementation and whose 88.6% is a MAC count (an entry-level update does one MAC per weight element read, against nn for a dense GEMM, so it cannot be made fast). The 1.90x and 1.46x belong to the row variant, whose full-test means at ρ=0.1\rho=0.1 are 45.9 and 56.3, i.e. 1.5 and 4.3 points below dense, falling to 41.7 and 48.7 at ρ=0.05\rho=0.05. The abstract places the entry-level "47.8 versus 47.4" next to the row variant's "1.90x, with equal or higher observed accuracy", the latter holding on a 200-problem subset; no single row delivers 89% sparsity, no accuracy loss and 1.9x together, and the end-to-end measurement covers one benchmark.
  3. State memory is unquantified. For LLaDA-8B the reference plus accumulator is about 7.3 MB per token (about 4.5 MB for the row variant), against roughly 0.5 MB per token for the model's KV cache, so the state is about 14x the KV cache, around 3.8 GB at n=512n=512, growing linearly with batch size. The paper offers only the qualitative statement that it grows with sequence length, with no absolute figure and no measured peak memory.
  4. No end-to-end comparison against the stronger efficiency line. All baselines are activation-sparsity methods, while dLLM acceleration is dominated by caching and parallel decoding. dLLM-Cache is compared only at the level of logit error, never accuracy versus wall-clock, and Fast-dLLM appears only in related work. The two lines act on different dimensions and are plausibly orthogonal, but that needs measuring.
  5. The conceptual delta is limited. Sparsifying a difference against a stored reference appears in delta networks, DeltaCNN, Eventful Transformers and Chipmunk, the sorted-chunk implementation follows the last of these, and the two propositions are an algebraic identity and greedy top-KK selection.
  6. Readability. The main text has three figures, all experimental, and no illustration of the method; Section 4 is entirely equations. The two pieces of state, the residual rolling into the next step, and how the global budget tilts toward changing tokens would each be clearer as a diagram. Several accounting details surface only in Appendix D, including that all accuracy experiments use the unstructured variant, that the timing sequences are synthetic, and that the deployed kernel thresholds squared scores so its effective gain is γ/2\gamma/2.
Questions for authors
  1. With block size 16 and 64, and maximum length 512 and 1024, how do realised sparsity, scores and speedup change? What is the actual density at the step that crosses a block boundary, and does the error curve of Figure 2(a) stay flat at L=1024L=1024?
  2. Please report the complete (realised sparsity, score, measured speedup) triple for the row and chunk variants on all four benchmarks rather than GSM8K alone. At matched end-to-end speedup, which variant scores highest?
  3. What are the absolute reference/accumulator memory and the measured peak GPU memory, as a function of sequence length and batch size, and how do they compare with the KV cache? In which configurations does this overhead cancel the gains?
  4. Composed with Fast-dLLM's block caching and confidence-based parallel commitment, what are end-to-end accuracy and latency, and how does the speedup decay at 2-4 tokens committed per step?
  5. Can TEAL and top-p be given comparable kernel implementations so that they appear on the same accuracy-versus-latency plot? The present comparison is MAC-only.
1 comment

Thank you. Your memory estimate and reading of the row-variant numbers are correct.

1. Block boundaries and length (W1, Q1)

  • A block boundary adds no masks. All L answer positions are masked from step 1; a block only limits which mask may be committed (Eq. 1), so one input token changes per step, block starts included. Fig. 2(b) shows later blocks' masks already in the input: 31% of positions, 36% of the budget ("future masks"). Sec. 3.1 says this only in words; we will add x(0) = [prompt; MASK × L].
  • The clip does not cap per-step work in the default method. It only limits how fast the threshold moves (at most 4^0.7 ≈ 2.6× per step). Every entry with s > τ is refreshed, so a step with larger changes gets more updates; skipped changes wait in the residual. The row variant instead refreshes a fixed ρn rows per step.
  • Length. Fig. 2(a) (teacher-forced) shows no upward drift over the 8 blocks, only small rises at block starts, where the measured masks switch to the new block. We did not test L > 256 or other block sizes. The abstract and conclusion will state the evaluated setting: answers up to 256 tokens, blocks of 32, one token per step, runtime at batch 1.

2. Accuracy and speed (W2, Q2)

Agreed. The abstract will mark 47.8 vs 47.4 as a MAC count without a kernel, drop "equal or higher observed accuracy", and add: "A GPU row variant skips 89% of linear-layer MACs, scores 45.9 vs 47.4 (LLaDA) and 56.3 vs 60.6 (Dream) on the four-task mean, and is 1.90× / 1.46× faster end to end on 200 GSM8K test problems at batch 1." On the four-task mean it beats all six baselines on Dream (best: top-p, 54.8 at 21% sparsity) and is 0.6 / 0.2 points below TEAL (50%) / top-p (17%) on LLaDA.

  • Matched speed (Table 5): rows win. LLaDA: row (ρ = 0.1) 1.90× / 79.0% vs chunk (ρ = 0.05) 1.87× / 73.5%. Dream: row (ρ = 0.1) 1.46× / 85.5% vs chunks 1.41–1.47× / 78.0–27.0%.
  • Other tasks: not timed. Row per-step work depends only on n and ρ (App. D) and our sequences have n ≈ 350–440, so per-step speedups should be similar.

3. State memory (W3, Q3)

Per token (Sec. 4.4 formula, public configs): LLaDA 7.3 MB (row 4.5 MB), 14× (8.5×) its 0.52 MB BF16 KV cache; Dream 7.2 MB (4.4 MB), 126× (78×) its GQA KV cache. Per LLaDA sequence: 3.8 GB (row 2.3 GB) at n = 512, 7.5 GB (4.6 GB) at n = 1024, linear in batch. Measured speedups include this state traffic; the cost is batch size. Beside 16 GB of weights and ~2 GB of activations, about six row sequences of length 512 (three at 1024) fit on a 32 GB GPU. TDS is a small-batch latency method; we will say so with these numbers. Peak memory was not measured.

4. Caching and parallel decoding (W4, Q4)

  • dLLM-Cache (our implementation, existing GSM8K dev sweep, same MAC accounting; to be added to the appendix): its lowest-sparsity points are near dense (LLaDA 80.1% at 63%, Dream 86.3% at 73%; dense 81.6 / 87.9), then it falls (LLaDA 66.0% at 78%, 28.1% at 82%; Dream 75.8% at 86%). At 89%, our row variant, also a whole-token refresh, scores 84.4% / 86.3% (Tables 3, 7). This is MACs, not wall-clock.
  • Parallel decoding: we claim nothing about composing with Fast-dLLM. Prop. 3 (fixed threshold) bounds refresh work by total activation change, not step count; k tokens per step cut dense work about k-fold but likely not the change, so achievable sparsity should fall with k. This fits our one data point: 79.3% for TDS vs 84.0% for dense, both at two tokens per step (LLaDA dev, 89% sparsity).

5. Baseline kernels (Q5)

Their masks differ across tokens, and a GEMM can skip a weight column only if all tokens in its tile do, so they would need restructuring like our rows. As ideal MAC-based caps (linear layers: 98% of MACs): TEAL 1.96× at 50% (2.4× / 1.7× at its 95%-accuracy limits, Table 2), top-p 1.20–1.26×, TDS-row 7.8× (measured 1.90× / 1.46×). Without baseline kernels we cannot compare measured speed; the caps will go in Sec. 5.6.

6. Novelty (W5)

We agree the delta update is from delta networks and Props. 1–2 are simple. Our contribution is making it work in masked DLMs, with ablations (fixed budget, ≈90% sparsity, LLaDA / Dream dev): TDS 84.8 / 84.0%; zero reference 0.0 / 0.4%; per-token budget 53.1 / 3.9%. Our row variant is close to Eventful Transformers' token gating; we will say so. Chipmunk's chunk order is static; versus our own consecutive 64-token chunks, re-sorting by change each step lifts LLaDA from 77.7 / 28.5 to 80.9 / 76.6% and Dream from 31.6 / 0.8 to 76.6 / 15.6% (ρ = 0.1 / 0.05; Tables 3c, 7c).

7. Readability (W6)

We will add a method figure (reference, accumulator, carried residual, shared budget) and state in Sec. 5.1 that results not labelled row or chunk use the unstructured variant, that kernel timings use synthetic inputs (currently only in captions), and that the deployed chunk kernel has effective gain γ/2 (rows use no controller).

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.