Image Diffusion Preview with Consistency Solver

ArXiv: 2512.13592

🎯 Pitch

You can slash image generation time nearly in half without sacrificing final quality, simply by letting users preview and reject low-quality samples early. This paper shows that a learned ODE solver trained via reinforcement learning can produce previews so faithful to the full-step result that user interaction time drops up to 55%, while matching the FID of standard solvers using 47% fewer steps.

---

1. Executive Summary

This paper introduces Diffusion Preview, a preview-and-refine paradigm that splits image generation into a rapid low-step preview stage—enabling users to iterate on prompts and seeds cheaply—followed by full-step refinement only once the preview is satisfactory. The core technical contribution is ConsistencySolver, a trainable high-order ODE solver derived from general linear multistep methods and optimized via Reinforcement Learning (specifically PPO with a similarity reward grounded in depth maps, segmentation masks, and DINO features) that learns adaptive, timestep-conditioned integration coefficients to maximize alignment between few-step previews and full-step reference outputs. On Stable Diffusion text-to-image generation, ConsistencySolver achieves an FID of 20.39 at 5 steps versus 25.87 for multistep DPM-Solver—matching its quality while using 47% fewer steps—and in user studies reduces average end-to-end inference time by up to 55% on LAION prompts, establishing that a learned solver policy can serve as a reliable proxy for full-step generation while preserving the deterministic PF-ODE mapping essential for consistency between previews and refined outputs.

2. Context and Motivation

The Core Problem: Diffusion Models Are Too Slow for Interactive Use

Diffusion models have become the dominant paradigm for high-fidelity image generation, but they suffer from a fundamental tension between quality and speed. Generating a single high-quality image requires numerically solving the reverse Probability Flow ODE (PF-ODE) over many discretized timesteps—typically dozens to hundreds of neural function evaluations (NFEs). Each evaluation requires a forward pass through a large neural network (often billions of parameters). The result is that producing one satisfactory image can take seconds to minutes on consumer hardware, and interactive workflows—where a user iterates on prompts, seeds, or editing instructions—become painfully slow.

This paper targets a specific deployment pattern that amplifies this tension: the iterative trial-and-error loop inherent in creative work. As the authors note in Section 1, a designer prototyping image variations might need to generate and evaluate dozens of candidates before finding one worth refining. If each candidate requires a full 40-step diffusion sampling process, the total wall-clock time becomes prohibitive. The core inefficiency is that most generated images are discarded—the user decides within seconds that a result is unsatisfactory, yet the system has already burned the full computational cost of high-step sampling.

The paper frames this as an allocation problem: computational resources should be concentrated on outputs that will actually be used, not wasted on previews that will be immediately rejected. This is analogous to progressive rendering in computer graphics or adaptive bitrate streaming in video—techniques that provide a lower-fidelity version first, deferring full quality until the user commits.

Why This Matters: Real-World Impact and Theoretical Significance

The practical significance is straightforward. Diffusion models underpin an increasingly large share of generative AI products—from Midjourney and DALL-E to inpainting tools in Photoshop to video generation systems. Any technique that reduces the perceived latency of these systems without degrading final output quality directly improves the user experience for millions of people. The paper's user study (Table 4) demonstrates up to 55% reduction in end-to-end inference time on LAION prompts, which translates to real dollars in GPU compute savings and real seconds in user waiting time.

But the problem also has theoretical depth. The paper is asking a more fundamental question: can we learn a solver that approximates the full PF-ODE trajectory well enough that users can make reliable decisions from low-step previews? This is not merely an engineering optimization—it touches on the geometry of diffusion trajectories, the nature of the consistency-fidelity tradeoff, and the question of what information about a final image is already present in early denoising steps. The paper's approach of treating solver coefficients as a policy to be optimized via reinforcement learning is a novel framing that connects numerical ODE solving to sequential decision-making, opening up a new axis for diffusion model acceleration that sits between pure training-free solvers and full model distillation.

Prior Approaches and Where They Fall Short

The paper identifies two broad families of existing acceleration techniques, each with fundamental limitations for the preview-and-refine use case.

Training-Free ODE Solvers

Training-free methods accelerate sampling by using cleverer numerical integration schemes without modifying the model weights. The paper surveys this landscape in Section 2, tracing the progression from early work that reduced NFEs from 1000 to under 50 (DDIM, Analytic-DPM), through semi-linear solvers that exploit the structure of the PF-ODE (DPM-Solver, DEIS, iPNDM), to modern methods that push toward 10-step regimes (DPM-Solver++, EDM, UniPC).

These methods have the crucial advantage of preserving the deterministic PF-ODE mapping—given the same initial noise and prompt, the output is identical to what full-step sampling would produce (up to numerical discretization error). This is exactly the consistency property that Diffusion Preview requires: the preview should be a reliable proxy for what the final output will look like.

However, the authors identify a critical limitation in Section 1:

"Training-free methods... rely on theoretical assumptions that may not align with the model's actual behavior. It frequently produces low-quality previews that fail to capture the essential characteristics of the final output."

The problem is that all training-free solvers make approximations about the smoothness or functional form of the score function $\boldsymbol{\epsilon}(\mathbf{x}_t, t)$—whether assuming it's locally constant (DDIM/Euler), locally linear (DPM-Solver-2/midpoint), or fitting a higher-order polynomial (PNDM/Adams-Bashforth). These assumptions are derived from classical numerical analysis and hold for well-behaved ODEs, but the PF-ODE of a real diffusion model is not a textbook ODE. The score function is a neural network, and its behavior across timesteps can be irregular in ways that fixed integration schemes cannot capture. At very low step counts (3-8 steps), these approximations introduce structurally meaningful errors—the preview doesn't just look slightly noisier; it may have different object layouts, missing elements, or altered semantics compared to the full-step output. This makes the preview unreliable for user decision-making: a user might reject a preview that looks bad, not realizing the final output would have been good, or accept a preview that looks promising, only to find the refined output differs substantially.

Distillation-Based Methods

Post-training distillation takes a different approach: train an auxiliary model or modify the base model's weights to produce high-quality outputs in very few steps. The paper distinguishes two sub-categories in Section 2:

ODE distillation methods (LCM, PCM, consistency models) train the model to map any point on the PF-ODE trajectory directly to the endpoint in a single step, effectively "baking in" the integration. Score distillation methods (DMD2, Diff-Instruct, SiD) use a GAN-like training objective where a student model is trained to match the distribution of the teacher model's outputs.

These methods can produce impressive results in extremely low step counts—even single-step generation. But the paper identifies three critical drawbacks for the preview-and-refine paradigm:

1. Loss of deterministic consistency. Distillation methods fundamentally alter the model's learned trajectory. The paper states in Section 1:

"ODE distillation methods suffer from accumulated distillation errors, causing degradation of the original ODE path and deterioration in generation quality. Score distillation methods fundamentally alter the model's learned trajectory due to their GAN-like training objectives."

In practice, this means the mapping from (noise, prompt) to output is no longer the same as the original model's PF-ODE trajectory. A preview generated by a distilled model and the final output generated by the original full-step model may differ substantially, even with the same seed. This breaks the preview-and-refine contract: the user can't trust that accepting a good preview will yield a good final output.

2. Loss of flexible step selection. Distilled models are typically trained for a specific step count (e.g., 1-step or 4-step generation). The original diffusion model's ability to trade off quality against speed by choosing different numbers of sampling steps is lost. This is incompatible with a two-stage workflow where preview and refinement use different step budgets.

3. Substantial training cost. Distillation requires retraining or fine-tuning the entire diffusion model, which is computationally expensive (often requiring hundreds of GPU-days). This makes it impractical for scenarios where the base model is frequently updated or where compute budgets are limited.

4. Hidden quality degradation not captured by FID. The paper's user study (Table 5) reveals a striking finding: DMD2, despite achieving competitive FID scores, satisfies only 57% as many prompts as the base model on GenEval. The authors interpret this as evidence that "the loss of consistency fundamentally undermines generation quality in ways not captured by distribution-level metrics." In other words, distillation methods can produce images that look good on average but fail on specific prompts in ways that matter for real users—and the FID metric, which measures distribution-level similarity, masks these failures.

The Gap: No Method Balances All Three Requirements

The paper argues that existing methods fail to simultaneously satisfy the three requirements of Diffusion Preview identified in Section 1:

• Fidelity: Previews should closely resemble the final output in visual and structural quality.
• Efficiency: The preview stage should be computationally cheap.
• Consistency: The mapping from (noise, prompt) to output should be deterministic and identical between preview and full-step sampling.

Training-free solvers provide consistency (they follow the same PF-ODE trajectory) and efficiency (no retraining), but their fidelity degrades severely at very low step counts. Distillation methods provide efficiency and sometimes fidelity, but sacrifice consistency and flexibility.

The paper positions ConsistencySolver as filling precisely this gap: a method that learns to be a better solver rather than learning to replace the model. By treating the solver's integration coefficients as learnable parameters optimized to maximize preview-reference similarity, ConsistencySolver can adapt to the actual behavior of the score function rather than relying on theoretical approximations, while preserving the exact PF-ODE trajectory (since it's still solving the same ODE, just with better step sizes/weights). The RL training approach further means the solver can be optimized for non-differentiable perceptual similarity metrics that better capture what users care about, rather than being constrained to differentiable losses that may not align with human judgment.

How ConsistencySolver Relates to Linear Multistep Methods

The paper grounds its approach in the classical numerical analysis of Linear Multistep Methods (LMMs), reviewed in Section 3.3. LMMs are a standard technique for solving ODEs that use multiple prior states to improve accuracy. The general $m$-step LMM update (Equation 4) is:

$\mathbf{x}_{t_{i+1}} = \sum_{j=0}^{m-1} \mu_j \mathbf{x}_{t_{i-j}} + (t_{i+1-j} - t_{i-j}) \sum_{j=0}^{m} w_j f(t_{i+1-j}, \mathbf{x}_{t_{i+1-j}})$

The key insight is that existing training-free diffusion solvers are special cases of LMMs with fixed, theoretically-derived coefficients. For example, DDIM is a 1-step method with $w_1=1$; PNDM is a 4-step Adams-Bashforth method with specific fixed coefficients ($w_1=55/24, w_2=-59/24, w_3=37/24, w_4=-9/24$); DPM-Solver-2 alternates between a 1-step and 2-step method with coefficients derived from the noise schedule. The paper demonstrates these connections concretely in Appendix B.

The crucial move is making these coefficients learnable and timestep-conditioned rather than fixed by theory. Equation 5 defines ConsistencySolver's update:

$\mathbf{y}_{t_{i+1}} = \mathbf{y}_{t_i} + (n_{t_{i+1}} - n_{t_i}) \cdot \left[\sum_{j=1}^{m} w_j(t_i, t_{i+1}) \cdot \boldsymbol{\epsilon}_{i+1-j}\right]$

where the coefficients $w_j(t_i, t_{i+1})$ are output by a lightweight MLP $\boldsymbol{f}_{\boldsymbol{\theta}}(t_i, t_{i+1})$. This preserves the LMM structure (using a weighted combination of past score estimates) but replaces fixed coefficients with a learned policy that can adapt to the local dynamics of the sampling trajectory. Critically, the paper also simplifies the LMM structure with three principled modifications (Section 4.2): (1) explicit-only design ($w_0=0$) since PF-ODE trajectories are smooth and non-stiff; (2) anchoring to the current state ($\mu_0=1$, $\mu_j=0$ for $j \geq 1$) to eliminate redundant history storage; and (3) timestep-conditioned coefficients to allow adaptation across the denoising schedule.

This design represents a middle ground between training-free solvers (which use fixed theoretically-derived coefficients) and full distillation (which modifies the model itself). ConsistencySolver modifies only the solver—a lightweight MLP with negligible parameters compared to the diffusion model—while keeping the base model frozen and the PF-ODE trajectory intact. The paper argues this is the right level of abstraction for the preview-and-refine problem: enough flexibility to learn high-quality low-step approximations from data, while preserving the structural guarantees (deterministic mapping, flexible step selection, model reuse) that distillation sacrifices.

The RL Framing: Why Not Just Distill the Solver?

A natural question is: if we're learning the solver coefficients, why use RL rather than straightforward supervised learning or trajectory distillation? The paper provides specific justification in Section 4.3:

1. Non-differentiable rewards. The metrics that best capture preview quality—perceptual similarity based on depth maps, segmentation masks, DINO features—are not easily differentiable. RL accepts a scalar reward signal without requiring gradients through the metric computation, enabling optimization for exactly the properties that matter for the task.

2. Avoiding backpropagation through the diffusion trajectory. Distillation approaches that differentiate through the full sampling chain must store intermediate activations for the entire diffusion model across all timesteps, which is memory-intensive and computationally expensive. RL only requires the final reward, eliminating this overhead. Only the lightweight MLP participates in loss computation, substantially reducing memory usage.

3. Superior generalization. The paper's empirical comparison (Table 2) shows that the RL-trained ConsistencySolver outperforms the trajectory-distilled version (Ours-Distill) across most metrics, suggesting that optimizing for the final objective directly is more effective than matching intermediate trajectory states. The paper attributes this to the fact that trajectory distillation imposes strong constraints on intermediate states that may be unnecessary—what matters is that the final preview resembles the final output, not that each intermediate step precisely matches a reference trajectory.

The offline dataset preparation (Section 4.1) is a pragmatic design choice: generating reference samples via 40-step DPM-Solver once and reusing them across training episodes eliminates the need for on-the-fly full-step generation, making the RL training loop efficient (training completes in approximately 12 H100 GPU hours, per Appendix D.1).

3. Technical Approach

3.1 Reader Orientation

This paper builds a trainable ODE solver—a lightweight neural network that sits alongside a frozen pretrained diffusion model and learns to produce high-quality preview images using very few sampling steps by adaptively choosing how to combine information from previous denoising steps. The core problem it solves is that existing fast diffusion samplers either (a) use fixed theoretical approximations that break down at very low step counts and produce previews that don't look like the final output, or (b) require expensive retraining of the entire model and sacrifice the deterministic consistency between preview and final image—and ConsistencySolver solves this by learning only the integration coefficients of a linear multistep solver, keeping the base model frozen and the ODE trajectory intact, while optimizing directly for perceptual similarity between few-step previews and full-step reference images using reinforcement learning.

3.2 Big-Picture Architecture (Diagram in Words)

