acceptodds
Under review as a conference paper at ICLR 2027

SparkDiffusion: A Unified Sparse Warm-Up and Few-Step Distillation Framework for Mitigating the High-Sparsity Trap

Abstract

Video diffusion transformers are central to visual generation, but inference is dominated by attention over long spatiotemporal sequences. While video attention's sparse-plus-low-rank structure suggests high sparsity is possible, existing models degrade beyond sparsity even after step-local training converges. We identify this failure regime as the high-sparsity trap: step-local objectives leave terminal-visible velocity errors that accumulate during sampling without direct gradient signals to correct them. We propose \method (\methodfull), a unified framework whose central principle is to first adapt a dense video DiT into a high-sparsity coarse prior through sparse warm-up, and then correct its terminal trajectory through few-step trajectory-mixed distillation; fused FP8 kernels provide the deployment layer. Our idealized analysis isolates the mechanism and limits, while experiments validate the staged framework across multiple backbones, tasks, resolutions, and hardware platforms.

Primary area:
generative models
Keywords:
sparse attention, few-step distillation, single-GPU acceleration

Reviews

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

This work identifies the high-sparsity trap failure regime, a problem that occur when velocity error accumulates at >= 90% sparsity, and they proposed a sparse warm up then trajectory-mixed distillation method to address this sparse attention conversion problem. They've shown the empirical evidence behind the velocity error accumulation, and shown SparkDiffusion as a better method than the baseline mentioned here.

Critical strengths

The exploration and empirical supports behind the high-sparsity trap failure are interesting, and the sparsity method motivation is sound, and the paper writing is really good.

Critical weaknesses

One potential concern is about model arch generalizations, does it generalize beyond wan attention arch?

On speedup baseline, PyTorch SDPA may be a better baseline (the later pytorch version, which select between the proper flash attention, cudnn, etc. based on env) for 5090.

Percentage sparsity itself is not as kernel friendly as fix budget sparse attention, even if it generalize better as context grow. Because fixed budget sparse allow fix shape for better kernel pre-compiling, and a potential improvement is find that, after the 90% or 97% sparsity conversion, under the model max context length, a fixed N tokens sparsity budget.

Questions for authors
  1. why only on WAN family, is this method generalize to other arch like HunyuanVideo and CogVideoX?
  2. For the high-sparsity trap failure discussion, can this just be a capacity or routing problem? Increasing the compensation rank doesn’t really rule it out, and fixing high-noise steps let us know the place where corrections help, but not why the model fails. Also, distillation also changes several things at once, so it is hard to fully justify the reasoning chain.
  3. This may not be as relevant, but sparsity becomes extremely beneficial when context grow up, but a common failure mode of sparsity method is it fail when context grow up and sparsity error accumulate to alternate the trajectory even with training. In my understanding, none of VBench, VBench-2.0, V-JEPA 2, VideoMAE V2 are long context video generation. Do sparkdiffusion have similar issue when applied on longer video generation model? I understand this may be beyond the this work, but I wanted to bring it up as an interesting point for further discussion.
1 comment

We thank the reviewer for these careful points. They ask three things: does the method work beyond Wan, how we measured speed, and when the sparse model fails. We answer them below.

1. Does it generalize beyond Wan? (W1, Q1)

The Wan experiments are enough to answer this, and the study is large. We trained on Wan2.1-T2V-1.3B, Wan2.1-T2V-14B-720P, Wan2.1-I2V-14B-720P and Wan2.2-A14B-MoE. The study spans multiple model scales (1.3B/14B/A14B), two resolutions (480P/720P), both tasks (T2V/I2V), and dense and MoE architectures, at 90% and 97% sparsity.

Wan is where the field compares. FastWan, TurboDiffusion and SLA all run on Wan, so our numbers sit next to theirs on the same model.

What the method needs from a model. Sparsifiable attention with a small dense correction branch, and a diffusion model with a slow teacher. HunyuanVideo and CogVideoX both satisfy this. Sec. 5 now states these conditions.

Percent sparsity vs. fixed block count (W3). In Wan2.1 the number of tokens is fixed, so "97%" always means the same number of retained blocks. The kernel sees a fixed shape and is compiled once, as with a fixed budget.

The percentage keeps one recipe across 480P/720P and 1.3B/14B/MoE. A fixed block count matters when the sequence length changes, as in autoregressive decoding. We added this to the appendix.

2. Is FA2 a fair speedup baseline? (W2)

FA2 is the right reference for this comparison. FastWan and TurboDiffusion report speedups against FlashAttention-2, so FA2 keeps our table comparable to theirs.

We also ran the SDPA check you suggested. RTX 5090, NGC 25.10, bf16, Diffusers group offload, 14B-720P, 50 steps:

KernelLatency
FlashAttention-24764.3 s
SDPA (auto)4774.2 s

The two differ by 0.2%, inside the 0.6% run-to-run noise. SDPA auto simply picked the same flash kernel on this machine. All speedup ratios in the paper stay the same.

3. Why does the sparse model fail? (Q2, Q3)

(a) The rank experiment was too strong a claim. We trained the same 14B-480P model with the dense branch at rank 64 and at rank 128. Terminal error went 0.124 → 0.121, and VBench 80.92 → 81.05. This rules out one capacity change. The earlier sentence said more than that, and Sec. 3.1 is now corrected.

(b) Fig. 4 localises the failure to the high-noise steps. We keep every weight and every routing decision, and only replace the model's velocity at the five noisiest steps with the teacher's. Most of the error disappears. This rules out routing or capacity problems outside that window: the later steps are untouched, yet the video recovers. Inside the window the substitution masks routing-, capacity-, and supervision-induced velocity errors together, so Fig. 4 localises the failure but cannot separate the three. We say so explicitly in the revision.

(c) Fig. 7 and two new controls explain the cause. Under the standard loss the model trains for 10,000 steps: validation loss keeps falling, video quality does not. Two extra signals, each a single change on the same VSA branch, recover part of the gap (14B-480P, 97%):

Training signal (VSA branch)Term. err ↓VBench ↑
Step-local FM (the trap)0.125579.72
+ high-noise reweighting0.114880.61
+ teacher-velocity on student states0.107981.34
+ trajectory-mixed distillation (VSA + Stage 2)0.100182.45

Each change is applied singly to the same VSA 97% checkpoint: high-noise reweighting reaches 80.61 (+0.89 over the 79.72 step-local baseline), teacher velocity on the student's own states reaches 81.34 (+1.62), and trajectory-mixed distillation reaches 82.45 (+2.73, Table 6). None closes the gap alone; the full RoLA recipe reaches 82.99, the extra 0.54 from the RoLA branch. The capacity question is handled by (a) and the training-signal question by Fig. 7.

(d) Longer videos (Q3). You are right that VBench, VBench-2.0, V-JEPA 2 and VideoMAE V2 are not long-context benchmarks, and our results are at 81 frames. We expect the same failure to grow with length: one bad high-noise step corrupts a block early, sparse attention copies it into later tokens, and three steps are too few to undo it. In bidirectional attention the damage stays inside one video; in causal autoregressive attention it passes into later chunks, which is why Sec. 1 argues the final alignment stage matters even more for autoregressive models. We state this as a limitation and a direction for future work.

4. Revision

We updated Sec. 3.1, Sec. 5, the appendix, and the limitations section. The new control rows will be added to Table 6 (Appendix D) and Sec. 5.3.

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

This paper studies video generation at very high attention sparsity. The authors observe that step-local training loss can decrease while final video quality remains poor, which they call the “high-sparsity trap.” They propose a pipeline that combines sparse warm-up, CrossDistill-based few-step distillation, and FP8 deployment. The experiments show substantial inference speedups with some loss in generation quality.

