DynamicCache-0.1: Adaptive Diffusion Acceleration

• DynamicCache-0.1 is a training-free framework that adaptively manages cache reuse to accelerate diffusion models across diverse architectures.
• It employs an online probe profiling mechanism using shallow-layer representations to estimate feature changes and trigger efficient cache refreshes.
• Empirical tuning of parameters such as probe depth and reuse threshold enables 2×–3× inference speedup while maintaining minimal perceptual drift.

DynamicCache-0.1 Configuration is a practical, training-free framework for accelerating diffusion models by adaptively determining both the timing of cache reuse and the strategy for combining multiple cached features at runtime. The approach is rooted in “DiCache” (Bu et al., 24 Aug 2025), which exploits the correlation between shallow-layer feature dynamics and final outputs, enabling the diffusion model itself to autonomously decide its own caching behavior. DynamicCache-0.1 is applicable across various architectures—transformers, U-Nets, image and video backbones—yielding substantial inference acceleration (2×–3× speedup) with minimal perceptual drift.

1. Key Configuration Parameters

DynamicCache-0.1 exposes a minimal set of tunable parameters, with design accommodating diverse diffusion model architectures and operational requirements. The principal parameters are as follows:

Parameter	Role	Typical Range/Default
Probe depth ($m$)	Shallow layers used for feature change probing	$m \in [1, M-1]$; default $m=1–3$
Reuse threshold ($\delta$)	Max cumulative error before recomputation	Model-specific: $0.10$–$0.40$
Distance metric	Measures relative feature change	$L_1^{\text{rel}}$ (recommended), $L_2^{\text{rel}}$

• Probe depth $m$: Number of initial layers executed as probe at each diffusion step. Larger $m$ provides more accurate error estimates but increases compute. Empirically, $m=1$ yields ~80% correlation to full-model change, with diminishing returns beyond $m\approx5$.
• Reuse threshold $\delta$: Upper limit of accumulated shallow-probe error tolerated before triggering full recomputation. Smaller $\delta$ increases fidelity, larger $\delta$ increases speed.
• Distance metric: Default is relative $L_1$ norm, $L_1^{\text{rel}}(a, b) = \|a-b\|_1 / \|b\|_1$. For features with heavy tails or compressed dynamic range (e.g., latent-space models), $L_2^{\text{rel}}$ can be advantageous.
• Alignment weight $\gamma_t$: A non-tunable scalar computed dynamically from shallow probes to interpolate between cached residuals.
• Book-keeping variables: $\Sigma_{\text{error}}$ records accumulated estimated cache error; $R_{\text{last}}$, $R_{\text{prev}}$ denote the two most recent full residuals for multi-step alignment.

2. Online Probe Profiling and Cache Scheduling

DynamicCache-0.1 utilizes an online profiling mechanism operating at shallow network layers to estimate cache error in real time. The true cache error for consecutive steps is defined as:

$$\epsilon_{t, t+1} = L_1^{\text{rel}}(y_t, y_{t+1}) = \frac{\|y_t - y_{t+1}\|_1}{\|y_{t+1}\|_1}$$

Since full-model evaluation is computationally expensive, only the first $m$ layers are computed to produce the shallow representation $y_t^m$. The estimated error is:

$$\hat{\epsilon}_{t, t+1} = L_1^{\text{rel}}(y_t^m, y_{t+1}^m) = \frac{\|y_t^m - y_{t+1}^m\|_1}{\|y_{t+1}^m\|_1}$$

This estimated error is accumulated, and a recomputation is triggered when:

$$\sum_{\tau = t_1}^{t_2+1} \hat{\epsilon}_{\tau, \tau+1} > \delta \quad \text{and} \quad \sum_{\tau = t_1}^{t_2} \hat{\epsilon}_{\tau, \tau+1} \leq \delta$$

where $t_1$ is the previous cache refresh point and $t_2 + 1$ the current timestep exceeding the error budget.

3. Dynamic Cache Trajectory Alignment

When two full residuals are available at recent cache refresh points $t_\alpha < t_\beta$, the current residual at $t$ is approximated by linear interpolation:

$$r_t = r_{t_\beta} + \gamma_t \cdot (r_{t_\alpha} - r_{t_\beta})$$

where $r_{t_\alpha} = y_{t_\alpha} - x_{t_\alpha}$, $r_{t_\beta} = y_{t_\beta} - x_{t_\beta}$. The interpolation weight $\gamma_t$ is inferred from shallow-probe residuals:

$$\hat{\gamma}_t = \frac{L_1^{\text{rel}}(r_t^m, r_{t_\beta}^m)}{L_1^{\text{rel}}(r_{t_\alpha}^m, r_{t_\beta}^m)}, \quad r_t^m = y_t^m - x_t$$

The aligned residual is then:

$$r_t = r_{t_\beta} + \left[ \frac{L_1^{\text{rel}}(r_t^m, r_{t_\beta}^m)}{L_1^{\text{rel}}(r_{t_\alpha}^m, r_{t_\beta}^m)} \right] \cdot (r_{t_\alpha} - r_{t_\beta})$$

The model output is recovered by $y_t = x_t + r_t$.

4. Integrated Algorithm Workflow

The joint scheduling and multi-step cache reuse strategy is summarized below:

for t = T, T-1, ..., 0: if first step: y_T = full_model(x_T, T, c) R_last = y_T - x_T R_prev = None else: y_t^m = probe_layers(x_t, t, c) e_hat = L1_rel(y_t^m, y_next^m) Sigma_error += e_hat if Sigma_error <= delta: if R_prev is not None: # Two-step trajectory alignment r_t^m = y_t^m - x_t gamma = L1_rel(r_t^m, r_{t_beta}^m) / L1_rel(r_{t_alpha}^m, r_{t_beta}^m) R_aligned = R_last + gamma * (R_prev - R_last) y_t = x_t + R_aligned else: y_t = x_t + R_last else: # Full recompute and cache refresh y_t = run_remaining_layers(y_t^m, t, c) R_prev = R_last R_last = y_t - x_t Sigma_error = 0 # Store y_t^m for next iteration

This mechanism ensures that cache refreshes occur only as needed and that trajectory alignment utilizes the shallow-probe information to minimize visual drift.

5. Recommendations and Tuning Strategies

Empirical guidelines enable practitioners to select robust settings and adapt the dynamic-caching framework to target applications:

• Default $m = 1$ provides significant acceleration with ~80% correlation to true feature change. $m = 2$–$3$ may be preferable for models exhibiting rapid inter-layer dynamics.
• Reuse threshold $\delta$ is the primary fidelity-speed trade-off:
  • $\delta \in [0.05, 0.10]$: very high fidelity, speedup $1.5\times$–$2.0\times$
  • $\delta \in [0.10, 0.20]$: balanced, speedup $2.0\times$–$2.5\times$, $<10\%$ perceptual drift
  • $\delta > 0.20$: more aggressive, speedup $\geq 3\times$, but with increased risk of artifacts
• Optional warm-up: Clearing $\Sigma_{\text{error}}$ in the first $5$–$10$ steps can avoid early cache reuse when the diffusion process exhibits the largest noise increments.
• Distance metric selection: $L_1^{\text{rel}}$ is robust across most backbones; for heavy-tailed or low-dynamic-range features (e.g., in latent space), $L_2^{\text{rel}}$ may be more representative.

6. Architectural Adaptation Guidelines

DynamicCache-0.1 is designed for flexibility across major diffusion backbone categories. Implementation notes include:

Architecture	Probe Layer Definition	Specific Tuning Advice
DiT (Transformer)	First $m$ attention+MLP blocks	High feature dimension stabilizes $L_1^{\text{rel}}$
U-Net	Encoder/decoder stages	Probe: encoder conv + decoder skip; lower $\delta$ in latent-space U-Nets
Latent space models	Same as respective backbone	Reduce $\delta$ by 20–30%, or use $L_2^{\text{rel}}$
Video diffusion	Include spatial + temporal blocks	Smoother step-wise noise change; $\delta$ can be raised by $+0.05$

For latent-space models, dynamic range compression necessitates smaller thresholds (e.g., $\sim75\%$ of pixel-space setting). For video models, temporal attention smooths cache error dynamics, permitting higher $\delta$ without loss of fidelity.

7. Empirical Performance and Scope

DynamicCache-0.1 has been validated on WAN 2.1 (DiT-based), HunyuanVideo (video generation), and Flux (image generation) models. When following recommended parameterizations, it achieves $2\times$–$3\times$ inference speedup with minimal perceptual quality loss, confirming both generality and efficacy across diverse high-performing diffusion backbones (Bu et al., 24 Aug 2025). The adaptive mechanism obviates the need for heuristic or dataset-level priors, instead leveraging real-time feature dynamics for robust, model-agnostic acceleration. A plausible implication is robust applicability to future backbone variants with non-trivial internal dynamics, subject only to appropriate probe layer and threshold selection.