The system has five major components connected in a training pipeline:

1. Frozen Pretrained Diffusion Model ($\boldsymbol{\epsilon}_{\boldsymbol{\phi}}$): A standard text-to-image diffusion model (Stable Diffusion or FLUX.1-Kontext) that takes a noisy image $\mathbf{x}_t$, timestep $t$, and text prompt $\boldsymbol{c}$, and outputs a denoising direction $\boldsymbol{\epsilon}_{\boldsymbol{\phi}}(\mathbf{x}_t, t, \boldsymbol{c})$. This model is never updated during training—it serves as the "ground truth" dynamics that the solver must navigate.

2. Learnable Solver Policy Network ($\boldsymbol{f}_{\boldsymbol{\theta}}$): A lightweight MLP that takes the current timestep $t_i$ and target timestep $t_{i+1}$ as input, and outputs $m$ scalar coefficients $w_1, \ldots, w_m$ that determine how to weight the last $m$ denoising predictions when taking a single ODE step. This is the only component that gets trained.

3. ConsistencySolver ODE Integrator ($\mathbf{\Psi}_{\boldsymbol{\theta}}$): The procedural component that executes few-step sampling. At each transition from $t_i$ to $t_{i+1}$, it calls $\boldsymbol{f}_{\boldsymbol{\theta}}(t_i, t_{i+1})$ to get coefficients, forms a weighted blend of the last $m$ denoising predictions $\sum_j w_j \cdot \boldsymbol{\epsilon}_{i+1-j}$, and performs a deterministic ODE update to advance the sample. This runs for $K$ steps (where $K$ is small, e.g., 3–12) to produce the preview image $\mathbf{x}_{\text{p}}$.

4. Reference Generator (Full-Step Solver): A standard training-free solver (40-step multistep DPM-Solver) that generates the ground-truth target image $\mathbf{x}_{\text{gt}}$ from the same initial noise $\mathbf{z}$ and prompt $\boldsymbol{c}$. These reference images are precomputed once and stored in an offline dataset, eliminating on-the-fly generation cost during training.

5. Perceptual Similarity Reward Function ($\mathcal{R}$): A function that compares the preview $\mathbf{x}_{\text{p}}$ against the reference $\mathbf{x}_{\text{gt}}$ and produces a scalar reward. By default, this uses depth map similarity (comparing depth estimates extracted from both images), but can also incorporate DINO features, segmentation masks, CLIP embeddings, or pixel-level similarity. Critically, this reward function does not need to be differentiable—it provides a scalar signal to the RL optimizer.

Information flow during training: A prompt–noise–reference triple is sampled from the offline dataset → the initial noise $\mathbf{z}$ is fed through the $K$-step ConsistencySolver pipeline, with the policy network $\boldsymbol{f}_{\boldsymbol{\theta}}$ producing coefficients at each step → the final preview $\mathbf{x}_{\text{p}}$ is compared to the precomputed reference $\mathbf{x}_{\text{gt}}$ via the reward function, yielding a scalar $\mathcal{R}$ → PPO uses this reward to update the policy parameters $\boldsymbol{\theta}$ to increase the probability of coefficient choices that led to high rewards, while the diffusion model $\boldsymbol{\epsilon}_{\boldsymbol{\phi}}$ remains completely frozen.

Information flow during inference (Diffusion Preview workflow): User provides a prompt and (optionally) a random seed → ConsistencySolver generates a low-step preview using the trained policy → user evaluates the preview → if unsatisfactory, user changes prompt or seed and repeats the cheap preview step → once satisfied, the same noise and prompt are fed through the full 40-step DPM-Solver to produce the final high-quality image, which is guaranteed to closely match the preview because both follow the same deterministic PF-ODE trajectory.

3.3 Roadmap for the Deep Dive

• First, the mathematical foundation of the PF-ODE (Equation 2): how diffusion sampling is formulated as an ODE, why this enables deterministic preview-to-final mapping, and what the key quantity $\boldsymbol{\epsilon}(\mathbf{x}_t, t)$ represents physically.
• Second, how existing ODE solvers approximate the exact integral (Equation 3): the Taylor expansion perspective that unifies DDIM, DPM-Solver-2, and PNDM as different orders of approximation, which motivates why a learned approach can outperform fixed coefficients.
• Third, the ConsistencySolver update equation (Equation 5): the concrete mathematical form of the solver—how it combines past noise predictions using learned coefficients, the three design choices that simplify general linear multistep methods for diffusion (Sections 4.2), and how existing solvers are special cases (Appendix B).
• Fourth, the policy network architecture and training objective (Equations 6–7): the MLP that outputs coefficients, and the formal optimization problem of maximizing similarity between preview and reference.
• Fifth, the RL training procedure (Equations 8–9): how solver coefficient selection is cast as a sequential decision problem, the PPO algorithm details, the offline dataset preparation, the episode rollout process, and the advantage computation.
• Sixth, the comparison between RL and distillation (Section 4.3): why the authors chose RL over gradient-based distillation, including the three claimed advantages and the empirical comparison in Table 2.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a methods paper whose core idea is that the integration coefficients of a linear multistep ODE solver can be treated as a policy to be optimized via reinforcement learning, where the reward is the perceptual similarity between a few-step preview and a full-step reference image generated from the same noise and prompt. The key insight that distinguishes this from prior work is that existing solvers use fixed, theoretically-derived coefficients that make assumptions about the smoothness of the score function $\boldsymbol{\epsilon}(\mathbf{x}_t, t)$—assumptions that fail at very low step counts—while ConsistencySolver learns coefficients that adapt to the actual behavior of the specific pretrained diffusion model being used.

---

The PF-ODE: Why Diffusion Sampling Has a Deterministic Path

The foundation for the entire method is the Probability Flow ODE (PF-ODE), which is the deterministic reverse-time dynamics of a diffusion model. Understanding this is essential because the preview-and-refine paradigm relies on the fact that, given the same initial noise and prompt, both the preview and the final output travel along the same deterministic trajectory—the only difference is how coarsely that trajectory is sampled.

A diffusion model defines a forward process that gradually adds noise to data. At any time $t$, the distribution of noisy data given clean data $\mathbf{x}_0$ is:

$\mathbb{P}_t(\mathbf{x} | \mathbf{x}_0) = \mathcal{N}(\alpha_t \mathbf{x}_0, \sigma_t^2 \mathbf{I})$

where $\alpha_t$ is a scaling factor that decreases over time (the signal component) and $\sigma_t$ is the noise standard deviation that increases over time (the noise component). At $t=0$, $\alpha_0 \approx 1$ and $\sigma_0 \approx 0$ (clean data); at $t=1$, $\alpha_1 \approx 0$ and $\sigma_1 \approx 1$ (pure noise). The specific functions $\alpha_t$ and $\sigma_t$ define the noise schedule.

The forward process can be written as a Stochastic Differential Equation (SDE):

$\mathrm{d}\mathbf{x}_t = f_t \mathbf{x}_t \mathrm{d}t + g_t \mathrm{d}\mathbf{w}_t$

where $\mathrm{d}\mathbf{w}_t$ is a Wiener process (continuous-time random noise), $f_t = \frac{\mathrm{d}\log\alpha_t}{\mathrm{d}t}$ is the drift coefficient (deterministic shrinking toward zero), and $g_t^2 = \frac{\mathrm{d}\sigma_t^2}{\mathrm{d}t} - 2\frac{\mathrm{d}\log\alpha_t}{\mathrm{d}t}\sigma_t^2$ is the diffusion coefficient (noise injection rate).

The key result from Song et al. (2021) is that this SDE has an equivalent deterministic reverse process—the PF-ODE—that produces the same marginal distributions $\mathbb{P}_t$ at every timestep without injecting any random noise:

$\mathrm{d}\mathbf{x}_t = \left[f_t \mathbf{x}_t - \frac{g^2_t}{2} \nabla_{\mathbf{x}_t} \log \mathbb{P}_t(\mathbf{x}_t)\right] \mathrm{d}t$

The term $\nabla_{\mathbf{x}_t} \log \mathbb{P}_t(\mathbf{x}_t)$ is the score function—the gradient of the log-density of the data distribution at noise level $t$, which points toward regions of higher probability. Intuitively, this ODE says: "at each infinitesimal timestep, move the sample in the direction of the deterministic drift $f_t\mathbf{x}_t$ (which shrinks it), and also move it in the direction of the score (which points toward clean data)."

The diffusion model $\boldsymbol{\epsilon}_{\boldsymbol{\phi}}(\mathbf{x}_t, t)$ is trained to predict the noise that was added to produce $\mathbf{x}_t$, which is related to the score by:

$\boldsymbol{\epsilon}(\mathbf{x}_t, t) = -\sigma_t \nabla_{\mathbf{x}_t} \log \mathbb{P}_t(\mathbf{x}_t)$

Substituting this into the PF-ODE yields a simplified form that the paper uses as its starting point (Equation 2):

$\mathrm{d}\left(\frac{\mathbf{x}_t}{\alpha_t}\right) = \mathrm{d}\left(\frac{\sigma_t}{\alpha_t}\right) \cdot \boldsymbol{\epsilon}(\mathbf{x}_t, t)$

where $\mathbf{y}_t = \mathbf{x}_t / \alpha_t$ can be thought of as the "signal-scaled" representation (dividing out the time-dependent shrinkage) and $n_t = \sigma_t / \alpha_t$ can be thought of as the "noise-to-signal ratio" at time $t$.

