acceptodds
Under review as a conference paper at ICLR 2027

KalmanCache+: Uncertainty-Aware Closed-Loop Diffusion Caching via Predict–Trust–Correct Residual Estimation

Abstract

Diffusion transformers (DiTs) achieve high-fidelity visual generation but incur substantial inference costs from repeated block evaluations across denoising steps. Training-free caching mitigates these costs through feature or residual reuse, yet fixed schedules, local proxies, and model-specific calibration provide limited control over cache reliability and accumulated skip errors. We introduce KalmanCache+, an uncertainty-aware closed-loop framework that formulates diffusion caching as sequential residual estimation. A lightweight channel-wise Kalman filter predicts residual evolution and uses predictive uncertainty to choose between FULL computation and SKIP. Prediction errors observed at FULL steps refine subsequent decisions and residual reconstructions during SKIP steps. This Predict–Trust–Correct cycle adapts online to each sampling run without modifying pretrained weights or requiring calibration tables. Across image and video DiTs, KalmanCache+ achieves latency speedups of on DiT-XL/2 (FID 2.241 vs. 2.282 for full computation), on FLUX.1-dev (LPIPS 0.199 vs. 0.368 for step reduction at ), and on Wan2.1-1.3B (PSNR 29.55 vs. 23.16 dB for TeaCache at ).

Primary area:
generative models
Keywords:
Diffusion transformers, training-free acceleration, adaptive caching, uncertainty quantification, sequential residual estimation, image and video generation

Reviews

Among:
Shape:
1234this paper, Top 17%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.75 over 4 reviews, above 83% of the others.
Reviewer_3vjROpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This work proposes KalmanCache+, a training-free framework for accelerating diffusion transformers by selectively skipping transformer-stack evaluations. A channel-wise Kalman filter estimates residual dynamics and predictive covariance, which determines whether to perform a full evaluation or reconstruct the output from cached residuals. Skipped computations use a blend of residual reuse, linear extrapolation, and a stored extrapolation mismatch. Full evaluations update both the estimator and the correction memory.

Critical strengths

The method couples the decision of when to recompute with the reconstruction of skipped outputs. Using full evaluations to improve subsequent decisions and reconstructions is a reasonable approach to managing caching errors.

The paper includes additional seeds, schedule-replay experiments, compute-budget targeting, sensitivity analysis, and overhead measurements. The reported 2.12% sampling-loop overhead over plain reuse under the same DiT schedule supports the practicality of the implementation.

Critical weaknesses

Appendix C.2 provides useful correlations with plain-reuse error on fully computed DiT trajectories, but does not directly validate the error of the actual reconstructed residual on trajectories affected by caching. The central concern is whether the gate reliably avoids large-error SKIP decisions.

Table 4 compares extrapolation with a reconstruction that includes both uncertainty-dependent blending and the stored mismatch. Although Appendix E.4 investigates blending, a controlled ablation removing only the C-DOB term while preserving the schedule and weights is still needed.

What advantages does KalmanCache+’s online adaptation offer over ERTACache’s offline-calibrated caching and error correction [1]? ERTACache explicitly analyzes cache-induced error accumulation and introduces timestep adjustment and residual error rectification.

How does C-DOB differ from FoCa’s predictor–corrector approach [2], and does it provide additional benefits under matched FULL/SKIP schedules? FoCa already combines feature forecasting with a correction mechanism to improve stability under aggressive skipping. Could the authors clarify the distinction between C-DOB and the predictor–corrector approach in FoCa?

[1] Peng, Xurui, et al. "Ertacache: Error rectification and timesteps adjustment for efficient diffusion." International Conference on Learning Representations. Vol. 2026. 2026.

[2] Zheng, Shikang, et al. "Forecast then calibrate: Feature caching as ode for efficient diffusion transformers." Proceedings of the AAAI Conference on Artificial Intelligence. Vol. 40. No. 16. 2026.

Questions for authors

Can you evaluate the relationship between the uncertainty score and the actual reconstructed-residual error on caching-generated trajectories across all three backbones? In particular, how frequently do large errors occur below the SKIP threshold, and does the score remain informative after controlling for skip length?

Can the key FLUX comparisons be conducted using a common implementation and full-computation reference? Please also report speedups relative to each implementation’s own baseline.

Can the authors provide matched-latency comparisons with ERTACache [1] and FoCa [2] under consistent implementations and evaluation protocols? Reporting both paired fidelity and reference-free generation quality, together with warmup and calibration costs, would clarify the practical advantage of KalmanCache+.

3 comments

Response to Reviewer 3vjR [1/3]: does the gate avoid large-error SKIPs, and what does C-DOB alone add?

We thank the reviewer for the careful reading and valuable feedback. Points shared with other reviewers are in the general response [1/4]–[4/4] and the additional results [1/2]–[2/2], posted at the top of this page; "reply to <reviewer>" means our comments under that reviewer's review.

Response W1/Q1

The score against the actual reconstructed error

Your central concern was whether the gate avoids large-error SKIPs. On both image backbones large errors are rare where it skips, and the score ranks the error beyond skip length; on Wan2.1 the gate is an adaptive refresh interval. Protocol and Table R1: general response [2/4].

  • Below the threshold: large errors at 2.9 and 3.0 percent‾\underline{\mathbf{2.9\text{ and }3.0\text{ percent}}} of skipped steps on DiT-XL/2 (batch 1, 23.4 FULL per image) and FLUX.1-dev, against 22.4% and 42.0% of computed steps (counterfactual skip at full weight); with plain reuse, an error without u or the weight, 1.1% vs. 25.5% and 7.2% vs. 20.9%.
  • Against two rules without error feedback (additional results [1/2]): fewer large-error SKIPs in 7 of 8 comparisons (two backbones and error definitions; the DiT-XL/2 gate at 23.4 vs. 21 FULL); the one exception is the uniform interval on FLUX.1-dev with plain reuse (7.2% vs. 6.4%); at 20.0 FULL on DiT-XL/2 the gate is not below the input-change rule.
  • At fixed cache age and step: u ranks the error at +0.30 [0.23, 0.36] (DiT-XL/2) and +0.42 [0.36, 0.47] (FLUX.1-dev). Part is mechanical, since u also sets the blend weight: for errors without u it is +0.29 and +0.15 [0.08, 0.22]. At lengths 6–7 on FLUX.1-dev (8% of gated steps) the ordering vanishes or reverses.
  • Wan2.1: u follows cache age (Spearman 0.98) and ranks the error inversely at fixed age and step (−0.40); skipped steps (81% of gated steps) hold 54% of the large errors, which occur at 9.1% of skipped vs. 32.9% of computed steps.

Response W2

Removing only C-DOB, with the schedule and weight rule fixed

