DPCache: Diffusion Acceleration via Path Planning

• DPCache is a training-free acceleration framework for diffusion models that reinterprets timestep selection as a global path planning problem.
• It constructs a Path-Aware Cost Tensor to quantify cumulative errors and uses dynamic programming to optimally select key timesteps under a compute budget.
• Empirical results on image and video backbones show that DPCache preserves trajectory fidelity while substantially reducing computational overhead.

Searching arXiv for the diffusion-model sense of DPCache and closely related work to ground the article. arXiv_search.query({"search_query":"all:DPCache diffusion path planning caching schedule ReCache", "start":0, "max_results":10}) DPCache is a training-free acceleration framework for diffusion model sampling that formulates diffusion sampling acceleration as a global path planning problem. It constructs a Path-Aware Cost Tensor from a small calibration set to quantify the path-dependent error of skipping timesteps conditioned on the preceding key timestep, and it uses dynamic programming to select an optimal sequence of key timesteps that minimizes the total path cost while preserving trajectory fidelity (Cui et al., 26 Feb 2026). Within diffusion-model acceleration, DPCache belongs to the feature-caching family: it performs full computation only at selected key timesteps, while intermediate outputs are predicted using cached features.

1. Problem formulation and conceptual reframing

A discrete-time diffusion model performs iterative denoising from $\mathbf{x}_T \sim \mathcal{N}(0,I)$ to $\mathbf{x}_0$, calling a large neural network at every reverse step. DPCache starts from the observation that existing caching methods typically decide which timesteps to recompute by fixed schedules or locally adaptive criteria. According to the formulation in the paper, these approaches do not consider the global structure of the denoising trajectory, and this can lead to error accumulation and visual artifacts (Cui et al., 26 Feb 2026).

DPCache reinterprets the denoising trajectory as a path in timestep space. Instead of computing all $T$ steps, it chooses a sparser set of key timesteps,

$\mathcal{T} = \{ t_1=T > t_2 > \dots > t_K > 0 \},$

with $t_{K+1}=0$ as a sentinel. At key timesteps, the model performs a full forward pass and caches features. At intermediate timesteps, the model does not run the backbone; it predicts features from cached information and reconstructs the model outputs from those predictions. The central optimization problem is therefore not merely feature reuse, but key-timestep selection under a compute budget.

This framing distinguishes DPCache from two neighboring acceleration classes. First, it differs from step-count reduction methods, such as ODE or SDE solvers and distillation-based schemes, because it does not redesign the trajectory or train a student. Second, it differs from conventional caching schedules because it treats timestep selection as a global optimization problem rather than a periodic rule or a local trigger. This suggests that DPCache is best understood as a scheduler over a fixed predictor, not as a new predictor in itself.

2. Path-Aware Cost Tensor and dynamic programming

The main technical object in DPCache is the Path-Aware Cost Tensor (PACT). A two-dimensional jump cost is insufficient for predictive caching, because the prediction quality at an intermediate timestep can depend not only on the current and next key timestep, but also on the preceding key timestep. DPCache therefore defines a three-dimensional cost tensor

$$\mathcal{C} \in \mathbb{R}^{(T+1)\times(T+1)\times(T+1)},$$

with entries $\mathcal{C}[i,j,k]$ for $i>j>k$.

The cost is defined from final-layer features. Let $\mathbf{h}_\tau^L$ be the full forward-pass feature at timestep $\tau$, and let $\mathbf{x}_0$0 be the predicted feature at $\mathbf{x}_0$1 using cached information at timesteps $\mathbf{x}_0$2 and $\mathbf{x}_0$3. Then DPCache uses the cumulative $\mathbf{x}_0$4 error

$\mathbf{x}_0$5

The cost is cumulative over the full skipped interval and explicitly path-dependent through the index $\mathbf{x}_0$6. The paper states that only the final layer is used for cost construction in order to save memory, and that this was empirically sufficient (Cui et al., 26 Feb 2026).

Given $\mathbf{x}_0$7, DPCache solves a dynamic program under a budget $\mathbf{x}_0$8. With $\mathbf{x}_0$9 as the minimum cumulative cost to reach timestep $T$0 using exactly $T$1 key timesteps, and $T$2 as the predecessor pointer, the recurrence is