Why this form matters: This equation says that the change in the signal-scaled sample $\mathbf{y}_t$ is proportional to the change in the noise-to-signal ratio $n_t$, with the denoising prediction $\boldsymbol{\epsilon}(\mathbf{x}_t, t)$ serving as the proportionality factor. This is a particularly clean form because the right-hand side only depends on $n_t$ (which is a known function of the noise schedule) and $\boldsymbol{\epsilon}$ (which is the model's output). There are no additional drift terms to approximate—the entire integration problem reduces to approximating $\int \boldsymbol{\epsilon}(\mathbf{x}_{t_n}, t_n) \mathrm{d}n$.

The consistency guarantee: Because the PF-ODE is deterministic, if you start from the same initial noise $\mathbf{z}$ at $t=1$ and integrate to $t=0$ using the exact score function, you always get the same final image. In practice, different solver approximations will produce different trajectories, but they are all approximating the same underlying ODE. ConsistencySolver is designed so that its low-step approximation stays close enough to the true trajectory that the preview $\mathbf{x}_{\text{p}}$ and the full-step reference $\mathbf{x}_{\text{gt}}$ look perceptually similar—they are both traveling along (or very near) the same deterministic path.

---

The Exact Integral and Why Approximation Is Necessary

Integrating Equation 2 from time $t$ to time $s$ (with $s < t$, meaning forward in the denoising direction) gives the exact solution (Equation 3):

$\mathbf{y}_s = \mathbf{y}_t + \int_{n_t}^{n_s} \boldsymbol{\epsilon}(\mathbf{x}_{t_n}, t_n) \mathrm{d}n$

where $\mathbf{y}_t = \mathbf{x}_t / \alpha_t$ is the signal-scaled sample at the starting time, $\mathbf{y}_s = \mathbf{x}_s / \alpha_s$ is the signal-scaled sample at the target time, $n_t = \sigma_t/\alpha_t$ and $n_s = \sigma_s/\alpha_s$ are the noise-to-signal ratios at the respective times, and $t_n$ is the inverse function of $n_t$ (the time corresponding to noise-to-signal ratio $n$).

What this equation means operationally: To compute the sample at time $s$ from the sample at time $t$, you take the current signal-scaled sample $\mathbf{y}_t$, and add the integral of the model's denoising prediction $\boldsymbol{\epsilon}$ over the noise-to-signal ratio interval $[n_t, n_s]$. The integral captures the cumulative denoising effect across the interval.

Why we can't compute this exactly: The integrand $\boldsymbol{\epsilon}(\mathbf{x}_{t_n}, t_n)$ is the output of a neural network evaluated at the current state along the trajectory, which itself depends on the integral up to that point. This is a circular dependency—to know $\mathbf{x}_{t_n}$ at intermediate points, you need to have already solved the integral. This is the fundamental challenge of all diffusion sampling: you need to approximate the integral using only evaluations of $\boldsymbol{\epsilon}$ at known points.

The Taylor expansion perspective (Appendix A) that unifies existing solvers:

Let $h = n_s - n_t$ be the size of the integration step. The Taylor expansion of the integrand around $n_t$ gives:

$\int_{n_t}^{n_s} \boldsymbol{\epsilon}(\mathbf{x}_{t_n}, t_n) \mathrm{d}n = h \boldsymbol{\epsilon}(\mathbf{x}_t, t) + \frac{h^2}{2} \frac{\mathrm{d}}{\mathrm{d}n}\boldsymbol{\epsilon}(\mathbf{x}_{t_n}, t_n)\big|_{n_t} + \frac{h^3}{6} \frac{\mathrm{d}^2}{\mathrm{d}n^2}\boldsymbol{\epsilon}(\mathbf{x}_{t_n}, t_n)\big|_{n_t} + \cdots$

Different solvers correspond to different truncations and approximations of this series:

• DDIM (first-order, naive approximation): Keep only the first term $\Delta\mathbf{y}_{t \to s} \approx h \boldsymbol{\epsilon}(\mathbf{x}_t, t)$. This assumes $\boldsymbol{\epsilon}$ is constant across the interval, which is only accurate for very small step sizes. At large step sizes (low step counts), this introduces substantial error because $\boldsymbol{\epsilon}$ varies significantly as denoising progresses.

• DPM-Solver-2 (second-order, midpoint): Approximate the first derivative using a finite difference at the midpoint. Evaluate $\boldsymbol{\epsilon}$ at an intermediate point $r$ where $n_r \approx n_t + h/2$, and use $\Delta\mathbf{y}_{t \to s} \approx h \boldsymbol{\epsilon}(\mathbf{x}_r, r)$. The paper shows algebraically (Appendix A.2, Equations 15–16) that this exactly matches the second-order Taylor expansion when the first derivative is estimated by a centered finite difference: $h\boldsymbol{\epsilon}_t + \frac{h^2}{2} \cdot \frac{\boldsymbol{\epsilon}_r - \boldsymbol{\epsilon}_t}{h/2} = h\boldsymbol{\epsilon}_r$. This is more accurate than DDIM because it accounts for the local slope of $\boldsymbol{\epsilon}$.

• PNDM (fourth-order Adams-Bashforth): Use a 4-step linear multistep method with fixed coefficients $w_1=55/24, w_2=-59/24, w_3=37/24, w_4=-9/24$ that approximate the integral using a weighted combination of $\boldsymbol{\epsilon}$ evaluated at the last four steps. These coefficients are derived from fitting a polynomial through the last four function values and integrating it.

The critical limitation of all these methods is that the coefficients are fixed and derived from theoretical assumptions about the smoothness of $\boldsymbol{\epsilon}$. In practice, the score function of a trained diffusion model is not a smooth polynomial—it can have sharp transitions, particularly at timesteps where semantic information emerges. Fixed coefficients cannot adapt to these irregularities, leading to systematic errors that accumulate across steps and cause the low-step preview to deviate from the true trajectory in structurally meaningful ways.

---

The ConsistencySolver Update Equation: Learned Multistep Integration

The core technical contribution is Equation 5, which defines how ConsistencySolver advances the sample from time $t_i$ to $t_{i+1}$:

$\mathbf{y}_{t_{i+1}} = \mathbf{y}_{t_i} + (n_{t_{i+1}} - n_{t_i}) \cdot \left[\sum_{j=1}^{m} w_j(t_i, t_{i+1}) \cdot \boldsymbol{\epsilon}_{i+1-j}\right]$

where $\mathbf{y}_{t_i} = \mathbf{x}_{t_i} / \alpha_{t_i}$ is the signal-scaled sample at the current time, $n_{t_{i+1}} - n_{t_i}$ is the step size in noise-to-signal ratio space, $m$ is the solver order (number of historical noise predictions used, typically 4), $w_j(t_i, t_{i+1})$ are the learned, timestep-conditioned coefficients output by the policy network, and $\boldsymbol{\epsilon}_{i+1-j} = \boldsymbol{\epsilon}_{\boldsymbol{\phi}}(\mathbf{x}_{t_{i+1-j}}, t_{i+1-j}, \boldsymbol{c})$ are the denoising predictions at the current and previous steps.

What this equation computes: At each transition, ConsistencySolver takes a weighted blend of the last $m$ denoising predictions (from the current step $i$ back to step $i+1-m$), where the weights $w_j$ are produced by a neural network that sees only the current and target timesteps. This weighted blend serves as an estimate of $\boldsymbol{\epsilon}$ across the interval $[t_i, t_{i+1}]$, and is then multiplied by the step size and added to the current signal-scaled sample. The result $\mathbf{y}_{t_{i+1}}$ is then unscaled by $\alpha_{t_{i+1}}$ to get $\mathbf{x}_{t_{i+1}}$, which becomes the input for the next step's denoising prediction.

The three principled simplifications from general LMMs (Section 4.2):

Recall the general $m$-step LMM (Equation 4): $\mathbf{x}_{t_{i+1}} = \sum_{j=0}^{m-1} \mu_j \mathbf{x}_{t_{i-j}} + (t_{i+1-j} - t_{i-j}) \sum_{j=0}^{m} w_j f(t_{i+1-j}, \mathbf{x}_{t_{i+1-j}})$. ConsistencySolver makes three modifications:

1. Explicit-only design ($w_0 = 0$): In a general LMM, $w_0 \neq 0$ means the method is implicit—the update equation includes $f(t_{i+1}, \mathbf{x}_{t_{i+1}})$, which is the derivative evaluated at the unknown next state. Implicit methods require solving a nonlinear equation at each step (typically via fixed-point iteration), which would require multiple additional network evaluations per step. The paper argues this is unnecessary because "PF-ODE trajectories are smooth and non-stiff"—meaning the solution doesn't have rapidly varying components that require the stability of implicit methods. By setting $w_0 = 0$, the update uses only past (already-computed) $\boldsymbol{\epsilon}$ evaluations, making each step a single explicit computation.

2. Anchor to current state ($\mu_0 = 1$, $\mu_j = 0$ for $j \geq 1$): In a general LMM, the new state can be a weighted combination of multiple past states ($\sum \mu_j \mathbf{x}_{t_{i-j}}$). ConsistencySolver simplifies this to using only the most recent state $\mathbf{y}_{t_i}$ as the base for the update, eliminating the need to store and weight past samples. The paper argues this "eliminates redundant history storage while preserving high-order accuracy via derivative blending"—meaning the historical information is captured entirely through the weighted combination of past denoising predictions ($\boldsymbol{\epsilon}$ values), not past states ($\mathbf{x}$ values). This is a design choice that trades some potential accuracy from state history for simplicity and reduced memory.

3. Timestep-conditioned coefficients: Classical LMMs use fixed coefficients $w_j$ that are the same regardless of where you are in the integration interval. ConsistencySolver makes them functions of $(t_i, t_{i+1})$—the specific start and end times of the current step. This is crucial because the behavior of $\boldsymbol{\epsilon}(\mathbf{x}_t, t)$ changes qualitatively across the denoising schedule: at high noise levels, it primarily determines coarse layout; at low noise levels, it adds fine details. Different regimes benefit from different integration strategies (different weightings of past predictions), and the timestep conditioning allows the solver to adapt accordingly.

How existing solvers fit within this framework (Appendix B):

The paper demonstrates that several widely-used solvers are special cases of Equation 5 with specific fixed coefficient choices:

• DDIM: $m=1$, $w_1 = 1$ for all timesteps. The update reduces to $\mathbf{y}_{t_{i+1}} = \mathbf{y}_{t_i} + (n_{t_{i+1}} - n_{t_i}) \boldsymbol{\epsilon}_i$, which is the naive constant-$\boldsymbol{\epsilon}$ approximation.

• PNDM: $m=4$, with fixed Adams-Bashforth coefficients $w_1 = 55/24, w_2 = -59/24, w_3 = 37/24, w_4 = -9/24$. These coefficients are derived from fitting a cubic polynomial through the last four $\boldsymbol{\epsilon}$ values and integrating it exactly—a standard technique from numerical analysis, but one that assumes polynomial behavior of $\boldsymbol{\epsilon}$.

• DPM-Solver-2: Alternates between two coefficient patterns. On even steps, it uses $m=1$, $w_1 = 1$ (a standard DDIM step used to reach an intermediate point). On odd steps, it uses $m=2$ with $w_1 = (n_{t_{i+1}} - n_{t_{i-1}}) / (n_{t_{i+1}} - n_{t_i})$ and $w_2 = -(n_{t_i} - n_{t_{i-1}}) / (n_{t_{i+1}} - n_{t_i})$, which are derived from the geometry of the midpoint approximation.

The critical insight is that all of these are specific points in the space of possible coefficient values—and that space is vast. A 4th-order solver has 4 continuous coefficients at each of, say, 8 timestep transitions, giving 32 degrees of freedom. The paper's hypothesis is that there exist coefficient configurations in this space that produce substantially better previews than any theoretically-derived set, precisely because they can be optimized to compensate for the specific non-idealities of the trained score function rather than assuming it behaves like a smooth mathematical function.

---

The Policy Network: Architecture and Coefficient Generation

The coefficients $w_j(t_i, t_{i+1})$ are produced by a lightweight neural network (Equation 6):

$\begin{bmatrix} w_1 & w_2 & \cdots & w_m \end{bmatrix}^{\top} = \boldsymbol{f}_{\boldsymbol{\theta}}(t_i, t_{i+1})$

where $\boldsymbol{f}_{\boldsymbol{\theta}}$ is implemented as a Multi-Layer Perceptron (MLP), $t_i$ is the current timestep, $t_{i+1}$ is the target timestep, and $m$ is the solver order.

Network architecture details (from Appendix D.4): The default configuration uses a hidden dimension of 256. The paper's ablation (Table 8) compares hidden dimensions of 128, 256, 512, and 1024, as well as a deep 12-layer MLP with residual LayerNorm connections. The 256-dimensional model "consistently outperforms others, delivering superior results in image similarity, semantic alignment, and overall consistency." Larger dimensions (1024) "slightly enhance depth estimation but compromise balance and efficiency." The deep 12-layer MLP "shows no meaningful advantage over the standard 256-dim architecture, suggesting that moderate capacity is sufficient for the task."

Why such a small network? The policy network is tiny compared to the diffusion model (hundreds of parameters versus billions). This is intentional and reflects the paper's design philosophy: the policy doesn't need to learn visual representations or generation capabilities—those are provided by the frozen diffusion model. The policy only needs to learn a strategy for combining denoising predictions, which is a low-dimensional function of timesteps. The simplicity also has practical benefits: training is fast (12 H100 GPU-hours), the policy generalizes well (it doesn't overfit to training prompts because it doesn't see prompts at all—only timesteps), and it adds negligible computational overhead at inference time.

What the policy does NOT see: The policy network takes only $(t_i, t_{i+1})$ as input. It does not see the prompt $\boldsymbol{c}$, the current sample $\mathbf{x}_{t_i}$, or any features of the image content. This is a deliberate design choice that forces the learned strategy to be content-agnostic—it learns a general integration strategy that works across all prompts, rather than overfitting to visual features of the training data. The paper argues this contributes to generalization, since the policy is learning something about the dynamics of the denoising process rather than about specific image content.

The order $m$ hyperparameter: The solver order $m$ controls how many past denoising predictions are used in the weighted blend. The paper's ablation (Table 6) compares orders 2, 3, 4, and 5 at 5, 8, and 10 steps. Order 4 "consistently achieves the best overall performance across step counts, leading in key structural and perceptual metrics while maintaining strong semantic alignment." Lower orders (2–3) "show reduced fidelity in layout and depth consistency," while Order 5 "yields only marginal improvements in minor dimensions likely due to the increased RL search space complexity." Order 4 strikes the best balance: it has enough capacity to capture higher-order dynamics of the denoising trajectory, but the coefficient space is not so large that RL optimization becomes inefficient.

---

The Training Objective: Maximizing Preview-Reference Similarity

The formal training objective is defined in Equation 7:

$\mathbf{\Psi}_{\theta^*} = \arg\max_{\mathbf{\Psi}_{\boldsymbol{\theta}}} \mathbb{E}_{\mathbf{z}, \boldsymbol{c}} \left[ \text{Sim}(\mathbf{x}_{\text{gt}}, \mathbf{x}_{\text{p}}) \right]$

where $\mathbf{\Psi}_{\boldsymbol{\theta}}$ is the ConsistencySolver (the ODE integrator parameterized by the policy network parameters $\boldsymbol{\theta}$), $\mathbf{z} \sim \mathcal{N}(0, \mathbf{I})$ is a random initial noise sample, $\boldsymbol{c}$ is a text prompt sampled from the training distribution, $\mathbf{x}_{\text{gt}}$ is the full-step reference image generated from $(\mathbf{z}, \boldsymbol{c})$ using 40-step multistep DPM-Solver, $\mathbf{x}_{\text{p}}$ is the preview image generated from the same $(\mathbf{z}, \boldsymbol{c})$ using ConsistencySolver with $K$ steps, and $\text{Sim}(\cdot, \cdot)$ is a perceptual similarity metric.

What this objective means: Find solver parameters $\boldsymbol{\theta}$ such that, on average over prompts and initial noise samples, the few-step preview and the full-step reference are perceptually similar. "Similar" is defined by the reward function, which by default compares depth maps extracted from both images—meaning the optimization encourages the preview to have the same 3D structure and object layout as the reference, even if pixel-level details differ slightly.

Why similarity rather than pixel-level reconstruction? The goal is not to produce a pixel-identical preview to the full-step output (which would be impossible at very low step counts). The goal is to produce a preview that is informative enough for user decision-making—if the reference image would have a dog on the left and a tree on the right, the preview should also have a dog on the left and a tree on the right, even if the fur texture isn't fully resolved. Perceptual similarity metrics (depth, DINO, segmentation) are designed to capture these structural and semantic properties while being somewhat invariant to high-frequency details, making them better aligned with the actual downstream task than pixel-wise losses like MSE.

Why this objective is hard to optimize directly: The function $\mathbf{x}_{\text{p}} = \text{ConsistencySolver}_{\boldsymbol{\theta}}(\mathbf{z}, \boldsymbol{c})$ involves $K$ sequential calls to the diffusion model interleaved with coefficient-weighted ODE updates. Computing the gradient $\nabla_{\boldsymbol{\theta}} \text{Sim}(\mathbf{x}_{\text{gt}}, \mathbf{x}_{\text{p}})$ would require backpropagating through the entire $K$-step chain—through the ODE updates, through the diffusion model's forward passes, and through the (potentially non-differentiable) similarity metric. This is computationally prohibitive (the diffusion model alone has billions of parameters, and activations would need to be stored for all $K$ steps) and can be numerically unstable. This is precisely the motivation for using RL.

---

RL Training: Casting Solver Design as Sequential Decision-Making

The paper formulates the training of $\boldsymbol{f}_{\boldsymbol{\theta}}$ as a reinforcement learning problem and optimizes it using Proximal Policy Optimization (PPO). This is the most technically novel aspect of the method—treating ODE solver coefficient selection as a policy rather than an optimization variable to be tuned by gradient descent.

Why this is a sequential decision problem: At each of the $K$ steps in the preview generation process, the policy network observes the state (the current timestep $t_i$ and target timestep $t_{i+1}$), takes an action (outputs a set of coefficients $w_1, \ldots, w_m$), and transitions the sample to the next state. The reward is only received at the end (when the final preview is compared to the reference), making this a sparse-reward episodic RL problem. The policy must learn to make good coefficient choices at each step such that the cumulative effect—the final preview—is similar to the reference.

Step 1: Offline dataset preparation. Before training, the authors generate a fixed dataset of $M = 2000$ triples:

$\{(\boldsymbol{c}^{(k)}, \mathbf{z}^{(k)}, \mathbf{x}_{\text{gt}}^{(k)})\}_{k=1}^{M}$

For each entry, $\boldsymbol{c}^{(k)}$ is sampled from the LAION training prompt distribution, $\mathbf{z}^{(k)} \sim \mathcal{N}(0, \mathbf{I})$, and $\mathbf{x}_{\text{gt}}^{(k)}$ is generated by running the 40-step multistep DPM-Solver from $\mathbf{z}^{(k)}$ with prompt $\boldsymbol{c}^{(k)}$. This dataset is computed once and reused across all training episodes. The key practical benefit is that the expensive full-step generation is amortized across training—during each episode, the reference image is already available, so the training loop only needs to run the cheap few-step ConsistencySolver.

Step 2: Training episode rollout. At each PPO episode, the authors sample a batch of $B$ triples from the offline dataset. For each selected triple $(\boldsymbol{c}, \mathbf{z}, \mathbf{x}_{\text{gt}})$, they unroll a $K$-step preview trajectory.

The paper specifies (Appendix D.1): "For each training iteration, we select one prompt-noise pair and replicate it 80 times. We then apply the trainable ConsistencySolver to generate 80 different sampling trajectories with random perturbations." This means $B = 80$ trajectories are generated from the same prompt–noise pair in each iteration, with stochasticity coming from the policy's action sampling (the coefficients are sampled from a distribution parameterized by the MLP outputs) rather than from different prompts or noise samples. This design choice ensures that the policy sees the same base conditions with different coefficient choices, making it easier to learn which choices lead to higher rewards—a form of variance reduction.

At each transition $(t_i \to t_{i+1})$ within a predefined $K$-step schedule $\{t_0 > t_1 > \cdots > t_K\}$, the policy network processes $(t_i, t_{i+1})$ and outputs coefficient distributions for each $w_j$. The actual coefficients used in the update are then sampled from these distributions, introducing the stochasticity needed for exploration in RL.

Step 3: Reward computation. Upon completing the $K$-step rollout, the resulting preview $\mathbf{x}_{\text{p}}$ is compared against the precomputed reference $\mathbf{x}_{\text{gt}}$ using the perceptual similarity function. The paper's default reward uses depth map similarity—depth maps are extracted from both images using an off-the-shelf depth estimator, and the similarity between these depth maps (likely a cosine similarity or L2 distance in feature space) is computed. Table 7 compares alternative reward functions: Depth reward (default), CLIP similarity, DINO feature similarity, and pixel-level similarity (Img. reward). Depth is chosen as default because it "provides strong structural fidelity, consistently achieving good performance across all steps" and "offers a more balanced trade-off between structural consistency and overall robustness."

Step 4: Policy update via PPO. The policy is optimized using the standard PPO clipped surrogate objective (Equation 8):

$\mathcal{J}_{\text{PPO}} = \mathbb{E}\left[ \min\left( r(\theta) \hat{A}, \operatorname{clip}(r(\theta), 1-\epsilon, 1+\epsilon) \hat{A} \right) \right]$

where $\theta$ denotes the current policy parameters, $r(\theta) = \pi_\theta(a|s) / \pi_{\theta_{\text{old}}}(a|s)$ is the probability ratio between the current policy and the old policy (before the update) for the action $a$ (the sampled coefficients) given state $s$ (the timestep pair), $\hat{A}$ is the estimated advantage (how much better this action was than the average), and $\epsilon \in (0, 1)$ is the clipping parameter that restricts $r(\theta)$ to $[1-\epsilon, 1+\epsilon]$.

What the PPO objective does in plain language: It encourages the policy to increase the probability of coefficient choices that led to higher-than-average rewards (positive advantage $\hat{A} > 0$), and decrease the probability of choices that led to lower-than-average rewards (negative advantage $\hat{A} < 0$). The clipping prevents the policy from changing too much in a single update—if the probability ratio $r(\theta)$ exceeds $1+\epsilon$ or falls below $1-\epsilon$, the gradient is clipped to zero for that sample, preventing destructive large updates. This is the key innovation of PPO over earlier policy gradient methods: it achieves stable training by limiting the per-update policy change.

Step 5: Advantage computation with batch self-normalization (Equation 9):

$\hat{A} = \frac{\mathcal{R} - \mathbb{E}[\mathcal{R}]}{\sigma[\mathcal{R}] + \delta}$

where $\mathcal{R}$ is the scalar reward for a specific trajectory, $\mathbb{E}[\mathcal{R}]$ is the mean reward across all trajectories in the current minibatch, $\sigma[\mathcal{R}]$ is the standard deviation of rewards in the current minibatch, and $\delta > 0$ is a small constant preventing division by zero.

What the advantage represents: The advantage $\hat{A}$ measures how much better a particular trajectory's reward is compared to the average for that prompt–noise pair, normalized to unit variance. A positive $\hat{A}$ means the trajectory produced a better-than-average preview (the coefficient choices were good); a negative $\hat{A}$ means it produced a worse-than-average preview (the coefficient choices were poor). This self-normalization is a common trick in RL for generative models (cited as following "common RL practice in generative modeling" with references to Li et al. 2023, Shao et al. 2024, Ahmadian et al. 2024, Black et al. 2023, and Fan et al. 2024).

Why self-normalization? The absolute scale of the reward $\mathcal{R}$ can vary depending on the prompt difficulty, the specific noise sample, and the reward function. By normalizing within each batch, the advantage becomes a relative signal that is comparable across different prompts and noise samples. The policy learns: "given this prompt and this noise, was this particular choice of coefficients better or worse than the average choice?" rather than "was the absolute similarity high or low?" This disentangles the quality of the coefficient choices from the inherent difficulty of generating a good image for that prompt.

Training hyperparameters (Appendix D.1): All experiments run on a single H100 GPU. The MLP policy network is trained from scratch using a learning rate of $1 \times 10^{-4}$ for 3,000 iterations. Each iteration processes 80 trajectories from a single prompt–noise pair. Total training time is approximately 12 H100 GPU hours. The paper notes that this is substantially cheaper than distillation approaches, which would require backpropagating through the full diffusion model.

What makes the RL formulation work for this problem: The key insight is that the reward signal—perceptual similarity between preview and reference—is a global property of the final output. It's not obvious how to assign credit to individual coefficient choices at each step. PPO handles this credit assignment implicitly: by sampling many trajectories with different coefficient choices and comparing their final rewards, the policy learns which choices at which timesteps tend to lead to better final outcomes. The stochasticity in coefficient sampling provides the exploration needed to discover good strategies, and the PPO clipping ensures stable convergence.

---

RL versus Distillation: Three Claimed Advantages

The paper explicitly motivates the choice of RL over gradient-based distillation in Section 4.3, and supports these claims with empirical evidence in Table 2 (comparing ConsistencySolver-RL against Ours-Distill, which uses trajectory-based distillation of the same solver architecture).

Advantage 1: Compatibility with non-differentiable rewards. The depth map similarity, DINO feature similarity, and segmentation-based metrics used as rewards are not naturally differentiable (or at least, computing gradients through them would require specialized differentiable implementations). RL accepts a scalar reward signal from any black-box function. This is a genuine practical advantage: it means the reward function can be chosen based on what best captures perceptual similarity for the downstream task, without being constrained by differentiability. The paper states this eliminates "a primary cause of instability and overhead in distillation."

Advantage 2: Superior generalization and quality. The paper claims the RL-trained solver "better generalizes to novel prompt-noise pairs, yielding higher fidelity and elevated average consistency scores." Table 2 provides the empirical evidence: at 8 steps, ConsistencySolver (RL) achieves FID 19.02 versus Ours-Distill at 20.01, and higher CLIP (97.4 vs. 95.9), DINO (94.7 vs. 93.6), and Depth (36.49 vs. 39.30, lower is better) scores. At 12 steps, the RL version achieves FID 18.53 versus 21.37 for Ours-Distill. The paper attributes this to trajectory distillation imposing "strong constraints on intermediate states that may be unnecessary—what matters is that the final preview resembles the final output, not that each intermediate step precisely matches a reference trajectory."

Advantage 3: Reduced training overhead. The key computational difference: RL only requires the scalar reward at the final step, eliminating the need to store intermediate activations of the diffusion model for backpropagation. In trajectory distillation, computing the gradient of the loss with respect to $\boldsymbol{\theta}$ requires backpropagating through the entire $K$-step sampling chain, including through the diffusion model's forward passes at each step. This means storing activations for the full diffusion model (billions of parameters) across all $K$ steps. RL avoids this entirely—gradients only flow through the lightweight MLP policy network. The paper states this "substantially lower[s] memory usage and facilitat[es] efficient training." The empirical result is that training completes in 12 H100 GPU-hours, which is feasible on a single GPU.

The trajectory distillation baseline (Ours-Distill, Appendix D.2): For completeness, the paper implements a distillation baseline that uses the same ConsistencySolver architecture but trains it via supervised learning. The approach: (1) store the complete 40-step trajectory from the multistep DPM-Solver for each training sample (requiring additional storage); (2) during training, match each intermediate state in the few-step ConsistencySolver trajectory to the corresponding state in the 40-step reference trajectory (e.g., when doing 8-step sampling, each ConsistencySolver step should align with 5 steps of the reference solver); (3) use negative similarity between these states as the loss, backpropagated through the diffusion model.

The paper also explored but abandoned a simpler "final-state distillation" approach that backpropagates through the entire sampling chain using only the final negative similarity as loss, reporting that it "exhibits significant drawbacks" including "severe training instability" and failure of the MLP to converge. This is consistent with known challenges in differentiating through long compute graphs—the gradient signal becomes noisy and unstable as it passes through many nonlinear operations.

How the empirical comparison supports RL: Table 2 shows that the RL-trained solver consistently outperforms the trajectory-distilled version across nearly all metrics and step counts. The exception is at very low step counts (3–4 steps), where Ours-Distill achieves slightly better FID (29.29 vs. 31.27 at 3 steps), though the RL version still leads in most consistency metrics. The paper's interpretation is that RL's advantage grows as the step count increases and the trajectory becomes more complex—direct optimization for the final objective is more robust than matching intermediate states.

Design Decision Summary

The paper makes several non-obvious design choices that are worth highlighting:

• Learning coefficients rather than learning a correction to the ODE update itself: Instead of learning an additive correction term $\Delta(\mathbf{x}_t, t)$ that is added to the standard solver update (which would be akin to learning a modified score function), ConsistencySolver learns how to combine existing denoising predictions. This preserves the structural property that the solver is still integrating the exact PF-ODE—it's just using a better numerical integration scheme. The preview is guaranteed to lie on (or very near) the same ODE trajectory as the reference, which is the consistency property essential for Diffusion Preview.

• Conditioning the policy only on timesteps, not on image content: The policy network $\boldsymbol{f}_{\boldsymbol{\theta}}(t_i, t_{i+1})$ sees only the start and end times of the current step. It does not condition on the current sample $\mathbf{x}_{t_i}$, the prompt embedding, or any features of the image. This forces the learned strategy to be a general integration strategy that works across all content, rather than a content-dependent correction. The paper argues this contributes to generalization—the policy learns about the denoising dynamics, not about specific visual features. However, this also means the solver cannot adapt its strategy based on how "difficult" a particular prompt is or how the denoising is progressing for a specific sample, which could be a limitation.

• Using PPO with batch self-normalization rather than REINFORCE or simpler policy gradient methods: PPO's clipping mechanism is specifically designed to prevent the policy from changing too much in a single update, which is important when the reward signal is noisy (as it is here, since reward depends on the entire sampling trajectory). The batch self-normalization of advantages (Equation 9) further stabilizes training by making the advantage signal relative within each batch, compensating for the fact that different prompt–noise pairs have different inherent difficulty levels.

• Precomputing reference images in an offline dataset: This is a pragmatic engineering choice that makes RL training feasible. Without it, each training episode would need to run both the few-step ConsistencySolver (cheap) and the 40-step reference solver (expensive), roughly quintupling the training time. The tradeoff is that the offline dataset is static—it doesn't adapt as the policy improves, which could limit exploration in principle (though in practice, the policy is optimizing similarity to the same references regardless of its current performance, so staleness isn't an issue).