Table R3: Same FULL/SKIP schedule and weight rule; only the C-DOB term removed. DiT-XL/2: FID-50K at 21/50 FULL steps (the gate's schedule replayed). FLUX.1-dev: DrawBench-200 at 13/50. Wan2.1-1.3B: 50 prompts at 22/50.

BackboneMetricwithout C-DOBwith C-DOB
DiT-XL/2, seed 0FID ↓2.3992.251‾\underline{\mathbf{2.251}}
DiT-XL/2, seed 1FID ↓2.3492.195†
FLUX.1-devPSNR ↑ / SSIM ↑ / LPIPS ↓20.49 / 0.7926 / 0.220520.85 / 0.7935 / 0.2160
Wan2.1-1.3BPSNR ↑ / SSIM ↑ / LPIPS ↓29.29 / 0.9144 / 0.048129.29 / 0.9195 / 0.0458

† Both seed-1 values are from the rebuttal server, which reproduces the paper's 2.195 (seed 1, replayed) and 2.241 (seed 0, adaptive).

On the calibrated 13-, 20-, and 10-FULL FLUX.1-dev schedules, C-DOB adds +0.20 / +0.09 / +0.04 dB on DrawBench-200 and +0.34 / +0.09 / +0.05 dB on 200 held-out COCO captions, every interval above zero.

Every question, in one line

Your questionOur answer in one lineEvidence
W1/Q1: does the gate avoid large-error SKIPs, also at fixed skip length?2.9% / 3.0% of SKIP steps on DiT-XL/2 / FLUX.1-dev, 1.1% / 7.2% with plain reuse; fewer than the two rules in 7 of 8 comparisons; u ranks the error at fixed cache age (skip length); Wan2.1: adaptive refresh interval.above; general response [2/4]
W2: remove only C-DOB, schedule and weights fixedWithout it, DiT-XL/2 FID goes 2.251 → 2.399 and 2.195 → 2.349; FLUX.1-dev loses 0.356 dB [0.195, 0.523] with per-step weights replayed exactly; Wan2.1: same PSNR, worse SSIM/LPIPS.Table R3, above
W3: online adaptation vs. ERTACache's offline calibrationNo trajectory dumps or fitted coefficients; near 2× on Wan2.1, +4.5 to +6.0 dB over its shipped list and +1.87 / +3.37 dB over a stronger one, both significant on new prompts; +1.42 dB at 2.64× vs. 2.67×, behind near 3×.Table R4, [2/3]
W4: C-DOB vs. FoCa, benefit on matched schedulesComplete methods: +3.3 / +2.5 / +1.7 dB over our FoCa on its uniform schedules; identical FULL lists: +0.76 / +1.63 dB at 13.2 / 10.1 FULL (n.s. at 17.9); same schedule and blend: 20.85 vs. 20.68 dB.Table R6, [3/3]
Q2: common implementation; own-baseline speedupsOne codebase, reference, and 4-step warmup: +3.2 / +1.9 / +0.9 dB over the best forecasting baseline at 2.6–2.8 / 3.8 / 5.0× FLOPs, with less time. Own denominators (six rows: reply to X484 [2/3]): ours 2.46× / 3.61×, TaylorSeer (N=5, O=1) 3.28×.Table R0 (general response [1/4]); reply to X484
Q3: matched latency, reference-free quality, costsERTACache on Wan2.1 and FLUX.1-dev; VBench near 2×: full 83.26%, ERTACache 82.60%, ours 82.79% / 83.19% (50 prompts, descriptive); FoCa at equal FULL counts and lists; costs: Table R5.Tables R4–R6

Response to Reviewer 3vjR [2/3]: how does KalmanCache+ compare with ERTACache at near-matched latency?

Response W3 and Q3

ERTACache at near-matched latency

We compare the complete methods near 2× with ERTACache's official code; calibration and warmup-selection costs are in Table R5 ([3/3]).

Without trajectory dumps or fitted coefficients, KalmanCache+ is closer to full computation than ERTACache near 2× on Wan2.1, against its shipped skip list and a stronger list we searched with its procedure. We ran its official code (timestep adjustment and rectification on, coefficients fitted on 10 prompts outside the evaluation set) with our 50 prompts (seed 2; also used by the paper's warmup sweep), reference, and evaluator. On Wan2.1 our gate acts as an adaptive refresh interval, so this compares schedule plus reconstruction with calibrated schedule plus rectification.

Table R4: Wan2.1-1.3B, 81 frames, 832×480, one A100; full computation 196 s. Bold: best per latency group.

MethodComputed stepsTime (speedup)PSNR ↑SSIM ↑LPIPS ↓
ERTACache, shipped list2495.2 s (2.06×)25.650.86700.0824
ERTACache, our list (thr. 0.12)2495.2 s (2.06×)28.240.91030.0541
KalmanCache+ (λ=22, W=15)22.690.7 s (2.16×)30.110.93110.0389
KalmanCache+ (λ=25, W=18)25.099.4 s (1.97×)31.610.94410.0311
ERTACache, our list (thr. 0.175)1873.5 s (2.67×)24.180.84050.1049
KalmanCache+ (λ=40, W=11)1874.3 s (2.64×)25.610.85920.1010
ERTACache, our list (thr. 0.2)1666.0 s (2.97×)22.170.79220.1485
KalmanCache+ (λ=32, W=7)1563.8 s (3.07×)21.170.75530.1852
  • Near 2×, from both sides of its latency: the paper's two settings are +4.5 to +6.0 dB closer than its shipped list. Its threshold search with our list-merging rule (its code gives none), run at 24 steps, beats the shipped list by +2.59 dB [1.88, 3.34]; against that list our margins are +1.87 and +3.37 dB‾\underline{\mathbf{+1.87\text{ and }+3.37\text{ dB}}} ([1.43, 2.32], [3.05, 3.73]), with lower LPIPS. On 50 new prompts, settings frozen: +4.23 / +5.39 dB over the shipped list and +1.25 / +2.42 dB over our list ([0.55, 1.82], [1.46, 3.14]; SSIM, LPIPS n.s.).
  • Higher acceleration (same procedure, 5 calibration prompts, step counts fixed in advance): at 2.64× vs. 2.67× we are +1.42 dB [0.50, 2.17] while 0.8 s slower (SSIM, LPIPS n.s.), and +0.27 dB with worse SSIM/LPIPS (all n.s.) when ERTACache gets 2.8 s more (2.54×). At about 3× ERTACache is 1.00 dB [0.37, 1.69] ahead with better SSIM and LPIPS, and still 1.09 dB [0.43, 1.75] ahead when we add one FULL step to match its time (66.4 vs. 66.0 s). New prompts: +1.36 / −1.05 dB at the 2.64× / 3× pairs, −0.72 at matched time (2.8 s bracket not re-run).
  • FLUX.1-dev: our fastest diffusers point (λ=100, 5.87 s) shows no significant PSNR, LPIPS, or ImageReward difference from ERTACache's released configuration (ImageReward 0.949 vs. 0.902; full computation 1.029), with lower SSIM. ERTACache (8 of 28 steps computed) is 1.5 s faster at 4.37 s (uncached 28 steps: 19.56 dB); we have no point at its speed.

Response to Reviewer 3vjR [3/3]: how does C-DOB differ from FoCa, and what does calibration cost?

Response W4

C-DOB vs. FoCa's predictor–corrector

Both correct forecasts with full computations; with the same schedule and blend they are close, and on identical FULL lists our margin over FoCa grows as FULL steps become scarcer. FoCa applies a BDF2 predictor and a Heun-type corrector per cached module with fixed weights. C-DOB stores one tensor, the extrapolation error Dj=Rj−EjD_j = R_j - E_j of the block-stack residual at a FULL step, and adds it through the next SKIP segment with the trust weight wi=min⁡(1,ui/λ)w_i = \min(1, u_i/\lambda); with equally spaced FULL steps, DjD_j is the second backward difference of the last three FULL residuals.

Table R6: FLUX.1-dev, DrawBench-200, the 13/50-FULL schedule of Table R3; block-stack residual only.

CorrectionPSNR ↑SSIM ↑LPIPS ↓
C-DOB in our trust-weighted blend20.850.79350.2160
FoCa-style corrector in the blend20.680.79600.2156
FoCa-style corrector, full weight20.250.78890.2216
C-DOB, full weight18.420.6840.376
  • Same schedule: in the blend, C-DOB is +0.16 dB PSNR and the FoCa-style corrector +0.0025 SSIM, LPIPS within 0.0004, and combining them does not help (20.77 dB). At full weight both fall below the blend, so on FLUX.1-dev the small blend weight matters more than the corrector.
  • Complete methods (our re-implementation; its corrector variant fixed by a pre-set rule on 30 of the 200 prompts): on FoCa's uniform schedules (Table R0) KalmanCache+ is +3.3, +2.5, and +1.7 dB‾\underline{\mathbf{+3.3\text{, }+2.5\text{, and }+1.7\text{ dB}}} above it at 2.6–2.8, 3.8, and 5.0× FLOPs and comparable FULL counts, ImageReward n.s. On our gate's identical FULL lists, KalmanCache+ − FoCa is +0.76 [0.62, 0.89] and +1.63 [1.47, 1.79] dB, LPIPS −0.008 and −0.040 (ImageReward n.s.), at 13.2 and 10.1 FULL steps; at 17.9 it is −0.09 dB [−0.40, +0.22] with worse LPIPS (+0.009 [0.004, 0.015]) and ImageReward (−0.019 [−0.038, −0.003]).
  • Scope: our FoCa is within 0.07 dB of TaylorSeer O2, with a smaller ImageReward gain than FoCa reports, so these rows are our best reproduction, not a verdict on FoCa; its times, slower than TaylorSeer's, do not represent FoCa's own latency, so we compare at comparable FULL counts and transformer FLOPs.

Response Q3

Warmup and calibration costs

KalmanCache+ stores no trajectory dumps or coefficients; λ comes from a sweep or a compute-log pilot, the video warmup from full computation.

Table R5: what each method needs before a run.

KalmanCache+ERTACacheFoCa
Calibration datacompute logs for λ; video warmup vs. full computationcached and full trajectories of calibration promptsnone
Stored per model and step countsettings λ, W only; no fitted tablesskip list, per-timestep coefficientsinterval N
Offline costλ pilot about 0.8 (DiT) and 16 (FLUX) A100-minutes; Wan W sweep: 5 × 50 videos, about 383 A100-minutes, plus 50 references (163)50.5 A100-minutes on Wan2.1 (8.5 GB of dumps, then the fit), 4.4 A100-minutes on FLUX.1-dev; list searches excludedinterval N per model

Warmup steps are FULL steps, included in all FLOPs and latencies.

Planned changes for the revised paper

  • Table R1 in Appendix C.4, the Wan2.1 scope in the Limitations, and C-DOB-only rows in Table 4.
  • ERTACache and FoCa in Section 2.2, Lim.2 revised; Tables R4–R6 in Appendix G.
  • Table 2 split by implementation, Table R0 in Section 4.2, Algorithm 1 and Table 5 moved up to Section 3.

If a comparison is still missing, please tell us; we will prioritize the requested comparisons during the discussion period.

Again, we sincerely thank the reviewer for the constructive feedback. If you feel your concerns have been addressed, we would be grateful if you could reconsider the rating.

Reviewer_XBVwOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

KalmanCache+ uses a compact state estimator to track residual dynamics and decides when to refresh the full diffusion model from predicted uncertainty. At skipped steps, it combines extrapolation, feedback from the last observed prediction mismatch, and an uncertainty-dependent blend. Full evaluations update both the estimator and the residual correction. Experiments on DiT, FLUX, and Wan2.1 report favorable speed–fidelity tradeoffs. The design is coherent and has useful controlled ablations, but the uncertainty score’s relationship to actual reconstruction error and the advantage over strong fixed schedules remain insufficiently established.

Critical strengths
  1. The method integrates prediction and feedback effectively. A full evaluation updates both the uncertainty estimate and the observed prediction mismatch, which then guide subsequent reuse. This addresses accumulated error while keeping the estimator state small. The reconstruction at skipped steps does not require an unavailable ground-truth residual, making the feedback mechanism practical for inference.
  2. The ablations separate reconstruction from scheduling. With the replayed schedule fixed, Table 4 improves DiT FID from 2.953 with reuse to 2.325 with extrapolation and 2.251 with the closed-loop reconstruction. A separate same-count analysis attributes 0.52 dB of the 0.69 dB FLUX adaptive-gate gain to changed step placement. These controls provide evidence for specific design choices beyond comparing complete systems.
  3. Controlled comparisons and measured overhead support practical value. The four-seed comparison against TeaCache uses a common reference and reports a FLUX PSNR improvement of 4.64 dB, with a 95% interval of [4.19, 5.09]. Parameter and warmup sensitivity are also examined. At an identical DiT schedule, the added machinery costs about 2.12% in sampling-loop time relative to plain reuse, supporting the feasibility of the implementation.
Critical weaknesses
  1. The uncertainty score is not directly validated against the error it controls. The diagnostic relates covariance to full-tensor plain-reuse error on shadow trajectories. Deployment instead uses corrected and blended residual predictions on trajectories already affected by caching. In addition, channel means can hide spatial errors that cancel under averaging. The gate’s empirical benefit is encouraging, but it does not establish that the score reliably ranks the actual reconstruction errors at deployed states. This relationship needs testing for both image and video generation before interpreting the score as a dependable measure of cache reliability.
  2. The main FLUX comparison does not use a single implementation and reference. The table combines two implementations with different full-model latencies, uses their mean as a shared speedup denominator, and measures fidelity against each method’s own implementation. This makes the overall ranking harder to interpret as a comparison against the same target trajectory. The controlled TeaCache experiment is a valuable partial remedy, but it does not establish the same conclusion for the other listed baselines. A common implementation and reference, or clearly separated within-implementation comparisons, are needed for the broader claim.
  3. The fixed-schedule baseline does not test the strongest alternative to online adaptation. The replay control uses the first prompt’s or batch’s schedule. This tests adaptation against one fixed choice, rather than a reusable schedule selected on independent calibration data at the same budget. Much of the observed improvement is already present when better reconstruction is used with fixed scheduling. A stronger static baseline is therefore important for determining whether uncertainty-based online decisions provide enough additional value beyond the reconstruction mechanism itself.
Questions for authors
  1. Can you compare the uncertainty score with the actual corrected-residual error at cached states, using full evaluations only for diagnosis? Please include cache age and a simple innovation-based score as controls, and test both image and video settings.
  2. Can the strongest FLUX baselines be evaluated with one implementation and reference, or reported as separate within-implementation comparisons with their own speedup denominators? Which conclusions remain beyond the controlled TeaCache result?
  3. How much of the adaptive-gate gain remains against a reusable schedule selected on disjoint calibration prompts, with the same reconstruction rule and FULL budget? Please retain the same-count analysis to distinguish better placement from extra computation
7 comments

Response to Reviewer XBVw [1/3]: does u rank the actual error beyond cache age?

We thank the reviewer for the careful reading and three precise requests. The results for each follow, with what they establish; points shared with other reviewers are in the general response [1/4]–[4/4] and the additional results [1/2]–[2/2], posted at the top of this page; "reply to <reviewer>" means our comments under that reviewer's review.

Your summary named two open points. The score's relation to the actual reconstruction error is now measured at deployed states (Table R10 below; as a gate, the innovation control loses on DiT-XL/2 at both seeds). Against strong fixed schedules, the gate's schedule leads at 21 FULL on DiT-XL/2 without a reference search, and our reconstruction lifts calibrated schedules too (+0.86 dB; +1.08 dB on held-out COCO). On FLUX.1-dev a schedule searched against full-computation references leads our deployed gate at 13 FULL ([3/3]), while at 20 FULL the gate, with its warmup and λ set on the same calibration prompts, leads the schedule selected for that budget by +1.42 dB on held-out prompts at 19.994 vs. 20.000 FULL (further results §17).

Response Q1 / W1

u against the actual corrected-residual error

Table R10 compares how u, innovation, and the C-DOB mismatch rank this error within fixed cache-age and step groups, and separately reports the correlation between u and cache age.

On both image backbones u ranks the actual error beyond cache age, and at the same FLUX.1-dev budget the gate built on u beats a gate on a better-ranking past-error signal by 2.08 dB‾\underline{\mathbf{2.08\text{ dB}}} [1.85, 2.32] with a shared blend (3.04 dB with each gate's own blend). The deployed method runs unchanged on all three backbones; at every gated step the true residual is evaluated at the cached state for diagnosis only (outputs bit-identical). The error is the relative squared L2 error over the whole hidden tensor, for the corrected and blended tensor used at skipped steps and for the full-weight (w = 1) reconstruction at computed steps.

Table R10: mean within-(cache age, step) Spearman with this error, on the common records (every score defined). 95% cluster-bootstrap intervals.

Score available at decision timeDiT-XL/2FLUX.1-devWan2.1-1.3B
u (the gate)+0.32 [0.24, 0.39]+0.41 [0.35, 0.47]−0.31 [−0.65, 0.12]
Kalman innovation on channel means, running average+0.45 [0.37, 0.50]+0.30 [0.20, 0.36]+0.36 [−0.02, 0.72]
Kalman innovation, last FULL step+0.48 [0.41, 0.53]+0.40 [0.33, 0.46]+0.36 [−0.02, 0.72]
Tensor mismatch stored by C-DOB, last FULL step+0.87 [0.85, 0.88]+0.85 [0.82, 0.86]+0.96 [0.86, 0.98]
Spearman(u, cache age), all gated steps0.590.880.98
  • Beyond cache age. Part of the ranking is mechanical, since u also sets the blend weight: for errors that do not contain u it is +0.29 on DiT-XL/2 and +0.15 on FLUX.1-dev.
  • Controls. The running-average innovation beats u on DiT-XL/2 (+0.12 [0.06, 0.19]) and trails it on FLUX.1-dev (−0.12 [−0.20, −0.04]). As a gate, however, the innovation score loses: on DiT-XL/2, with its running average (times cache age) thresholded to target about 21 FULL on calibration batches, FID-50K is 2.281 / 2.232 vs. 2.241 / 2.187 for the Kalman gate (seeds 0 / 1). The tensor mismatch ranks best everywhere, which supports the premise of C-DOB, but it is observed only at FULL steps, while a SKIP decision needs a forecast along the next segment. Gating on its running average (rank correlation +0.66 on FLUX.1-dev) at the same budget gives 18.49 vs. 21.54 dB (18.35 vs. 23.54 dB with W = 8 for both), and with a shared constant blend the Kalman gate is still +2.08 / +3.11 dB ahead; six tuned variants trail by at least 1.81 dB (reply to X484).
  • Video. On Wan2.1-1.3B u is almost a function of cache age and ranks the error inversely at fixed age (−0.40 [−0.68, −0.04] on all records, Table R1); we describe the video gate as an adaptive refresh interval.

Response to Reviewer XBVw [2/3]: what remains beyond TeaCache in one implementation?

Every question, in one line

Your question or pointOur answer in one lineWhere
W1 / Q1: u vs. the actual corrected-residual error, with cache-age and innovation controls, image and videoOn images large errors occur at 2.9% / 3.0% of skipped vs. 22.4% / 42.0% of computed steps (scored at w = 1), and u ranks the error at fixed cache age and step (+0.32 / +0.41, Table R10; +0.30 / +0.42 on all records, Table R1); innovation ranks better on DiT-XL/2 but as a gate loses there at both seeds (FID 2.281 / 2.232 vs. 2.241 / 2.187), and ranks worse on FLUX.1-dev; the last-step mismatch ranks best, yet a gate on its running average is 3.04–5.19 dB worse, and the best of six tuned variants 1.81 dB worse (held-out COCO: 2.02 dB); on video the gate acts as an adaptive refresh interval.Q1, Table R10; general response (GR) Table R1
W1: channel means may hide spatial errors that cancelThe error is measured over the whole hidden tensor, so spatial errors cannot cancel in the test, and u, from channel means, still ranks it (+0.32 / +0.41 on images, Table R10); revised Section 3 will state that the filter sets the budget and the reconstruction uses full tensors.Q1
W2 / Q2: one implementation and reference, or own denominatorsBoth: forecasting baselines and our TeaCache port share one codebase and reference with KalmanCache+; Table 2 will be split into blocks by implementation with their own denominators.Q2; GR Table R0
Q2: what remains beyond the TeaCache control+3.2 / +1.9 / +0.9 dB over uniform-schedule forecasting at 2.6–2.8 / 3.8 / 5.0× FLOPs with less time; mostly the gate's schedule below 5×, plus +0.39 / +0.55 / +0.78 dB from our reconstruction on the same lists.Q2
W3 / Q3: reusable schedule from calibration prompts, same reconstruction and budgetDiT-XL/2 (21 FULL): the gate's schedule has 0.05–0.07 lower FID than the selected one (all three seeds; further results §18). FLUX.1-dev: the selected one is 1.51 dB higher at 13 FULL, while at 20 FULL the gate, with W and λ set on the calibration prompts, leads it by +1.42 dB (further results §17).Q3, Table R11
Q3: keep the same-count analysisKept, and reported beside the tuned schedule in [3/3]: the gate is −1.60 / −1.10 dB on prompts where it uses 13 / 14 FULL (static uses 13 in both).Q3
Strengths you creditedC-DOB lowers DiT-XL/2 FID at a fixed schedule on two seeds, and the mismatch it stores ranks later errors best; the reconstruction gain holds on the calibrated schedule (+0.86 dB over reuse on FLUX.1-dev); TeaCache also trails in one codebase (+2.7 to +6.2 dB).GR Table R3; Table R10; reply to X484

Response Q2 / W2

One implementation, and what remains beyond TeaCache

We did both: forecasting baselines and TeaCache share one codebase and reference with KalmanCache+, and Table 2 will be split into within-implementation blocks (own denominators shift speedups by about 5% in the TaylorSeer-codebase and diffusers blocks; reply to X484).

  • What remains. (i) With the same 4-step warmup, KalmanCache+ is +3.2, +1.9, and +0.9 dB‾\underline{\mathbf{+3.2\text{, }+1.9\text{, and }+0.9\text{ dB}}} closer to full computation than the best of TaylorSeer O2, HiCache, and our FoCa on their uniform schedules at 2.6–2.8, 3.8, and 5.0× FLOPs, with less time (Table R0). Below 5× most of the margin is the gate's schedule: on our gate's per-prompt lists HiCache gains +2.98 / +1.37 / +0.13 dB, and our reconstruction adds +0.39 / +0.55 / +0.78 dB (the split reproduces on 200 held-out COCO captions). (ii) TeaCache trails in both implementations (+2.7 to +6.2 dB at nearby-latency pairs in one codebase; reply to X484).
  • Other schedules and baselines. (iii) On tuned static schedules our reconstruction is +0.43 dB above HiCache at 13 FULL, the highest PSNR of the five methods (Table R14, reply to SFES); SeaCache, absent from the submission: our reconstruction improves its warmup-matched 13-FULL schedule (Table R13, general response [4/4]). (iv) FORA, ToCa, and Δ-DiT will be ranked within their own implementations.

Response to Reviewer XBVw [3/3]: how does the gate compare with a schedule selected on calibration prompts?

Response Q3 / W3

The gate against a schedule selected on calibration prompts

On DiT-XL/2 (21 FULL) the gate's schedule has 0.05–0.07 lower FID‾\underline{\mathbf{0.05\text{–}0.07\text{ lower FID}}} than the selected static schedule at both seeds, without the search. On FLUX.1-dev the selected schedule is 1.51 dB [1.24, 1.78] above our deployed gate at 13 FULL; at 20 FULL, with its warmup and λ set on the same calibration prompts, the gate is +1.42 dB above the schedule selected for that budget on held-out prompts at 19.994 vs. 20.000 FULL, and on DiT-XL/2 its lower FID holds at a third seed (further results §17–§18). The rule was fixed before the runs: 18 FLUX.1-dev and 16 DiT-XL/2 candidates at Table 4's budget, the same protected steps and reconstruction, and the lowest LPIPS on calibration data (40 DrawBench prompts; 1,024 DiT samples at a non-evaluation seed), frozen and evaluated once.

Table R11: same FULL budget and reconstruction; static from the rebuttal server, seed-1 gate values from the submission's runs (the adaptive 2.187 and the replay 2.195 reproduced on the rebuttal server).

Backbone (FULL of 50), metricScheduleResult
FLUX.1-dev (13), PSNR / LPIPSSelected static (front-loaded, λ=8)23.05 / 0.176
Gate, deployed (W=4, λ=8; 13.2 FULL)21.54 / 0.199
Gate, W=6 (λ=20; 13.1 FULL)22.58 / 0.185
Gate, W=8 (λ=40; 13.5 FULL)23.54 / 0.176
DiT-XL/2 (21), FID-50K seed 0 / 1Selected static (late-dense)2.301 / 2.252
Gate, adaptive (λ=5)2.241 / 2.187
Gate's schedule, replayed2.251 / 2.195
  • FLUX.1-dev, same count. The gap holds on the 160 held-out prompts (+1.53) and on 200 COCO captions never used for any choice (+1.67 dB [1.40, 1.95]). The deployed gate is −1.60 / −1.10 dB on 165 / 35 prompts where it uses 13 / 14 FULL; the static schedule uses 13. The W=8 gate (a warmup examined on the evaluation prompts, blend λ=40) is +0.49 dB above the static schedule only through its 109 prompts with a 14th FULL step (+1.05 dB; −0.18 dB on the other 91). The paper's 0.52 of 0.69 dB is a placement gain over first-prompt replay, as revised Appendix D.3 will state.
  • DiT-XL/2. The gate's schedule is 0.05–0.07 FID better at two seeds and replays nearly as well, so the gain is its schedule; the selection's own LPIPS ranked the gate's schedule second of 16, so the ordering is specific to FID.
  • What the gate contributes. A schedule obtained inside the run without a search against full-computation references, with λ setting the budget without reference outputs (W is a second setting; in further results §17 W and λ are set on the calibration prompts). Separately, the reconstruction adds +0.86 dB [0.69, 1.04] and −0.030 LPIPS over plain reuse on the selected FLUX.1-dev schedule (+1.08 dB [0.93, 1.23] on 200 held-out COCO captions); on DiT-XL/2 plain reuse is 0.72–1.84 FID worse on the selected lists of all three budgets (Table R21, additional results [2/2]) and 2.953 vs. 2.251 on the gate's fixed schedule.

Planned changes for the revised paper

  • Appendix C.2: the sentence that u "carries information about this error beyond the gap itself, which is what the trust gate relies on" is replaced by Tables R1 and R10 (Appendix C.4), with the controls and the video scope.
  • Section 4.3 and Table 4: the calibrated static schedule is added and the placement claim scoped to first-prompt replay (Tables R11–R12, same-count analysis: Appendices D.3, G); the Limitations will state that a tuned static schedule beats the deployed gate on FLUX.1-dev and at the two lower DiT-XL/2 budgets.
  • Table 2 in within-implementation blocks with each baseline's initial FULL steps; Table R0.
  • Contributions: a reference-free budget controller that finds its schedule inside the run, and a reconstruction that improves on plain reuse at fixed schedules; the abstract and contributions define closed-loop as closing at FULL steps.

If a comparison is still missing, please tell us; we will prioritize the requested comparisons during the discussion period.

Again, we sincerely thank the reviewer for the constructive feedback. If you feel your concerns have been addressed, we would be grateful if you could reconsider the rating.

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

KalmanCache+ accelerates diffusion transformers by treating residual caching as an online estimation problem. A channel-wise Kalman filter tracks residual dynamics and uses predicted uncertainty to decide when to run the transformer blocks. At full-computation steps, the observed prediction errors update the filter and provide a correction term for later residual reconstruction. The method is evaluated on DiT, FLUX, and Wan.

Critical strengths

A Coherent Use of Online Feedback.** The method gives full-computation steps a useful role beyond refreshing the cache. Observed errors inform both future computation decisions and residual reconstruction. This is a coherent approach to reducing drift during cached inference. Promising Results with Substantial Component Analysis.** The results are promising across image and video generation. On FLUX, the method reaches 3.10× acceleration with LPIPS 0.199, compared with 0.368 for step reduction at 2.88×. On Wan, it improves fidelity over TeaCache at a similar latency. The experiments make a substantial effort to explain the gains. They include schedule replay, reconstruction ablations, noise-adaptation checks, multiple seeds for selected comparisons, and runtime overhead measurements. The additional FLUX comparison against TeaCache uses shared references across four seeds, providing useful support for the fidelity improvement.

Critical weaknesses

The Uncertainty and Feedback Mechanisms Need Closer Validation. The filter tracks channel means, while the skipped computation reconstructs a full tensor using extrapolation, blending, and a stored correction. Spatial errors can cancel when averaged within a channel, so the connection between these two quantities deserves closer examination. Appendix C.2 provides useful evidence, but it measures plain-reuse error on fully computed DiT trajectories. The method's actual predictions are made on trajectories already affected by earlier skips, and use a different reconstruction rule. The current analysis therefore leaves an important part of the uncertainty argument untested.

Individual Feedback Components Are Not Sufficiently Isolated.** The method combines covariance-based gating, adaptive noise estimation, uncertainty-weighted blending, and the C-DOB correction. Table 4 supports the combined reconstruction, and Appendix E.4 shows that the proposed blend is better than applying the correction at full weight. A stronger test would compare it with a tuned constant weight or a weight based only on the gap since the last full evaluation. The matched-budget noise-adaptation ablation also changes the threshold and hence the blend weights. This makes it difficult to tell how much of the improvement comes from better scheduling and how much comes from reconstruction.

The FLUX Comparison Would Be Clearer Under a Common Implementation and Reference.** Appendix B.3 reports two implementations with full-computation latencies of 23.28 s and 25.71 s, while Table 2 uses their mean as the speedup reference. Paired fidelity metrics are also computed against each method's own full-computation output. These differences complicate comparisons across implementations, especially when methods operate at nearby latencies. The shared-reference TeaCache experiment in Appendix E.2 is helpful. Extending that control to a forecasting baseline would make the broader comparison more convincing.

Questions for authors

Q1. How well does the uncertainty score track the full-tensor reconstruction error during cached inference on all three backbones? In particular, how often do large errors occur at scores that the gate considers safe to skip?

Q2. On a fixed schedule, could the authors separately remove the C-DOB term and replace the uncertainty-based blend with simpler weights? A matched-budget comparison with a gate based on a running average of recent prediction errors would also help establish the value of the Kalman formulation.

Q3. Could the authors compare KalmanCache+, TaylorSeer, and a strong adaptive caching baseline in one implementation, using the same full-computation reference and comparable measured latency?

7 comments

Response to Reviewer X484 [1/3]: does u track the error on cached trajectories?

We thank the reviewer for the careful reading and valuable feedback. Each requested control follows, with its backbone; points shared with other reviewers are in the general response [1/4]–[4/4] and the additional results [1/2]–[2/2], posted at the top of this page; "reply to <reviewer>" means our comments under that reviewer's review.

Response Q1 / W1

u on the deployed, cached trajectories

On the deployed, cached trajectories we compare how often large errors occur at skipped and at computed steps, also for plain reuse, which contains no u.

On trajectories shaped by earlier skips, large errors are rarer at skipped than at computed steps on both image backbones, also for an error without u. Protocol: general response [2/4]; the error is ‖R − R̂‖²/‖R‖² over the whole hidden tensor, so nothing is averaged within a channel.

  • How often. Large errors (top decile, threshold from other runs) occur at 2.9% (DiT-XL/2, batch 1, 23.4 FULL), 3.0%, and 9.1% (Wan2.1, 12 prompts) of skipped steps vs. 22.4%, 42.0%, and 32.9% of computed steps. For plain reuse, an error without u, 1.1% and 7.2% vs. 25.5% and 20.9% on the two image backbones. Against the uniform and input-change rules at the main operating points, the gate has fewer in 7 of 8‾\underline{\mathbf{7\text{ of }8}} comparisons (two backbones and error definitions; the DiT-XL/2 gate at 23.4 vs. 21 FULL; additional results [1/2]). The exception is the uniform interval on FLUX.1-dev with plain reuse (7.2% vs. 6.4%; 13.3% with its deployed, weight-capped reconstruction).
  • Beyond cache age. At fixed cache age and step, u ranks the error at +0.30 [0.23, 0.36] on DiT-XL/2 and +0.42 [0.36, 0.47] on FLUX.1-dev; for plain reuse, whose error does not contain u, +0.29 and +0.15.
  • Wan2.1 and channel means. On Wan2.1 u is almost cache age (Spearman 0.98; −0.40 at fixed age), so the video gate is an adaptive refresh interval. The tensor mismatch C-DOB stores ranks the error better than u (+0.87 / +0.85 / +0.96), yet a gate on its running average is much worse (Q2).

Every question, in one line

Your questionOur answer in one lineEvidence
W1: channel means; C.2 uses plain reuse on fully computed trajectoriesFull-tensor error of the method's own reconstruction on its cached trajectories, three backbones.Q1
Q1: does u track that error; how often are large errors skipped?2.9% / 3.0% of skipped steps (DiT-XL/2 at 23.4 FULL / FLUX.1-dev), 1.1% / 7.2% with plain reuse; fewer than the two rules in 7 of 8 tested comparisons; u ranks the error beyond cache age; Wan2.1: cache age.Q1; Table R1
W2: constant or gap-only weights; noise adaptation confounds schedule and weightsOn FLUX.1-dev no simple weight is significantly better than u (best +0.09 dB, n.s.). With one constant blend for both, freezing the noise scales at the same FULL count costs 1.98 / 3.49 dB, so the schedule carries the effect.Q2; additional results [1/2]
Q2: C-DOB alone; running-average gateC-DOB isolated: DiT-XL/2 FID 2.399 → 2.251. Kalman gate +2.08 dB with a shared blend (+3.04 dB with its own); the best tuned variant stays 1.81 dB behind.Q2; Tables R3, R8
Q3: one implementation, TaylorSeer, strong adaptive baselineOne codebase and reference: +3.2 / +1.9 / +0.9 dB over forecasting, +2.7 to +6.2 dB over TeaCache, faster on one GPU. With W chosen on calibration prompts our gate beats SeaCache at its 13 / 20 FULL budgets (+0.69 / +2.42 dB); without our runner's per-image memory reset we take 6.906 vs. 6.965 s at 13.24 vs. 13.00 FULL; and on SeaCache's δ=0.3 schedule our reconstruction beats it at matched latency (further results §15–§16).Q3; Table R0 (general response [1/4])
W3: mean denominator; own referencesOwn denominators; re-measured latencies are 0.984–1.031× the paper's.W3

Response to Reviewer X484 [2/3]: what does each component add, and what do own denominators change?

Response Q2 / W2

Each component isolated

At the same budget and with one shared blend, the Kalman gate beats a running-average gate by +2.08 dB‾\underline{\mathbf{+2.08\text{ dB}}} (+3.04 dB with each gate's own blend); on a fixed schedule C-DOB lowers DiT-XL/2 FID at two seeds, raises FLUX.1-dev PSNR by 0.36 dB, and improves SSIM and LPIPS on Wan2.1 (no interval).

Table R8: requested controls (FLUX.1-dev, 200 prompts, unless noted)

ControlResult
Running-average gate (EMA 0.5 of ‖D‖²/‖R‖² × age²; threshold for 13.3 vs. 13.2 FULL)Kalman gate 21.54 vs. 18.49 dB (paired 3.04 [2.75, 3.35]), LPIPS 0.199 vs. 0.301; warmup 8: +5.19 dB [4.76, 5.63]
Both gates, one constant blend (w = 0.25)Kalman gate +2.08 dB [1.85, 2.32] and +3.11 dB [2.74, 3.53] (warmup 4, 8), lower LPIPS
Without → with C-DOB, schedule fixedDiT-XL/2 FID 2.399 → 2.251 (seed 0), 2.349 → 2.195 (seed 1); FLUX.1-dev +0.356 dB [0.195, 0.523] with weights replayed; Wan2.1 SSIM 0.9144 → 0.9195, LPIPS 0.0481 → 0.0458, equal PSNR
Full weight (w = 1) + C-DOBDiT-XL/2 FID 2.219 (one seed; lower than our 2.251); FLUX.1-dev 18.42 dB, below plain reuse (20.37)
Six constant or gap-only weights (swept on evaluation prompts), 13-FULL schedulebest +0.09 dB above u [−0.05, +0.23]; u has the lowest LPIPS (tied); fast-growing weights lose 1.1–1.4 dB
Noise adaptation on vs. off, 2×2 (on: λ=2, 17.9 FULL; off: λ=8, 18.1 FULL)schedule effect +3.20 dB [2.77, 3.65] with reconstruction held 'off' (+5.04 held 'on'); reconstruction effect +0.24 dB [−0.13, 0.63] with schedule held 'on' (−1.60 held 'off')

Six tuned variants (three rates × two age powers) trail by at least 1.81 dB [1.59, 2.04] at the same budget and blend. On 200 held-out COCO captions, with every threshold re-calibrated the same way, the best of the six trails by 2.02 dB [1.80, 2.24]. On DiT-XL/2, a gate on the running average of the filter's innovation (times cache age), thresholded to target about 21 FULL on calibration batches, also loses at both seeds: FID-50K 2.281 / 2.232 vs. 2.241 / 2.187 for the Kalman gate. The weight rule needs no parameter of its own: it is scaled by λ, the same knob that sets the FULL budget.

Response W3

Denominators and references

With each implementation's own full computation as denominator, the speedups in diffusers, including ours, rise and those in the TaylorSeer codebase fall; Table 2 will become blocks by implementation, with each fidelity reference stated. Re-measured on unshared A100 GPUs (50 prompts per row), every latency is 0.984–1.031×‾\underline{\mathbf{0.984\text{–}1.031\times}} the paper value; one nearby pair swaps order: KalmanCache+ at 36% compute and TeaCache (l=0.4) take 10.60 vs. 10.35 s in this re-timing.

Method (Table 2 latency)Own full computation (paper)Table 2Own denominator
TaylorSeer (N=3, O=1), 9.69 sTaylorSeer, 23.28 s2.53×2.40×
TeaCache (l=0.4), 10.52 sdiffusers, 25.71 s2.33×2.44×
KalmanCache+ (36%), 10.46 sdiffusers, 25.71 s2.34×2.46×
TaylorSeer (N=5, O=1), 7.10 sTaylorSeer, 23.28 s3.45×3.28×
TeaCache (l=0.8), 6.87 sdiffusers, 25.71 s3.56×3.74×
KalmanCache+ (24%), 7.13 sdiffusers, 25.71 s3.44×3.61×

Table 2's TaylorSeer rows used its default warmup; the revision will report re-runs with four warmup steps (general response [4/4]).

Response to Reviewer X484 [3/3]: how does KalmanCache+ compare in one implementation with one reference?

Response Q3

One implementation, one reference, measured latency

In the official TaylorSeer codebase, with one bit-identical reference, KalmanCache+ is closer to full computation than second-order TaylorSeer, HiCache, and TeaCache (the adaptive baseline of the submission), and faster when re-timed on one GPU. Our reconstruction also improves SeaCache's warmup-matched 13-FULL schedule.

FLUX.1-dev, DrawBench-200, near 13 FULL steps and 7 s (200-prompt runs, A100 GPUs of one server):

Implementation, referenceMethodTimePSNR ↑LPIPS ↓ImageReward ↑
TaylorSeer codebase, 23.39 sTaylorSeer O2 (13 FULL)7.99 s18.210.2781.097
HiCache (13 FULL)8.01 s18.740.2621.054
TeaCache (l=0.6, 15.0 FULL)7.31 s17.080.3441.040
KalmanCache+ (λ=8, 13.2 FULL)6.45 s20.660.2131.076
diffusers, 25.45 sTeaCache (l=0.8), re-run6.80 s16.450.3880.868
SeaCache (δ=0.6, 13.0 FULL)6.98 s21.720.2121.003
KalmanCache+ (λ=14)7.27 s20.820.2291.016
  • Forecasting, every budget (Table R0). All forecasting baselines compute steps 0–3 as our warmup does. Against the highest-PSNR baseline among TaylorSeer O2, HiCache, and our FoCa, KalmanCache+ is +3.2, +1.9, and +0.9 dB‾\underline{\mathbf{+3.2\text{, }+1.9\text{, and }+0.9\text{ dB}}} closer at 2.6–2.8, 3.8, and 5.0× FLOPs with a comparable FULL count and no significant ImageReward difference, and takes 18–25% less time than TaylorSeer O2 and HiCache when re-timed back to back on one GPU. Our gate's schedules raise HiCache by +2.98 / +1.37 / +0.13 dB, and on them our reconstruction is still +0.39 / +0.55 / +0.78 dB above it; on tuned static schedules it is +0.43 / −0.13 / +0.12 (n.s.) dB against HiCache with worse LPIPS (Table R14, reply to SFES). Schedules tuned against references lead our deployed gate on FLUX.1-dev, while on DiT-XL/2 at 21 FULL the gate's schedule leads (general response [3/4]).
  • TeaCache in the same codebase. Our port uses the reference FULL path (threshold 0: pixel-identical on 2/2 test prompts) and TeaCache's official FLUX coefficients. Against l = 0.4 / 0.6 / 0.8 / 1.0, the selected nearby-latency KalmanCache+ rows (λ = 2 / 8 / 14 / 40) are +6.2 / +3.6 / +3.6 / +2.7 dB higher, with lower LPIPS and fewer FULL steps, and faster in all four pairs, by 2.5–11.6%, when re-timed back to back on one GPU.
  • SeaCache (general response [4/4]). On its own warmup-matched schedule our reconstruction adds +0.28 dB (+0.25 dB on 200 held-out COCO captions). Our diffusers time in this table (λ=14) included a GPU-memory reset after each image that SeaCache's runner does not do; with it removed (identical images) we take 6.906 vs. 6.965 s at 13.24 vs. 13.00 FULL, and with W chosen on calibration prompts KalmanCache+ is +0.69 / +2.42 dB above SeaCache at its 13 / 20 FULL budgets (further results §15–§16). With our reconstruction, SeaCache's δ=0.3 schedule leads SeaCache itself at matched latency, +0.67 dB (Table R22, additional results [2/2]); on 200 held-out COCO captions, with SeaCache's δ re-chosen by the same rule, +1.53 dB [1.20, 1.85].

Planned changes for the revised paper

  • Appendix C.4 adds this diagnostic with the mismatch control; the reliability claim for u is restricted to the image backbones, and the video gate is called an adaptive refresh interval.
  • Table 4 gains the C-DOB-removed row, and Appendix G adds Table R8 with the 2×2; the weight rule is stated as a small-weight heuristic scaled by λ.
  • Table 2 is split by implementation; Table R0, TeaCache in the same codebase with same-GPU timing, and SeaCache join the FLUX.1-dev comparison, and every Table 2 baseline's initial FULL steps are listed.
  • The contribution statement is scoped to these measurements (general response [1/4]).

If a control is still missing for Q1–Q3, please tell us; we will prioritize it during the discussion period.

Again, we sincerely thank the reviewer for the constructive feedback. If you feel your concerns have been addressed, we would be grateful if you could reconsider the rating.

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

This paper proposes KalmanCache+, a training-free caching method that formulates diffusion caching as sequential residual estimation. A channel-wise Kalman filter tracks the channel mean of the block-stack residual. The predicted covariance decides FULL or SKIP (Predict–Trust). At each FULL step, the observed mismatch is fed back to re-estimate the noise scales and to correct the extrapolated residual of the next SKIP segment (Correct). Experiments on DiT-XL/2, FLUX.1-dev and Wan2.1-1.3B show better fidelity to full computation than the compared caching methods at 2-3.4 times latency speedup.

Critical strengths
  • The closed-loop correction is simple, needs no offline calibration, and consistently improves fidelity to full computation over the compared methods across image and video models.
Critical weaknesses

The most critical weakness is the lack of comparison with recent caching methods, which directly target the two limitations this paper claims. The main motivation is that existing methods are reliability-blind (Lim.1) and open-loop (Lim.2). However, several recent works already address these points:

  • forecast-then-calibrate caching (FoCa [1]), which corrects forecasts using the latest full computation (Lim.2);

  • improved forecasting over TaylorSeer (HiCache [2]), relevant to the SKIP reconstruction; recent proxy-based schedules with noise-robust input signals (Lim.1).

None of them is compared or discussed, and TaylorSeer seems only evaluated with first order, which is weaker than the commonly used second-order setting. Moreover, the acceleration range is limited (up to 3.4x latency on FLUX and 2.25x on Wan2.1), while recent methods report results at much higher acceleration. For example, FoCa [1] reports ImageReward close to the 50-step baseline on FLUX.1-dev at 5.54x FLOPs (4.05x latency) speedup, and HiCache [2] reports similar results at 5.55x FLOPs. In contrast, KalmanCache+ reports results only up to 4.16x FLOPs (3.44x latency). Moreover, the claimed closed loop only corrects at FULL steps; between FULL steps, the decision does not observe the current state at all, while proxy-based methods measure the input change at every step. Thus, the contrast between "open-loop" baselines and the proposed method seems overstated. Thus, it is unclear whether the proposed closed loop actually advances the state of the art, and I think the main claim is not sufficiently supported.

Also, the “uncertainty-aware” decision is not measured from the current step. The covariance grows deterministically with the gap from the last FULL step, so the decision is essentially an adaptive refresh interval. This matches the ablation, where the fixed replayed schedule performs almost the same as the adaptive gate (FID 2.251 vs. 2.241). The reconstruction is also first-order extrapolation with a stored offset, without using the Kalman state.

[1] Zheng, Shikang, et al. "Forecast then calibrate: Feature caching as ode for efficient diffusion transformers." Proceedings of the AAAI Conference on Artificial Intelligence. Vol. 40. No. 16. 2026. [2] Feng, Liang, et al. "HiCache: A plug-in scaled-Hermite upgrade for Taylor-style cache-then-forecast diffusion acceleration." International Conference on Learning Representations. Vol. 2026. 2026.

Questions for authors
  • Could you compare with FoCa, HiCache, second-order TaylorSeer and recent proxy-based schedules at matched FLOPs, including higher acceleration (e.g., 4x latency)? This would decide whether the closed loop is beneficial beyond the compared baselines.

  • What does the adaptive gate gain over a tuned non-uniform schedule (e.g., denser FULL steps at the late stage)?

8 comments

Response to Reviewer SFES [1/3]: how does KalmanCache+ compare with FoCa, HiCache, and second-order TaylorSeer?

We thank the reviewer for the careful reading and for naming the methods and operating points that decide the comparison; points shared with other reviewers are in the general response [1/4]–[4/4] and the additional results [1/2]–[2/2], posted at the top of this page; "reply to <reviewer>" means our comments under that reviewer's review.

You wrote that the Q1 comparison "would decide whether the closed loop is beneficial beyond the compared baselines." In one codebase, with one reference and the same four warmup steps, KalmanCache+ is closer to full computation than FoCa (our re-implementation), HiCache, and second-order TaylorSeer on their uniform schedules at all three compared budgets, 2.6–5.0× FLOPs (4.6× latency at 5.0×), with ImageReward 1.073–1.094 vs. 1.066 for full computation.

Response Q1

FoCa, HiCache, and second-order TaylorSeer at matched FLOPs

Table R9 puts every method in one codebase, with one reference and the same four warmup steps.

The margin comes with less time, and on our gate's own schedule our reconstruction still beats HiCache.

Table R9 (rows of Table R0, general response): FLUX.1-dev, DrawBench-200, official TaylorSeer codebase, one reference; all methods compute steps 0–3. PSNR / LPIPS / time; paired differences with 95% intervals.

FLOPs (FULL)Best baseline, uniform scheduleKalmanCache+ (λ)Δ PSNRSame lists: ours − HiCache
2.6× (19) vs. 2.8× (17.9)TaylorSeer O2: 21.28 / 0.173 / 10.61 s24.52 / 0.117 / 8.64 s (2)+3.2 dB‾\underline{\mathbf{+3.2\text{ dB}}} [2.8, 3.7]+0.39 [0.03, 0.73]
3.8× (13 vs. 13.2)HiCache: 18.74 / 0.262 / 8.01 s20.66 / 0.213 / 6.45 s (8)+1.9 [1.7, 2.1]+0.55 [0.41, 0.69]
5.0× (10 vs. 10.1)HiCache: 17.35 / 0.336 / 6.69 s18.26 / 0.324 / 5.04 s (40)+0.9 [0.8, 1.0]+0.78 [0.69, 0.88]

Re-timed on one GPU (50 prompts), the time reductions hold; no ImageReward difference from a baseline is significant. FoCa is our re-implementation (reply to 3vjR [3/3]).

  • Where the margin comes from. Moved from its uniform lists to our gate's per-prompt lists, HiCache gains +2.98 / +1.37 / +0.13 dB, so most of the margin at 2.6–3.8× is the gate's schedule and most at 5× is the reconstruction (last column). On 200 held-out COCO captions the reconstruction share replicates (+0.32 / +0.40 / +0.79 dB over HiCache on the same lists); ImageReward on COCO: general response [3/4].
  • Up to 4.6× latency. λ=40 (5.04 vs. 23.39 s) keeps ImageReward at 1.073 (full computation 1.066).
  • Wan2.1 beyond 2.25×, against ERTACache: 4.5–6.0 dB closer than its shipped list near 2× (1.9–3.4 dB against a stronger list from its procedure); +1.42 dB [0.50, 2.17] at 2.64× vs. 2.67× (ours 0.8 s slower; n.s. when ERTACache gets 2.8 s more); −1.00 dB [−1.69, −0.37] at 3.07× vs. 2.97×, with worse SSIM and LPIPS. On 50 new prompts, settings frozen, each re-run PSNR gap keeps its sign (reply to 3vjR).
  • Proxy-based schedules (SeaCache). With our reconstruction, SeaCache's δ=0.3 schedule is +0.67 dB above SeaCache at matched latency (+1.53 dB on held-out COCO); at SeaCache's 13 / 20 FULL budgets, KalmanCache+ with W chosen on calibration prompts is +0.69 / +2.42 dB above SeaCache on held-out prompts, and without our runner's per-image memory reset we take 6.906 vs. 6.965 s at 13.24 vs. 13.00 FULL (further results §15–§16).
  • Design. HiCache and FoCa forecast every cached module on a fixed interval; ours reconstructs one block-stack residual on a filter-set schedule.

Response to Reviewer SFES [2/3]: what happens when all methods share one tuned schedule?

Every question, in one line

Your pointOur answer in one lineEvidence
FoCa, HiCache, and second-order TaylorSeer missingRun in one codebase with the same four warmup steps: against the best of them on uniform schedules we are +3.2 / +1.9 / +0.9 dB closer to full computation at 2.6–2.8 / 3.8 / 5.0× FLOPs, with 19–25% less time.Table R9
TaylorSeer only first orderAll new FLUX.1-dev comparisons use second order. DiT-XL/2, second order with four warmup steps (FID-50K): 2.384 at 21 FULL steps vs. our 2.241 at 21 (42% compute), and 2.490 at 17 vs. our 2.489 at 16 (32%); ours has higher IS and precision, lower recall, and sFID within 0.02.this row; R9, R14
Proxy-based schedulesOn SeaCache's schedule near 20 FULL, our reconstruction beats SeaCache itself at matched latency (DrawBench, held-out COCO); with W chosen on calibration prompts our gate beats it at its 13 / 20 FULL budgets (further results §15–§16).below
Acceleration rangeFLUX.1-dev: ahead of uniform-schedule forecasting up to 5.0× FLOPs (4.6× latency), ImageReward 1.073 vs. 1.066 for full computation; Wan2.1: ahead of ERTACache near 2× and by +1.42 dB at 2.64×, behind at 3.07×.[1/3]
"Closed loop"It closes only at FULL steps, as we will state in the revision; each loop element is tested separately (C-DOB, noise adaptation, +1.81 dB over tuned past-error gates on FLUX.1-dev, +2.02 dB on held-out COCO); a TeaCache-style input-change rule skips more large-error steps at a similar budget (FLUX.1-dev, plain reuse: 15.5% vs. 7.2%).[3/3]; additional results [1/2]
Uncertainty ≈ refresh intervalOn images u ranks the error beyond cache age (+0.30 / +0.42), and freezing its noise scales costs 1.98 / 3.49 dB on FLUX.1-dev and 0.08–0.16 FID on DiT-XL/2 at the same FULL count; on video it acts as an adaptive refresh interval, yet freezing costs 1.33 dB on its control set at 22 FULL (+0.78, n.s., on new prompts).[3/3]; additional results [1/2]
Q1Ahead of all three on their uniform schedules in one implementation, mostly via the gate's schedule at 2.6–3.8×; on the same tuned static schedules our reconstruction takes 13–26% less time than HiCache and is +0.43 dB above it at 13 FULL.R9, R14
Q2DiT-XL/2 (21 FULL): the gate's schedule has 0.05–0.07 lower FID than a reference-searched one (three seeds; further results §18); FLUX.1-dev: the searched one is 1.51 dB higher at 13 FULL; at 20 FULL the gate leads it by +1.42 dB (§17).[3/3]

Response Q1 (continued)

All methods on the same tuned schedules; SeaCache

On the same tuned static schedules our reconstruction takes 13–26% less time than HiCache and, at 13 FULL, is +0.43 dB above it with the highest PSNR of the five methods.

Table R14: FLUX.1-dev, DrawBench-200, TaylorSeer codebase; per row, all methods forced onto one static schedule selected on 40 calibration prompts (general response Table R12; ours λ=8 unless noted). PSNR / LPIPS / ImageReward.

Schedule (FULL)TaylorSeer O2HiCacheFoCa†Plain reuseKalmanCache+
Front, power (13)21.80 / 0.180 / 1.11221.82 / 0.173 / 1.07721.75 / 0.176 / 1.10321.34 / 0.219 / 1.05222.25 / 0.186 / 1.081
Front, geometric (20)26.69 / 0.084 / 1.08327.20 / 0.077 / 1.06827.17 / 0.076 / 1.07326.69 / 0.106 / 1.05327.06 / 0.093 / 1.057
Front-dense (10)18.56 / 0.292 / 1.07019.58 / 0.256 / 1.05418.80 / 0.267 / 1.07719.56 / 0.312 / 1.00719.70 / 0.291 / 1.028 (λ=100); 17.28 / 0.427 / 0.976 (λ=8)

† Our re-implementation (reply to 3vjR).

  • Same schedule. Against HiCache +0.43 dB‾\underline{\mathbf{+0.43\text{ dB}}} [0.29, 0.58] at 13 FULL, −0.13 [−0.27, −0.005] at 20, and +0.12 (n.s.) at 10, and against our FoCa† +0.51 / −0.11 (n.s.) / +0.90 dB, with worse LPIPS in all six; against TaylorSeer higher PSNR (+0.45 / +0.38 / +1.14 dB) but significantly lower ImageReward; against plain reuse better PSNR and LPIPS at all three.
  • SeaCache: with steps 0–3 forced (13.11 FULL), our reconstruction on its schedule adds +0.28 dB [0.16, 0.41], −0.020 LPIPS, and +0.027 ImageReward (held-out COCO: +0.25 dB [0.16, 0.35], −0.022 LPIPS). With W chosen on calibration prompts KalmanCache+ leads SeaCache by +0.69 / +2.42 dB at its 13 / 20 FULL budgets, and without our runner's per-image memory reset we take 6.906 vs. 6.965 s at 13.24 vs. 13.00 FULL (further results §15–§16); SeaCache stays ahead near 10 FULL, and on COCO its warmup-forced schedule leads our W=8 gate by 0.39 dB. With our reconstruction, SeaCache's δ=0.3 schedule leads SeaCache itself at matched latency by 0.67 dB (Table R22, additional results [2/2]), and on 200 held-out COCO captions, with SeaCache's δ re-chosen by the same rule, by 1.53 dB [1.20, 1.85].

Response to Reviewer SFES [3/3]: what does the gate gain over a tuned schedule, and where does the loop close?

Response Q2

What does the gate gain over a tuned non-uniform schedule?

For a late-dense schedule following your example, the gate has higher PSNR on FLUX.1-dev: 21.54 vs. 14.91 dB at 13.2 vs. 13 FULL (LPIPS 0.199 vs. 0.587). On DiT-XL/2 at 21 FULL the gate's schedule has lower FID than a schedule searched against full-computation references, and the gate builds its schedule inside the run without that search; our reconstruction lifts the searched schedule as well. At 19 and 16 FULL on DiT-XL/2 and on FLUX.1-dev at 13 FULL (1.51 dB) the searched schedules lead our deployed gate (additional results [2/2] §7); at FLUX.1-dev's 20 FULL, with its warmup and λ set on the same calibration prompts, the gate leads the schedule searched for that budget by +1.42 dB on held-out prompts at 19.994 vs. 20.000 FULL, and on DiT-XL/2 at 21 FULL its lower FID holds at a third seed (further results §17–§18).

  • DiT-XL/2 (21 FULL): the search selects a late-dense schedule, FID-50K 2.301 / 2.252 vs. 2.241 / 2.187‾\underline{\mathbf{2.241\text{ / }2.187}} for the gate (seeds 0 / 1); replaying the gate's schedule gives 2.251 / 2.195, so the gain is the gate's schedule.
  • FLUX.1-dev (diffusers, Table R12): the best of 18 static schedules, selected on 40 calibration prompts by a rule fixed in advance, reaches 23.05 dB at 13 FULL, 1.51 dB [1.24, 1.78] above our deployed gate (21.54 dB; +1.67 dB on 200 held-out COCO captions); +0.86 dB of the 23.05 (+1.08 dB on held-out COCO) comes from our reconstruction over plain reuse on that schedule.

Response to the weaknesses

Closed loop, uncertainty, and reconstruction: three clarifications

  • Closed loop. The loop closes at FULL steps: the extrapolation error measured there corrects the next SKIP segment (+0.04 to +0.36 dB on FLUX.1-dev, FID 2.399 → 2.251 on DiT-XL/2; general response [3/4] §3), and the innovation re-estimates the noise scales that place the next FULL step (at a matched budget the schedule alone is +3.20 dB over the variant without Sage–Husa, and +3.49 dB over fully frozen noise scales with a shared blend; reply to X484 [2/3]; additional results [1/2]). Between FULL steps the score follows the last update; FoCa also corrects at FULL steps; what is specific to ours is that each FULL step updates both schedule and reconstruction. Our reconstruction complements per-step proxies: used with SeaCache's δ=0.3 schedule, it outperforms SeaCache at matched latency (+0.67 dB; +1.53 dB on held-out COCO).
  • Uncertainty. On images u ranks the error at fixed cache age and step (+0.30 on DiT-XL/2, +0.42 on FLUX.1-dev; general response Table R1). On Wan2.1 u follows cache age (Spearman 0.98), so there the gate is an adaptive refresh interval. The 2.251 vs. 2.241 you note compares the gate with its own replayed schedule; freezing the noise scales instead gives 2.321 / 2.267‾\underline{\mathbf{2.321\text{ / }2.267}} at the same FULL count (seeds 0 / 1; additional results [1/2]), so the replayed schedule owes its quality to the loop.
  • Reconstruction. The covariance sets the gate and the blend weight wi=min⁡(1,ui/λ)w_i = \min(1, u_i/\lambda); the residual is extrapolation plus the offset stored at the last FULL step, computed on full tensors rather than from the Kalman posterior mean. Plain reuse on the selected DiT-XL/2 lists is 0.72–1.84 FID worse at all three budgets (Table R21, additional results [2/2]).

Planned changes for the revised paper

  • Tables R0 and R14 in Section 4.2 and Appendix G; FoCa, HiCache, and SeaCache in Section 2.
  • Each claim with its measured range; the closed- vs. open-loop tests in Appendix G.7.
  • Closed-loop defined as closing at FULL steps; Lim.1 and Lim.2 no longer call proxy-based schedules reliability-blind or open-loop.

If a comparison is still missing, please tell us; we will prioritize the requested comparisons during the discussion period.

Again, we sincerely thank the reviewer for the constructive feedback. If you feel your concerns have been addressed, we would be grateful if you could reconsider the rating.

Comments on the paper

11 comments

General response [1/4]: what is established, and in which scope

We thank all reviewers; replies to each reviewer are under each review. Forecasting and TeaCache comparisons now share one implementation and reference, and the paper's FID-50K of 2.241 reproduces on our server.

What the rebuttal establishes

  1. One implementation, one reference, the same four initial FULL steps. Against the best of second-order TaylorSeer, HiCache, and our FoCa on their uniform schedules, KalmanCache+ is +3.2, +1.9, and +0.9 dB‾\underline{\mathbf{+3.2\text{, }+1.9\text{, and }+0.9\text{ dB}}} closer to full computation at 2.6–2.8, 3.8, and 5.0× FLOPs, at comparable FULL counts, with 19–25% less time (Table R0).
  2. Closing the loop shapes the schedule: with the noise scales frozen after warmup and λ reset to the same FULL count, the gate loses 1.98 / 3.49 dB on FLUX.1-dev (one shared blend) and 1.33 dB on the Wan2.1 control set at 22 FULL, and DiT-XL/2 FID-50K rises by 0.08–0.16 at three budgets and two seeds (additional results [1/2]).
  3. The Kalman gate beats six tuned running-average gates on FLUX.1-dev at the same budget and blend, by at least +1.81 dB ([2/4]).
  4. Few large-error SKIPs on images: 2.9% and 3.0% of skipped steps on DiT-XL/2 (batch 1, 23.4 FULL) and FLUX.1-dev; for plain reuse (no u), 1.1% and 7.2% of skipped vs. 25.5% and 20.9% of computed steps; fewer than the two feedback-free rules in 7 of 8 comparisons ([2/4]).
  5. C-DOB and our reconstruction lower DiT-XL/2 FID at three budgets and two seeds on fixed lists: no C-DOB +0.15–0.45, plain reuse +0.70–1.84 (additional results [2/2]).
  6. TeaCache in the same codebase: +2.7 to +6.2 dB with lower LPIPS and fewer FULL steps (reply to X484).
  7. ERTACache on Wan2.1 near 2×: +4.5 to +6.0 dB over its shipped list and +1.9 to +3.4 dB over a stronger searched list, without trajectory dumps (reply to 3vjR).

Scope of the main claims

  • Schedule. The gate builds its schedule inside the run, with λ settable from compute logs and no reference search for deployed image settings. On DiT-XL/2 at 21 FULL its schedule has 0.05–0.07 lower FID than a searched one at three seeds, and on FLUX.1-dev at 20 FULL a calibrated gate leads one by +1.42 dB ([3/4]; further results §17–§18).
  • Score. On images u ranks errors beyond cache age (+0.30, +0.42 at fixed age and step); on video it acts as an adaptive refresh interval that still leads TeaCache, MagCache, and ERTACache near 2× ([2/4]; Table 3; reply to 3vjR).
  • Closed loop. It closes at FULL steps: observed channel means re-estimate the noise scales, and the tensor mismatch corrects the next SKIP segment. FoCa also corrects with FULL steps; ours adds that each FULL step updates both the schedule and the reconstruction.

1. Forecasting baselines in one implementation (SFES Q1, X484 Q3, XBVw Q2, 3vjR Q2)

Table R0: FLUX.1-dev, DrawBench-200, seed 0, official TaylorSeer codebase, one 50-step reference (full computation 23.39 s, ImageReward 1.066, reproduced bit for bit by our port and HiCache). Every baseline computes steps 0–3 as our warmup does (their default warmup loses 1.7–2.0 dB).

FLOPs (FULL)MethodTimePSNR ↑LPIPS ↓ImageReward ↑
2.6× (19)TaylorSeer O210.61 s21.280.1731.080
HiCache10.64 s21.150.1771.079
FoCa†12.37 s21.210.1741.086
2.6× (19.6)KalmanCache+ λ=1.59.50 s24.890.1101.092
2.8× (17.9)KalmanCache+ λ=28.64 s24.520.1171.094
3.8× (13)TaylorSeer O27.99 s18.210.2781.097
HiCache8.01 s18.740.2621.054
FoCa†10.14 s18.190.2781.098
3.8× (13.2)KalmanCache+ λ=86.45 s20.660.2131.076
4.2× (12.0)KalmanCache+ λ=145.92 s19.820.2461.065
5.0× (10)TaylorSeer O26.65 s16.550.3831.082
HiCache6.69 s17.350.3361.059
FoCa†9.03 s16.550.3821.086
5.0× (10.1)KalmanCache+ λ=405.04 s18.260.3241.073
5.3× (9.4)KalmanCache+ λ=704.74 s17.580.3691.026
5.6× (9.0)KalmanCache+ λ=1004.51 s17.430.3851.032

Bold: best per pair (λ = 2 / 8 / 40 vs. 19 / 13 / 10 FULL); λ=1.5, 40, 70 were fixed in advance. † Our re-implementation (no official code). Times: A100s of one server; re-timed on one GPU, the reductions hold (50 prompts).

Reading (paired, 95% bootstrap intervals):

  • 2.6–3.8× FLOPs: +3.2 dB [2.8, 3.7] and +1.9 dB [1.7, 2.1] over the highest-PSNR baseline (17.9 vs. 19 and 13.2 vs. 13 FULL), LPIPS lower by 0.056 and 0.049, about 19% less time, and ImageReward n.s. Most of this margin is the gate's schedule ([3/4]).
  • 5.0× (10.055 vs. 10 FULL): +0.9 dB [0.8, 1.0] over HiCache and +1.7 dB over TaylorSeer and our FoCa, with lower LPIPS, ImageReward n.s., and 25% less time than HiCache.

General response [2/4]: does the gate skip where errors are small?

2. Large errors are rarer at skipped steps: a relative-tail diagnostic (X484 Q1, XBVw Q1, 3vjR Q1, SFES)

We measure how often large errors occur at skipped and at computed steps, then test whether the gate's score u ranks errors beyond cache age and step.

Protocol. Deployed KalmanCache+ runs unchanged at the paper's operating points: DiT-XL/2 λ=5 (100 images, batch 1: 23.4 of 50 FULL per image; at Table 1's batch 32 and 21 FULL, large deployed errors at 1 of 116 skipped vs. 20 of 64 computed steps on an evaluation half of 4 batches), FLUX.1-dev λ=8 (200 prompts), and Wan2.1-1.3B λ=22 (24 prompts × both CFG branches). At every step after the warmup we also run the transformer blocks at the cached state, for diagnosis only; outputs are bit-identical to runs without diagnosis. Error is the relative squared L2 error of the block-stack residual over the full hidden tensor, so nothing is averaged within a channel. At skipped steps it is the error of the tensor actually used; at computed steps, the error a skip at full blend weight (w = 1) would have caused. Large means the top 10% (relative squared error above 0.0182, 0.469, and 0.0283 on DiT-XL/2, FLUX.1-dev, and Wan2.1), with the threshold fixed on one half of the runs and the probabilities measured on the other half (50 images / 100 prompts / 12 prompts); correlations use all runs. Brackets: 95% cluster-bootstrap intervals.

Table R1: What the gate skips and what it computes

DiT-XL/2FLUX.1-devWan2.1-1.3B
Skipped, of gated steps58.7%81.9%80.6%
P(large error ∣ skipped)2.9% [1.7, 4.1]3.0% [2.5, 3.4]9.1% [7.3, 11.3]
P(large error ∣ computed)22.4% [19.7, 25.5]42.0% [39.4, 44.2]32.9% [17.2, 51.6]
Share of large errors on skipped steps15.4%24.3%53.6%
Spearman(u, cache age)0.590.880.98
Rank correlation of u with the error at fixed cache age and step+0.30 [0.23, 0.36]+0.42 [0.36, 0.47]−0.40 [−0.68, −0.04]

Reading.

  • Images: large errors are rarer at skipped steps on DiT-XL/2 and FLUX.1-dev: 23× and 2.9× for plain reuse, an error that contains no u (next bullet), and 7.7× and 14× when computed steps are scored at full weight. At fixed cache age and step index u still ranks the error, so what the filter observed at earlier FULL steps carries information beyond the gap; between FULL steps the score evolves from the last updated filter state.
  • Not only through the blend weight. Because u also sets the blend weight, part of this ranking is mechanical. For an error that does not contain u (plain reuse of the cached residual), large errors remain far rarer at skipped steps (1.1% vs. 25.5% on DiT-XL/2, 7.2% vs. 20.9% on FLUX.1-dev), and the ranking at fixed age and step holds on DiT-XL/2 (+0.29 [0.22, 0.37]) but weakens on FLUX.1-dev (+0.15 [0.08, 0.22]).
  • Video: on Wan2.1-1.3B u follows cache age and the gate acts as an adaptive refresh interval; large errors are still 3.6× rarer at skipped steps, which hold 54% of them. The revision will state this scope.
  • Against two rules without error feedback (additional results [1/2]): we scored the uniform interval and the input-change rule with the deployed reconstruction and with plain reuse. At the main operating points (two backbones × two errors × two rules; the DiT-XL/2 gate computes 23.4 vs. 21 FULL) the gate skips fewer large-error steps in 7 of 8 comparisons, e.g. 3.0% vs. 38.6% (input-change) on FLUX.1-dev; the exception is the uniform interval on FLUX.1-dev with plain reuse (7.2% vs. 6.4%; 13.3% with its deployed, weight-capped reconstruction). On DiT-XL/2 with fewer FULL steps (20.0, λ=7) the gate still has fewer than the uniform interval with plain reuse, but not fewer than the input-change rule.
  • Scope: a relative-tail diagnostic at the tested operating points.
  • Controls (XBVw Q1, X484 Q2): on the same records, the size of the extrapolation mismatch observed at the last FULL step (the quantity C-DOB stores) ranks the error even more strongly (Table R10, reply to XBVw), which supports feeding FULL-step errors forward. As a gate it is worse. Gating on its running average scaled by the squared cache age, with the threshold calibrated to the same budget on FLUX.1-dev (13.3 vs. 13.2 of 50 FULL steps, 200 prompts), gives 18.49 dB (LPIPS 0.30) against 21.54 dB (0.20) for the Kalman gate; with one shared constant blend (w = 0.25) the Kalman gate is still +2.08 dB [1.85, 2.32] ahead. Tuning does not close the gap: over six variants (averaging rate 0.3 / 0.5 / 0.8, cache age or its square, each threshold set from FULL counts on 40 calibration prompts), the Kalman gate leads the best by +1.81 dB‾\underline{\mathbf{+1.81\text{ dB}}} [1.59, 2.04] at the same budget and blend, with lower LPIPS than all six; +2.02 dB [1.80, 2.24] on held-out COCO (reply to X484).

General response [3/4]: C-DOB, schedule, reconstruction

3. C-DOB at a fixed schedule: it lowers DiT-XL/2 FID at two seeds and raises FLUX.1-dev PSNR by 0.36 dB (3vjR W2, X484 Q2)

Table R3: Same FULL/SKIP schedule and weight rule; only the C-DOB term removed. DiT-XL/2: FID-50K at 21/50 FULL steps (the gate's schedule replayed). FLUX.1-dev: DrawBench-200 at 13/50. Wan2.1-1.3B: 50 prompts at 22/50.

BackboneMetricwithout C-DOBwith C-DOB
DiT-XL/2, seed 0FID ↓2.3992.251‾\underline{\mathbf{2.251}}
DiT-XL/2, seed 1FID ↓2.3492.195†
FLUX.1-devPSNR ↑ / SSIM ↑ / LPIPS ↓20.49 / 0.7926 / 0.220520.85 / 0.7935 / 0.2160
Wan2.1-1.3BPSNR ↑ / SSIM ↑ / LPIPS ↓29.29 / 0.9144 / 0.048129.29 / 0.9195 / 0.0458

† Both seed-1 values are from the rebuttal server, which reproduces the paper's 2.195 (seed 1, replayed) and 2.241 (seed 0, adaptive).

Replaying the full run's per-step weights without C-DOB gives the same FLUX.1-dev gap (+0.356 dB [0.195, 0.523]), so the row isolates C-DOB; on the calibrated 13-, 20-, and 10-FULL schedules (§5 below) it adds +0.20, +0.09, and +0.04 dB, every interval above zero (LPIPS +0.004, −0.003, −0.004). On the selected DiT-XL/2 lists of all three budgets, removing C-DOB costs 0.21–0.45 FID and plain reuse 0.72–1.84, at both seeds (Table R21, additional results [2/2]).

4. Schedule vs. reconstruction (SFES Q1–Q2, X484 W2, XBVw Q3)

Where the margin of Table R0 over HiCache comes from — official TaylorSeer codebase, PSNR in dB on DrawBench-200 (200 held-out COCO captions in parentheses); "our reconstruction" = PSNR gap of KalmanCache+ over HiCache run on the gate's per-prompt FULL lists.

Ours vs. HiCache (mean FULL)TotalGate's scheduleOur reconstruction
17.9 vs. 19+3.37 (+3.39)+2.98 (+3.07)+0.39 [0.03, 0.73] (+0.32)
13.16 vs. 13+1.92 (+1.77)+1.37 (+1.38)+0.55 [0.41, 0.69] (+0.40)
10.055 vs. 10+0.91 (+0.95)+0.13 (+0.16)+0.78 [0.69, 0.88] (+0.79)
  • Gate's lists: LPIPS −0.001 (n.s.), −0.006, and −0.001 (n.s.); ImageReward n.s. (on COCO 0.026 below HiCache at 17.8 FULL). On these lists, ours − our FoCa re-implementation is +0.76 / +1.63 dB at 13.2 / 10.1 FULL and −0.09 dB at 17.9 (n.s.; FoCa better in LPIPS and ImageReward).
  • Tuned static lists (Table R14, reply to SFES; blend λ = 8 / 8 / 100 at 13 / 20 / 10 FULL): against HiCache +0.43 [0.29, 0.58], −0.13 [−0.27, −0.005], and +0.12 [−0.02, 0.26] dB with worse LPIPS on all three; against our FoCa +0.51, −0.11 (n.s.), and +0.90 dB, also with worse LPIPS; against plain reuse +0.91, +0.38, and +0.14 dB with lower LPIPS (at 10 FULL with λ=8, 17.28 vs. 19.56 dB for plain reuse).
  • Uniform lists: +0.44, −0.03 (n.s.), and +0.97 dB over the best baseline (λ = 8 / 8 / 100).
  • So our reconstruction beats HiCache on the gate's lists and plain reuse on all three tuned lists at their λ.

5. Calibrated static schedules (SFES Q2, XBVw Q3)

Table R12: FLUX.1-dev, diffusers; λ per row; FULL = computed steps of 50. Static rows: the candidate of our schedule generator with the lowest LPIPS on 40 calibration prompts (every fifth DrawBench prompt), by a rule fixed before the runs, with the same reconstruction formula.

BudgetScheduleFULLPSNR ↑LPIPS ↓
13Selected static (λ=8)13.023.050.176
Gate, deployed (W=4, λ=8)13.221.540.199
Gate, W=6 / 8 (λ=20 / 40)13.1 / 13.522.58 / 23.540.185 / 0.176
20Selected static (λ=8)20.028.300.086
Gate, W=8 (λ=4)18.727.770.085
10Selected static, λ=8 (pre-set)10.018.180.381
Same schedule, λ=10010.020.640.269
Gate, W=6 (λ=100)10.620.120.310
  • DiT-XL/2 (21 FULL): the gate's schedule, adaptive or replayed, has 0.05–0.07 lower FID than the searched one at both seeds. The procedure (16 candidates, paired LPIPS on 1,024 samples at a separate seed) selects a late-dense schedule: FID-50K 2.301 and 2.252 vs. 2.241 and 2.187 for the gate (seeds 0, 1).
  • FLUX.1-dev: the searched schedule is 1.51 dB [1.24, 1.78] above the deployed gate at 13 FULL (held-out prompts +1.53; 200 COCO captions +1.67 [1.40, 1.95]). With W=8 the gate reaches 23.54 dB and LPIPS 0.176 at 13.5 FULL, its gain over the static schedule (13 FULL) confined to the 109 prompts where it computes 14 (W = 6 and 8 examined on the evaluation prompts). At 10 FULL, the static schedule with the gate's λ=100 blend leads (+0.52 [0.28, 0.76]).
  • What the gate provides: a schedule produced inside the run without a search over candidates against full-computation references (18 × 40 prompts on FLUX.1-dev), and a budget set by λ without reference outputs; the warmup W is a second setting, chosen against full computation on video.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.