$T$3

The total schedule cost is

$T$4

and the schedule is recovered by backtracking from the terminal state. The reported complexity is $T$5 in time and $T$6 in space. The paper also fixes the first $T$7 timesteps as computed timesteps in experiments, describing this as a stabilization device for early denoising (Cui et al., 26 Feb 2026).

An important ablation in the paper compares 2D versus 3D costs and cumulative versus non-cumulative costs. The best results are obtained by the full 3D cumulative design. On FLUX with $T$8, the paper reports ImageReward $T$9 and PSNR $\mathcal{T} = \{ t_1=T > t_2 > \dots > t_K > 0 \},$0 for 2D non-sum, versus ImageReward $\mathcal{T} = \{ t_1=T > t_2 > \dots > t_K > 0 \},$1 and PSNR $\mathcal{T} = \{ t_1=T > t_2 > \dots > t_K > 0 \},$2 for 3D plus sum (Cui et al., 26 Feb 2026). This supports the claim that both path dependence and cumulative interval error matter for schedule quality.

3. Inference procedure, predictors, and calibration

DPCache is training-free because it does not change the diffusion model’s parameters and introduces no learnable modules. Its only offline phase is calibration. The calibration pipeline uses a small set $\mathcal{T} = \{ t_1=T > t_2 > \dots > t_K > 0 \},$3, runs full $\mathcal{T} = \{ t_1=T > t_2 > \dots > t_K > 0 \},$4-step sampling on those examples, stores final-layer features $\mathcal{T} = \{ t_1=T > t_2 > \dots > t_K > 0 \},$5 for all timesteps, computes $\mathcal{T} = \{ t_1=T > t_2 > \dots > t_K > 0 \},$6 by feature prediction and $\mathcal{T} = \{ t_1=T > t_2 > \dots > t_K > 0 \},$7 comparison, and then runs dynamic programming to obtain a fixed schedule for a given budget $\mathcal{T} = \{ t_1=T > t_2 > \dots > t_K > 0 \},$8 (Cui et al., 26 Feb 2026).

At inference time, the precomputed schedule $\mathcal{T} = \{ t_1=T > t_2 > \dots > t_K > 0 \},$9 is loaded. For each timestep $t_{K+1}=0$0 from $t_{K+1}=0$1 down to $t_{K+1}=0$2, the model checks whether $t_{K+1}=0$3 is a key timestep. If it is, the backbone is executed fully and the relevant predictor state is cached. If it is not, the model predicts the required features and uses those predicted features to generate the denoiser output without rerunning the heavy backbone. The paper emphasizes that DPCache is independent of the exact predictor, and instantiates it with a TaylorSeer-style predictor of order $t_{K+1}=0$4, typically $t_{K+1}=0$5 for FLUX and DiT and $t_{K+1}=0$6 for HunyuanVideo (Cui et al., 26 Feb 2026).

The approach is model-agnostic in the sense used by the paper: it assumes that intermediate features, at least the final layer, can be observed and cached. Reported applications include FLUX.1-dev, HunyuanVideo, and DiT-XL/2. In all three cases, the method requires no retraining and no architectural modification. The calibration set can be very small. The paper reports that even $t_{K+1}=0$7 calibration sample works fairly well, while $t_{K+1}=0$8 to $t_{K+1}=0$9 samples give essentially the same schedule; it also reports that prompts from a different dataset produce almost identical schedules (Cui et al., 26 Feb 2026).

This calibration strategy suggests a particular design philosophy. DPCache does not attempt to learn a prompt-conditional policy; instead, it assumes that a small number of full trajectories contains enough structural information about the backbone and sampler to expose globally important timesteps.

4. Empirical behavior across image and video backbones

The paper reports results on text-to-image, text-to-video, and class-conditional image generation, with quality evaluated against both baseline outputs and standard perceptual metrics. A recurring pattern is that DPCache preserves more trajectory fidelity than fixed or locally adaptive caching methods at comparable speedup (Cui et al., 26 Feb 2026).

The following reported operating points summarize the main quantitative outcomes.