• Choosing order 4 as default: The ablation (Table 6) shows Order 4 is the sweet spot. Order 2 and 3 are underparameterized—they can't capture enough of the denoising dynamics. Order 5 adds degrees of freedom without commensurate improvement, likely because the additional coefficients are harder for RL to optimize (the search space grows, and the credit assignment problem becomes more difficult when more past steps influence each update).

4. Key Insights and Innovations

Innovation 1: Reframing ODE Solver Design as a Reinforcement Learning Problem

The paper's most conceptually distinctive move is not the solver architecture itself—linear multistep methods are classical numerical analysis, and trainable coefficients have precedent in learned ODE solvers—but rather the framing of coefficient selection as a sequential decision-making problem to be optimized via RL with a perceptual similarity reward. This is a fundamental category shift from how the field has approached diffusion acceleration.

What the field did before: All prior work on diffusion ODE solvers, whether training-free or learned, treated the solver design as an optimization problem within a differentiable framework. Training-free solvers (DDIM, DPM-Solver, PNDM, UniPC) derive coefficients analytically from Taylor expansions or polynomial interpolation of the score function. Learned solvers (AMED, D-ODE, GENIE) use trajectory distillation—supervising intermediate states with multi-step reference trajectories—which requires backpropagating gradients through the full diffusion sampling chain. In both paradigms, the "goodness" of a solver is encoded in a differentiable loss function (typically MSE between predicted and reference states), and solver parameters are optimized by gradient descent.

This creates three interlocking constraints: (1) the training objective must be differentiable, which rules out many perceptual metrics that best capture what users care about; (2) gradients must flow through the entire sampling chain, which is memory-intensive and limits scalability; (3) the objective is typically defined at intermediate states (trajectory matching) rather than at the final output, which may impose unnecessary constraints—matching intermediate states is a proxy for matching the final image, and the proxy may be imperfect.

What ConsistencySolver changes: By casting solver coefficient selection as a policy, the paper breaks all three constraints simultaneously. The reward function can be any black-box perceptual similarity metric—depth maps, DINO features, segmentation masks, CLIP embeddings, or combinations thereof—without requiring differentiability. Gradients flow only through the lightweight MLP policy network, not through the billion-parameter diffusion model, because the reward is a scalar signal at the end of the episode rather than a loss computed at each intermediate step. And the optimization target is directly the final preview-reference similarity, not a proxy based on intermediate state matching.

This reframing is non-obvious because solver design doesn't naturally look like an RL problem. An ODE solver is a deterministic procedural component—it takes a state and produces a next state according to fixed rules. The paper's insight is that when the rules themselves become learnable, the process of selecting those rules across a sequence of timesteps has the structure of a decision process: at each transition, the solver (acting as the agent) observes the current timestep range (its state), outputs coefficients (its action), and transitions the sample to the next timestep. The reward arrives only at the end, making it a sparse-reward episodic problem that RL is designed to handle.

