betaFeedback

WorksComputer Science

PEEK: One-Step-Look-Ahead Exposure Bias Correction for Diffusion Sampling

Abstract

Diffusion image generators owe much of their practical success to accurate denoising networks and strong numerical samplers. However, during sampling, the denoiser predicts the next step from flawed inputs that differ substantially from real data. This train-test gap, or exposure bias, caps image generation quality (i.e., blurry images, missing details, or distorted shapes). To mitigate the problem, we propose PEEK, a training-free deterministic sampler plugin. At each eligible denoising step, PEEK first performs a provisional one-step update, evaluates the denoiser once at the look-ahead state, and interpolates the current clean prediction with this one-step-later prediction to form the next noisy state. By taking the additional step, we obtain a generally more image like prediction from the higher-signal noisy state, mitigating exposure bias. To optimize the interpolation positions, PEEK searches for an interpolation schedule with a greedy metric-driven search made efficient by the PEEK prefix and baseline noise-schedule-rebasing caches. Across pixel-space and latent-space diffusion models with unconditional, label-guided, and text-guided settings on CIFAR-10, LSUNBedroom,I mageNet, and MS-COCO,the look-ahead correction consistently improves over baselines matched by number of function evaluations (NFE), with Fréchet Inception Distance (FID) reductions up to 49.3%. The one-time per-model calibration, the only extra cost, takes at most 2.2 minutes in our experiments. Project website is available at https://dachengruoque.github.io/PEEK-Video/.

Introduction

Diffusion models have become a dominant paradigm for image generation, combining a supervised denoising objective with an iterative generation process that gradually transports noise to data [29, 10, 31]. Their practical progress has come from both sides of the system: more capable denoising models and representations [6, 26, 24], and increasingly accurate samplers that treat generation as the numerical solution of a reverse-time stochastic or ordinary differential equation [Song et al., 2021a, Karras et al., 2022, Lu et al., 2022a,b, Zhang and Chen, 2023, Zhao et al., 2023].

Despite this progress, diffusion sampling remains sensitive to errors made along the denoising trajectory, which is most visible in the low-number-of-function-evaluations (NFE) regime, where a small number of large steps must convert an initial high-noise state into a noise-free image. Training typically supervises the network on forward-corrupted clean data, while inference applies the same network to states produced by previous flawed model predictions. The resulting states do not follow the same conditional distributions encountered during training [22]. Figure 1 gives a visual instance of the PEEK trajectory: the denoiser’s prediction tends to be low-quality especially at the high-noise steps, though the training-time counterparts are real high-quality images. The final consequences of the exposure bias include limited generation quality, such as blurry images lacking details of those in the real images.

Figure 1. PEEK performs a provisional one-step update, and uses the look-ahead prediction to interpolate the current prediction at selected positions. The selected clean prediction is then used to construct the next noisy state. The trajectories illustrate that the early-step predictions tend to be especially low-quality, and PEEK can yield higher-quality images. Best viewed in color.

Existing inference-side methods mostly address the problem indirectly. Fast ODE solvers reduce discretization error by deriving higher-order updates [19 b]. Exponential-integrator and predictor-corrector designs pursue the same low-NFE goal with problem-adapted updates [37, 38, 12]. Heun-type predictor-corrector samplers, for example, first form an Euler predictor and then mix the ODE derivatives estimated at the current and predicted states, usually by averaging the two slopes. Schedule optimization methods choose better time grids for a fixed sampler [27]. Restart sampling adds stochastic noise and then re-denoises to contract accumulated sampling errors, and requires selecting restart intervals and repetition counts [35]. Thus prior training-free improvements primarily change the integration rule, change the timestep grid, or insert a stochastic re-denoising segment. PEEK targets, to our knowledge, a simple, important but underexplored correction mechanism: what if we query the denoiser at a deterministic provisional next state and inject the resulting one-step-later clean prediction back to correct exposure bias, instead of just increasing the standard inference steps, for image generation quality improvement?

In short, PEEK is a one-step-look-ahead correction for the deterministic sampling trajectory. Given a current noisy state, PEEK computes the usual clean prediction, takes a provisional next step, obtains the next clean prediction, and then uses an interpolation gate to form the new noisy state as input for the next-step model prediction. We additionally study a solver-direction variant, PEEK-G, for DPM-Solver-style samplers as an extension. Instead of interpolating the clean prediction used to form the next noisy state, PEEK-G interpolates the current solver direction with the direction implied by the one-step-later prediction. So far, extensive work has demonstrated that the generation quality improves along the denoising trajectory, which is expected as the later-step predictions are based on the higher signal-to-noise-ratio input. Furthermore, interchanging the current prediction with the one-step-look-ahead prediction does not break the inherent logic behind deterministic diffusion, as different time steps share the same real-image input and supervision target during training, where only the noise levels differ [10, 30, 12, 20, 37, 38]. Intuitively speaking, assuming perfect corrections that minimize the train-test gap, the otherwise-drifting denoising trajectory can reach the optimal track characterized by only the empirical training error. In contrast, if we only densify the denoising trajectory by increasing the number of ordinary solver steps, we may continue from the already-drifting trajectory where the wide early-inference train-test gaps persist throughout. Therefore, PEEK has the comparative advantage.

On the other hand, each active interpolation spends an extra denoiser evaluation and may exacerbate bias. Therefore, interpolation positions matter. We avoid manual hyperparameter tuning through a schedule search, with a greedy search selecting per-step interpolation gates using a target metric such as FID [8], and the NFE-matched guardrail rejecting look-ahead edits that are a weaker use of the same extra evaluation than an ordinary solver step. To make this search efficient, we exploit the cumulative structure of deterministic denoising, where 1) an NFE-matched baseline noise-schedule-rebasing cache and 2) a PEEK prefix cache avoid rerunning unchanged prefix noise states. Our contributions are:

  • Against the exposure bias problem in low-NFE deterministic diffusion sampling, we propose PEEK, a training-free deterministic one-step-look-ahead interpolation that edits the current prediction to form the noisy state for the next-step inference.

  • We extend the same look-ahead principle to PEEK-G, a DPM-Solver-compatible solver-direction variant.

  • We introduce a metric-driven interpolation schedule search for PEEK(-G), together with baseline noise-schedule-rebasing and PEEK prefix caches that reduce the 9-step vanilla search count from 225 to 78 denoiser evaluations, a 65.3% reduction.

  • We evaluate PEEK and PEEK-G on pixel-space and latent-space generation settings, including CIFAR-10 [14], LSUN Bedroom [36], ImageNet [5], and MS-COCO [17], and demonstrate nontrivial improvements over the NFE-matched baselines, with FID reductions up to 49.3%, under matched denoiser-evaluation budgets.

Related Work

Fast Diffusion Sampling. Diffusion image generation combines denoising models [29, 10, 31] with numerical samplers. Low-NFE generation has been improved through deterministic sampling paths, higher-order ODE solvers, exponential integrators, predictor-corrector updates, and schedule design [Song et al., 2021a, Liu et al., 2022, Lu et al., 2022a,b, Zhang and Chen, 2023, Zhao et al., 2023, Karras et al., 2022, Sabour et al., 2024]. These methods mainly change the integration rule or the timestep grid. Predictor-corrector samplers instantiate this idea at different levels: Heun’s second-order sampler takes an Euler predictor, reevaluates the ODE slope at the predicted endpoint, and applies a trapezoidal average of the two slopes [12], while UniPC derives unified predictor and corrector formulas in half-log-SNR space, using current and previous model outputs so the corrector can raise solver order without an extra model evaluation [38]. In contrast, PEEK interpolates the clean-sample prediction with the one-step-look-ahead counterpart.

Inference Mismatch and Correction. Other approaches reduce few-step error by distilling trajectories or adapting the model for short sampling [28, 32, 23, 1]. Training-free inference corrections are closer to our setting. Restart sampling inserts forward-noising and re-denoising segments to contract accumulated error [35], while SE2P uses information from adjacent denoising times in a parallel-processor design [4]. PEEK instead spends selected extra evaluations on a deterministic one-step look-ahead query and compares against ordinary NFE-matched trajectories. The appendix gives more related work.

Method

Vanilla PEEK

We describe PEEK for deterministic first-order samplers, the setting used for the DPM-Solver++, DEIS, and UniPC wrapper experiments [20, 37, 38]. Appendix gives preliminaries. Let t0>t1>⋯>tN−1t_0 > t_1 > \cdots> t_{N-1} be decreasing timesteps and ziz_i the sampler state at tit_i. We write the ordinary clean prediction as

x^0,ibase=Dθ(zi,ti).(1)\hat{x}^{\mathrm{base}}_{0,i} = D_\theta(z_i,t_i). \tag*{(1)}

A deterministic solver step is

zi+1=Φi(zi,x^0,ibase),(2)z_{i+1} = \Phi_i(z_i,\hat{x}^{\mathrm{base}}_{0,i}), \tag*{(2)}

where Φi\Phi_i includes the sampler-specific conversion from prediction to the next noisy state.

One-Step Look-Ahead Interpolation. At step ii, PEEK first computes the ordinary clean prediction x^0,ibase\hat{x}^{\mathrm{base}}_{0,i} and an ordinary provisional next state

z~i+1=Φi(zi,x^0,ibase).(3)\tilde{z}_{i+1} = \Phi_i(z_i,\hat{x}^{\mathrm{base}}_{0,i}). \tag*{(3)}

It then evaluates the denoiser once more at the next solver timestep:

x^0,ilook=Dθ(z~i+1,ti+1).(4)\hat{x}^{\mathrm{look}}_{0,i} = D_{\theta}(\tilde{z}_{i+1},t_{i+1}). \tag*{(4)}