Backbone	Setting	Reported outcome
FLUX.1-dev	$$\mathcal{C} \in \mathbb{R}^{(T+1)\times(T+1)\times(T+1)},$$0, $$\mathcal{C} \in \mathbb{R}^{(T+1)\times(T+1)\times(T+1)},$$1 speedup	ImageReward $$\mathcal{C} \in \mathbb{R}^{(T+1)\times(T+1)\times(T+1)},$$2, CLIP $$\mathcal{C} \in \mathbb{R}^{(T+1)\times(T+1)\times(T+1)},$$3, PSNR $$\mathcal{C} \in \mathbb{R}^{(T+1)\times(T+1)\times(T+1)},$$4, SSIM $$\mathcal{C} \in \mathbb{R}^{(T+1)\times(T+1)\times(T+1)},$$5, LPIPS $$\mathcal{C} \in \mathbb{R}^{(T+1)\times(T+1)\times(T+1)},$$6
FLUX.1-dev	$$\mathcal{C} \in \mathbb{R}^{(T+1)\times(T+1)\times(T+1)},$$7, $$\mathcal{C} \in \mathbb{R}^{(T+1)\times(T+1)\times(T+1)},$$8 speedup	ImageReward $$\mathcal{C} \in \mathbb{R}^{(T+1)\times(T+1)\times(T+1)},$$9, CLIP $\mathcal{C}[i,j,k]$0, PSNR $\mathcal{C}[i,j,k]$1, SSIM $\mathcal{C}[i,j,k]$2, LPIPS $\mathcal{C}[i,j,k]$3
HunyuanVideo	$\mathcal{C}[i,j,k]$4, $\mathcal{C}[i,j,k]$5 speedup	VBench $\mathcal{C}[i,j,k]$6, PSNR $\mathcal{C}[i,j,k]$7, SSIM $\mathcal{C}[i,j,k]$8, LPIPS $\mathcal{C}[i,j,k]$9
DiT-XL/2	$i>j>k$0, $i>j>k$1 speedup	FID $i>j>k$2, sFID $i>j>k$3, IS $i>j>k$4, memory $i>j>k$5 GB

On FLUX.1-dev, the paper reports that DPCache outperforms prior acceleration methods by $i>j>k$6 ImageReward at $i>j>k$7 speedup and even surpasses the full-step baseline by $i>j>k$8 ImageReward at $i>j>k$9 speedup (Cui et al., 26 Feb 2026). The phrasing in the paper is careful: the method is optimized for fidelity to the baseline trajectory, but its reported perceptual scores can nevertheless exceed the full-step baseline at selected operating points.

On HunyuanVideo, the paper highlights both quality and memory. Baseline memory is reported as $\mathbf{h}_\tau^L$0 GB, DPCache as $\mathbf{h}_\tau^L$1 GB, and TaylorSeer or SpeCa as $\mathbf{h}_\tau^L$2 GB. The stated reason is that DPCache builds PACT from final-layer features only, whereas prior predictive caching methods can store intermediate activations for all layers and all tokens (Cui et al., 26 Feb 2026). This makes memory overhead a distinguishing part of the method’s empirical profile, especially for large video transformers.

Qualitative summaries in the paper are also consistent with the quantitative pattern: DPCache is reported to avoid blurriness seen in naive fewer-step baselines and TeaCache, to avoid structural misalignment and background artifacts found in TaylorSeer and SpeCa, and to retain sharper edges and better object count and background clarity on FLUX. For HunyuanVideo, it is reported to preserve fine details such as lifebuoys and object geometry better than competing methods (Cui et al., 26 Feb 2026).

5. Relation to ReCache and the scheduling literature

DPCache and ReCache address closely related but not identical questions. DPCache is a training-free acceleration framework that formulates denoising as path planning and uses a Path-Aware Cost Tensor plus dynamic programming to choose key timesteps (Cui et al., 26 Feb 2026). ReCache, by contrast, takes an already chosen caching mechanism and learns the recomputation schedule under an explicit budget $\mathbf{h}_\tau^L$3 via policy gradients, using uncached generations as matching targets and a reward for generation quality (Aliev et al., 4 Jun 2026).