Why this is fundamental, not incremental: This is not a small tweak to an existing training pipeline—it changes the entire relationship between the solver and the training signal. In distillation, the solver is a student mimicking a teacher's intermediate states; error compounds at each step. In RL, the solver is an agent exploring a space of coefficient strategies and receiving feedback only on the final outcome; it can discover strategies that make suboptimal local choices (intermediate states that don't perfectly match the reference trajectory) if they lead to a better final preview. The paper provides empirical evidence for this distinction: the trajectory-distilled Ours-Distill baseline, which uses the same ConsistencySolver architecture but trains via intermediate-state supervision, consistently underperforms the RL-trained version (Table 2, FID 19.02 vs. 20.01 at 8 steps, 18.53 vs. 21.37 at 12 steps). The gap widens with step count, suggesting that the RL formulation's advantage—optimizing for the true final objective rather than a trajectory-matching proxy—becomes more important as the sampling chain lengthens.

The paper also notes a negative result that reinforces this point: their attempted "final-state distillation"—which backpropagates through the full sampling chain using only the final similarity as loss—exhibited "severe training instability" and failed to converge (Appendix D.2). This means that even when the objective is the final output, gradient-based optimization through the long sampling chain is unreliable. RL sidesteps this by converting the non-differentiable, long-horizon optimization into a credit assignment problem handled by PPO's policy gradient machinery, which has proven stable in similar settings (language model fine-tuning, game playing).

Significance beyond performance: The RL framing opens a new axis for diffusion acceleration research that sits between training-free solvers and full model distillation. It suggests that future work could explore more sophisticated RL algorithms (actor-critic methods that learn a value function for intermediate states, reward shaping that provides earlier feedback), multi-objective reward functions that balance different perceptual qualities, or online RL that adapts the solver as the base model is fine-tuned. More broadly, it demonstrates that the choice of optimization paradigm (gradient-based vs. reward-based) is itself a consequential design decision, not just an implementation detail—a lesson that may transfer to other generative modeling problems where the true objective is non-differentiable or the generation process is a long sequential chain.

---

Innovation 2: Identifying Consistency as the Missing Requirement in Diffusion Acceleration

Prior work on diffusion acceleration has largely been evaluated along two axes: fidelity (how good do the generated images look, measured by FID, IS, or CLIP score) and efficiency (how many NFEs are required, measured by step count or wall-clock time). The paper introduces a third axis—consistency—and argues that it is equally important, particularly for interactive workflows, yet systematically violated by existing acceleration approaches.

What the field did before: The dominant evaluation framework for diffusion acceleration treats the problem as "generate the best possible image in the fewest steps." FID is the canonical metric—it measures how well the distribution of generated images matches the distribution of real images, capturing both quality and diversity. Under this framework, distillation methods like LCM, PCM, and DMD2 are highly successful: they achieve competitive or superior FID scores at drastically reduced step counts compared to the base model. The implication is that the acceleration problem is essentially solved—if a 1-step distilled model achieves FID comparable to a 40-step base model, what more is there to optimize?

The paper argues that this framework is incomplete because it evaluates the accelerated model as a standalone generator rather than as a component in a human-in-the-loop workflow. In the Diffusion Preview paradigm, the accelerated output is not the final product—it is a decision-making aid that the user evaluates to decide whether to commit to full-step refinement. For this to work, the preview must satisfy three properties simultaneously: it must look good enough to evaluate (fidelity), be computationally cheap (efficiency), and faithfully represent what the final output will look like (consistency). The first two are captured by standard metrics; the third is not.

What "consistency" means concretely: Consistency is the property that given the same initial noise $\mathbf{z}$ and prompt $\boldsymbol{c}$, the few-step preview $\mathbf{x}_{\text{p}}$ and the full-step reference $\mathbf{x}_{\text{gt}}$ are perceptually similar. This is not the same as image quality—a preview can be high-quality (sharp, detailed, aesthetically pleasing) but inconsistent (different object layout, different colors, different composition than the reference). The paper measures consistency through six metrics (Table 1): CLIP similarity, DINO similarity, Inception Score correlation, Depth map similarity, Segmentation consistency, and pixel-level SSIM—all computed between $\mathbf{x}_{\text{p}}$ and $\mathbf{x}_{\text{gt}}$ rather than between generated and real images.

Why existing methods fail at consistency:

• Training-free solvers: These preserve the PF-ODE trajectory (they follow the same ODE, just with coarser discretization), so their consistency is theoretically perfect at the limit of infinitesimal step sizes. However, at very low step counts (3–8 steps), discretization error becomes structurally meaningful—the solver's approximations cause the trajectory to deviate from the true ODE path in ways that change object placement, semantic content, or composition. The quantitative evidence is in Table 2: multistep DPM-Solver at 5 steps achieves only 83.6 DINO consistency and 58.84 Depth consistency (lower is better), despite producing reasonable-looking images (FID 25.87). The preview and reference are not the same image; they differ in structurally important ways.

• Distillation-based methods: These break consistency fundamentally. ODE distillation methods (LCM, PCM) train the model to jump directly from a noisy state to a clean image, which alters the trajectory itself—the distilled model follows a different path through image space than the original PF-ODE. Score distillation methods (DMD2) use a GAN-like objective that optimizes for distributional matching, which explicitly changes the mapping from noise to images. The consequence is that even with the same noise and prompt, a distilled model's output can differ substantially from the base model's full-step output. The paper quantifies this in Table 2: LCM at 4 steps achieves DINO consistency of 87.0 (vs. 91.4 for ConsistencySolver at 4 steps) and Depth consistency of 54.39 (vs. 43.92 for ConsistencySolver). DMD2's consistency numbers are not reported in Table 2, but the user study in Table 5 provides the most damning evidence.

The user study as a diagnostic tool (Tables 4–5): The paper's user study is not just an application demonstration—it is a diagnostic experiment that reveals a hidden failure mode of distillation. Table 5 shows that DMD2, despite achieving competitive FID scores (reported elsewhere as state-of-the-art for few-step generation), satisfies only 57.0% (with GAN) or 47.1% (without GAN) as many GenEval prompts as the base 40-step model within 10 attempts. In contrast, ConsistencySolver's 8-step preview satisfies 94.2% as many prompts. The paper's interpretation is direct and significant:

"This disparity reveals a critical insight: despite the competitive FID scores achieved by distillation-based methods, the loss of consistency fundamentally undermines generation quality in ways not captured by distribution-level metrics."

What's happening is that FID measures distribution-level similarity—it asks "do images from this model look like they could have come from the real image distribution?" But consistency asks a different question: "for this specific noise and prompt, does the accelerated output match what the full model would produce?" A distilled model can produce images that look realistic and diverse (good FID) but that correspond to different noise-to-image mappings than the base model, so a user who iterates on seeds expecting consistent behavior will be frustrated. The 57% satisfaction rate on GenEval means that for 43% of prompts, the distilled model fails to produce an acceptable image even with 10 attempts—not because the images are low-quality, but because the mapping from seed to output is no longer reliable.

Why this is a fundamental insight, not just a new metric: The paper is not merely proposing that we should measure consistency alongside FID. It is arguing that FID and consistency can be in tension, and that optimizing for FID alone (as distillation methods do) can actively harm consistency in ways that matter for real users. This reframes the acceleration problem: the goal is not just to generate good images quickly, but to generate images that are predictable proxies for what the full model would produce. This has implications for how acceleration methods should be designed (preserve the ODE trajectory rather than learning a shortcut) and how they should be evaluated (user studies or consistency metrics, not just FID).

The insight also explains a practical phenomenon that practitioners may have observed: distilled models sometimes produce "uncanny" outputs for specific prompts that the base model handles well, even though their aggregate metrics look good. The paper provides a vocabulary and a measurement framework for diagnosing this issue, and shows that a method designed explicitly for consistency (ConsistencySolver) avoids it while maintaining competitive fidelity and efficiency.

---

Innovation 3: The Minimal Intervention Principle—Learning the Solver, Not the Model

The paper makes a deliberate architectural choice that distinguishes it from both training-free solvers and distillation methods: modify only the integration coefficients of the ODE solver, keeping the pretrained diffusion model completely frozen. This is a specific instance of what might be called the "minimal intervention principle" in generative model acceleration—the idea that one should change only what is necessary to achieve the speed-quality target, preserving as much of the original model's behavior as possible.

What the field did before: The dominant approaches sit at two extremes. Training-free solvers modify nothing—they use the exact pretrained model with cleverer integration schedules, which preserves all model properties but limits how much acceleration is possible before fidelity degrades. Distillation methods modify everything—they retrain or replace the model weights entirely, which enables extreme acceleration (1–4 steps) but sacrifices the base model's properties: its deterministic noise-to-image mapping, its flexible step selection, its score estimation capability, and often its per-prompt reliability.

ConsistencySolver occupies a deliberate middle ground: modify the solver (a lightweight MLP with negligible parameters relative to the base model) but preserve the model and the ODE trajectory. This is not just an engineering compromise—it is a claim about what level of intervention is appropriate for the preview-and-refine use case.

Why this level of intervention is the right one:

1. The solver is the right abstraction for consistency. The PF-ODE defines a unique deterministic trajectory from noise to image. Any solver that accurately integrates this ODE will produce outputs consistent with the full-step reference, up to discretization error. By keeping the ODE itself unchanged (the right-hand side $\boldsymbol{\epsilon}(\mathbf{x}_t, t)$ is computed by the frozen base model), ConsistencySolver is guaranteed to stay on the same trajectory—it's just taking bigger, smarter steps along it. Distillation methods, by modifying the model, change the ODE itself, which fundamentally breaks consistency.

2. The solver is also the right abstraction for learning. The space of possible coefficient choices for a linear multistep solver is vast but low-dimensional—an order-4 solver at 8 steps has only 32 learnable parameters (4 coefficients at each transition, though the policy network has more parameters to generate them). This is small enough to learn efficiently with RL (12 GPU-hours on a single H100) but expressive enough to capture the non-ideal behavior of the real score function that fixed solvers miss. If the paper had instead tried to learn a correction to the model's predictions (a residual added to $\boldsymbol{\epsilon}$), the parameter space would be enormous (matching the model's output dimension) and training would be as expensive as fine-tuning.

3. The solver preserves model reuse and flexibility. Because the base model is frozen, any improvements to the base model (better architecture, more training data, fine-tuning on new domains) can be immediately used with the same trained solver, since the solver learns a strategy for combining denoising predictions that depends only on timesteps, not on the specific model weights. Distilled models would need to be retrained for each base model update. Additionally, the solver can be used at any step count—the same trained policy can generate previews at 3, 5, 8, or 12 steps by selecting appropriate timestep schedules, while distilled models are typically step-count-specific.

Empirical evidence for the minimal intervention claim: The paper demonstrates that this level of intervention is sufficient to achieve the design goals. At 8 steps, ConsistencySolver achieves FID 19.02—competitive with methods that require much more aggressive intervention (LCM at 4 steps achieves FID 20.68, but sacrifices consistency; DMD2 achieves lower FID but fails the user study). More importantly, it achieves this while maintaining consistency scores substantially higher than distillation methods (Table 2: DINO 94.7 vs. 87.0 for LCM, Depth 36.49 vs. 54.39 for LCM at comparable step counts).

Why this is a conceptual contribution, not just an architecture choice: The paper is implicitly making an argument about where the "intelligence" in diffusion sampling should reside. In the standard view, the diffusion model contains all the intelligence—it has learned the data distribution, the semantic correspondences, the visual concepts. The solver is a "dumb" procedural component that just approximates an integral. ConsistencySolver challenges this separation: it argues that the solver itself can be intelligent—it can learn to adapt its integration strategy to the specific dynamics of the model it's paired with—and that this intelligence can be acquired with minimal intervention (a lightweight MLP, modest training data, RL rather than full backpropagation). This is a novel perspective on the division of labor in generative models: the model handles what to generate; the solver handles how to navigate the generation process efficiently.

This insight may generalize beyond diffusion models. Any generative model that uses iterative sampling (autoregressive models with chain-of-thought, energy-based models with Langevin dynamics, flow matching models) has a "solver" component that determines the sampling trajectory. The paper suggests that making these solvers learnable—while keeping the generative model frozen—could be a broadly applicable strategy for trading off speed against quality without sacrificing the model's learned capabilities.

---

Innovation 4: Diagnosing and Avoiding Verifier Over-Optimization in Learned Solvers (An Implicit but Important Finding)

While not explicitly framed as a core contribution, the paper's experimental analysis contains an important diagnostic finding about the relationship between training methodology and solver behavior that has implications beyond this specific method. Specifically, the comparison between RL-trained and trajectory-distilled solvers reveals a phenomenon analogous to reward hacking or over-optimization in learned systems, where optimizing for a proxy objective (intermediate state matching) can produce worse results on the true objective (final preview quality) than optimizing for the true objective directly, even when the proxy seems well-aligned.

The phenomenon: The trajectory distillation baseline (Ours-Distill) and the RL-trained ConsistencySolver share the identical solver architecture—the same order-4 linear multistep form, the same MLP policy network, the same timestep-conditioned coefficient generation. The only difference is the training signal: Ours-Distill is trained to match intermediate states along the 40-step reference trajectory at each of the K preview steps, while ConsistencySolver is trained to maximize only the final preview-reference similarity. If matching intermediate states were a perfect proxy for matching the final output, the two methods should perform similarly. They do not.

Table 2 shows that Ours-Distill underperforms ConsistencySolver across nearly all metrics and step counts: at 8 steps, FID 20.01 vs. 19.02, CLIP 95.9 vs. 97.4, DINO 93.6 vs. 94.7, Depth 39.30 vs. 36.49. At 12 steps, the gap widens: FID 21.37 vs. 18.53. The trajectory-distilled solver is optimizing the "right" thing—minimizing deviation from the reference trajectory—but achieving worse final outcomes.

Why this happens: The paper's interpretation (Section 4.3) is that trajectory distillation imposes "strong constraints on intermediate states that may be unnecessary." Concretely, to exactly match the 40-step reference trajectory at intermediate points, the 8-step solver may need to make coefficient choices that are locally optimal (they minimize per-step deviation) but globally suboptimal (they lead to compounding errors that push the final preview away from the reference). The RL-trained solver, by contrast, has the freedom to deviate from the reference trajectory at intermediate steps if doing so results in a final preview that is perceptually closer to the reference. It can "take a wider path" through the ODE trajectory space as long as it converges to the right endpoint.