The clean prediction is passed through a binary gate:

x^0,isel=(1−γi)x^0,ibase+γix^0,ilook,(5)\hat{x}^{\mathrm{sel}}_{0,i} = (1-\gamma_i)\hat{x}^{\mathrm{base}}_{0,i}+\gamma_i\hat{x}^{\mathrm{look}}_{0,i}, \tag*{(5)}

where γi∈{0,1}\gamma_i \in\{0,1\}. The final step starts from the original state ziz_i but uses the selected clean prediction:

zi+1PEEK=Φi(zi,x^0,isel).(6)z^{\mathrm{PEEK}}_{i+1} = \Phi_i(z_i,\hat{x}^{\mathrm{sel}}_{0,i}). \tag*{(6)}

Let qtq_t be the forward-noised data marginal and pip_i the sampler marginal at the same timestep. The denoiser is trained under qtiq_{t_i} but queried under pip_i. If ℓi(x)=∥Dθ(x,ti)−mi(x)∥2\ell_i(x)=\lVert D_{\theta}(x,t_i)-m_i(x)\rVert^2 is the clean-prediction loss relative to mi(x)=Eq[x0∣xti=x]m_i(x)=\mathbb{E}_{q}[x_0\mid x_{t_i}=x], the trajectory mismatch induces excess risk

Δi=Ex∼piℓi(x)−Ex∼qtiℓi(x).(7)\Delta_i = \mathbb{E}_{x\sim p_i}\ell_i(x)-\mathbb{E}_{x\sim q_{t_i}}\ell_i(x). \tag*{(7)}

Large low-NFE steps can make Δi\Delta_i positive because pip_i contains model-generated states away from the forward-noised data distribution. Let x0∗x_0^* be a reference clean target and LiL_i a local Lipschitz constant of the deterministic step with respect to its clean prediction. Then ∥Φi(z,x^0)−Φi(z,x0∗)∥≤Li∥x^0−x0∗∥\lVert\Phi_i(z,\hat{x}_0)-\Phi_i(z,x_0^*)\rVert\le L_i\lVert\hat{x}_0-x_0^*\rVert, so reducing clean-prediction error tightens the corresponding upper bound on one-step state error.

Diffusion training ties predictions at different noise levels to the same clean target [10, 31 a]. The look-ahead query uses a higher-SNR state while the update remains anchored at ziz_i, so the correction is local and can propagate through later deterministic steps.

Interpolation Schedule Search

A fully interpolated PEEK can spend unnecessary denoiser calls. We therefore learn a schedule γ=(γ0,…,γN−2)\gamma=(\gamma_0,\ldots,\gamma_{N-2}) for the N−1N-1 peekable gates; the final step has no later noisy timestep.

With candidate set A={0,1}\mathcal{A}=\{0,1\}, the search greedily chooses one gate at a time. Let M(γ)M(\gamma) be the target validation metric, FID in our experiments. At step ii, previous gates are fixed and future gates are zero:

Mi(γ)=M(γ0,…,γi−1,γ,0,…,0).M_i(\gamma)=M(\gamma_0,\ldots,\gamma_{i-1},\gamma,0,\ldots,0).

Let MibaseM_i^{\mathrm{base}} be the metric of the ordinary solver at the denoiser-evaluation budget obtained by activating the proposed gate, including all previously selected nonzero gates. We evaluate each γ∈A\gamma\in\mathcal{A} and activate the gate only when it passes both comparisons:

γi={1,if Mi(1)<min⁡{Mi(0),Mibase},0,otherwise.(8)\gamma_i = \begin{cases} 1, & \text{if } M_i(1)<\min\{M_i(0),M_i^{\mathrm{base}}\},\\ 0, & \text{otherwise.} \end{cases} \tag*{(8)}

The guardrail therefore compares an active correction with spending its extra evaluation on an ordinary solver step. The zero candidate retains the current partial schedule at its lower budget.

For each candidate position, the search reuses the selected prefix state, evaluates the NFE-matched baseline, evaluates the current partial schedule, and tests each candidate gate. The selected state becomes the next prefix. Appendix gives pseudocode and a real search-log excerpt.

A nonzero γi\gamma_i means the active candidate outperforms both the current partial schedule and the NFE-matched ordinary baseline. A zero means the active candidate fails at least one of these two comparisons.

The search is a one-time calibration for a model, sampler, step count, and target metric. At deployment, the schedule is fixed. A PEEK sample with NN solver steps and KK nonzero gates uses N+KN+K denoiser evaluations, and our main comparisons use ordinary baselines with the same budget.

PEEK-G Extension

PEEK-G forms the same provisional one-step-look-ahead state as PEEK, and blends the current and look-ahead solver directions. The appendix gives the formal DPM-Solver direction notation.

Search-Time Cache Optimization

PEEK uses two caches for deterministic cumulative first-order search. Figure 2 summarizes their complementary reuse paths.

Figure 2. Caches used during schedule search. Baseline rebasing avoids rerunning ordinary prefixes as the NFE-matched chain grows, while the PEEK prefix cache lets later candidates run only the remaining suffix. Best viewed in color.

Baseline Noise-Schedule Rebasing Cache. For a deterministic sampler state ztz_t and clean prediction x^0\hat{x}_0, the variance-preserving implied noise is

ϵ^=zt−αˉtx^01−αˉt.(9)\hat{\epsilon} = \frac{z_t-\sqrt{\bar{\alpha}_t}\hat{x}_0}{\sqrt{1-\bar{\alpha}_t}}. \tag*{(9)}

For target timestep ss, the rebased state is

zs=αˉsx^0+1−αˉsϵ^.(10)z_s = \sqrt{\bar{\alpha}_s}\hat{x}_0+\sqrt{1-\bar{\alpha}_s}\hat{\epsilon}. \tag*{(10)}

(10) moves cached ordinary prefixes to the next NFE-matched grid without recomputing them. Substituting (9) into (10) gives

Rt→s(zt,x^0)=αˉsx^0+1−αˉs1−αˉt(zt−αˉtx^0)=cxzt+c0x^0,(11)\begin{aligned} R_{t\to s}(z_t,\hat{x}_0) &= \sqrt{\bar{\alpha}_s}\hat{x}_0+\sqrt{\frac{1-\bar{\alpha}_s}{1-\bar{\alpha}_t}}\left(z_t-\sqrt{\bar{\alpha}_t}\hat{x}_0\right) \\ &= c_xz_t+c_0\hat{x}_0, \tag*{(11)} \end{aligned}

where cx=(1−αˉs)/(1−αˉt)c_x=\sqrt{(1-\bar{\alpha}_s)/(1-\bar{\alpha}_t)} and c0=αˉs−cxαˉtc_0=\sqrt{\bar{\alpha}_s}-c_x\sqrt{\bar{\alpha}_t}. Thus a cached pair (zt,x^0)(z_t,\hat{x}_0) gives the target-timestep state zs=Rt→s(zt,x^0)z_s=R_{t\to s}(z_t,\hat{x}_0). The baseline cache is an approximation because step-interval differences can cause small mismatch.

PEEK Prefix Cache. After selecting γi\gamma_i, the state at ti+1t_{i+1} is independent of future gates. We cache it, so a later candidate at position jj starts from the cached state after step j−1j-1 and computes only the suffix.

Search Cost. Let candidate index i=0,…,N−2i=0,\ldots,N-2, so its NFE-matched budget is N+i+1N+i+1 in the worst case where every preceding gate is nonzero. Without caching, the initial partial schedule costs NN queries, and both the ordinary baseline and the PEEK candidate are rerun at every budget:

Cn=N+2∑i=0N−2(N+i+1)=3N2−2N.(12)C_n=N+2\sum_{i=0}^{N-2}(N+i+1)=3N^2-2N. \tag*{(12)}

With caching, the initial partial schedule is evaluated once at a cost of NN queries. The first N+1N+1-query ordinary baseline is then evaluated in full. At each later position i=1,…,N−2i=1,\ldots,N-2, rebasing converts the cached pre-final state to the new grid, leaving only the new final-step query. Thus, the baseline cost is

Cb=N+1+∑i=1N−21=2N−1.(13)C_b=N+1+\sum_{i=1}^{N-2}1=2N-1. \tag*{(13)}

For the PEEK candidate at position ii, its cached prefix is free; one new base query, one new look-ahead query, and N−1−iN-1-i ordinary suffix queries remain. Hence

Cp=∑i=0N−2[2+(N−1−i)]=N2+3N−42.(14)C_p = \sum_{i=0}^{N-2} [2+(N-1-i)] = \frac{N^2+3N-4}{2}. \tag*{(14)}

Including the initial partial schedule, the cached total is therefore Cc=N+Cb+Cp=(N2+9N−6)/2C_c=N+C_b+C_p=(N^2+9N-6)/2. For N=9N=9, the naive and cached counts are 225 and 78, respectively, a 65.3% reduction. Appendix E gives the expanded count.

Experiments

Evaluation Protocol. We evaluate unconditional pixel-space generation on CIFAR-10 [14] and LSUN Bedroom [36], class-conditional pixel-space generation on ImageNet at 64×6464 \times64, class-conditional latent generation on ImageNet at 256×256256 \times256 [5], and text-conditioned latent generation on MS-COCO [17]. For CIFAR-10 (Models A and B), LSUN Bedroom (basic and EDM), and ImageNet (64×6464 \times64 and 256×256256 \times256), we evaluate two models per dataset. We report Fréchet Inception Distance (FID) [8], where lower is better. All methods in a comparison use the same model and evaluation protocol unless stated otherwise. Parenthetical percentages in the result tables report relative FID reductions over the corresponding NFE-matched baseline and are shown only when they exceed 5%.

Baselines. The NFE-matched baseline uses the same solver with additional ordinary steps so that it spends the same number of denoiser evaluations as PEEK. The NFE-matched baseline uses the same default schedule as PEEK’s to ensure fairness. We compare DPM-Solver++, DEIS, Heun’s 2nd and UniPC through the solver wrappers used by Zhou et al. [ [40], Chen et al. [ [3]. Heun’s 2nd and

MethodLSUN FID (Base NFE 6) ↓\downarrowRecall ↑\uparrowCoverage ↑\uparrow
DEIS, NFE-Matched20.570.5210.558
DPM-Solver++, NFE-Matched15.950.5670.656
UniPC, NFE-Matched12.110.6010.773
Heun’s 2nd, NFE-Matched51.690.3690.254
Restart-style repeat30.970.3300.400
PEEK, DEIS11.38 (44.7%)↓\downarrow0.6140.744
PEEK, DPM-Solver++11.59 (27.3%)↓\downarrow0.6270.755

Table 1. PEEK main results on the basic LSUN model [36]. Lower FID is better, while higher recall and coverage are better.

UniPC are included as explicit predictor-corrector baselines. We also include a Restart-style repeat baseline in Restart sampling [35]. Note that the original Restart sampling requires tuning of intervals and denoising repetition steps, but the exact method of tuning is underspecified. Therefore, we compare the Restart correction mechanism against ours using the exact same configurations (e.g., NFE), so as to keep variables controlled and contrast the core replacement mechanisms directly. The appendix specifies this baseline in more detail.

Models and Compute. For CIFAR-10 and the basic LSUN Bedroom model we use pretrained DDPM-family pixel-space models [10]. CIFAR-10 is evaluated at 32×3232 \times32; LSUN Bedroom at 256×256256 \times256; ImageNet at 64×6464 \times64 or 256×256256 \times256, depending on the model; and MS-COCO at 512×512512 \times512. For ImageNet we use a DiT-XL/2-256 latent diffusion model with classifier-free guidance [24, 9]. For MS-COCO we use a Stable Diffusion v1.5 latent model with the conventional text-guided evaluation configuration [26]. We additionally evaluate ImageNet-EDM (64×6464 \times64) and the EDM LSUN model (256×256256 \times256), both based on the EDM training paradigm [12]; for the EDM LSUN model, we include iPNDM [18]. Schedule search and final sampling were run on multi-GPU H200 nodes. Pixel-space PEEK applies the interpolation in image space; latent-space PEEK applies the same clean-prediction interpolation in latent space before decoding for evaluation. Unless otherwise stated, all PEEK and PEEK-G visual samples use DPM-Solver++ schedules and sampling. In schedule search, vanilla PEEK uses gate candidates {0,1}\{0,1\}, while PEEK-G uses {0,0.25,0.5,0.75,1}\{0,0.25,0.5,0.75,1\}.

PEEK Results. Table 1 shows that PEEK improves over strong NFE-matched baselines. With DEIS, FID decreases from 20.57 to 11.38 on the basic LSUN model, a 44.7% improvement. With DPM-Solver++, PEEK decreases FID from 15.95 to 11.59, a 27.3% improvement. The Restart-style repeat baseline under the same NFE budget is worse in these runs, suggesting our comparative advantage in the core exposure bias correction mechanism. Both PEEK and Restart-style repeat spend extra evaluations on correction rather than model retraining, but the correction signal is different: PEEK remains on the deterministic trajectory and edits the current clean prediction, while the Restart-style baseline revisits a noised state for stochastic re-noising and denoising. Heun’s 2nd performs worse than the DPM-Solver++, DEIS, and UniPC baselines in these low-NFE settings, aligning with related reports and demonstrating our comparative advantage over this traditional predictor-corrector mechanism [33].

DatasetBase NFENFE-Matched FID ↓\downarrowPEEK FID ↓\downarrow
CIFAR-10 32×3232 \times32 (Model A, 9 steps)925.8020.23 (21.6%)↓\downarrow
CIFAR-10 32×3232 \times32 (Model A, 20 steps)2018.1615.05 (17.1%)↓\downarrow
CIFAR-10 32×3232 \times32 (Model B, 9 steps)919.8716.46 (17.2%)↓\downarrow
CIFAR-10 32×3232 \times32 (Model B, 20 steps)2012.2310.04 (17.9%)↓\downarrow
ImageNet 256×256256 \times256920.4019.64
MS-COCO 512×512512 \times512 (order 1)914.5812.93 (11.3%)↓\downarrow
MS-COCO 512×512512 \times512 (order 3)913.5411.74 (13.3%)↓\downarrow

Table 2. Additional datasets and proxy-search results with PEEK and DPM-Solver++ [20].

DatasetBase NFE256-Dim Proxy FID ↓\downarrowSearch Time / Peak CUDA MemoryFinal FID ↓\downarrow
ImageNet 256×256256 \times25695.151.5 min / 39.0 GB19.64
MS-COCO 512×512512 \times51292.792.2 min / 102.2 GB12.93

Table 2 (PDF p. 8). Additional datasets and proxy-search results with PEEK and DPM-Solver++ [20].

The NFE-matched rows are the intentionally compute-matched baselines. Improvements over these rows therefore indicate that PEEK is improving the use of computation. The PRDC results support the FID comparison. Relative to their NFE-matched baselines, DEIS PEEK raises recall from 0.521 to 0.614 and coverage from 0.558 to 0.744, while DPM-Solver++ PEEK raises recall from 0.567 to 0.627 and coverage from 0.656 to 0.755.

Table 2 reports additional datasets. On CIFAR-10, schedules are selected with the proxy FID and then rerun for standard final FID. To assess the sensitivity of PEEK to model choice, we test CIFAR-10 Models A and B, which are trained on the same dataset but have different generation quality. With CIFAR-10 Model A, a 9-step base solver reduces FID from 25.80 to 20.23, a 21.6% improvement. Increasing the base solver to 20 steps lowers both FID values, moving the NFE-matched baseline to 18.16 and PEEK to 15.05, a 17.1% improvement. With CIFAR-10 Model B, the same study gives lower absolute FID values: PEEK reduces 9-step FID from 19.87 to 16.46 (17.2%), and 20-step FID from 12.23 to 10.04 (17.9%).

On ImageNet, the binary proxy-selected PEEK schedule reduces FID from 20.40 to 19.64. On MS-COCO, the same proxy-search protocol reduces first-order DPM-Solver++ FID from 14.58 to 12.93, an 11.3% relative reduction. These results suggest that one-step-look-ahead correction can apply beyond one resolution, architecture family, or conditioning mode, but the effectiveness varies across models and variants. Note that the ImageNet result tests a class-conditional latent transformer, while MS-COCO tests text-guided latent sampling with a different prompt-conditioned pipeline.

Table 3 adds checkpoints trained under the EDM paradigm [12]. On ImageNet-EDM at 64×6464 \times64, PEEK reduces FID by 49.3% for first-order DPM-Solver++ and 28.0% for first-order DEIS under the same compute. On the EDM LSUN model, the corresponding improvements are 48.6% for DPM-Solver++, 27.4% for DEIS, and 32.6% for iPNDM [18]. These EDM LSUN rows use a different EDM-trained model from the basic LSUN model in Table 1, so the two LSUN blocks should be read as separate models.

Dataset / modelResolutionSolverBase NFENFE-Matched FID ↓\downarrowPEEK FID ↓\downarrow
ImageNet-EDM64×6464 \times64DPM-Solver++619.719.99 (49.3%)↓\downarrow
ImageNet-EDM64×6464 \times64DEIS610.137.29 (28.0%)↓\downarrow
LSUN-Bedroom-EDM256×256256 \times256DPM-Solver++522.8911.77 (48.6%)↓\downarrow
LSUN-Bedroom-EDM256×256256 \times256DEIS512.108.79 (27.4%)↓\downarrow
LSUN-Bedroom-EDM256×256256 \times256iPNDM515.8610.69 (32.6%)↓\downarrow

Table 3. PEEK vs the NFE-matched baselines on EDM-trained models.

Higher-Order Solver. We also evaluate third-order DPM-Solver++ on MS-COCO with the same binary interpolation schedule. The higher-order NFE-matched baseline improves over the first-order baseline from 14.58 to 13.54 FID, and PEEK further improves the higher-order run to 11.74 FID, a 13.3% relative reduction over its NFE-matched baseline, suggesting compatibility.

Schedule Effectiveness. Figure 5 shows representative search traces. The selected schedules are not uniformly dense. Interpolating at all peekable positions does not worsen the ordinary prediction on the basic LSUN Bedroom model. However, not every extra denoiser call is equally valuable, and very late interpolations can have limited impact because much of the layout has already been determined, while the early extra denoiser call may remain low-quality and insufficient to beat the NFE-matched baseline at one extra inference step. Therefore, the early extra denoiser call may also be skipped. Table 5 tests this directly on the basic LSUN Bedroom model by holding the number of interpolations fixed and changing only which candidate position is disabled; binary strings list the five peekable positions from left to right. It also reports the all-one schedule and its 11-step ordinary baseline. In this single-evaluation ablation, the all-one schedule improves its baseline but yields a higher FID than the searched schedule. All-one interpolation improves over its own NFE-matched 11-step baseline by 10.7% for DPM-Solver++ and 29.6% for DEIS. The searched schedule also uses fewer interpolation calls than the all-one schedule.

Figure 5. Schedule Search and Cache Behavior. The PEEK curve improves as useful interpolation positions are accepted. Prefix reuse and baseline rebasing reduce repeated denoising work during schedule search, especially as the selection moves toward later timesteps.

Method/γ\gammaNFEDPM-Solver++DEIS
PEEK 01111 (Greedy Search Schedule)1011.5911.38
PEEK 101111012.6313.34
PEEK 110111013.8214.39
PEEK 111011013.5013.51
PEEK 111101013.9013.36
NFE-Matched Baseline1114.4318.45
PEEK 111111112.8912.98

Table 5. Basic LSUN Bedroom model schedule ablation.

Table 6 evaluates the fixed all-one schedule more broadly, without schedule search, on DPM-Solver++. It improves over the NFE-matched baseline by 28.1% on ImageNet-EDM, and 28.2% on the EDM LSUN model. The all-one schedule requires no search and stills provide non-trivial generation-quality gains, demonstrating PEEK effectiveness at almost zero overhead. Nevertheless, the schedule search remains useful for selecting a sparser, higher-quality schedule.

Dataset / modelBase NFETotal NFENFE-Matched FID-5K ↓\downarrowAll-One PEEK FID-5K ↓\downarrow
CIFAR-10 (Model A)91734.2129.15 (14.8%)↓\downarrow
ImageNet-EDM 64 × 6461120.9315.05 (28.1%)↓\downarrow
LSUN-Bedroom-EDM 256 × 2565921.5915.50 (28.2%)↓\downarrow

Table 6. Fixed all-one PEEK schedules without schedule search.

Cache Effectiveness. Figure 5 summarizes the runtime effect of the cache strategy. The main gain comes from avoiding repeated prefixes: once the search has accepted the first several interpolation gates, testing a later candidate only requires denoising the remaining suffix.

PEEK-G Extension. Table 4 reports PEEK-G results on CIFAR-10 Model B, the basic LSUN model, ImageNet, and MS-COCO. It reduces FID by 24.6% on CIFAR-10 Model B and 26.0% on MS-COCO; the corresponding reductions on the basic LSUN model and ImageNet are 2.2% and 3.5%, respectively.

DatasetBase NFENFE-Matched FID ↓\downarrowPEEK-G FID ↓\downarrow
CIFAR-10 (Model B)917.4813.18 (24.6%)↓\downarrow
Basic LSUN model615.9515.60
ImageNet920.4019.68
MS-COCO914.4110.66 (26.0%)↓\downarrow

Table 4. PEEK-G versus the NFE-matched DPM-Solver++ baseline.

Qualitative Comparison. Figure 3 compares standard, NFE-matched, Restart-style repeat, and PEEK samples. PEEK tends to preserve the deterministic trajectory while sharpening object details. In contrast, Restart-style repeat can introduce larger stochastic deviations because it explicitly adds fresh noise before denoising. Figure 4 compares the NFE-matched samples against those generated by PEEK-G, which renders clearer details. The appendix includes additional qualitative samples.

Qualitative comparison showing Standard, NFE-Matched, Restart, and PEEK image generations

Figure 3. Qualitative Comparison. PEEK uses clean-prediction interpolation and generally achieves better detail-rendering or shape coherence for the generated images. Best viewed in color.

PEEK-G qualitative comparison

Figure 4. PEEK-G Qualitative Comparison. PEEK-G uses solver-direction interpolation and generally achieves better detail-rendering or shape coherence for the generated images. Best viewed in color.

Conclusion

We presented PEEK, a training-free and model-agnostic algorithm for improving deterministic diffusion sampling. By interpolating the current clean prediction with its look-ahead counterpart at searched positions to construct the next noisy state, PEEK improves the NFE-matched baselines in diverse image generation settings. The cache design makes schedule calibration more efficient. A current limitation is the drop in coverage, which could be mitigated as future work. Overall, PEEK spends inference computation on generally cleaner signals, potentially improving generation across different models and samplers, without model fine-tuning and or deployment overhead beyond the per-model calibration cost.

Funding Disclosure

Funding in direct support of this work was provided in part by the Ministry of Education, Singapore, under its MOE AcRF Tier 3 Grant (MOE-MOET32022-0001). The authors declare no competing interests.

Diffusion and Sampling Preliminaries

This appendix briefly reviews the diffusion notation used in the main text and clarifies how PEEK fits into standard deterministic sampling. We focus on the variance-preserving notation used in our cache derivation and on the clean-prediction interface used by the samplers in our experiments.

Forward Noising Process. Diffusion models define a family of noisy marginals by gradually corrupting a clean data sample x0x_0. Under the standard variance-preserving parameterization, the noisy variable at diffusion time tt can be written as

xt=αˉtx0+1−αˉtϵ,ϵ∼N(0,I),x_t = \sqrt{\bar{\alpha}_t}x_0 + \sqrt{1-\bar{\alpha}_t}\epsilon,\qquad\epsilon\sim\mathcal{N}(0,I),

or equivalently

q(xt∣x0)=N(αˉtx0,(1−αˉt)I).q(x_t \mid x_0) = \mathcal{N}\left(\sqrt{\bar{\alpha}_t}x_0,(1-\bar{\alpha}_t)I\right).

Here αˉt\bar{\alpha}_t is the cumulative signal coefficient. Large diffusion times correspond to high-noise states, where αˉt\bar{\alpha}_t is small and most clean-image structure has been obscured. Small diffusion times correspond to low-noise states, where the clean image is more visible.

The marginal distribution of forward-noised real data at time tt is denoted by qtq_t. During training, the denoising network is supervised on samples xt∼qtx_t \sim q_t, so its inputs are noisy versions of real data rather than states produced by its own previous predictions.

Clean-Prediction Notation. Denoising networks can be parameterized in several equivalent ways, such as predicting noise, predicting the clean sample, or predicting a velocity variable. PEEK operates on the clean prediction, so throughout the paper we write

x^0,i=Dθ(zi,ti)\hat{x}_{0,i}=D_\theta(z_i,t_i)

for the clean-sample estimate obtained from the denoiser at sampler state ziz_i and timestep tit_i. If the underlying model predicts noise ϵθ(xt,t)\epsilon_\theta(x_t,t), this clean estimate is obtained by the usual conversion

Dθ(xt,t)=xt−1−αˉtϵθ(xt,t)αˉt.D_\theta(x_t,t)=\frac{x_t-\sqrt{1-\bar{\alpha}_t}\epsilon_\theta(x_t,t)}{\sqrt{\bar{\alpha}_t}}.

Other prediction parameterizations are converted analogously. Thus DθD_\theta should be read as the denoiser after conversion to a clean-sample estimate, not necessarily as the model’s native output.

The subscript convention is important. The subscript 0 in x0x_0 and x^0,i\hat{x}_{0,i} denotes the clean endpoint of the diffusion process. We use ziz_i for the noisy sampler state at discrete index ii and timestep tit_i; x^0,i\hat{x}_{0,i} is the clean prediction made from that state. This distinction avoids overloading x0x_0 as both the clean endpoint and the initial high-noise sampler state.

Deterministic Sampling. At inference time, a deterministic sampler starts from a high-noise state and follows a decreasing timestep grid

t0>t1>⋯>tN−1.t_0 > t_1 > \cdots> t_{N-1}.

Let ziz_i denote the sampler state at timestep tit_i. A first-order deterministic solver step can be written abstractly as

zi+1=Φi(zi,x^0,i),x^0,i=Dθ(zi,ti),z_{i+1}=\Phi_i(z_i,\hat{x}_{0,i}),\qquad\hat{x}_{0,i}=D_\theta(z_i,t_i),

where Φi\Phi_i includes the sampler-specific conversion between the clean prediction, the implied noise prediction, and the next noisy state. This notation covers the deterministic first-order wrappers used in our experiments.

For example, a DDIM-style update under the same variance-preserving parameterization first computes the implied noise

ϵ^i=zi−αˉtix^0,i1−αˉti,\hat{\epsilon}_i=\frac{z_i-\sqrt{\bar{\alpha}_{t_i}}\hat{x}_{0,i}}{\sqrt{1-\bar{\alpha}_{t_i}}},

and then forms the next state by reusing this clean/noise decomposition at the lower-noise timestep:

zi+1=αˉti+1x^0,i+1−αˉti+1ϵ^i.z_{i+1}=\sqrt{\bar{\alpha}_{t_{i+1}}}\hat{x}_{0,i}+\sqrt{1-\bar{\alpha}_{t_{i+1}}}\hat{\epsilon}_i.

Different deterministic solvers use different numerical updates, but they share the same practical structure: the denoiser is queried at the current state, the prediction is converted into the sampler’s preferred parameterization, and the next state is produced without adding fresh random noise.

DPM-Solver Direction Form. DPM-Solver-style samplers write the reverse diffusion dynamics as an ODE in a noise-time variable and approximate the integral of a model-derived direction over each solver interval [19 b]. Abstractly, the update can be written as

zi+1=Aizi+∑j=0r−1Bi,jdi−j,di=Gi(zi,Dθ(zi,ti)),z_{i+1} = A_i z_i + \sum_{j=0}^{r-1} B_{i,j} d_{i-j}, \qquad d_i = G_i(z_i, D_\theta(z_i,t_i)),

where the coefficients AiA_i and Bi,jB_{i,j} are determined by the timestep grid and solver order, and did_i is the current model direction after converting the denoiser output into the solver’s parameterization. First-order DPM-Solver++ uses only the current direction; multistep variants additionally use stored directions from previous timesteps.

PEEK-G Formalization

PEEK interpolates the clean prediction before the next noisy state is formed. For DPM-Solver-style updates, the same look-ahead information can also be used at the solver-direction level. Let

x^0,ibase=Dθ(zi,ti),dibase=Gi(zi,x^0,ibase)(15)\hat{x}_{0,i}^{\mathrm{base}} = D_\theta(z_i,t_i), \qquad d_i^{\mathrm{base}} = G_i(z_i,\hat{x}_{0,i}^{\mathrm{base}}) \tag*{(15)}

denote the model direction used by the deterministic solver at timestep tit_i, where GiG_i is the sampler-specific conversion from the denoiser output to the ODE direction. At a nonzero gate, PEEK-G first forms the same provisional next state z~i+1\tilde{z}_{i+1} as in PEEK using the ordinary scheduler step, but does not commit that state. It then evaluates the denoiser at the look-ahead state,

x^0,ilook=Dθ(z~i+1,ti+1),dilook=Gi+1(z~i+1,x^0,ilook).(16)\hat{x}_{0,i}^{\mathrm{look}} = D_\theta(\tilde{z}_{i+1},t_{i+1}), \qquad d_i^{\mathrm{look}} = G_{i+1}(\tilde{z}_{i+1},\hat{x}_{0,i}^{\mathrm{look}}). \tag*{(16)}

For a nonzero gate, the selected solver direction is

disel=(1−γi)dibase+γidilook.(17)d_i^{\mathrm{sel}} = (1-\gamma_i)d_i^{\mathrm{base}} + \gamma_i d_i^{\mathrm{look}}. \tag*{(17)}

For a zero gate, PEEK-G instead sets disel=dibased_i^{\mathrm{sel}} = d_i^{\mathrm{base}} without computing dilookd_i^{\mathrm{look}}. The actual DPM-Solver step is still applied from the current state ziz_i with the usual timestep coefficients for the current solver interval. Fractional gates are natural in this direction space, so our PEEK-G searches use γi∈{0,0.25,0.5,0.75,1}\gamma_i \in\{0, 0.25, 0.5, 0.75, 1\}. The solver coefficients remain those of the current interval, so PEEK-G is not a new DPM-Solver derivation. It is a post-hoc direction correction using a model prediction from a higher-SNR state. This is mathematically coherent with the diffusion target because denoiser predictions at different timesteps are trained toward the same clean data endpoint x0x_0, after the appropriate parameterization conversion. The practical risk is that the look-ahead prediction may be confidently biased; in that case PEEK-G can amplify the bias even while sharpening the local direction.

NFE Accounting. We count one function evaluation for each call to DθD_\theta. A base deterministic trajectory with NN denoiser queries therefore uses NN NFEs. PEEK can be applied at the first N−1N-1 positions, because the final denoising query has no later noisy timestep inside the trajectory from which to obtain a look-ahead prediction.

If KK interpolation gates in the PEEK schedule are nonzero, then PEEK makes KK additional look-ahead denoiser calls. Its deployment cost is therefore N+KN+K NFEs. The NFE-matched baseline uses the same solver with N+KN+K ordinary denoiser evaluations and no look-ahead interpolation.

Training Distribution versus Sampling Trajectory. A useful way to view low-NFE sampling is through the mismatch between the training inputs and the inference-time states. During training, the denoiser is optimized on xt∼qtx_t \sim q_t, where qtq_t is obtained by forward noising real data. During deterministic sampling, however, the state ziz_i is generated recursively by the sampler and the model’s own previous predictions. Let pip_i denote the marginal distribution of these generated states at timestep tit_i. In general,

pi≠qti.p_i \ne q_{t_i}.

This mismatch is especially important in the low-NFE regime, where each solver step is large and early prediction errors can move the trajectory away from the forward-noised data manifold.

Under squared clean-prediction loss, the ideal training-time predictor at timestep tit_i is the conditional mean

mi(x)=Eq[x0∣xti=x].m_i(x) = \mathbb{E}_{q}[x_0 \mid x_{t_i}=x].

The denoiser DθD_\theta is trained to approximate this target on samples from qtiq_{t_i}. At inference time, however, it is queried on samples from pip_i. When pip_i contains states that are less data-like than the training marginal, the clean prediction x^0,i\hat{x}_{0,i} can be biased or unstable. This motivates using information from a nearby later state on the same deterministic trajectory.

Pixel-Space and Latent-Space Usage. The same notation applies to both pixel-space and latent-space diffusion models. For pixel-space models, ziz_i and x^0,i\hat{x}_{0,i} are image-space tensors. For latent diffusion models, they are latent tensors, and decoding is applied only after sampling for evaluation or visualization. In both cases, PEEK modifies the predicted clean sample in the space where the deterministic solver operates.

Further Implementation Details

Solvers and Timestep Grids. Most reported PEEK runs use deterministic first-order solver wrappers to keep the comparison variables controlled. The DPM-Solver++ rows use the dpmsolver++ algorithm type in the scheduler implementation [20]; the MS-COCO higher-order check additionally uses the order-3 DPM-Solver++ setting. DEIS rows use the DEIS update rule [37] but, unless explicitly marked otherwise, reuse the DPM-Solver++ binary interpolation schedule for the same dataset and base step count. This makes the DEIS result a transfer test of the learned correction positions while preserving the same N+KN + K denoiser-evaluation budget as its NFE-matched DEIS baseline.

Models, Resolution, and Conditioning. CIFAR-10 Model A uses the google/ddpm-cifar10-32 checkpoint evaluated at 32232^2 resolution, and CIFAR-10 Model B uses the DanielBairamian/ddpm-cifar10-32-ema checkpoint for the second CIFAR study and PEEK-G CIFAR rows. Both checkpoints expose the same UNet2DModel macro-architecture in Diffusers: 35.75M parameters, block widths (128,256,256,256)(128, 256, 256, 256), two residual layers per block, and one attention block at the 16-by-16 scale. The basic LSUN model uses google/ddpm-ema-bedroom-256. The EDM table additionally uses the ImageNet 64264^2 conditional EDM checkpoint and the EDM LSUN model checkpoint at 2562256^2 [12]. For the EDM LSUN model, we include an iPNDM baseline [18]. ImageNet uses facebook/DiT-XL-2-256 in latent space with classifier-free guidance scale 4.0. MS-COCO uses a Stable Diffusion v1.5 checkpoint fine-tuned/evaluated with guidance scale 7.5, discrete latent-diffusion timesteps, and 512×512512 \times512 decoding before FID evaluation. The latent-space experiments interpolate the predicted clean latent, not decoded RGB images.

Distributed Evaluation. The pixel-space and latent-space evaluations use multi-GPU H200 nodes with one sample shard per process. The CIFAR-10 qualitative grid uses saved snapshots from the 9-step proxy runs.

Interpolation in Pixel and Latent Spaces. For pixel-space DDPM models, the clean prediction in the main-paper PEEK interpolation equation is an image-space prediction. For latent diffusion models, the same operation is applied to the predicted latent clean sample. FID and qualitative visualizations are computed after the standard decoder is applied.

Candidate Gates. Vanilla PEEK uses binary interpolation gates {0,1}\{0,1\}. PEEK-G uses the direction-space candidate set {0,0.25,0.5,0.75,1}\{0, 0.25, 0.5, 0.75, 1\}.

NFE-Matched Baseline. If an NN-step PEEK schedule uses KK nonzero look-ahead positions, then the deployment run uses N+KN + K denoiser evaluations. The NFE-matched baseline is the same deterministic solver run with N+KN + K ordinary solver steps and no look-ahead interpolation.

Restart-Style Repeat Baseline. The Restart-style baseline follows the same NFE budget as the corresponding PEEK run. After each selected main step, it forwards the current state from the next lower-noise timestep back to the previous higher-noise timestep by adding fresh Gaussian noise, then runs one deterministic solver step back to the lower-noise timestep. The selected repeat positions are the nonzero entries of the PEEK schedule, so a schedule with KK nonzero entries also spends KK extra denoiser evaluations [35].

Evaluation Artifacts. Final FID values are measured on held-out samples distinct from those used for validation search. We use the StyleGAN Inception feature extractor for FID statistics, with 2048-dimensional features for reported final FID except where explicitly marked as a 256-dimensional proxy. CIFAR-10, ImageNet, and MS-COCO schedules are selected with lightweight proxy runs and then rerun with the fixed schedules under the standard final-reporting protocol. Unless otherwise stated, qualitative PEEK and PEEK-G figures use DPM-Solver++ schedules and samples.

Selected Schedules. Table 7 lists the schedules used for the main final evaluations. Each entry has one fewer interpolation gate than solver steps because the final denoising step has no later timestep to peek at. The DEIS final evaluation on the basic LSUN model uses the corresponding DPM-Solver++ schedule as a transfer test; the EDM DEIS and iPNDM rows likewise reuse the corresponding DPM-Solver++ schedule. All other rows use the schedule searched with the same sampler as the final evaluation.

DatasetEvaluation samplerBase NFETotal NFEγ\gamma
PEEK
Unconditional Pixel-Space Generation on CIFAR-10DPM-Solver++917(1,1,1,1,1,1,1,1)(1,1,1,1,1,1,1,1)
Unconditional Pixel-Space Generation on CIFAR-10 (EMA, PEEK)DPM-Solver++911(0,0,0,0,0,0,1,1)(0,0,0,0,0,0,1,1)
Unconditional Pixel-Space Generation on CIFAR-10 (EMA, PEEK)DPM-Solver++2023(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1)(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1)
Unconditional Pixel-Space Generation on Basic LSUN Bedroom ModelDPM-Solver++ / DEIS610(0,1,1,1,1)(0,1,1,1,1)
Class-Conditional Latent Generation on ImageNet 256×256256 \times256DPM-Solver++913(0,0,0,0,1,1,1,1)(0,0,0,0,1,1,1,1)
Text-Conditional Latent Generation on MS-COCODPM-Solver++ (order 1 / 3)912(0,0,0,0,0,1,1,1)(0,0,0,0,0,1,1,1)
Conditional EDM Generation on ImageNet 64×6464 \times64DPM-Solver++ / DEIS69(1,1,1,0,0)(1,1,1,0,0)
Unconditional EDM Generation on EDM LSUN ModelDPM-Solver++ / DEIS / iPNDM58(1,1,1,0)(1,1,1,0)
PEEK-G
Unconditional Pixel-Space Generation on CIFAR-10 (EMA, PEEK-G)DPM-Solver++913(1,0,0,0,0,1,1,1)(1,0,0,0,0,1,1,1)
Unconditional Pixel-Space Generation on Basic LSUN Model (PEEK-G)DPM-Solver++610(0,0.5,1,0.5,0.5)(0,0.5,1,0.5,0.5)
Class-Conditional Latent Generation on ImageNet 256×256256 \times256 (PEEK-G)DPM-Solver++913(0,0,0,0,0.5,0.5,0.25,1)(0,0,0,0,0.5,0.5,0.25,1)
Text-Conditional Latent Generation on MS-COCO (PEEK-G)DPM-Solver++ (order 1)913(0,0,0,0,1,1,1,0.25)(0,0,0,0,1,1,1,0.25)

Table 7. Interpolation schedules used in the reported final evaluations. NFE counts the ordinary solver calls plus nonzero look-ahead calls. Vanilla PEEK uses binary gates, while PEEK-G searches over {0,0.25,0.5,0.75,1}\{0,0.25,0.5,0.75,1\}.

Calibration Cost. Schedule calibration uses proxy metrics. On CIFAR-10, we use a 1,000-sample, 256-dimensional proxy for the DPM-Solver++ schedule sweep, then rerun the fixed schedules with the standard final-reporting protocol. The 9-step schedule search took 20.4 seconds, and the 20-step schedule search took 32.5 seconds; both used about 2.2 GB peak CPU resident set size and 8.7 GB peak CUDA reserved memory. For the latent ImageNet and MS-COCO runs, the main-paper additional-datasets table reports the proxy-search time and peak CUDA memory for PEEK before the selected schedules are rerun with the standard final evaluation metric. Once calibration is complete, the schedule is fixed and no search is run at deployment, so inference speed is determined only by the selected NFE budget.

Extended Related Work

Training and Distillation for Fast Generation. One way to reduce few-step sampling error is to train or distill a model specifically for short trajectories. Progressive distillation compresses a many-step diffusion sampler into a smaller number of student steps [28], while consistency models learn mappings that support direct or few-step generation [32]. Recent lightweight variants optimize a small sampler or conditioning component instead of the whole denoiser: GAS distills and adversarially trains a generalized ODE solver [23], and MTEO freezes the pretrained backbone while optimizing step-wise, layer-wise time embeddings. These approaches can deliver strong low-NFE deployment with little or no per-step overhead after training [1]. PEEK addresses a different operating point: it is training-free and can be applied to an existing sampler immediately, at the cost of selected extra denoiser calls during inference.

Sampler and Schedule Design. DDIM introduced deterministic non-Markovian sampling paths that can use fewer denoising steps than ancestral sampling [30]. PNDM, DPM-Solver, DPM-Solver++, DEIS, UniPC, GENIE, AMED-Solver, and DPM-Solver-v3 further improve low-NFE performance through ODE-aware integration, multistep history, exponential-integration formulas, learned directions, solver statistics, or predictor-corrector design [Liu et al., 2022, Lu et al., 2022a,b, Zhang and Chen, 2023, Zhao et al., 2023, Dockhorn et al., 2022, Zhou et al., 2023, Zheng et al., 2023]. Heun’s method is a representative predictor-corrector update: it forms a predicted next state and combines the current and predicted ODE derivatives, whereas PEEK uses the predicted state only to obtain a clean-sample estimate that can interpolate the current clean prediction before the next noisy state is formed. EDM and schedule-alignment work show that noise parameterization, timestep placement, and architecture allocation are also central to sample quality [12, 15, 27, 3, 25]. SDM formalizes an adaptive sampling design that uses low-order solvers in early high-noise stages and progressively deploys higher-order solvers later [11]. ERK-Guid instead exploits embedded Runge-Kutta local-error estimates as a guidance signal, so its mechanism is specific to embedded/higher-order ODE-solver structure [13]. PEEK is orthogonal to these advances: it uses the same timestep grid at deployment and changes the denoiser-derived clean estimate inside selected deterministic steps.

Inference-Time Correction. Restart sampling alternates a backward ODE path with forward noising segments, using stochasticity to contract accumulated sampling error [35]. Among prior training-free inference-time methods, this is the closest in spirit because it spends extra denoiser evaluations on correction rather than only densifying an ordinary trajectory. The mechanism is different: Restart exposes the sampler to a fresh-noise sub-trajectory and requires interval boundaries, restart counts, and sub-trajectory lengths; PEEK uses a deterministic provisional next state only to obtain a one-step-later clean prediction, then applies the correction to the current step. Recent adaptive-stochasticity plugins make a different tradeoff. AdaSDE learns a per-step stochastic coefficient through lightweight distillation, dynamically regulating correction strength while remaining compatible with existing solvers [34]. PEEK uses no distillation and no injected stochasticity; its correction is deterministic once the schedule is fixed, so it can be layered conceptually with stochastic or learned correction methods but occupies the simpler training-free setting. DiffRS is also post-hoc, but uses a learned time-dependent discriminator to accept or reject intermediate samples and therefore refines different samples with different effort [21]. DiffRS is attractive when sample-adaptive quality filtering and auxiliary discriminator training are acceptable, whereas PEEK is preferable when a fixed deployment NFE budget, no extra learned model, and a simple deterministic trajectory are desired. SE2P is another relevant inference-time correction: it uses two parallel samplers at successive times and integrates information from the later-step processor into the earlier one without adding extra model calls per processor [4]. This is conceptually close to PEEK’s use of a later-step state as a correction signal, but the computational assumptions differ. SE2P relies on parallel processors, whereas PEEK uses explicit extra look-ahead evaluations within one sampler and reports comparisons against NFE-matched ordinary trajectories. Related analyses of diffusion trajectories and schedule flaws emphasize that sampler states encountered during inference can differ from idealized training or terminal distributions [16, 2]. PEEK targets this issue without injecting fresh noise, changing the timestep grid, or deriving a new solver: the correction comes from the model’s own next-step clean prediction along the current deterministic trajectory and is selected with an automated metric-driven search.

Pseudocode

PEEK Sampling. Given timesteps t0,…,tN−1t_0,\ldots,t_{N-1}, initial state z0z_0, and schedule γ\gamma:

  1. For i=0,…,N−2i = 0,\ldots,N - 2, compute the ordinary prediction x^0,ibase=Dθ(zi,ti)\hat{x}^{\mathrm{base}}_{0,i} = D_\theta(z_i, t_i).

  2. If γi=0\gamma_i = 0, set zi+1=Φi(zi,x^0,ibase)z_{i+1} = \Phi_i(z_i, \hat{x}^{\mathrm{base}}_{0,i}) and continue.

  3. Otherwise compute the provisional state z~i+1=Φi(zi,x^0,ibase)\tilde{z}_{i+1} = \Phi_i(z_i, \hat{x}^{\mathrm{base}}_{0,i}).

  4. Compute the look-ahead prediction x^0,ilook=Dθ(z~i+1,ti+1)\hat{x}^{\mathrm{look}}_{0,i} = D_\theta(\tilde{z}_{i+1}, t_{i+1}).

  5. Select x^0,isel=x^0,ilook\hat{x}^{\mathrm{sel}}_{0,i} = \hat{x}^{\mathrm{look}}_{0,i}.

  6. Take the actual step zi+1=Φi(zi,x^0,isel)z_{i+1} = \Phi_i(z_i, \hat{x}^{\mathrm{sel}}_{0,i}).

  7. Run the final ordinary solver step at tN−1t_{N-1}.

PEEK-G Sampling. PEEK-G follows the same provisional look-ahead procedure, but interpolates the solver direction rather than the clean prediction. At step ii, compute the ordinary direction dibased_i^{\mathrm{base}}. If γi=0\gamma_i = 0, take the ordinary update without a look-ahead query. Otherwise, form z~i+1\tilde{z}_{i+1}, query the denoiser at (z~i+1,ti+1)(\tilde{z}_{i+1}, t_{i+1}), convert the result to dilookd_i^{\mathrm{look}}, and use (1−γi)dibase+γidilook(1-\gamma_i)d_i^{\mathrm{base}}+\gamma_i d_i^{\mathrm{look}} inside the ordinary DPM-Solver update for the current interval. The final step remains an ordinary solver step because no later timestep is available.

DPM-Solver with PEEK-G. For a DPM-Solver-style sampler, let Ui(zi,di)U_i(z_i,d_i) denote the ordinary solver update over interval [ti,ti+1][t_i,t_{i+1}] after the denoiser output has been converted to the solver direction did_i. Given a direction schedule γ\gamma:

  1. For i=0,…,N−2i = 0,\ldots,N - 2, evaluate the denoiser at the current state and form the ordinary direction dibase=Gi(zi,Dθ(zi,ti))d_i^{\mathrm{base}} = G_i(z_i, D_\theta(z_i,t_i)).

  2. If γi=0\gamma_i = 0, set zi+1=Ui(zi,dibase)z_{i+1} = U_i(z_i,d_i^{\mathrm{base}}) and continue.

  3. Take the provisional DPM-Solver step z~i+1=Ui(zi,dibase)\tilde{z}_{i+1} = U_i(z_i,d_i^{\mathrm{base}}).

  4. Query the denoiser at the provisional next state, x^0,ilook=Dθ(z~i+1,ti+1)\hat{x}^{\mathrm{look}}_{0,i} = D_\theta(\tilde{z}_{i+1},t_{i+1}), and convert it to a look-ahead direction dilook=Gi+1(z~i+1,x^0,ilook)d_i^{\mathrm{look}} = G_{i+1}(\tilde{z}_{i+1},\hat{x}^{\mathrm{look}}_{0,i}).

  5. Blend the direction according to the selected gate:

disel=(1−γi)dibase+γidilook.d_i^{\mathrm{sel}} = (1-\gamma_i)d_i^{\mathrm{base}}+\gamma_i d_i^{\mathrm{look}}.
  1. Apply the ordinary DPM-Solver update with the original interval coefficients:

zi+1=Ui(zi,disel).z_{i+1} = U_i(z_i,d_i^{\mathrm{sel}}).
  1. At tN−1t_{N-1}, run the final ordinary DPM-Solver step, because there is no later timestep from which to obtain a look-ahead direction.

Greedy Schedule Search. For each peekable position ii, the search reuses the selected prefix state, evaluates candidate interpolation gates on the remaining suffix, compares the best candidate to the NFE-matched ordinary baseline, and stores the selected prefix state for position i+1i + 1. Vanilla PEEK uses A={0,1}A = \{0,1\}, while PEEK-G uses A={0,0.25,0.5,0.75,1}A = \{0,0.25,0.5,0.75,1\}. The selected schedule is then used unchanged for final evaluation.

Cache Derivation

Worst-Case Count. We count denoiser queries and index the N−1N - 1 peekable positions by i=0,…,N−2i = 0,\ldots,N - 2. In the worst case, every previous gate is nonzero, so the NFE-matched budget at position ii is N+i+1N + i + 1. Without caching, the initial current schedule costs NN queries. The ordinary baseline and the PEEK candidate are then both rerun in full at each budget from N+1N+1 through 2N−12N-1. Thus

Cn=N+2∑i=0N−2(N+i+1).(18)C_n = N + 2\sum_{i=0}^{N-2}(N+i+1). \tag*{(18)}

Changing the summation index gives

Cn=N+2∑m=N+12N−1m=3N2−2N.(19)C_n = N + 2\sum_{m=N+1}^{2N-1}m = 3N^2 - 2N. \tag*{(19)}

The two caches change the count as follows. The initial partial schedule is evaluated once at a cost of NN queries, and its metric supplies the zero-gate candidate at the first position. The first ordinary baseline costs N+1N+1 queries. At each later position i=1,…,N−2i=1,\ldots,N-2, baseline rebasing maps the cached pre-final state to the new grid, leaving only the new final-step query. Consequently,

Cb=N+1+∑i=1N−21=2N−1.(20)C_b = N+1+\sum_{i=1}^{N-2}1=2N-1. \tag*{(20)}

For the PEEK candidate at position ii, the selected prefix contains all earlier base and look-ahead results. Only one new base query, one new look-ahead query, and the N−1−iN-1-i ordinary queries in the remaining suffix must be evaluated. Therefore,

Cp=∑i=0N−2[1+1+(N−1−i)].(21)C_p = \sum_{i=0}^{N-2}[1+1+(N-1-i)]. \tag*{(21)}

Reversing the suffix index gives

Cp=2(N−1)+∑r=1N−1r=N2+3N−42.(22)C_p = 2(N-1)+\sum_{r=1}^{N-1}r=\frac{N^2+3N-4}{2}. \tag*{(22)}

Including the initial partial schedule, the cached search cost is

Cc=N+Cb+Cp=N2+9N−62.(23)C_c = N+C_b+C_p=\frac{N^2+9N-6}{2}. \tag*{(23)}

For the paper’s N=9N=9 search, the naive count is 9+2(10+⋯+17)=2259+2(10+\cdots+17)=225. The initial partial schedule costs 9, the cached baseline costs 10+7⋅1=1710+7\cdot1=17, and the cached PEEK candidates cost 2⋅8+(8+⋯+1)=522\cdot8+(8+\cdots+1)=52, for a total of 78. The reduction is (225−78)/225=65.3%(225-78)/225=65.3\%. These sums count denoiser queries; cached base and look-ahead results incur no new query. Additional nonzero gate candidates add their corresponding PEEK candidate work.

Example Search Log

step 0: NFE-matched baseline FID 3.0802; current PEEK FID 3.2585; candidate γ=1\gamma=1 gives 3.2459; selected γ=0\gamma=0. step 5: NFE-matched baseline FID 3.0802; current PEEK FID 3.2585; candidate γ=1\gamma=1 gives 3.0634; selected γ=1\gamma=1. step 7: NFE-matched baseline FID 2.9720; current PEEK FID 2.9003; candidate γ=1\gamma=1 gives 2.7922; selected γ=1\gamma=1.

Reproducibility and Responsible Use

All reported results use pretrained image generators and image benchmarks. The method does not introduce new training data or a new model checkpoint; it is an inference procedure plus a schedule-calibration routine. Code and reproduction materials are available from the project website at https://dachengruoque.github.io/PEEK-Video/, including the schedules, commands, and evaluation utilities needed to reproduce the reported sampling results. Image generation systems can be misused to synthesize deceptive or harmful visual content. PEEK can improve generation quality, so releases should follow the same safeguards and usage restrictions as the underlying generative models.

Existing Assets. The experiments use benchmarks and pretrained generators: CIFAR-10 [14], LSUN Bedroom [36], ImageNet [5], MS-COCO [17], DDPM-family checkpoints [10], DiT [24], Stable Diffusion [26], and solver implementations following DPM-Solver++, DEIS, UniPC, and fast-sampler codebases [20, 37, 38, 40, 3].

Additional Visualizations

Figure 6-Figure 10 provide additional PEEK samples, and Figure 11-Figure 19 provide PEEK-G samples and direct qualitative contrasts.

Basic LSUN Bedroom model PEEK Qualitative Comparison I

Figure 6. Basic LSUN Bedroom model PEEK Qualitative Comparison I. Samples are generated by PEEK with the google/ddpm-ema-bedroom-256 pixel-space DDPM checkpoint. Best viewed in color.

Figure 10. MS-COCO PEEK Qualitative Comparison II. Samples are generated by PEEK with the Stable Diffusion v1.5 latent text-to-image checkpoint. Best viewed in color.

CIFAR-10 PEEK-G qualitative comparison

Figure 11. CIFAR-10 PEEK-G Qualitative Comparison. Each method block contains five rows with 20 samples per row. PEEK-G is compared against the NFE-matched DPM-Solver++ baseline under the same denoiser-evaluation budget. Best viewed in color.

PEEK and PEEK-G qualitative contrast

Figure 19. PEEK and PEEK-G Qualitative Contrast. Rows show the basic LSUN Bedroom model and MS-COCO. Columns show the NFE-matched DPM-Solver++ baseline, vanilla PEEK, and PEEK-G. Best viewed in color.

Basic LSUN Bedroom model PEEK Qualitative Comparison II

Figure 7. Basic LSUN Bedroom model PEEK Qualitative Comparison II. Samples are generated by PEEK with the google/ddpm-ema-bedroom-256 pixel-space DDPM checkpoint. Best viewed in color.

ImageNet PEEK Qualitative Comparison

Figure 8. ImageNet PEEK Qualitative Comparison. Samples are generated by PEEK with the facebook/DiT-XL-2-256 class-conditional latent diffusion transformer with classifier-free guidance. Best viewed in color.

NFE-Matched and PEEK qualitative comparison images

Figure 9. MS-COCO PEEK Qualitative Comparison I. Samples are generated by PEEK with the Stable Diffusion v1.5 latent text-to-image checkpoint. Best viewed in color.

Basic LSUN Bedroom model PEEK-G Qualitative Comparison I

Figure 12. Basic LSUN Bedroom model PEEK-G Qualitative Comparison I. Samples are generated by PEEK-G with the google/ddpm-ema-bedroom-256 pixel-space DDPM checkpoint. Best viewed in color.

Basic LSUN Bedroom model PEEK-G Qualitative Comparison II

Figure 13. Basic LSUN Bedroom model PEEK-G Qualitative Comparison II. Samples are generated by PEEK-G with the google/ddpm-ema-bedroom-256 pixel-space DDPM checkpoint. Best viewed in color.

ImageNet PEEK-G qualitative comparison showing NFE-Matched and PEEK-G samples

Figure 14. ImageNet PEEK-G Qualitative Comparison I. Samples are generated by PEEK-G with the facebook/DiT-XL-2-256 class-conditional latent diffusion transformer with classifier-free guidance. Best viewed in color.

ImageNet PEEK-G qualitative comparison II

Figure 15. ImageNet PEEK-G Qualitative Comparison II. Samples are generated by PEEK-G with the facebook/DiT-XL-2-256 class-conditional latent diffusion transformer with classifier-free guidance. Best viewed in color.

ImageNet PEEK-G Qualitative Comparison III

Figure 16. ImageNet PEEK-G Qualitative Comparison III. Samples are generated by PEEK-G with the facebook/DiT-XL-2-256 class-conditional latent diffusion transformer with classifier-free guidance. Best viewed in color.

MS-COCO PEEK-G Qualitative Comparison I

Figure 17. MS-COCO PEEK-G Qualitative Comparison I. Samples are generated by PEEK-G with the Stable Diffusion v1.5 latent text-to-image checkpoint. Best viewed in color.

MS-COCO PEEK-G Qualitative Comparison II

Figure 18. MS-COCO PEEK-G Qualitative Comparison II. Samples are generated by PEEK-G with the Stable Diffusion v1.5 latent text-to-image checkpoint. Best viewed in color.

References

  1. [1]Yuren Cai, Guangyi Wang, Zongqing Li, Li Li, Zhihui Liu, and Songzhi Su. Three creates all: You only sample 3 steps. arXiv preprint arXiv:2603.22375, 2026.arxiv.org/abs/2603.22375
  2. [2]Defang Chen, Zhenyu Zhou, Jian-Ping Mei, Chunhua Shen, Chun Chen, and Can Wang. A geometric perspective on diffusion models. arXiv preprint arXiv:2305.19947, 2023.arxiv.org/abs/2305.19947
  3. [3]Defang Chen, Zhenyu Zhou, Can Wang, Chunhua Shen, and Siwei Lyu. On the trajectory regularity of ode-based diffusion sampling. arXiv preprint arXiv:2405.11326, 2024.arxiv.org/abs/2405.11326
  4. [4]Pedro Cisneros-Velarde. It takes two to tango: Two parallel samplers improve quality in diffusion models for limited steps. arXiv preprint arXiv:2510.21802, 2025.
  5. [5]Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. ImageNet: A large-scale hierarchical image database. In IEEE Conference on Computer Vision and Pattern Recognition, 2009.
  6. [6]Prafulla Dhariwal and Alex Nichol. Diffusion models beat gans on image synthesis. In Advances in Neural Information Processing Systems, 2021.
  7. [8]Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. In Advances in Neural Information Processing Systems, 2017.
  8. [9]Jonathan Ho and Tim Salimans. Classifier-free diffusion guidance. In NeurIPS Workshop on Deep Generative Models and Downstream Applications, 2021.arxiv.org/abs/2207.12598
  9. [10]Jonathan Ho, Ajay Jain, and Pieter Abbeel. Denoising diffusion probabilistic models. In Advances in Neural Information Processing Systems, 2020.arxiv.org/abs/2006.11239
  10. [11]Sangwoo Jo and Sungjoon Choi. Formalizing the sampling design space of diffusion-based generative models via adaptive solvers and wasserstein-bounded timesteps. arXiv preprint arXiv:2602.12624, 2026.arxiv.org/abs/2602.12624
  11. [12]Tero Karras, Miika Aittala, Timo Aila, and Samuli Laine. Elucidating the design space of diffusion-based generative models. In Advances in Neural Information Processing Systems, 2022.arxiv.org/abs/2206.00364
  12. [13]Inho Kong, Sojin Lee, Youngjoon Hong, and Hyunwoo J. Kim. Error as signal: Stiffness-aware diffusion sampling via embedded runge-kutta guidance. arXiv preprint arXiv:2603.03692, 2026.arxiv.org/abs/2603.03692
  13. [14]Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, University of Toronto, 2009.
  14. [15]Lijiang Li, Huixia Li, Xiawu Zheng, Jie Wu, Xuefeng Xiao, Rui Wang, Min Zheng, Xin Pan, Fei Chao, and Rongrong Ji. AutoDiffusion: Training-free optimization of time steps and architectures for automated diffusion model acceleration. In IEEE/CVF International Conference on Computer Vision, 2023.arxiv.org/abs/2309.10438
  15. [16]Shanchuan Lin, Bingchen Liu, Jiashi Li, and Xiao Yang. Common diffusion noise schedules and sample steps are flawed. arXiv preprint arXiv:2305.08891, 2023.arxiv.org/abs/2305.08891
  16. [17]Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C. Lawrence Zitnick. Microsoft COCO: Common objects in context. In European Conference on Computer Vision, 2014.arxiv.org/abs/1405.0312
  17. [18]Luping Liu, Yi Ren, Zhijie Lin, and Zhou Zhao. Pseudo numerical methods for diffusion models on manifolds. In International Conference on Learning Representations, 2022.arxiv.org/abs/2202.09778
  18. [19]Cheng Lu, Yuhao Zhou, Fan Bao, Jianfei Chen, Chongxuan Li, and Jun Zhu. DPM-Solver: A fast ODE solver for diffusion probabilistic model sampling in around 10 steps. In Advances in Neural Information Processing Systems, 2022a.arxiv.org/abs/2206.00927
  19. [20]Cheng Lu, Yuhao Zhou, Fan Bao, Jianfei Chen, Chongxuan Li, and Jun Zhu. DPM-Solver++: Fast solver for guided sampling of diffusion probabilistic models. arXiv preprint arXiv:2211.01095, 2022b.DOI
  20. [21]Byeonghu Na, Yeongmin Kim, Minsang Park, Donghyeok Shin, Wanmo Kang, and Il-chul Moon. Diffusion rejection sampling. In International Conference on Machine Learning, 2024.arxiv.org/abs/2405.17880
  21. [22]Mang Ning, Mingxiao Li, Jianlin Su, Albert Ali Salah, and Itir Onal Ertugrul. Elucidating the exposure bias in diffusion models. arXiv preprint arXiv:2308.15321, 2023.arxiv.org/abs/2308.15321
  22. [23]Aleksandr Oganov, Ilya Bykov, Eva Neudachina, Mishan Aliev, Alexander Tolmachev, Alexander Sidorov, Aleksandr Zuev, Andrey Okhotin, Denis Rakitin, and Aibek Alanov. GAS: Improving discretization of diffusion ODEs via generalized adversarial solver. arXiv preprint arXiv:2510.17699, 2025.arxiv.org/abs/2510.17699
  23. [24]William Peebles and Saining Xie. Scalable diffusion models with transformers. In IEEE/CVF International Conference on Computer Vision, 2023.arxiv.org/abs/2212.09748
  24. [25]Jianning Pei, Han Hu, and Shuyang Gu. Optimal stepsize for diffusion sampling. arXiv preprint arXiv:2503.21774, 2025.arxiv.org/abs/2503.21774
  25. [26]Robin Rombach, Andreas Blattmann, Dominik Lorenz, Patrick Esser, and Bjorn Ommer. High-resolution image synthesis with latent diffusion models. In IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2022.arxiv.org/abs/2112.10752
  26. [27]AmirMojtaba Sabour, Sanja Fidler, and Karsten Kreis. Align your steps: Optimizing sampling schedules in diffusion models. arXiv preprint arXiv:2404.14507, 2024.arxiv.org/abs/2404.14507
  27. [28]Tim Salimans and Jonathan Ho. Progressive distillation for fast sampling of diffusion models. In International Conference on Learning Representations, 2022.arxiv.org/abs/2202.00512
  28. [29]Jascha Sohl-Dickstein, Eric A. Weiss, Niru Maheswaranathan, and Surya Ganguli. Deep unsupervised learning using nonequilibrium thermodynamics. In International Conference on Machine Learning, 2015.
  29. [30]Jiaming Song, Chenlin Meng, and Stefano Ermon. Denoising diffusion implicit models. In International Conference on Learning Representations, 2021a.arxiv.org/abs/2010.02502
  30. [31]Yang Song, Jascha Sohl-Dickstein, Diederik P. Kingma, Abhishek Kumar, Stefano Ermon, and Ben Poole. Score-based generative modeling through stochastic differential equations. In International Conference on Learning Representations, 2021b.
  31. [32]Yang Song, Prafula Dhariwal, Mark Chen, and Ilya Sutskever. Consistency models. In International Conference on Machine Learning, 2023.arxiv.org/abs/2303.01469
  32. [33]Guangyi Wang, Wei Peng, Lijiang Li, Wenyu Chen, Yuren Cai, and Songzhi Su. Diffusion sampling correction via approximately 10 parameters. In International Conference on Machine Learning, 2025a.arxiv.org/abs/2411.06503
  33. [34]Ruoyu Wang, Beier Zhu, Junzhi Li, Liangyu Yuan, and Chi Zhang. Adaptive stochastic coefficients for accelerating diffusion sampling. In Advances in Neural Information Processing Systems, 2025b.arxiv.org/abs/2510.23285
  34. [35]Yilun Xu, Mingyang Deng, Xiang Cheng, Yonglong Tian, Ziming Liu, and Tommi Jaakkola. Restart sampling for improving generative processes. In Advances in Neural Information Processing Systems, 2023.arxiv.org/abs/2306.14878
  35. [36]Fisher Yu, Yinda Zhang, Shuran Song, Ari Seff, and Jianxiong Xiao. LSUN: Construction of a large-scale image dataset using deep learning with humans in the loop. In arXiv preprint arXiv:1506.03365, 2015.arxiv.org/abs/1506.03365
  36. [37]Qingsheng Zhang and Yongxin Chen. Fast sampling of diffusion models with exponential integrator. In International Conference on Learning Representations, 2023.arxiv.org/abs/2204.13902
  37. [38]Wenliang Zhao, Lujia Bai, Yongming Rao, Jie Zhou, and Jiwen Lu. UniPC: A unified predictor-corrector framework for fast sampling of diffusion models. In Advances in Neural Information Processing Systems, 2023.arxiv.org/abs/2302.04867
  38. [40]Zhenyu Zhou, Defang Chen, Can Wang, and Chun Chen. Fast ode-based sampling for diffusion models in around 5 steps. arXiv preprint arXiv:2312.00094, 2023.arxiv.org/abs/2312.00094

Paper details

vlnc:W_ge8tdfba
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 2

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents