yitongl/wan21-flsplan-matched-budget

Same budget, different allocation — many rough steps vs few good ones at ~4x

Wan2.1-T2V-14B, 1280x720, 81 frames, 50 steps, unipc, shift 5.0, seed 42, one prompt, single H100, SDPA (no flash-attn).

No quality verdict is offered. These arms exist to be watched. The question is semantic alignment and visual plausibility, not similarity metrics, so no LPIPS or SSIM is reported and the arms are listed in plan order rather than ranked.

The question

At extreme acceleration a cache is forced to freeze long stretches of the trajectory. Every step of denoising is one of three things, and all three were measured on this model as a whole forward pass:

action	what it does	measured
F	full-resolution compute, 21x45x80 = 75,600 tokens	13.30 s
L	low-resolution compute, 21x30x52 = 32,760 tokens, plus the CRF high band carried from the last F	3.75 s — 28%
S	skip: reuse the cached residual on this step's embedding	0.12 s — 0.9%

One F buys three and a half L. So at a fixed budget you can trade quality per step for number of steps. Note 50 x L = 188 s = 3.6x sounds attractive but is not reachable: L needs an F to refresh its high band, and pure-L would drift with nothing to anchor it. The skips are what make 4x possible, so this is a three-way allocation, not a two-way one.

The arms — all at the same measured budget

Reference: 1336.5 s. Every arm is a fixed 50-character plan; nothing is adaptive. Dense ends are a hard constraint: the first three and last two computed steps are always F, because those set composition and final detail. Remaining F steps are spread evenly through the middle so the carried CRF high band is refreshed at regular intervals instead of going stale across the whole run.

arm	F	L	S	computed	longest frozen run	forward s	speedup	mp4 MB
A cache-only	12	0	38	12	11	329.2	4.06x	8.1
D	11	5	34	16	8	350.8	3.81x	11.7
C	9	10	31	19	6	325.7	4.10x	17.2
B	7	18	25	25	4	330.8	4.04x	19.0
B (in_scale 1.5603)	7	18	25	25	4	330.4	4.04x	16.5
reference	50	—	—	50	0	1336.5	1.00x	7.1

A  FFFSFSFSSFSSSFSSSSFSSSSSFSSSSSSSSSFSSSSSSSSSSSFSSF
D  FFFLFSFSLSFSSFSSLSSSFSSSSFSSSSSLSSSSSSSSLSSSSSSFSF
C  FFFLLFLSLSFSLSFSSLSSLSSSFSSSLSSSSSLSSSSSSLSSSSFSSF
B  FFFLLLLLLFLSLSLSLSLSFSLSSLSSLSSSLSSSSLSSSSLSSLSSFF
   high noise <                                  > low noise

A -> D -> C -> B is a monotone ladder: computed steps 12 -> 16 -> 19 -> 25, longest frozen run 11 -> 8 -> 6 -> 4. Watching them in that order is watching "few good steps" turn into "many rough ones" at constant cost.

One signal worth knowing before watching

File size rises monotonically with the number of L steps — 8.1, 11.7, 17.2, 19.0 MB against the reference's 7.1. In the earlier round of this project the mp4 size ordering matched the LPIPS ordering exactly, and the extra bytes were high-frequency artefacts. B is 2.7x the reference's size. This is a proxy, not a verdict, and it is stated here so it is not discovered as a surprise.

Arm A is not SeaCache

ZZ_seacache_d060_2.97x.mp4 is real SeaCache at delta 0.60, included for reference. It computes the same 12 steps as arm A, and its plan is where arm A's plan came from, but it runs at 2.97x where arm A runs at 4.06x. The difference is entirely the price of adaptivity: SeaCache's indicator applies a Wiener filter via a 3-D FFT over the full 75,600 x 5,120 hidden state on every forward, skipped ones included.

Two consequences, and they must not be conflated:

• B vs A is a clean question — same harness, same skip mechanism, same fixed plan. It asks only whether L beats S at matched cost.
• B vs SeaCache is a harder bar. Our arms pay nothing for choosing where to spend, because a human chose. A fair comparison against SeaCache eventually has to either pay for an indicator or justify a fixed schedule.

Part of SeaCache's overhead here is also self-inflicted by this repo: its four full-resolution caches were moved to host memory to survive the 14B/720p OOM, adding a 1.44 GiB PCIe round trip per forward, roughly 0.29 s of the 0.93 s. The original does not do this, but the original does not run at this size either.

Speedups moved — read this if you saw earlier numbers

Earlier figures for SeaCache in this project timed only the block loop, which excluded its indicator; the arms it was compared against measured their own spectral resizes. Two different rulers, biased toward the new method. Everything above is whole-forward timing on both sides. The correction is large:

delta	block-loop only (superseded)	whole forward
0.40	2.93x	2.40x
0.60	3.88x	2.97x
0.80	4.67x	3.42x
1.00	5.13x	3.82x

The videos never changed; only the labels. So SeaCache's visible breakdown, previously described as starting at 3.88x, actually starts near 3.0x.

Files

videos/    reference, four arms, the in_scale variant, and real SeaCache d=0.60
traces/    per-forward record for every arm: step, stream, action, ms, ms_forward
code/      crf_lowres.py (the F/L/S scheduler), crf_generate.py, make_plan.py,
           test_crf_lowres.py (42 checks)

test_crf_lowres.py note: until this round its load-bearing check — "an empty plan is bit-identical to stock WanModel.forward" — was vacuous. Wan's init_weights() does nn.init.zeros_(self.head.head.weight), so a freshly built model emits exactly zero and the test compared two all-zero tensors. The head is now perturbed before any output-level assertion runs, and the identity holds for real (mean |ref| 0.187, max abs diff 0). It was a repeatedly-failing assertion, "L and S differ from F", that exposed this; it was correct and the fix was not to weaken it.