The ReCache paper explicitly treats DPCache’s forecasting mechanism as “Taylor-DP,” and contrasts the original dynamic-programming schedule with a learned budget-conditioned schedule. In this formulation, DPCache provides the mechanism and a dynamic-programming scheduler; ReCache keeps the mechanism fixed and replaces only the scheduler. The ReCache paper states that for DPCache-like systems, one can treat Taylor-DP as the fixed $\mathbf{h}_\tau^L$4 and replace the DP scheduler with a ReCache policy (Aliev et al., 4 Jun 2026).

The reported comparisons are mechanism-matched and budget-matched.

Backbone / setting	DPCache	ReCache on Taylor-DP
FLUX.1-dev, $\mathbf{h}_\tau^L$5	LPIPS $\mathbf{h}_\tau^L$6, HPS $\mathbf{h}_\tau^L$7, IR DB $\mathbf{h}_\tau^L$8	LPIPS $\mathbf{h}_\tau^L$9, HPS $\tau$0, IR DB $\tau$1
Wan 2.1, $\tau$2	LPIPS $\tau$3, HPS $\tau$4, VBench $\tau$5	LPIPS $\tau$6, HPS $\tau$7, VBench $\tau$8
HunyuanVideo, $\tau$9	LPIPS $\mathbf{x}_0$00, HPS $\mathbf{x}_0$01, VBench $\mathbf{x}_0$02	LPIPS $\mathbf{x}_0$03, HPS $\mathbf{x}_0$04, VBench $\mathbf{x}_0$05

These results do not invalidate DPCache’s formulation; rather, they isolate the schedule as a separate optimization target. A common misconception is that DPCache and ReCache are competing end-to-end mechanisms. The data instead supports a more precise distinction: DPCache is a path-aware, training-free framework built around dynamic programming and a cost tensor, whereas ReCache is a budget-aware reinforcement-learning scheduler that can sit on top of DPCache’s Taylor-DP mechanism (Aliev et al., 4 Jun 2026).

This suggests a broader taxonomy within diffusion caching. One axis is the feature approximation mechanism, such as direct reuse or feature forecasting. The other axis is the schedule optimizer, such as uniform spacing, heuristic triggers, dynamic programming, or reinforcement learning. DPCache is distinctive because it made the schedule itself a global path-planning object before the reinforcement-learning alternative was introduced.

6. Limitations, misconceptions, and terminological ambiguity

Several limitations are explicit in the DPCache paper. First, the method minimizes deviation from the baseline trajectory, so if the baseline makes semantic or structural mistakes, DPCache can preserve them. The paper gives examples such as misrendered text and spurious debris that are preserved or amplified (Cui et al., 26 Feb 2026). Second, PACT construction and storage add calibration overhead, even if the overhead is described as manageable for $\mathbf{x}_0$06. Third, the resulting schedule is fixed and input-agnostic; prompt-conditional scheduling is identified as future work (Cui et al., 26 Feb 2026).

The paper also suggests several extensions: input-adaptive scheduling, learnable predictors in place of analytic Taylor or Hermite rules, extension to other modalities and backbones, and richer cost modeling that includes intermediate layers or perceptual metrics (Cui et al., 26 Feb 2026). These are stated as future directions rather than demonstrated properties.

A further source of confusion is that the term “DPCache” is overloaded across different research areas. In diffusion-model acceleration, it denotes “Denoising as Path Planning: Training-Free Acceleration of Diffusion Models with DPCache” (Cui et al., 26 Feb 2026). In differential privacy, the related system is CacheDP, described as “an interactive, accuracy-aware DP query engine” that uses a differentially private cache of past responses (Mazmudar et al., 2022). In systems research, DPC denotes “Distributed Page Cache,” an OS-level distributed page cache over CXL 3.0 memory semantics (Bergman et al., 21 Apr 2026). In coded caching, closely related terminology appears around D2D placement delivery arrays rather than diffusion acceleration (T. et al., 2024). These uses are unrelated except for the surface form of the acronym.

Within the diffusion literature itself, a second misconception is that DPCache is simply a fixed-step reduction method. The paper’s defining claim is more specific: it is a feature-caching method whose novelty lies in path-aware global scheduling over the original denoising trajectory (Cui et al., 26 Feb 2026). Its historical significance therefore lies less in introducing feature forecasting, which predated it, than in formalizing schedule selection as a global optimization problem with an explicit path-dependent cost.