yitongl/wan21-crf-lowres-window

A low-resolution window recombined at the CRF level — Wan2.1-T2V-14B, 720p

Result: negative, and the reason is measured rather than guessed. Inside a window of denoising steps the transformer is run on the 480p token grid and its output is recombined with a cached high-frequency band at the CRF. The half that is cached works. The half that is recomputed does not: the low-resolution forward's low band lands 1.30 away from the truth in relative L1, against 0.22 for simply reusing the previous step's. Every arm here is strictly dominated by SeaCache.

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

What is implemented

CRF = the pre-head hidden state, the output of the last transformer block before self.head. On a windowed step:

E      = patch_embedding(x)                    full grid  21 x 45 x 80 = 75,600 tokens
E_low  = spec_down(E)                          low  grid  21 x 30 x 52 = 32,760 tokens
C_low  = blocks(E_low)                         rope / seq_lens rebuilt for the low grid
CRF    = spec_up(C_low) + (C - P(C))|last full step
v      = unpatchify(head(CRF, e))              back at the full grid

P = spec_up . spec_down is an exact idempotent projector, so spec_up(C_low) has a strictly zero high band and the carried band has a strictly zero low band: the sum is a clean split with no double counting (measured 8.5e-08). Nothing is done to the predicted velocity v — the frequency split lives entirely in the hidden state.

No step is ever skipped. All 50 steps run the full 40-block stack; windowed steps run it on a smaller grid. That is the whole difference from the cache family:

# full-resolution compute     o low-resolution compute     . not computed at all

ours crf_w30      ##############################oooooooooo##########   1.155x
SeaCache d=0.20   ###########.#.#.#.#.#.#..#..#...#....#....#..#..##   ~2.1x
high noise <                                                > low noise

A low-resolution step measures 33% of a full step (1133.9 s vs 1309.8 s of block time for 20 of 100 forwards). So even making every step low-resolution caps this technique at 3.0x, and quality collapses long before that.

Videos and scores

LPIPS/PSNR against crf_ref.mp4, which is this same script with an empty window and is bit-identical to stock generate.py (test T5, max abs diff 0). Speedup divides block-loop time, not wall time — wall additionally contains the T5 encoder round trip, a 28.6 GB DiT offload and an 81-frame 720p VAE decode, roughly a minute of fixed overhead that would compress the ratio.

video	PSNR	LPIPS	speedup	window	notes
sea720_t0.20_p0.mp4	29.70	0.0453	~2.1x	—	SeaCache, the thing to beat
crf_w30_s1.0.mp4	28.60	0.0780	1.155x	30..39	our best
crf_w24_s1.56.mp4	26.98	0.0837	1.150x	24..33	variance-preserving input
sea720_t0.30_p0.mp4	25.67	0.0856	~2.6x	—	SeaCache
crf_w24_s1.0.mp4	26.51	0.0873	1.155x	24..33
crf_w20_s1.0.mp4	24.56	0.1155	1.158x	20..29
crf_w24_nocarry.mp4	25.24	0.1389	1.152x	24..33	ablation: no carried band
crf_w20x40_s1.0.mp4	21.81	0.2589	1.390x	20..39	20-step window
crf_ref.mp4	—	—	1.000x	—	reference
ref720_p0.mp4	—	—	—	—	stock generate.py, same thing

SeaCache's speedup is estimated from its computed-step count (25/50, 19/50); its block time was not instrumented, so do not quote it as measured. Ours are measured.

Read the file sizes as a second opinion: reference 7.1 MB, arms 7.8-10.1 MB. The extra bytes are high-frequency artefacts, and the ordering by size matches the ordering by LPIPS.

SSIM is deliberately absent. What was implemented here was a single global-window approximation, not the standard sliding-window statistic, and printing it beside a paper's number would mislead.

Why it fails — the diagnostic

On every windowed step the probe additionally runs the full-resolution forward and scores the cheap one against it, split by band, on a fixed 512-of-5120 channel subset. diagnostics/diag2_native.jsonl.

steps 20-40, mean	value	what it is
err_low	1.3021	the band we recompute at low resolution
err_high	0.2155	the band we carry from the last full step
err_low_gc	0.8360	err_low after the best possible scalar gain
cos_low	0.5725	direction agreement of the low band
gain_low	1.5642	the low-resolution CRF is 1.56x too large

Two things are true at once. There is a large scale mismatch — the low-resolution CRF is 1.3-2.5x the magnitude of the true low band, and correcting it optimally moves err_low from 1.30 to 0.84. But the floor is set by the cosine: sqrt(1 - 0.57^2) = 0.82, which is exactly err_low_gc. The entire remaining error is directional, and no scalar can touch it. At high noise cos_low is 0.10 — the low-resolution forward is nearly orthogonal to what it is supposed to approximate.

Meanwhile the competing approximation, measured in the same metric on the same channels at the same step: reusing the previous full step's low band. That number is being re-measured (see Corrections below) and is of order 0.22-0.27, i.e. reuse is several times more accurate than low-resolution recomputation, at a fraction of the cost. That single comparison is the whole story of why the cache family wins.

Things that were tested and did not rescue it

RoPE position interpolation. rope_apply indexes freqs[1][:h], so passing the low grid makes the model read a native 21x30x52 video — the same content spanning 30 rows instead of 45, i.e. a smaller video rather than a coarser sampling of this one. rope_mode="interp" stretches the positions back over the full grid instead. Measured, steps 20-40:

	native	interp
cos_low	0.5725	0.5957
err_low	1.3021	1.2875

+4% on the cosine, -1% on the error. Right direction, negligible magnitude. So "the model is computing a smaller video" is not the main cause; the divergence is not a coordinate problem.

The input normalisation. norm="forward" is amplitude-preserving but not variance-preserving: a white field's std drops to 0.644 at 45x80 -> 30x52, so the downsampled latent looks ~1.55x cleaner than the timestep the model is simultaneously told it is at. Preserving variance instead (in_scale = 1.5603) fixes the noise and over-drives the signal. Neither is right for a mixture, so it was measured:

step	err_low @1.0	@1.5603
2	2.89	2.46
20	2.03	1.55
44	0.93	1.02
48	0.75	1.01

Variance-preserving wins at high noise, amplitude-preserving at low noise, crossover around step 40-42 — exactly where the field stops being noise-dominated. The reasoning held; it is worth ~20% and does not change the verdict.

Window position and length. Later is better (err_low falls monotonically along the trajectory), and the videos agree: 0.0780 at 30..39, 0.0873 at 24..33, 0.1155 at 20..29. Doubling the window to 20 steps more than doubles the damage (0.2589) for 1.39x. There is no window that changes the exchange rate.

What did work

Carrying the CRF's high band is sound. err_high 0.2155, and on video the carry is worth 37% (LPIPS 0.0873 with, 0.1389 without). This half of the design is orthogonal to the cache family and is the part worth keeping.

The dense CRF band table

One dense 50-step generation, no caching anywhere, spectral magnitude and step-to-step change per band, low band = exactly what a 30x52 grid can represent. diagnostics/crf_bands_720p.json.

step	d_low / |low|	d_high / |high|
1-2	51-58%	40-49%
12	11.5%	19.1%
24-36	8.7%	14.3-14.8%
48-49	18-28%	24-32%

Both bands are flattest at steps 24-36, which is where the windows were placed, and which coincides with the sparsest part of the SeaCache strip. Note the high band's relative change rate exceeds the low band's everywhere — long carries are not viable.

The high band is 45-59% of the low band per coefficient (24% of total CRF energy).

Corrections — things stated earlier in this work that were wrong

1. Two earlier CRF band datasets were invalid and are not included. SIZE_CONFIGS['1280*720'] is (1280, 720) = (width, height); unpacking it as (H, W) transposed the token grid. Because F*H*W is unchanged the reshape succeeded and the spectrum came out scrambled rather than raising. The figures "high band is ~6% of low, mid-trajectory change 4.6-5.5%" came from that and are void — the correct figures are in the table above. crf_probe.py now reads the grid off patch_embedding instead of deriving it from a size string.

2. "Reuse is an order of magnitude more accurate than low-resolution recomputation." That compared two different metrics (spectral RMS over all channels vs mean-abs over 512). The same-metric measurement was then found to be contaminated — see 3 — and is being re-run. The honest statement is "several times", pending that number.

3. The reuse baseline had a cross-stream bug, found by an identity rather than by inspection: err_high and err_reuse_high are the same quantity by construction (the band we carry is the last full step's high band) and they disagreed, 0.2155 vs 0.3199. prev_crf was a single slot while Wan alternates conditional and unconditional forwards, so the conditional step was scoring itself against the unconditional stream's previous CRF. Fixed and now asserted (test T18).

4. "Passing the low grid to rope is the correct choice, not a compromise." Written into the source on the grounds that 480p is a trained resolution. Overconfident — position interpolation is standard practice and RoPE is defined continuously. It was then implemented and measured (above); it does not help, but the original dismissal was not justified by the argument given for it.

5. The reference arm was not a clean baseline. The carry ran unconditionally on every full step, so --window "" paid a full-resolution FFT round trip and 1.5 GB of PCIe per step for a cache nothing read — inflating the denominator of every speedup. Now cached only when the next step is windowed.

6. The CRF is fp32, 1.44 GiB, not bf16 774 MB. WanAttentionBlock does x = x + y * e[2] with e asserted fp32, promoting the hidden state at the first block. Every memory and PCIe estimate in the first design was 2x optimistic; it is also exactly the allocation the 14B/720p SeaCache OOM reported.

Reproducing

python crf_generate.py --task t2v-14B --size 1280*720 --ckpt_dir $CK \
  --prompt "..." --window 30-40 --low_h 30 --low_w 52 \
  --in_scale 1.0 --rope_mode native --carry high \
  --save_file out/crf_w30.mp4 --trace out/crf_w30.jsonl

--window "" gives the reference. Ranges are half-open: 30-40 is ten steps, 30..39. --probe additionally runs the full forward on every windowed step and records the per-band errors above; it doubles the cost of a windowed step and is never valid for timing.

test_crf_lowres.py — 33 checks, all passing. The load-bearing ones: T5 the empty window is bit-identical to stock WanModel.forward (max abs diff 0), since the patched forward is a reimplementation and any drift would masquerade as the method failing; T7 a correct high band recombines to 1.4e-07, so the projector, the normalisation and the up/down pairing are right; T18 the err_high == err_reuse_high identity.

Files

videos/            10 x 720p mp4, table above
traces/            per-forward record for every arm: step, stream, low, ms
                   + trace720_t0.{20,30}.jsonl, the SeaCache strips
diagnostics/       diag2_{native,interp}.jsonl   the rope comparison
                   crfprobe_alt_s{1.0,1.5603}.jsonl  the in_scale comparison
                   crf_bands_720p.json          the dense band table
code/              crf_lowres.py crf_generate.py test_crf_lowres.py
                   crf_probe.py dump_crf.py score_crf.py