Critical strengths
  1. The experiment result is impressive.

  2. The work has practical value. A recipe that makes highly sparse video models usable could help reduce the cost of video generation.

Critical weaknesses
  1. The method mainly combines existing components, and the added contribution is unclear. The sparse attention module comes from RoLA, while the distillation stage follows CrossDistill. Sparse attention combined with few-step distillation has also been explored in earlier work (FastWan, TurboDiffusion). At the method level, this paper mainly adds sparse warm-up before applying CrossDistill to a sparse student. This can be practically useful, but the paper does not clearly show what the proposed framework adds beyond combining these existing methods.

  2. The experiments do not sufficiently isolate the claimed benefit of staged training. The warm-up study provides useful evidence that some sparse adaptation helps. However, Table 3 shows that PCM-only and DMD-only training already recover much of the lost quality, suggesting that changing the training objective accounts for a substantial part of the improvement. The FastWan comparison also changes the distillation recipe, so it cannot isolate the effect of training order. Since staging is presented as the main contribution, the paper should compare staged and joint training with the same sparse architecture, distillation objectives, data, and comparable compute budgets.

  3. The practical benefit of pushing sparsity to 97% is unclear. The 90% sparse model already achieves about 200× speedup (265x / 1.32 , since oving from 90% to 97% sparsity gives about 1.32× additional speedup). Increasing sparsity to 97% reduces latency from 23.7 to 18.0 seconds on RTX 5090, but lowers VBench from 83.42 to 83.15 and VBench-2.0 from 59.36 to 58.05. This is a useful speed–quality trade-off, but not a clear improvement over the 90% setting.

Questions for authors
  1. The paper identifies staged training as its main methodological contribution. What makes sparse warm-up followed by an existing distillation method a substantial advance over a straightforward combination of RoLA and CrossDistill?

  2. Beyond showing that early denoising errors matter and that distillation improves sample quality, what new understanding does the “high-sparsity trap” provide, and how does it lead to a training design that differs from existing methods?

5 comments

We thank the reviewer. The question runs through all the points: what the paper adds on top of RoLA and CrossDistill. We answer it first, then the understanding behind it, then the 97% setting.

Testbed. New ablations: Wan2.1-T2V-14B-480P, 97% (Table 6, Appendix D). Operating points: 14B-720P (Table 2).

1. What the paper adds (W1, W2, Q1)

RoLA and CrossDistill are earlier work. The paper adds a design rule and the reason for it: build the sparse model first, then align it to the final output.

Order decides the outcome. Same RoLA branch, same objective, same data, 8,250 updates:

ScheduleVBench ↑Term. err ↓
Joint (both losses from step 0)82.310.110
Warm-up, then distillation (ours)82.990.092

The reason shows up in the frames. RoLA's branch starts at zero, so it does almost nothing at the dense checkpoint, while distillation simultaneously pushes the sampler to 3 steps: two large changes at once. Fig. 10 (14B-480P) shows the effect at equal budget: without warm-up the frame is still dark noise at iteration 2000; with a short warm-up first it is coherent from the start. A warm-up sweep at 0, 100, 250, 500, and 1000 steps (fixed budget) gives VBench 76.80, 81.33, 82.99, then 83.01 and 82.95 at 500 and 1000. The 0-step point (distillation on the un-adapted checkpoint, no sparse objective trained) falls into the trap at 76.80; "Joint" trains both losses from step 0 and reaches 82.31.

The paper's own comparison corroborates this. Table 6, same VSA branch, same checkpoint, same data:

97%, VSA branchVal lossTerm. errVBench
FastWan recipe retrained (joint)0.09960.119880.23
Same checkpoint + our Stage-2 (staged)0.09950.100182.45

The two rows have the same validation loss, yet video quality differs by 2.2 points. This table also changes the distillation recipe (DMD-style vs trajectory-mixed), so it corroborates the order effect. The clean isolation is the first table, which holds the recipe fixed.

The first table is the comparison you ask for: recipe fixed, only the schedule varies, same 8,250 updates on both runs, so the gap is not a compute artefact.

On Table 1. Table 1 (14B-720P) isolates the objective choice (~1.2 points, 81.94 → 83.15). The larger part of the trap is having any alignment at all (480P VSA):

97%, VSA branchUpdatesTerm. err ↓VBench ↑
Step-local only10,0000.125579.72
Warm-up → PCM onlywarm-up + 8,0000.107481.6
Warm-up → DMD onlywarm-up + 8,0000.103282.3
Warm-up → trajectory-mixed (VSA + Stage 2)warm-up + 8,0000.100182.45

The step-local run gets 40× the warm-up budget (10,000 vs 250) and still stops at 79.72. Every aligned objective reaches 81.6–82.45 on the VSA branch; the full RoLA recipe reaches 82.99 (Table 6). The objective choice is ~0.9 points on 480P; the larger part is having any alignment at all.

On the FastWan comparison. That row also changes the recipe; the ablation above keeps one recipe and varies only the order. Separate training plus merging is TurboDiffusion's schedule, and it releases inference code only, so we cannot reproduce it on our data and budget.

2. What the trap adds (Q2)

  1. Training longer plateaus. Validation loss keeps dropping for 10,000 steps while video quality flattens and then falls (Fig. 7), and it still ends at 79.72.
  2. The loss measures each step in isolation. It records how large each single-step error is. The final video depends on whether those errors add up or cancel (Lemma C.1). Two models can have the same loss and make very different videos.
  3. So the target must reach past the current step. A target built from a later point in the trajectory predicts the Table 1 result: consistency and distribution matching help, plain per-step velocity does not.
  4. So does the order. Once the sparse model has converged, the remaining error sits in directions that the step-local loss cannot move (Lemma C.4, Prop. C.6). Aligning afterwards is cheap. Table 6 and the schedule ablation (Table 7) test this directly.

3. The 97% setting (W3)

You are right that 97% is a separate operating point, and we now label it that way.

  • 90% is our quality setting. On Wan2.1-T2V-14B-720P it beats TurboDiffusion on every metric (VBench 83.42 vs 82.88, VBench-2.0 59.36 vs 57.98) and is faster (23.7s vs 25.3s).
  • 97% is our latency setting. 18.0s on a single RTX 5090, costing 0.27 VBench and 1.31 VBench-2.0 against our 90% row.
  • Why we report it. At 97% a step-local recipe drops to 79.72 (Table 6, 14B-480P). Our recipe holds, and runs 1.41× faster than TurboDiffusion at 90% with matched quality. On H100 it is 2.0× (8.0s vs 16.0s).

The two rows will be labelled in Table 2; Sec. 5.1 will state this cost. New ablation rows go into Table 6 (Appendix D) and Sec. 5.3.

Thank you for the additional experiments and clarification. The rebuttal answered my concerns W2 and W3. Notably, high sparsity trap is an interesting finding and the proposed training recipe is effective.

However, my concern about novelty (W1) remains. As clarified by the authors, the contribution is the design order: first build sparse model then distill, which I find the novelty limited. Besides, the paper is not organized in a way that emphasize this novelty. For example, the Figure 2, 3 give impressive numbers like "265x", but the largest speedup is not brought by the novelty of this paper, but by the related works. The FP8 kernels, similarly, is more like an engineering effort rather than a methodological contribution. I therefore maintain my rating of 2 (weak reject).

Thanks for the follow-up. We are glad W2 and W3 are settled. On W1, we would like to explain what we see as the core contribution.

The core contribution is the high-sparsity trap itself. We found it, diagnosed it, and showed why training with a terminal-aligned signal fixes it. The two-stage recipe is the conclusion of this analysis. The page allocation reflects this. The method section is about one page (Sec. 4). The diagnosis spans Sec. 3 and the whole of Appendix C.

The analysis goes in three steps.

First, we locate the trap (Sec. 3.1). At 95% to 97% sparsity the training loss keeps going down, but the final video quality stalls. Training 40× longer does not fix it. Widening the compensation branch barely helps (terminal error 0.124 vs 0.121). Replacing the student's velocity with the teacher's on just the five highest-noise steps removes most of the error (Fig. 4). These experiments show the problem is in the supervision signal, and the error enters at the high-noise steps.

Second, we prove the mechanism (Appendix C). In a simplified model we show that per-step errors add up along the sampling trajectory. Step-local training fixes the part it can reach and then stalls. A terminal-aligned loss removes the error that survives to the final output (Prop. C.8). This is the theoretical basis for the fix.

Third, the recipe follows (Sec. 3.3). We define terminal-aligned supervision and derive the two-stage schedule from the analysis. The recipe looks simple because the analysis already did the hard work. We claim it escapes the trap because we can explain why it works.

This evidence is what supports the "unified" claim. The diagnosis is about the training signal, so it applies to any sparse branch. We verified this in Appendix D. The trap reappears on VSA-style and SLA-style designs, and the same two-stage training fixes both (Table 6). The unified framework at high sparsity is a conclusion we tested across designs.

We would also say a word about simplicity. Every choice in the recipe is backed by the experiments and proofs above. We warm up first and distill second, and we know where the terminal signal needs to act. A recipe that runs in two stages with standard components is easy to adopt in practice, and simple methods are often the ones that deliver real gains. We see the combination of a new diagnosis and a simple, well-supported fix as the contribution of this paper.

We hope this clarifies where the weight of the paper lies, and we would appreciate a reconsideration of the score.

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

This paper studies the “high-sparsity trap” in video diffusion transformers: at extreme attention sparsity, step-local training losses can improve while generated-video quality remains poor. The proposed SparkDiffusion framework first adapts the model to compensated sparse attention through a short warm-up, then applies trajectory-mixed few-step distillation, followed by FP8 quantization and kernel optimizations. The framework achieves 97% attention sparsity on WAN with competitive performance.

Critical strengths
  1. The paper addresses an important practical problem. Making extreme attention sparsity usable could substantially reduce video-generation costs. The reported deployment results are compelling: Wan2.1-T2V-14B at 720P reaches a denoising latency of 18 seconds on RTX 5090 and 8 seconds on H100 while retaining competitive benchmark scores.
  2. The evaluation includes meaningful controls and multiple sparse designs. Appendix D evaluates VSA- and SLA-style attention, retrains the FastWan recipe at 97% sparsity, and demonstrates improvements after applying Stage 2. Table 3 compares PCM-only, DMD-only, and mixed distillation from the same warm-up checkpoint.
  3. The speedup accounting is reasonably transparent. The authors explicitly distinguish the full-stack 265× acceleration from the additional approximately 1.32× improvement obtained by increasing sparsity from 90% to 97%.
Critical weaknesses
  1. The central contribution is not sufficiently isolated. The framework adopts RoLA attention and CrossDistill’s objective schedule. Related work already combines sparse attention, few-step distillation, and quantization; TurboDiffusion differs by training sparse adaptation and distillation separately and merging their updates. The specific benefit of SparkDiffusion’s sequential recipe therefore deserves a controlled comparison.
  2. The causal interpretation of the high-sparsity trap is stronger than the evidence supports. Extended training and the high-noise intervention establish a mismatch between step-local error and terminal quality. However, they do not uniquely identify the training objective as the cause or exclude representational constraints. Doubling the compensation rank tests only one capacity modification.
  3. The quality–speed and quality–diversity claims need more precise qualification. For Wan2.1-T2V-14B, increasing sparsity from 90% to 97% reduces RTX 5090 latency from 23.7 to 18.0 seconds, but also reduces VBench-2.0 from 59.36 to 58.05. At 97%, the VBench-2.0 advantage over TurboDiffusion is only 0.07 points, without reported uncertainty for this comparison. Table 2 supports improved diversity relative to the tested accelerated baselines, but Table 3 does not measure diversity for its PCM-only and DMD-only variants. Consequently, the proposed explanation of the mixed objective’s fidelity–diversity advantage is not directly established by that ablation.
Questions for authors
  1. Can the authors quantitatively compare sequential warm-up and distillation against joint training and separate-training-plus-merging, using the same sparse architecture, objectives, data, and total training compute? How sensitive are the results to warm-up duration?
  2. Does the high-sparsity trap persist under high-noise-reweighted flow matching or teacher-velocity regression on student-generated states? Such controls would help distinguish objective weighting and state-distribution effects from the need for few-step distillation.
  3. How does the theoretical result justify staging over a weighted joint objective? Could the authors revise the interpretation of Figure 19 to match what the surrogate establishes?
2 comments

We thank the reviewer. We take the points in three groups: what the paper adds, where the error comes from, and what the efficiency numbers support. The controlled runs are below, and the paper has been revised.

Testbed. New ablations: Wan2.1-T2V-14B-480P, 97% (Table 6, Appendix D). Operating points: 14B-720P (Table 2).

1. What the paper adds (W1, Q1, Q3)

RoLA and CrossDistill are earlier work. Our claim is the order of the two training stages. We trained the same RoLA sparse model two ways under the same 8,250-update budget:

ScheduleVBench ↑Term. err ↓
Joint (both losses from step 0)82.310.110
Warm-up, then distillation (ours)82.990.092

Order is worth 0.68 VBench here. Table 6 shows the same pattern: FastWan's recipe retrained at 97% matches our staged run's validation loss (0.0996 vs 0.0995) yet lands 2.2 VBench lower.

Fig. 19 answers a narrower question: once the sparse model is well trained, a terminal-aligned stage lowers the terminal error at little cost. The schedule comparison comes from the table above. We reworded the Fig. 19 caption, Sec. C.6 and Sec. 5.3.

Four points on why order matters:

  1. Sparse training alone leaves a gap. It stops at VBench 79.72 after 10,000 steps. Every trajectory-mixed recipe in Table 6 lands at 82.45–82.99 on the same testbed.
  2. Training both at once interferes. The compensation branch starts at zero and has to build its signal while the sampler is pushed to 3 steps. Fig. 10 (14B-480P) shows this at equal budget: distillation alone gives a dark noisy frame at iteration 2000; a short warm-up first is coherent from the start.
  3. The split matters at 97%, and warm-up length is not delicate. At 90% one loss converges; at 97% it stalls. A warm-up sweep at 0, 100, 250, 500, and 1000 steps (fixed 8,250-update budget) gives VBench 76.80, 81.33, 82.99, then 83.01 and 82.95 at 500 and 1000. The 0-step point is distillation on the un-adapted checkpoint (Fig. 10, no sparse objective trained) and falls into the trap (76.80); "Joint" trains both losses from step 0 and only partially escapes it (82.31).
  4. Compute and the merge baseline. Stage 1 ≈250 updates (≈23 GPU h), Stage 2 8,000 updates (≈1K GPU h). TurboDiffusion releases inference code only, so we cannot reproduce its merge schedule.

2. Where the error comes from (W2, Q2)

Fig. 4 (teacher velocity on the five noisiest steps removes most error), the rank sweep (0.124 → 0.121), and Fig. 7 (loss falls, quality stalls) bound the cause but do not settle it. Sec. 3's "the bottleneck is the training signal, not capacity" was stronger than the evidence; it now says terminal quality at 95–97% (r ≥ 64) is limited by the supervision target in the range we tested.

We ran the two controls from the same VSA Stage-1 97% checkpoint, 10,000 updates each, then added distillation on that same branch:

Training signal (VSA branch)Terminal err ↓VBench ↑
Step-local FM (the trap)0.125579.72
+ high-noise reweighting0.114880.61
+ teacher-velocity on student states0.107981.34
+ trajectory-mixed distillation (VSA + Stage 2)0.100182.45

Each change is applied singly to the same VSA 97% checkpoint: high-noise reweighting reaches 80.61 (+0.89 over the 79.72 step-local baseline), teacher velocity on the student's own states reaches 81.34 (+1.62), and trajectory-mixed distillation reaches 82.45 (+2.73, Table 6). None closes the gap alone; the full RoLA recipe reaches 82.99, the extra 0.54 from the RoLA branch. Measuring alignment on a fixed branch keeps it separate from the branch effect. Both controls act on the high-noise window and stop short, supporting Fig. 4: part of the error is outside what a per-step target can see.

3. Speed and diversity (W3)

Sec. 5.1 now spells out the 90% → 97% trade-off on 14B-720P: 23.7s → 18.0s, VBench-2.0 59.36 → 58.05. At 90% we beat TurboDiffusion (59.36 vs 57.98). At 97% we match 90%-TurboDiffusion (58.05 vs 57.98) while being 1.4× faster. On 14B-480P, recipes pushed to 97% drop to 80.23 (Table 6).

You are right that Table 1 had no diversity numbers. We measured them with the Table 3 protocol (14B-720P, 97%):

Stage-2 objectiveVBenchVBench-2.0V-JEPA 2 cos ↑VideoMAE V2 cos ↑
Full Attention (dense)83.6960.200.1250.0252
PCM only81.9456.410.0820.0143
DMD only82.5657.380.0680.0124
CrossDistill (ours)83.1558.050.0870.0142

PCM-only keeps diversity and loses fidelity. DMD-only gains fidelity and loses diversity. The mixed objective is best on VBench, VBench-2.0 and V-JEPA 2, and ties PCM on VideoMAE V2 (0.0142 vs 0.0143). These numbers are now in Table 1.

The new rows (schedule, warm-up sweep, controls) are now in Table 7 and Table 6, with Sec. 5.3 reporting the schedule comparison and the supervision controls.

Dear Reviewer,

Thank you again for the careful review. We posted our response earlier in the discussion period and wanted to follow up in case it was missed.

The presentation has been revised to match what we claim. The title is now "SparkDiffusion: Diagnosing and Mitigating the High-Sparsity Trap for Efficient Video Diffusion". The abstract and contribution list now put the trap and its diagnosis first. The new understanding is that at 95% to 97% sparsity the failure lies in the supervision signal: it is localized to high-noise structure generation, persists under extended training and added capacity, and the mechanism analysis explains why a terminal-aligned signal fixes it. The staged recipe is presented as the remedy derived from this diagnosis (W1, Q1, Q2).

The controlled experiments from our response address the isolation concern (W2):

  1. Same architecture, objective, data, and 8,250-update budget: joint training reaches VBench 82.31 (terminal error 0.110), while warm-up then distillation reaches 82.99 (0.092). A warm-up sweep (0 to 1000 steps) shows the warm-up is necessary but its length is not sensitive.
  2. In Table 3 all students start from the same warm-up checkpoint, so the objective comparison sits on top of staging. FastWan's recipe retrained at 97% matches our validation loss (0.0996 vs 0.0995) yet lands 2.2 VBench lower (Table 6).

On the 97% setting (W3), Sec. 5.1 now states the trade-off explicitly: 90% is the quality operating point and 97% the latency one. Even at 97%, the model slightly exceeds the strongest 90% baseline on VBench-2.0 (58.05 vs 57.98) at 1.41× lower latency.

All new results are in the revised paper. We would be grateful to hear whether these address your concerns, and we are happy to clarify or run additional checks within the remaining discussion time.

Best regards, The Authors

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.