This is a specific instance of a general principle: optimizing for a proxy that is correlated with but not identical to the true objective can produce worse results than optimizing for the true objective directly, because the optimization process will exploit any discrepancies between the proxy and the true objective. Here, the proxy is "intermediate states match the reference trajectory" and the true objective is "final preview perceptually matches the reference." The discrepancy arises because small per-step deviations that compound differently across the trajectory can produce final outputs that are perceptually similar (satisfying the true objective) even if intermediate states don't exactly match (violating the proxy).

Connection to broader ML phenomena: This is structurally similar to the reward hacking problem in RLHF, where a language model optimized for a learned reward model learns to produce outputs that score highly on the reward model but are not actually better by human judgment. The proxy (reward model score) is imperfectly correlated with the true objective (human preference), and optimization amplifies the imperfections. In the solver context, the proxy (intermediate trajectory matching) is imperfectly correlated with the true objective (final preview quality), and gradient-based optimization amplifies the imperfections—the solver finds coefficient configurations that minimize per-step deviation at the cost of final output quality.

Why this is significant beyond this paper: This finding suggests that trajectory distillation, a widely-used paradigm for training accelerated diffusion samplers (AMED, D-ODE, GENIE, and many consistency models), may be fundamentally limited by the proxy-objective problem. The standard approach of matching intermediate states along a teacher trajectory assumes that good intermediate matches produce good final matches, but the ConsistencySolver results suggest this assumption can fail in practice. The RL approach offers a way to bypass the proxy entirely by optimizing for the true final objective, at the cost of requiring a non-differentiable reward and an RL training loop.

The paper also provides a negative result that reinforces this point: the "final-state distillation" approach—backpropagating through the full chain using only the final loss—was attempted and failed due to training instability (Appendix D.2). This means that simply changing the distillation loss from intermediate states to final output is not sufficient; the RL formulation (which handles credit assignment through policy gradients rather than backpropagation-through-time) is necessary to make final-state optimization work. This is a non-trivial finding about the interaction between optimization algorithm and objective function in long sequential generation processes.

5. Experimental Analysis

Evaluation Methodology

• Dataset. For text-to-image generation, the primary evaluation uses 2,000 prompts sampled from the COCO 2017 validation set (lin2014microsoft). The training dataset for ConsistencySolver's RL optimization is 2,000 prompts randomly sampled from LAION (laion), with corresponding reference images generated via 40-step multistep DPM-Solver. For instructional image editing, evaluation uses KontextBench (labs2025flux) with its reference images and editing instructions. The user study evaluates on three prompt sets: GenEval (553 prompts), COCO 2017 validation (5,000 prompts), and LAION (5,000 randomly sampled prompts).

• Base model(s). Two pretrained diffusion models are used: Stable Diffusion (rombach2022high) for text-to-image generation and FLUX.1-Kontext (labs2025flux) for instructional image editing. These represent widely-used models in distinct generative tasks (unconditional text-to-image synthesis vs. conditioned image editing), testing whether the approach generalizes across architectures and use cases. The base models are used completely frozen—no weights are modified during ConsistencySolver training.

• Metrics. The paper evaluates along three axes corresponding to the three Diffusion Preview requirements (Section 5.1). For fidelity: Fréchet Inception Distance (FID) (heusel2017gans) for text-to-image, and Edit Reward and Edit Score for instructional image editing. For efficiency: inference time per image. For consistency, six metrics are computed between the few-step preview $\mathbf{x}_{\text{p}}$ and the 40-step reference $\mathbf{x}_{\text{gt}}$ (Table 1): CLIP similarity (cosine similarity between CLIP embeddings), DINO similarity, Inception Score correlation, Depth map similarity (distance between off-the-shelf depth estimator outputs), Segmentation consistency, and pixel-level similarity. Lower values are better for Depth and pixel-level metrics; higher is better for CLIP, DINO, and Inception.

• Baselines. The paper compares against three categories of methods (Section 5.2, Table 2). Training-free ODE solvers: DDIM (song2021ddim), iPNDM (a multistep variant), and multistep DPM-Solver (lu2022dpm; lu2022dpmpp). Distillation-based methods: DMD2 (dmdv2), Rectified Diffusion (which trains a student to match the teacher's ODE trajectory), LCM (Latent Consistency Models, luo2023latentconsistencymodelssynthesizing), and PCM (a variant of consistency models). Trajectory distillation using the same ConsistencySolver architecture: AMED (zhou2024fastodebasedsamplingdiffusion) and Ours-Distill (the authors' own implementation training the MLP policy network via intermediate-state matching rather than RL, described in Appendix D.2). For FLUX.1-Kontext editing (Table 3), baselines are the base FLUX.1-Kontext model with its default solver at matching step counts.

• Generation budget / compute accounting. The budget is measured in number of sampling steps ($K$), also referred to as NFEs (Neural Function Evaluations). Each step requires one forward pass through the frozen diffusion model. For fairness, all methods are compared at the same step count—a 5-step ConsistencySolver is compared against 5-step DDIM, 5-step DPM-Solver, etc. The policy network's overhead is negligible relative to the diffusion model forward pass (the MLP has only hundreds of parameters vs. billions for the base model). Reference images are generated using a canonical 40-step multistep DPM-Solver, which serves as the "full-step" baseline throughout.

• Cross-validation / statistical protocol. Training and evaluation use disjoint prompt sets: ConsistencySolver is trained on 2,000 LAION prompts, then evaluated on COCO 2017 validation prompts for text-to-image and on KontextBench for image editing. This tests generalization to unseen prompts. The offline training dataset of noise–prompt–reference triples is precomputed once and fixed across all experiments, enabling reproducible reward computation. The user study uses both automated LLM evaluation (Claude Sonnet 4 with a strict evaluation prompt requiring the judge to "be extremely critical—only approve if it perfectly matches the description") and human evaluation with 20 volunteers each evaluating 100 prompts, providing complementary assessments of practical effectiveness.

---

Main Quantitative Results

Text-to-Image Generation with Stable Diffusion (Table 2)

The headline result for fidelity is that ConsistencySolver achieves an FID of 20.39 at 5 steps, compared to 25.87 for multistep DPM-Solver at the same step count—a substantial improvement in image quality with identical computational budget. This represents matching the reference solver's quality while using roughly 47% fewer steps, since multistep DPM-Solver requires approximately 9–10 steps to achieve similar FID (the 10-step multistep DPM-Solver result is not directly in Table 2, but the trend is clear from the progression).

Examining the full step-count sweep in Table 2 (3, 4, 5, 8, 10, 12 steps):

• At 3 steps, ConsistencySolver achieves FID 31.27, which is worse than the distillation baselines Ours-Distill (29.29) and AMED (29.29). This is the one regime where the RL-trained solver does not lead—the paper does not explicitly discuss why, but it likely reflects that at extremely low step counts, the signal-to-noise ratio in the RL training becomes unfavorable because the preview-reference similarity is inherently low, making it harder to distinguish good from bad coefficient choices.

• At 4 steps, ConsistencySolver achieves FID 27.19, surpassing multistep DPM-Solver (33.96), DDIM (35.80), and iPNDM (29.35). Among distillation methods, it trails DMD2 (which achieves lower FID at 4 steps but has consistency issues as shown in the user study) but outperforms LCM (30.84) and PCM (31.29).

• At 5 steps, FID drops to 20.39—a large jump from 4 steps—outperforming all training-free solvers by wide margins (multistep DPM-Solver: 25.87, DDIM: 30.49, iPNDM: 24.82). This is one of the paper's headline numbers, demonstrating that the learned integration strategy provides meaningful improvement over fixed solvers at budgets where theoretical approximations break down.

• At 8 steps, FID reaches 19.02. Ours-Distill achieves 20.01, and AMED achieves 19.89—the RL-trained solver maintains a consistent advantage over trajectory-distilled variants of the same architecture. Multistep DPM-Solver achieves 21.67 at 8 steps, showing that ConsistencySolver continues to outperform fixed solvers even as the budget increases.

• At 10 and 12 steps, FID reaches 18.51 and 18.53 respectively, suggesting a performance floor around 18.5. The diminishing returns from 8 to 12 steps indicate that the preview is approaching the quality ceiling achievable without modifying the base model. At 12 steps, the gap over Ours-Distill widens to nearly 3 FID points (18.53 vs. 21.37), which the paper interprets as evidence that RL's advantage over distillation grows with trajectory length.

For consistency metrics, the pattern is even more pronounced. At 8 steps, ConsistencySolver achieves CLIP similarity of 97.4 (vs. 93.0 for multistep DPM-Solver, 91.9 for DMD2, 87.8 for LCM), DINO similarity of 94.7 (vs. 89.3 for DPM-Solver, 87.0 for LCM), and Depth consistency of 36.49 where lower is better (vs. 49.78 for DPM-Solver, 54.39 for LCM). These numbers quantify the paper's central claim: training-free solvers produce previews that deviate from the reference in structurally meaningful ways at low step counts, while ConsistencySolver's learned coefficients keep the preview trajectory closer to the true PF-ODE path.

Comparing against distillation methods specifically: LCM at 4 steps achieves FID 30.84 but CLIP consistency of only 87.8 and Depth consistency of 54.39. ConsistencySolver at 4 steps achieves FID 27.19 (better image quality) with CLIP 92.8 and Depth 43.92 (substantially better consistency). This demonstrates that distillation trades off consistency for speed in a way that ConsistencySolver avoids—the distilled model generates images that look reasonable in aggregate (acceptable FID) but don't faithfully represent what the full model would produce for a given seed.

DMD2's consistency metrics at 4 steps are notable: CLIP 91.9 and DINO 91.0, which are competitive with but slightly below ConsistencySolver's 92.8 and 92.2 respectively. However, the user study (discussed below) reveals that these distribution-level consistency metrics don't fully capture DMD2's practical failure modes.

Instructional Image Editing with FLUX.1-Kontext (Table 3)

Table 3 evaluates on the fundamentally different task of instructional image editing, where the model must modify a reference image according to a text instruction. At 3 steps, ConsistencySolver achieves Edit Reward of 0.65 (vs. 0.49 for the base FLUX.1-Kontext solver) and Edit Score of 5.56 (vs. 5.20). The Edit Reward improvement is particularly large—roughly 33% relative improvement—indicating that the learned solver substantially improves editing accuracy at very low step counts.

At 4 steps, Edit Reward reaches 0.73 (vs. 0.61 for the baseline) and Edit Score 5.67 (vs. 5.45). At 5 steps, ConsistencySolver achieves the best results across all metrics: Edit Reward 0.86, Edit Score 5.78, combined with consistency metrics (DINO 97.1, CLIP 97.0, Depth 25.18). The base model at 5 steps achieves substantially lower Edit Reward (0.75) and similar consistency, indicating that ConsistencySolver's learned coefficients transfer effectively across model architectures and tasks—the policy learns a general integration strategy that works for both Stable Diffusion's text-to-image dynamics and FLUX.1-Kontext's image-conditioned editing dynamics, despite these being qualitatively different denoising processes.

This cross-model generalization is a significant but understated result: the policy network $\boldsymbol{f}_{\boldsymbol{\theta}}$ is trained only on Stable Diffusion text-to-image data (2,000 LAION prompts), yet it improves FLUX.1-Kontext editing at deployment without any fine-tuning. The paper does not explicitly claim this as a finding, but it emerges from the experimental design: the learned coefficients are content-agnostic and model-agnostic to the extent that the underlying ODE dynamics share similar structure across diffusion models trained on different tasks.

User Study: Diffusion Preview Efficiency (Tables 4–5)

The user study is the paper's most direct evaluation of the end-to-end Diffusion Preview workflow and its practical value proposition. The protocol (Section 5.4, Appendix D.3): for each prompt, images are repeatedly generated with different random seeds until either the user is satisfied or 10 attempts are exhausted. Two modes are compared: high-quality mode (40-step multistep DPM-Solver on every attempt) and preview mode (8-step ConsistencySolver previews until satisfaction, then one 40-step refinement of the accepted seed). The primary metric is average end-to-end inference time per prompt, including both denoising and VAE decoding time on an H100 GPU.

Table 4 reports results across three prompt sets, with both Claude Sonnet 4 (LLM) and human evaluators:

• LAION prompts, LLM evaluation: High-quality mode requires 6.00 average attempts and 221.4 seconds total. Preview mode requires 6.35 attempts and 99.3 seconds—a 55.1% reduction in end-to-end time. The slight increase in attempts (6.00 → 6.35) is negligible compared to the time savings: each rejected attempt costs 8 steps in preview mode vs. 40 steps in high-quality mode, meaning preview mode's "cost of rejection" is 5× lower.

• LAION prompts, human evaluation: 5.90 attempts / 218.8 seconds for high-quality vs. 6.25 attempts / 97.9 seconds for preview—a 55.3% reduction, nearly identical to the LLM evaluation, providing cross-validation that the LLM judge's strictness is well-calibrated to human standards.

• COCO 2017, LLM evaluation: 6.02 attempts / 223.0 seconds vs. 6.12 attempts / 95.6 seconds—a 57.1% reduction.

• COCO 2017, human evaluation: 6.07 attempts / 224.8 seconds vs. 6.15 attempts / 96.2 seconds—a 57.2% reduction.

• GenEval, LLM evaluation: 5.42 attempts / 200.8 seconds vs. 5.82 attempts / 94.3 seconds—a 53.0% reduction.

• GenEval, human evaluation: 5.48 attempts / 203.1 seconds vs. 5.95 attempts / 94.4 seconds—a 53.5% reduction.

The consistency across LLM and human evaluations is striking: the percentage reductions differ by less than 0.5% on all three datasets, suggesting the LLM judge is a reliable proxy for human satisfaction in this task. The slight increase in attempt count in preview mode (~0.1–0.5 additional attempts) is economically insignificant—the time savings from cheap previews vastly outweigh the cost of occasionally needing one extra iteration.

Table 5 addresses the critical question: "do we still need preview-and-refine if distillation models are good enough?" The result is damning for distillation. On COCO 2017 validation (2,143 prompts evaluated), the base 40-step model satisfies 100% of prompts within 10 attempts (by definition—it's the baseline). DMD2 with GAN satisfies only 64.8% (1,389 prompts). DMD2 without GAN satisfies only 59.1% (1,267 prompts). ConsistencySolver at 8 steps satisfies 96.0% (2,057 prompts). On GenEval (121 prompts), the numbers are: base 100%, DMD2 with GAN 57.0%, DMD2 without GAN 47.1%, ConsistencySolver 94.2%.

The paper's interpretation of this result is in Section 5.4:

"despite the competitive FID scores achieved by distillation-based methods, the loss of consistency fundamentally undermines generation quality in ways not captured by distribution-level metrics"

This is a significant empirical finding with direct practical implications. An FID score tells you the average quality of generated images; it does not tell you whether a specific prompt, when combined with a specific noise seed, will produce a satisfactory result. Distillation methods, by altering the noise-to-image mapping, can produce images that are high-quality on average but fail unpredictably on individual prompts—the 35–40% of prompts that DMD2 fails to satisfy even with 10 attempts would be extremely frustrating in an interactive setting, since the user has no way to know whether their prompt is in the "good" 60% or the "bad" 40%.

In contrast, ConsistencySolver's 96.0% and 94.2% satisfaction rates indicate that the preview-and-refine workflow with a consistent solver preserves the base model's per-prompt reliability—if the base model can produce a satisfactory image for a prompt within 10 attempts, the preview workflow almost always identifies that seed, because the preview faithfully represents what the refined output will look like.

---

Ablation Studies and Robustness Checks

Solver order (Table 6): The ablation compares solver orders 2, 3, 4, and 5 at 5, 8, and 10 steps across all consistency metrics (CLIP, DINO, Inception, Depth, pixel-level, and the aggregate structural/perceptual dimensions). Order 4 "consistently achieves the best overall performance across step counts." At 8 steps, Order 4 achieves DINO 94.7 and Depth 36.49, versus Order 3 (93.7 and 38.82) and Order 5 (94.4 and 37.60). Lower orders (2–3) show clear degradation in layout and depth consistency, suggesting insufficient capacity to capture the higher-order dynamics of the denoising trajectory. The drop from Order 4 to Order 5 is small but consistent—Order 5 underperforms Order 4 in most metrics at most step counts. The paper attributes this to "the increased RL search space complexity": with 5 coefficients per transition instead of 4, the policy must explore a larger action space, making credit assignment harder and potentially requiring more training iterations than the fixed 3,000 used in all experiments.

Reward model choice (Table 7): Four reward functions are compared at 5, 8, and 10 steps: Depth (default), CLIP similarity, DINO feature similarity, and pixel-level image similarity (Img.). The key finding is that Depth provides the most balanced performance. At 8 steps: Depth reward yields DINO 94.7 and Depth 36.49; CLIP reward yields DINO 93.4 but Depth 41.12 (worse structural consistency); DINO reward yields competitive semantic metrics (CLIP 97.1) but Depth 41.68; Img. reward yields the best pixel-level fidelity (particularly at 10 steps) but weaker structural consistency. The paper's choice of Depth as default is justified by the observation that structural fidelity (captured by depth maps) is "critical for informed user decisions"—a preview with the correct object layout but slightly different textures is more useful for decision-making than one with photorealistic textures but incorrect composition.

A non-obvious finding: the reward function influences which consistency dimensions are optimized, but the effects are not always intuitive. Training with CLIP reward (which measures semantic similarity) produces previews with good CLIP scores but worse depth consistency, suggesting that optimizing for one perceptual dimension can come at the cost of others—there is a genuine multi-objective tradeoff in preview quality that the choice of reward function navigates.

Model structure (Table 8, Appendix D.4): The policy MLP's hidden dimension is varied across 128, 256, 512, and 1024, and a deep 12-layer MLP with residual LayerNorm connections is also tested. The 256-dimensional model "consistently outperforms others." Larger dimensions (1024) produce slightly better depth estimation at 10 steps (39.08 vs. 39.64 for 256-dim) but are worse or equivalent on other metrics, and the deep 12-layer MLP "shows no meaningful advantage over the standard 256-dim architecture." This confirms the paper's argument that "moderate capacity is sufficient for the task"—the policy doesn't need to learn complex visual representations, only a smooth function from timestep pairs to coefficient vectors. The fact that additional capacity doesn't help (and sometimes slightly hurts) is a positive result for the method's practicality: it means the MLP is cheap to train, cheap to store, and adds negligible inference overhead.

Training methodology: RL vs. distillation (Table 2, Ours-Distill vs. ConsistencySolver): This is effectively a full-method ablation appearing in the main results table. The RL-trained solver and the trajectory-distilled solver share identical architecture but differ in training signal. At every step count from 4 upward, the RL version achieves better FID and better or equivalent consistency metrics. At 12 steps, the FID gap is 18.53 vs. 21.37—a 2.84 point difference. This ablation demonstrates that the training paradigm (RL vs. distillation) is responsible for a substantial fraction of ConsistencySolver's performance, not just the architectural choice of a learnable linear multistep solver. The paper's interpretation—that RL avoids the "intermediate state matching" proxy problem by optimizing for the true final objective—is supported by the fact that the gap widens at higher step counts, where the discrepancy between per-step matching and final-output quality would compound more severely.

Base model generalization (Table 2 vs. Table 3): While not explicitly labeled as an ablation, the transfer from Stable Diffusion (Table 2) to FLUX.1-Kontext (Table 3) constitutes a robustness check on whether the learned policy overfits to a specific diffusion model's dynamics. The policy is trained only on Stable Diffusion data but evaluated on FLUX.1-Kontext, and it improves editing performance across all metrics and step counts. This suggests the learned integration strategy captures something general about diffusion denoising dynamics rather than model-specific artifacts.

Negative result: ReST$^{EM}$ revision model degradation. This is not part of the current paper but rather a reference to the prior summary's structure; the current paper does not contain a comparable negative training result. However, the failure of "final-state distillation" (Appendix D.2)—where backpropagating through the full chain with only the final loss caused "severe training instability" and failure to converge—is a meaningful negative result that motivated the RL approach.

---

Critical Assessment

Claim: ConsistencySolver significantly improves generation quality and consistency in low-step regimes.

This claim is strongly supported by the quantitative evidence in Table 2. At 5 steps, FID improves from 25.87 (multistep DPM-Solver) to 20.39—a 21% relative improvement. Consistency metrics show even larger gaps: DINO from 83.6 to 91.8, Depth from 58.84 to 43.51. The improvements are consistent across step counts (4, 5, 8, 10, 12) and across all six consistency dimensions. The one qualification is at 3 steps, where ConsistencySolver trails distillation baselines in FID (31.27 vs. 29.29)—the method's advantage requires a minimum step budget to manifest, likely because at extremely low step counts the preview-reference similarity is so low that the RL signal becomes noisy.

However, the paper does not report confidence intervals, standard deviations, or statistical significance tests for any of the metrics in Tables 2, 3, 6, 7, or 8. Given that evaluation uses 2,000 COCO prompts, small numerical differences (e.g., FID 19.02 vs. 19.89 at 8 steps between ConsistencySolver and AMED) could fall within sampling error. The paper's conclusions would be more robust with error bars or at minimum a statement about measurement variance.

Claim: The approach reduces overall user interaction time by nearly 50% while maintaining generation quality.

This claim is supported by the user study (Tables 4–5), but with important caveats about what "maintaining generation quality" means. The time reduction numbers are unambiguous: 53–57% reduction across datasets and evaluator types. The satisfaction rate is also strong: 94.2–96.0% of prompts satisfied relative to the base model (Table 5). These numbers demonstrate that the preview workflow is both faster and preserves most of the base model's per-prompt reliability.

However, the paper implicitly defines "maintaining generation quality" as "users are satisfied at a rate close to the base model." This is not the same as "the final refined images are of identical quality to what the user would have received in high-quality mode," because the two modes involve different selection processes. In high-quality mode, the user evaluates full-step images and selects the first satisfactory one. In preview mode, the user evaluates low-step previews and selects based on those, then refines. If the previews are imperfect proxies (which they are—even 97.4 CLIP consistency leaves room for differences), there will be cases where a user accepts a preview that looked good but whose refinement is actually unsatisfactory, or rejects a preview that looked bad but whose refinement would have been good. The satisfaction rate of 94.2–96.0% indicates these failures are rare, but they are not zero. The paper could strengthen this claim by reporting the rate at which accepted previews produce refined outputs that the user would have rejected if they saw them in high-quality mode—this would require a more complex study design.

Additionally, the user study imposes a maximum of 10 attempts per prompt and discards prompts that remain unsatisfactory. This is a reasonable experimental choice (preventing outliers from skewing timing statistics), but it means the reported satisfaction rates and timing numbers are conditional on prompts that are satisfiable within 10 attempts. A harder, more realistic test would be to include all prompts and report time-to-satisfaction or failure rate separately.

Claim: ConsistencySolver outperforms distillation baselines.

This claim is supported with qualifications. Table 2 shows that ConsistencySolver outperforms LCM, PCM, and Rectified Diffusion in both FID and consistency metrics at comparable step counts. The comparison with DMD2 is more nuanced: DMD2 achieves lower FID at 4 steps (in the distillation literature, DMD2 is a state-of-the-art single-step model), but the paper argues that FID alone is insufficient. The user study (Table 5) provides compelling evidence that DMD2's consistency failures cause real usability problems: 35–40% of prompts cannot be satisfied within 10 attempts. If the use case is "generate a single high-quality image as fast as possible where the user doesn't care about seed consistency," DMD2 may be preferable. If the use case is "iterate on prompts and seeds interactively with predictable behavior," ConsistencySolver is clearly better.

The paper does not compare against all relevant distillation methods. Notable absences: consistency models trained with consistency distillation (song2023consistency), progressive distillation (salimans2022progressive), and the various InstaFlow/BOOT methods. Some of these may offer better consistency than DMD2 or LCM—the paper's claim about "distillation baselines" should be understood as applying to the specific methods tested, not to all distillation methods universally.

Claim: The RL training approach provides advantages over distillation for training the solver.

This claim is supported by the Ours-Distill ablation (Table 2), but the comparison is imperfect. Ours-Distill trains the same MLP architecture via trajectory matching; ConsistencySolver trains it via RL with a depth-map similarity reward. There are two differences between these training procedures: (1) RL vs. gradient-based optimization, and (2) final-output reward vs. intermediate-state matching. The paper's theoretical argument in Section 4.3 emphasizes both factors—non-differentiable rewards and avoidance of the intermediate-state proxy—but the experimental design cannot fully disentangle them. A more diagnostic ablation would include: RL trained with a differentiable reward (e.g., MSE to reference) to isolate the RL vs. gradient descent factor, and gradient-based training with only the final loss (the "final-state distillation" that was attempted and failed, but perhaps with engineering improvements like gradient checkpointing or truncated backpropagation) to isolate the proxy-objective factor.

Missing experiments that would strengthen the paper:

1. Statistical significance testing. None of the tables include confidence intervals or standard deviations. With 2,000 COCO evaluation prompts, some of the smaller numerical differences (especially at higher step counts where metrics converge) may not be statistically significant.

2. Direct measurement of preview-refinement consistency in the user study. The user study measures whether the preview satisfies the user, and separately measures whether the refined output from an accepted seed satisfies the user. But it does not report how often an accepted preview leads to a refined output that the user would reject—the most direct measure of whether the consistency property is working as intended.

3. Ablation on the offline dataset size. Training uses 2,000 LAION prompts. How does performance scale with dataset size? Would 500 prompts suffice? 10,000? This matters for practical adoption—if the method requires thousands of full-step reference generations for training, the upfront cost may offset some of the inference-time savings.

4. Ablation on the number of training iterations. Training runs for 3,000 iterations (12 GPU-hours). Would longer training improve performance further, or has convergence been reached? Table 2 shows performance plateauing around 18.5 FID at 10–12 steps; is this the ceiling for this architecture, or would more training push it lower?

5. Comparison against simply using more steps with a standard solver. The paper's core efficiency claim is that 8-step ConsistencySolver matches or exceeds 40-step DPM-Solver in the user workflow. But a simpler baseline would be: use a standard solver at 15–20 steps for both preview and refinement (skipping the two-stage process entirely). Would this mid-step-count approach achieve similar time savings with less complexity? The paper does not evaluate this "uniform acceleration" baseline against the two-stage preview-and-refine workflow.

6. Evaluation on a non-LAION, non-COCO prompt distribution. Both training (LAION) and evaluation (COCO, GenEval, LAION) use web-scraped image caption datasets. The method's generalization to substantially different prompt distributions (e.g., highly specific technical descriptions, long-form narrative prompts, non-English prompts) is untested.

7. Latency measurement details. The paper reports end-to-end inference time including VAE decoding, but doesn't break down what fraction of time is spent in the diffusion UNet forward passes versus the VAE decoder versus the solver's coefficient computation. Understanding these proportions would clarify whether further solver optimization could yield meaningful additional speedups.

Overall assessment.

The paper demonstrates that a learned, RL-optimized ODE solver can produce previews that are substantially more consistent with full-step reference outputs than existing training-free solvers, while requiring no modification to the base model and preserving the deterministic PF-ODE mapping that distillation methods sacrifice. The quantitative improvements in FID and consistency metrics are consistent and meaningful. The user study provides ecologically valid evidence that these improvements translate to practical benefits in an interactive workflow.

The paper's more ambitious claim—that consistency is an overlooked but essential requirement for diffusion acceleration, and that FID-based evaluation systematically masks failures of distillation methods—is supported by the DMD2 user study results but would benefit from evaluation against a broader set of distillation methods and from a more rigorous decomposition of why DMD2 fails on specific prompts (are the failures due to inconsistency with the base model's trajectory, or due to independent quality failures?).

The method's primary limitations are practical: it requires precomputing a dataset of full-step reference images for training, it uses RL which can be sensitive to hyperparameters, and the 12 GPU-hour training cost—while modest by modern standards—means the solver must be retrained for each new base model or noise schedule. Whether these costs are justified depends on the deployment scenario: for a model serving millions of interactive users, the upfront training cost is negligible compared to the inference savings; for a researcher prototyping a new model, the overhead may not be worthwhile.

6. Limitations and Trade-offs

The Difficulty Estimation and Dat

7. Implications and Future Directions

How This Work Changes the Landscape

This paper introduces a third category into the diffusion acceleration landscape that previously had only two: training-free solvers (fast, consistent, but low-fidelity at very low step counts) and distillation (fast, high-fidelity, but inconsistent). ConsistencySolver demonstrates that learning the solver, rather than replacing the model or using fixed theoretical approximations, is a viable and competitively performant middle ground. This is not a paradigm shift on the scale of diffusion models themselves, but it is a meaningful reframing of the acceleration problem: the solver is not a "dumb" numerical integrator but an intelligent component that can be optimized for a specific model's actual denoising dynamics.

The conceptual shift has several specific implications for the field:

1. The acceleration problem is now decoupled from the model itself. Prior work implicitly assumed that to get better low-step sampling, you must either (a) derive cleverer integration formulas from theory, which is bounded by the accuracy of theoretical assumptions about score function smoothness, or (b) modify the model weights, which is expensive and sacrifices properties like deterministic seed-to-image mapping and flexible step selection. ConsistencySolver shows that neither path is necessary—you can keep the model frozen and learn a better integration strategy for it. This decoupling means that improvements to the base model (better architectures, more training data, domain-specific fine-tuning) and improvements to the solver (better RL algorithms, better reward functions, higher-order architectures) can proceed independently and compose multiplicatively. A future state-of-the-art diffusion model can immediately benefit from an existing trained solver, and vice versa.

2. Consistency is now a first-class evaluation criterion, not an afterthought. The paper's demonstration that DMD2—a state-of-the-art distillation method by FID standards—satisfies only 57% as many prompts as the base model in user studies (Table 5) is a diagnostic finding that should change how the field evaluates acceleration methods. FID measures distribution-level quality; it does not measure whether a specific noise seed produces the image the user expects. The paper provides a concrete measurement framework (Table 1: six consistency metrics computed between preview and reference) and shows that optimizing for the final preview-reference similarity directly (via RL with perceptual rewards) produces better real-world outcomes than optimizing for FID indirectly (via distillation). This reframes the acceleration problem from "generate good images fast" to "generate images that are reliable proxies for what the full model would produce"—a subtle but important distinction that particularly matters for interactive, human-in-the-loop workflows.

3. The proxy-objective problem in trajectory distillation is now empirically documented. The paper demonstrates concretely that a solver trained via intermediate-state matching (Ours-Distill) underperforms an identically-architected solver trained via final-output RL optimization (Table 2: FID 21.37 vs. 18.53 at 12 steps). This is not a small difference—it is a 2.84 FID point gap that widens with step count. This finding has implications beyond this specific method: it suggests that the dominant paradigm for training accelerated samplers (trajectory distillation in AMED, D-ODE, GENIE, and related work) may be fundamentally limited by the mismatch between the per-step matching proxy and the true objective of final output quality. The paper provides a concrete alternative (RL with perceptual rewards) and demonstrates its superiority, opening a new axis for research on how to train accelerated samplers.

4. The RL formulation opens solver design to non-differentiable objectives. All prior learned solvers were constrained to differentiable loss functions (typically MSE between predicted and reference states). ConsistencySolver's RL training accepts any scalar reward, enabling optimization for depth consistency, segmentation consistency, DINO feature alignment, or any combination thereof—metrics that better capture what users actually care about when evaluating a preview. This is a genuine expansion of the design space: the community can now explore reward functions tailored to specific applications (e.g., facial identity preservation for portrait generation, text rendering accuracy for typography, compositional faithfulness for layout-sensitive tasks) without needing to make those metrics differentiable.

5. The "minimal intervention" approach changes the economics of acceleration. Training ConsistencySolver requires 12 H100 GPU-hours (Appendix D.1) and 2,000 precomputed reference images. This is orders of magnitude cheaper than distillation methods that require retraining the full diffusion model (often hundreds of GPU-days). It means that solver optimization becomes feasible for individual practitioners, for frequently-updated models, and for specialized domains where full distillation would be prohibitively expensive. The paper does not emphasize this economic argument, but it is a significant practical implication: the barrier to entry for getting good low-step sampling from a diffusion model is now dramatically lower.

Reconciliation of prior contradictions. The paper helps resolve a tension in the literature between training-free solvers (which preserve consistency but degrade at low step counts) and distillation (which achieves low-step quality but loses consistency). ConsistencySolver demonstrates that these are not inherent tradeoffs—a learned solver can achieve both properties simultaneously by adapting to the actual model dynamics rather than relying on theoretical approximations or altering the model's learned trajectory. This reconciliation is important because it means future work does not need to choose between consistency and quality; it can pursue both by focusing on solver optimization rather than model modification.

Research directions that become less attractive. The paper's findings suggest that developing ever-more-complex fixed-coefficient solvers (the path from DDIM to DPM-Solver to DPM-Solver++ to UniPC) may be approaching diminishing returns. The gap between the best training-free solver (multistep DPM-Solver, FID 25.87 at 5 steps) and ConsistencySolver (FID 20.39 at 5 steps) is large enough to suggest that theoretical approximations of the score function's behavior have hit a ceiling, and further improvements will require data-driven adaptation. Similarly, trajectory distillation of solver parameters (AMED, D-ODE) is called into question by the Ours-Distill ablation, which shows that per-step matching can be counterproductive compared to final-output optimization. Research effort may be better directed toward RL-based or other final-output optimization paradigms.

Follow-Up Research This Work Enables

1. Online, adaptive solver policies that condition on image content. ConsistencySolver's policy network takes only timesteps $(t_i, t_{i+1})$ as input—it learns a content-agnostic integration strategy. A natural extension would condition the policy on features of the current sample $\mathbf{x}_t$ (e.g., through a lightweight encoder that extracts structural information) or on the prompt embedding. This would allow the solver to adapt its integration strategy based on how denoising is progressing for a specific sample: aggressive steps when the structure is already clear, conservative steps when the layout is still ambiguous, or prompt-dependent strategies (e.g., different coefficient patterns for "a photo of a cat" versus "a watercolor painting of a dragon in a cyberpunk city"). A concrete experiment: augment the MLP to take CLIP image embeddings of $\mathbf{x}_{t_i}$ as additional input, train with the same RL pipeline, and measure whether consistency metrics improve on heterogeneous prompt distributions (e.g., a dataset mixing simple and complex scenes). The risk is that content-conditioning could overfit to training prompts; evaluation on held-out prompt categories would be essential.

2. Multi-objective reward shaping for application-specific preview quality. The paper's ablation (Table 7) shows that different reward functions (Depth, CLIP, DINO, pixel-level) produce solvers with different consistency profiles—Depth excels at structural fidelity, CLIP at semantic alignment, etc. This suggests that for specific applications, tailored reward combinations could produce solvers optimized for the dimensions that matter most. A concrete follow-up: for a portrait generation application, combine a face identity preservation reward (e.g., ArcFace feature similarity between preview and reference) with a depth consistency reward (for pose/structural fidelity). Train with this composite reward and evaluate against the Depth-only baseline on a portrait dataset, measuring both standard consistency metrics and face-specific metrics (identity retention, expression matching, gaze direction consistency). The hypothesis is that application-specific reward engineering can push consistency beyond what a generic perceptual reward achieves, and the paper's RL framework makes this trivial to test (just change the reward function—no architectural changes needed).

3. Combining ConsistencySolver with the revision model to close the capability gap on hard prompts. The paper's user study (Table 5) shows that ConsistencySolver's preview workflow satisfies 94.2–96.0% of prompts—a 4–6% gap from the base model's 100%. These failures occur when even the base model cannot produce a satisfactory image within 10 attempts with the specific seed used, and the 8-step preview cannot identify this because the preview is imperfect. A concrete extension: use ConsistencySolver for the preview stage, but if the preview is ambiguous (measured by, e.g., low confidence in the similarity between preview and a quick intermediate refinement), fall back to a revision-based approach that iteratively refines the output rather than resampling from scratch. This hybrid workflow would combine ConsistencySolver's fast consistent previews with a revision model's ability to improve a specific output, potentially closing the 4–6% satisfaction gap. The experiment: measure end-to-end satisfaction rate and time for the hybrid workflow against the ConsistencySolver-only workflow across 5,000 prompts, tracking whether the revision fallback triggers and whether it successfully rescues prompts that the preview workflow would have failed.

4. Stress-testing the cross-model generalization claim. The paper shows that a ConsistencySolver trained on Stable Diffusion text-to-image data improves FLUX.1-Kontext instructional editing (Table 3) without any fine-tuning. This is reported as a result but not systematically investigated. A concrete follow-up: train ConsistencySolver policies on several different base models (e.g., SD 1.5, SD 2.1, SDXL, FLUX.1-dev) and cross-evaluate each policy on every model, measuring consistency metrics. This would reveal (a) whether the learned integration strategy is genuinely universal across diffusion architectures or whether there are model-specific dynamics that matter, (b) whether training on a "more capable" model produces a better solver for all models (suggesting the solver learns higher-quality integration principles), and (c) whether there are model pairs where cross-transfer fails, which would define the boundary conditions for when a new model needs a new solver. The hypothesis is that the policy captures something about the shape of denoising trajectories that is shared across models trained with similar noise schedules, and divergence would indicate fundamentally different learned score function behaviors.

5. Scaling laws for solver training: data, iterations, and model capacity. The paper trains on 2,000 LAION prompts for 3,000 iterations with a 256-dim MLP. How does performance scale with each of these resources? A concrete scaling study: train ConsistencySolver policies with prompt dataset sizes of 100, 500, 2,000, and 10,000; training iterations of 500, 1,500, 3,000, and 10,000; and MLP hidden dimensions of 64, 128, 256, 512, 1024. Measure FID and consistency metrics at 8 steps on a held-out evaluation set. This would produce scaling curves that tell practitioners the minimum resources needed for a given performance target, and would reveal whether the current configuration is near saturation or whether more resources would yield substantially better solvers. The paper's result that 1024-dim MLPs underperform 256-dim (Table 8) suggests the relationship may be non-monotonic, which would be interesting to characterize more thoroughly.

6. ConsistencySolver as a drop-in replacement in self-improvement and data generation pipelines. Many self-improvement methods for diffusion models (e.g., rejection sampling fine-tuning, where the model generates many candidates, scores them, and fine-tunes on the best) require generating thousands of images at high step counts for reliable quality assessment. If ConsistencySolver's 8-step previews are sufficiently consistent with 40-step outputs, the generation phase could be dramatically accelerated by using 8-step previews for the filtering/selection step, followed by 40-step refinement only for selected candidates. A concrete experiment: replicate a standard rejection-sampling fine-tuning pipeline (e.g., fine-tune Stable Diffusion on its own best generations as scored by a reward model), but use ConsistencySolver 8-step previews for the candidate generation and scoring phase, with 40-step refinement only for the top-K candidates that are selected for fine-tuning. Measure the final fine-tuned model's FID and compare against a baseline that uses 40-step generation for all candidates. The hypothesis is that the preview-based pipeline achieves comparable final model quality with a 5× reduction in total generation compute. This would quantify the economic value of consistency in a setting where diffusion models are used as data generators rather than end-user products.

Practical Applications and Downstream Use Cases

1. Interactive creative tools with reduced latency and preserved predictability. The most direct application is in design tools (e.g., generative fill in Photoshop, concept art generation, architectural visualization) where users iterate rapidly on prompts and seeds. The paper's user study (Table 4) shows that the preview workflow reduces end-to-end time by 53–57% across datasets, from roughly 200–225 seconds to 94–100 seconds for a typical session. For a professional designer generating hundreds of images per day, this translates to hours of saved time. Critically, unlike distillation-based acceleration, the preview faithfully represents what the refined output will look like—the user doesn't experience the frustration of accepting a good-looking preview only to receive a different-looking final image, which is a known failure mode of LCM and DMD2 in production settings. This reliability is essential for professional workflows where predictability matters more than raw speed.

2. Cost-efficient batch inference for content production pipelines. Media companies, game studios, and e-commerce platforms routinely generate thousands or millions of images using diffusion models (e.g., product visualization, background generation, texture synthesis). In these batch settings, the two-stage preview-and-refine workflow offers a concrete cost optimization: use 8-step ConsistencySolver to generate and evaluate candidates, and only run the expensive 40-step refinement on the small fraction of outputs that pass quality checks. If a quality filter accepts 20% of generated images (typical in production), the total compute is $0.8 \times 8 + 0.2 \times 40 = 14.4$ equivalent forward passes per output, versus 40 for naive full-step generation—a 64% reduction in inference cost. The paper's 12 GPU-hour training cost is amortized over millions of images, making the economics clearly favorable. This use case does not even require the interactive preview workflow; it simply exploits the consistency property to defer expensive computation until after filtering.

3. On-device or edge deployment of diffusion models. On mobile devices and edge hardware, running a 40-step diffusion sampling process may be infeasible due to memory and latency constraints. ConsistencySolver's policy network adds negligible parameters (a 256-dim MLP with a few thousand weights) and computational overhead relative to the base UNet. Combined with a lightweight base model (e.g., a distilled or pruned Stable Diffusion variant), the preview-and-refine workflow could enable a practical on-device experience: the user generates and iterates on 8-step previews locally (fast, low battery drain), and when satisfied, the device either runs the 40-step refinement locally if capable, or sends the seed and prompt to a cloud endpoint for final refinement. The paper's Table 4 latency numbers (95–100 seconds for full sessions including refinement on H100) suggest that on a modern phone GPU, 8-step previews alone would be fast enough for near-interactive use (a few seconds per preview), while the rare refinement step could be offloaded. This is a concrete deployment architecture that ConsistencySolver enables but that distillation methods cannot because they break the preview-refinement consistency contract.

4. Human-feedback data collection for alignment and preference optimization. Training reward models or preference classifiers for diffusion models (analogous to RLHF for language models) requires collecting human judgments on generated images. The bottleneck is often the generation itself—if each image seen by a human annotator required 40 steps, the generation cost would dominate the annotation budget. With ConsistencySolver, the annotation pipeline could display 8-step previews to annotators for rapid judgment (e.g., "does this image match the prompt?"), and only generate the full-step version for accepted images or for the final fine-tuning dataset. The paper's demonstration that previews have 94–96% satisfaction alignment with full-step outputs (Table 5) suggests that annotation decisions made on previews would agree with decisions made on full-step images in the vast majority of cases, making this a low-risk optimization. For a dataset of 100,000 human annotations, this could save millions of GPU-seconds of generation compute.