1 Introduction↩︎

Diffusion probabilistic models [1]–[4] have become a standard tool for text-guided image editing [5], [6]. A common approach is inversion-based editing—given a real image, the probability-flow ODE [4] is integrated backwards in time to a latent noise state conditional on a source prompt, after which the forward ODE is integrated under a new target prompt to obtain an edited image [7]–[9].

In this setting, the choice of numerical solver is vital, since errors resulting from inexact inversion compound through the editing process, especially under classifier-free guidance [10]. For instance, classical DDIM inversion incurs a systematic trajectory mismatch, since the reverse update is not the algebraic inverse of the forward update. A long line of work aims to reduce the resulting diffusion inversion error [11]–[13]. Recently, algebraically reversible (or simply reversible) ODE solvers such as EDICT [14], BDIA [15], BELM [16], and Rex [17] have been proposed as an alternative to DDIM inversion, yielding improved reconstructions and background preservation in editing pipelines. However, our empirical evidence suggests that reversibility alone is not enough. On standard editing tasks, reversible solvers exhibit a clear trade-off between background preservation and prompt alignment. This becomes particularly apparent when the editing trajectory departs substantially from the inversion trajectory, in which case many reversible solvers suffer sharp drops in edit quality.

To benchmark solver performance for image editing, we distinguish two evaluation settings. The first is the widely used small edits setting of the PIE-Bench image editing benchmark introduced by [9], where edits are usually local to a subset of the prompt and image (see 5.2). In addition, we introduce a second large edits regime, where the edited prompt induces a large semantic or visual change, forcing the sampling trajectory away from the original inversion path (see 5.3). Figure 1 previews the key findings.

In 4, we argue that the failure modes of existing reversible schemes, illustrated in Figure 1, can be attributed to numerical stability. To address these issues, we propose using the recently introduced class of near-reversible Explicit and Effectively Symmetric (EES) Runge–Kutta methods [18] as diffusion solvers. EES schemes relax exact reversibility, instead enforcing only approximate symmetry up to an acceptably low error tolerance. This relaxation allows them to retain an explicit Runge–Kutta form and benefit from much more favourable stability properties. Since the inversion error depends on the regularity of the underlying trajectory, we additionally combine EES schemes with vector-field smoothing strategies previously proposed for DDIM inversion. Together, this yields a family of solvers that is competitive with exactly reversible solvers on standard editing benchmarks and substantially more stable under challenging edits.

In addition to proposing EES solvers, our paper clarifies the broader design space of reversible diffusion solvers for editing. We investigate guidance and smoothing heuristics such as Smooth Diffusion [13], Negative Prompt Inversion [12], and Proximal Guidance [11], which have previously been treated mainly as orthogonal DDIM-based techniques. We show that these methods can also yield substantial gains for reversible solvers, and characterise when they help. We also benchmark Reversible Heun and McCallum–Foster methods, originally introduced outside the diffusion models literature, and run extensive ablations over ODE parametrisations, step schedules, and solver formulations.

We summarise our main contributions as follows:

1. We provide a side-by-side evaluation of (near) reversible diffusion solvers for image editing, revealing a trade-off curve between background preservation and prompt alignment.

2. We propose using near-reversible EES Runge–Kutta methods for inversion-based diffusion editing. For small edits, when combined with vector-field smoothing, these methods retain much of the background-preservation benefit of exactly reversible solvers while improving edit fidelity.

3. For large edits, we show that EES is the most robust (near) reversible family in our study, maintaining output quality under large trajectory deviations where most exactly reversible solvers degrade substantially.

2 Preliminaries↩︎

2.1 Reversible Solvers↩︎

In the setting of an autonomous ODE \(dy_t = f(y_t)dt\), a one-step method \[\label{eq:ode} y_{n+1} = y_n + h\Phi_h(y_n)\tag{1}\] is said to be symmetric if \(\Phi_{-h} = \Phi_h^{-1}\). That is, a step of the method \(\Phi\) applied to \(y_{n+1}\) with a negative step size exactly recovers \(y_n\). Classical symmetric numerical integration methods, such as those of Runge–Kutta type, have been studied extensively for their favourable long-term behaviour, especially in the context of Hamiltonian systems [19]–[21]. More recently, symmetric methods have proven useful in the training of neural differential equations [22], where the ability to recover the full solution trajectory from the terminal point allows for memory-efficient backpropagation.

A major drawback of classical symmetric methods lies in their low efficiency. It is well-known that any symmetric Runge–Kutta scheme is necessarily implicit, and more generally any symmetric parasitism-free general linear method cannot be explicit [23]. This inefficiency makes classical schemes unsuitable for applications in machine learning. To solve this problem, several new algebraically reversible schemes, typically of low-order, were introduced. The asynchronous leapfrog integrator (ALF) [24] for Neural ODEs overcomes the problem of implicit schemes by tracking an auxiliary state as part of the integration. A similar approach is taken by the Reversible Heun method [25], where the technique of tracking an auxiliary state is applied to form a reversible version of Heun’s method for SDEs.

Whilst both methods prove to be efficient, they are inherently unstable. This instability is a significant bottleneck in certain practical applications [26], [27]. In [28], a new method was proposed for transforming any existing one-step integration method into one which is reversible. Whilst these methods offer increased stability over the ALF and Reversible Heun solvers, their stability domains are still typically much smaller than those of classical methods. This method was later adapted to the case of diffusion models, where the approach forms the basis for Rex solvers [17].

A potential solution to the issues of stability is offered by Explicit and Effectively Symmetric (EES) Runge–Kutta schemes [18]. Whilst symmetric Runge–Kutta methods are necessarily implicit, the authors show that it is possible to derive explicit schemes which are almost symmetric, up to a given tolerance level. The resulting schemes are virtually indistinguishable from perfectly symmetric schemes for sufficiently smooth problems and maintain stability domains which are comparable to those of classical schemes such as RK4 and RK5. It was shown in [26] that EES schemes produce superior results to Reversible Heun and McCallum-Foster methods when applied to stiff or highly volatile Neural SDEs.

2.2 Diffusion ODE and Inversion-Driven Image Editing↩︎

2.2.0.1 Diffusion models.

Diffusion probabilistic models (DPMs) [1], [2], [4] define a forward noising process that gradually perturbs data \(x_0 \sim q_0\) into a tractable Gaussian at time \(T\). In the variance-preserving (VP) setting, the forward marginals satisfy \[q_{t|0}(x_t \mid x_0)=\mathcal{N}(x_t;\,\alpha_t x_0,\,\sigma_t^2 I), \qquad \alpha_t,\sigma_t>0, \label{eq:vp95marginal}\tag{2}\] or equivalently \(x_t=\alpha_t x_0+\sigma_t \varepsilon\) with \(\varepsilon\sim\mathcal{N}(0,I)\). We fix \(\alpha_t^2 + \sigma_t^2 = 1\). DPMs aim to learn a denoiser \(\epsilon_\theta(x_t,t,c)\) that predicts the noise \(\varepsilon\) from \(x_t\), optionally dependent on some condition \(c\). At test time, generation can be performed by solving a reverse-time stochastic differential equation (SDE) [4] that replaces the intractable score term \(\nabla_x \log q_t(x)\) with the model prediction.

2.2.0.2 Probability-flow ODE.

A convenient deterministic alternative to the reverse-time SDE is the probability-flow ODE [4], which has the same marginals \(q_t\) as the reverse-time SDE but removes the stochastic term. For the VP parametrisation 2 , using the standard score approximation \(\nabla_x \log q_t(x_t) \approx -\hat{\epsilon}_\theta(x_t,t,c)/\sigma_t\), the probability-flow ODE can be written in the form \[\frac{d x_t}{d t} = \frac{d\log\alpha_t}{dt}\left(x_t - \frac{\hat{\epsilon}_\theta(x_t,t,c)}{\sigma_t}\right), \quad t\in[0,T]. \label{eq:pf95ode95logalpha}\tag{3}\] Sampling corresponds to drawing \(x_T \sim \mathcal{N}(0,\sigma_T^2 I)\) and integrating 3 from \(t=T\) to \(t=0\).

2.2.0.3 Classifier-free guidance.

When sampling a diffusion model conditional on \(c\) (often a text prompt), classifier-free guidance [10] has proven particularly effective for improving conditional sample fidelity. A guided noise prediction is formed by combining conditional and unconditional outputs (\(c_{\texttt{null}}:=\texttt{<empty string>}\)): \[\hat{\epsilon}_\theta(x_t,t,c) = g\epsilon_\theta(x_t,t,c)+(1-g)\epsilon_\theta(x_t,t,c_{\texttt{null}}), \label{eq:cfg}\tag{4}\] where \(g\ge 0\) is the guidance weight.

2.2.0.4 Inversion-driven image editing.

A common approach to text-guided image editing with diffusion models is to first invert a real image into the model’s latent noise space and then resample under a new, “edited” prompt [7], [8], [29]. Given a real input image \(x_0\) with source prompt \(c_{\texttt{src}}\) and a target prompt \(c_{\texttt{trg}}\), we perform editing via ODE inversion by integrating 3 in the backward direction from \(t=0\) to \(t=T\) with \(c_{\texttt{src}}\) to obtain \(x_T\), and then integrating 3 forward from \(t=T\) to \(t=0\) starting from the same \(x_T\) but using \(c_{\texttt{trg}}\), yielding the edited image \(\tilde{x}_0\).

2.3 Inversion Samplers↩︎

To edit images as described above, we need to be able to invert a diffusion solver, i.e., run it in the backward direction. In this section, we introduce several inversion strategies, ranging from DDIM inversion to reversible solvers.

2.3.0.1 DDIM inversion.

Define \(\bar x(t):=x(t)/\alpha_t\) and \(\bar\sigma(t):=\sigma_t/\alpha_t\). As summarised in [16], the probability-flow ODE can be written in the form: \[\frac{d\bar x}{d\bar\sigma}(t) = \bar\epsilon_\theta(\bar x(t),\bar\sigma(t),c), \quad \bar\epsilon_\theta(\bar x,\bar\sigma,c) := \epsilon_\theta(\alpha_t \bar x, t, c). \label{eq:diffusion95ivp95barsigma}\tag{5}\]

Let \(t_N=T>\cdots>t_0=0\) and \(\bar\sigma_N>\cdots>\bar\sigma_0\), and define steps \(h_i:=\bar\sigma_i-\bar\sigma_{i-1}>0\). Then the DDIM sampler corresponds to an explicit Euler step: \[\bar x_{i-1} = \bar x_i - h_i\,\bar\epsilon_\theta(\bar x_i,\bar\sigma_i,c). \label{eq:ddim95euler}\tag{6}\] In the original \(x\)-variable this is equivalently \[x_{i-1} = \frac{\alpha_{i-1}}{\alpha_i}x_i + \Bigl(\sigma_{i-1}-\frac{\alpha_{i-1}}{\alpha_i}\sigma_i\Bigr)\, \epsilon_\theta(x_i,t_i,c). \label{eq:ddim}\tag{7}\] DDIM inversion involves running 7 in the reverse direction from \(t_0\) to \(t_N\) using the same scheme 6 .

2.3.0.2 DDIM is not algebraically reversible.

It is clear that, since the Euler update rule does not satisfy the symmetry property in 2.1, the DDIM inversion approach is not exact—the forward and backward maps evaluate the network \(\epsilon_\theta\) at different points \(x_i\) and \(x_{i-1}\). In inversion-driven editing, this mismatch accumulates along the trajectory, leading to low background preservation and a decrease in overall edit quality. Multiple works also observe that the degradation becomes substantially worse under classifier-free guidance, which amplifies per-step errors [14], [29].

2.3.0.3 Mitigating DDIM inversion error.

Many works reduce DDIM inversion drift via inference-time or model-level interventions. Smooth Diffusion [13] fine-tunes the model to encourage smoother latent geometry, improving inversion and downstream edits. Other methods adjust conditioning during inversion, e.g. null-text inversion (NTI) [8], negative-prompt inversion (NPI) [12] and proximal guidance [11]. We summarise the latter two in 11.1. Some methods also store and reuse information from the source trajectory to guide editing, e.g.Prompt-to-Prompt [29], MasaCtrl [30], pix2pic-zero [31], plug-and-play [32], and Direct Inversion [9]. These techniques do not make DDIM algebraically reversible, but often reduce the practical impact of inversion errors.

2.3.0.4 Reversible diffusion samplers.

Motivated by the inexact inversion of DDIM, several works design samplers whose forward and backward updates are algebraic inverses.

EDICT [14] introduces an auxiliary diffusion state \(y_i\) coupled with \(x_i\) via a mixing coefficient \(p\in(0,1)\). Writing \(a_i := \alpha_{i-1}/\alpha_i\) and \(b_i := \sigma_{i-1} - \frac{\alpha_{i-1}}{\alpha_i}\sigma_i\), one EDICT step takes the form \[\begin{align} x_i^{\mathrm{inter}} &= a_i x_i + b_i\,\epsilon_\theta(y_i, t_i, c), \\ y_i^{\mathrm{inter}} &= a_i y_i + b_i\,\epsilon_\theta(x_i^{\mathrm{inter}}, t_i, c), \\ x_{i-1} &= p\,x_i^{\mathrm{inter}} + (1-p)\,y_i^{\mathrm{inter}}, \\ y_{i-1} &= p\,y_i^{\mathrm{inter}} + (1-p)\,x_{i-1}. \end{align} \label{eq:edict95core}\tag{8}\]

BDIA [15] instead derives an exact-inversion two-step recursion by combining a forward DDIM increment with a backward DDIM increment. Let \(\Delta(i\!\to\!j\,|\,x_i)\) denote the DDIM increment from index \(i\) to \(j\) computed from \(x_i\) (i.e., \(x_j = x_i + \Delta(i\!\to\!j\,|\,x_i)\)). Then BDIA computes \(x_{i-1}\) from \(x_{i+1}\) and \(x_i\) as \[\begin{align} x_{i-1} =\, &x_{i+1} - (1-\gamma)(x_{i+1}-x_i) \\ &- \gamma\,\Delta(i\!\to\!i+1\,|\,x_i) + \Delta(i\!\to\!i-1\,|\,x_i), \end{align}\] for a mixing parameter \(\gamma\in[0,1]\).

BELM [16] unifies these designs by showing that EDICT and BDIA fall into a class of bidirectional explicit linear multi-step methods for 5 . In particular, a two-step BELM sampler can be written as \[\bar x_{i-1} = a_{i,2}\,\bar x_{i+1} + a_{i,1}\,\bar x_i + b_{i,1}\,h_i\,\bar\epsilon_\theta(\bar x_i,\bar\sigma_i,c). \label{eq:belm952step}\tag{9}\] The exact inversion property follows from the fact that the same linear relation can be solved in the opposite direction to recover \(\bar x_{i+1}\). The authors derive an optimal choice of coefficients \(a_{i,1}=\frac{h^2_{i+1}-h^2_i}{h^2_{i+1}}\), \(a_{i,2}=\frac{h^2_i}{h^2_{i+1}}\), and \(b_{i,1}=-\frac{h_i+h_{i+1}}{h_{i+1}}\), forming the O-BELM variant of the scheme [16].

Rex [17] combines the Lawson method with the McCallum–Foster reversible solver for diffusion ODE and SDE sampling. Here, we focus on the ODE variant in the noise-prediction parameterisation. Rex uses the reparameterised time variable \(\tau=\sigma/\alpha\). We denote the corresponding positive- and negative-step Princeps increments, induced by a chosen explicit Runge–Kutta method, by \(\Psi_{h_i}\) and \(\Psi_{-h_i}\), where \(h_i=\tau_{i-1}-\tau_i\). Mapping back to the original diffusion state gives \[\begin{align} x_{i-1} &= \frac{\alpha_{i-1}}{\alpha_i} \bigl(\zeta x_i + (1-\zeta)\hat{x}_i\bigr) + \alpha_{i-1}\Psi_{h_i}(\tau_i,\hat{x}_i), \\ \hat{x}_{i-1} &= \frac{\alpha_{i-1}}{\alpha_i}\hat{x}_i - \alpha_{i-1}\Psi_{-h_i}(\tau_{i-1},x_{i-1}). \end{align} \label{eq:rex95core}\tag{10}\] Here \(\zeta\) is a coupling parameter.

2.4 Alternative ODE Parametrisations↩︎

2.4.0.1 Half-logSNR parametrisation (\(\epsilon\)-prediction).

Let \(\lambda := \log(\alpha_t/\sigma_t)\), which is strictly decreasing and invertible. For VP schedules one can show that \(\frac{d\log \alpha_\lambda}{d\lambda}=\sigma_\lambda^2\), and the probability-flow ODE can be written as \[\frac{dx_\lambda}{d\lambda} = \sigma_\lambda^2\,x_\lambda-\sigma_\lambda\,\epsilon_\theta(x_\lambda,\lambda). \label{eq:ode95lambda95eps95main}\tag{11}\] This is the \(\lambda\)-domain ODE used by DPM [33].

2.4.0.2 Half-logSNR parametrisation (\(x_0\)-prediction).

DPM-Solver++ [34] solves the equivalent ODE expressed in terms of the data predictor \[x_\theta(x_t,t):=\frac{x_t-\sigma_t\epsilon_\theta(x_t,t)}{\alpha_t}. \label{eq:x095predictor}\tag{12}\] Substituting \(\sigma_\lambda\epsilon_\theta = x_\lambda-\alpha_\lambda x_\theta\) into 11 yields \[\frac{dx_\lambda}{d\lambda} = -\alpha_\lambda^2\,x_\lambda+\alpha_\lambda\,x_\theta(x_\lambda,\lambda). \label{eq:ode95lambda95x095main}\tag{13}\]

3 EES Solvers for the Diffusion ODE↩︎

Building on the reversible and near-reversible solver families reviewed in 2.1, we now specialise EES schemes [18] to the diffusion probability-flow ODE. We refer to 7 for the scheme definitions and Butcher tableaux. Here we state the forward and backward update formulas.

We work in the half-logSNR time variable \(\lambda_t := \log(\alpha_t/\sigma_t)\) and use the \(x_0\)-predictor from 12 . As discussed in 2.4, the probability-flow ODE can be written in \(\lambda\)-time as 13 . Let \(\lambda_0>\lambda_1>\cdots>\lambda_N\) be a uniform grid with step \(h:=\lambda_{i-1}-\lambda_i>0\). Following [34], we introduce the rescaled state \(y_\lambda := x_\lambda/\sigma_\lambda\), for which the dynamics become \[\frac{d y_\lambda}{d\lambda} = e^{\lambda}\,x_\theta(\sigma_\lambda y_\lambda,\lambda), \label{eq:y95ode}\tag{14}\] using \(\alpha_\lambda/\sigma_\lambda = e^{\lambda}\) (see 11.2.1). Let \(\Phi_h(y,\lambda)\) denote the EES Runge–Kutta increment for 14 with step size \(h\), so that one step takes the form \(y \mapsto y + h\,\Phi_h(y,\lambda)\).

A forward step from \(\lambda_i\) to \(\lambda_{i-1}=\lambda_i+h\) is \[\begin{align} y_i &= \frac{x_i}{\sigma_{\lambda_i}}, \qquad y_{i-1} = y_i + h\,\Phi_h(y_i,\lambda_i), \\ x_{i-1} &= \sigma_{\lambda_{i-1}}\,y_{i-1}. \end{align} \label{eq:ees95sampler95update95fwd}\tag{15}\] The corresponding backward step from \(\lambda_{i-1}\) to \(\lambda_i=\lambda_{i-1}-h\) is \[\begin{align} \tilde{y}_{i-1} &= \frac{x_{i-1}}{\sigma_{\lambda_{i-1}}}, \qquad \tilde{y}_i = \tilde{y}_{i-1} - h\,\Phi_{-h}(\tilde{y}_{i-1},\lambda_{i-1}), \\ \tilde{x}_i &= \sigma_{\lambda_i}\,\tilde{y}_i. \end{align} \label{eq:ees95sampler95update95bwd}\tag{16}\] Because the endpoint rescaling is exact and EES methods are near symmetric, one forward step followed by the corresponding backward step satisfies \(\tilde{x}_i = x_i + \mathcal{O}(h^{m+1})\), where \(m\) depends on the chosen EES scheme. Finally, while the one-step EES construction itself is not tied to a particular ODE parametrisation, the overall editing performance can be sensitive to this choice. We therefore repeat the experiments from 5.2 under alternative formulations in 11.2.

3.1 Dependence of EES on Trajectory Regularity↩︎

We briefly note the dependence of the error of a near-reversible method on the solution trajectory and its derivatives. Given a numerical method of order \(n\), it is clear from the definition of order and the Taylor series expansion of the solution that the leading term of the local error takes the form \(C y_t^{(n+1)} h^{n+1}\) for some constant \(C\) independent of \(y\) and \(h\). In a similar fashion, the local error of a reversible solver (that is, the error in recovering the initial condition when the solver is run forwards and then backwards) has a leading term of the form \(Cy_t^{(m+1)}h^{m+1}\). As such, regularity of the solution trajectory \(y_t\) and its derivatives plays a significant role in the effectiveness of near-reversible methods such as EES schemes. To mitigate this effect, we apply a number of vector-field smoothing and guidance tricks (see 5.1).

3.2 Additional Reversible Solvers↩︎

For completeness, we also include Reversible Heun [25] and McCallum–Foster [28] in our experiments as additional reversible solvers for the diffusion ODE. We use the same probability-flow ODE parametrisation as in 3, but, based on the ablation in 11.2, we integrate it directly as a black-box vector field rather than using the rescaled form 14 . We discretise on a uniform \(t\)-grid \(t_0,t_1,\ldots,t_N\) and use the corresponding \(\lambda_{t_i}\) values. See 9 and 10 for the exact forms. In 5, we find that although these methods originate from the neural differential equations literature, they are competitive with the other diffusion samplers in our setting.

4 Stability↩︎

In this section, we show that EES methods offer significantly stronger stability guarantees than multi-step methods such as BELM, due to their near-symmetric properties and Runge–Kutta type.

4.1 Multi-Step Methods↩︎

It is well known that multi-step methods typically possess lower stability than one-step methods. A concrete example of this reduced stability is given by the second Dahlquist barrier [35], which famously states that no multi-step method of order greater than 2 can be A-stable.

The stability of multi-step methods can be difficult to analyse, especially in the case of time-varying coefficients such as the ones used by the BELM sampler 9 . A common proxy for the stability of a linear method is zero-stability, which requires that small perturbations to the initial condition lead to small changes in the numerical solution. An equivalent definition which is aligned closer with the notion of linear-stability of one-step methods is given by the following.

As discussed in [16], both DDIM and BELM are zero-stable, whilst the zero-stability of the EDICT and BDIA solvers is unclear. Whilst zero-stability is a useful metric for multi-step solvers, the condition is significantly weaker than that of the linear stability of one-step methods. As we will see, the stability guarantees of EES schemes far exceed those of zero-stability.

4.2 One-Step Methods↩︎

We begin by defining the more general notion of linear stability.

We note that linear stability is a more expressive notion of stability than zero-stability, as the latter corresponds to the case \(z = 0\).

As remarked in [25], this bounded-stability interval is also the absolute stability region for the reversible asynchronous leapfrog integrator [24]. Since \([-i,i]\) has empty interior in \(\mathbb{C}\), these methods are nowhere linearly stable. [17] further show that this is also the case for BDIA and fixed-step O-BELM. In contrast, the McCallum–Foster method has a non-trivial linear stability region, albeit smaller than that of the base solver [28]. We restate this result in 10.1. Rex inherits its non-zero stability guarantee from McCallum–Foster [17].

By forgoing exact reversibility, \(\mathrm{EES}\) methods are able to offer significantly larger stability domains, even when compared to classical Runge–Kutta methods. The stability domains of \(\mathrm{EES}(2,5)\) and \(\mathrm{EES}(2,7)\) are shown in Figure 6, and their exact forms are given in Appendix 8.1. \(\mathrm{EES}(2,5)\) possesses a stability domain comparable to that of RK4 whilst requiring one fewer stage. \(\mathrm{EES}(2,7)\) is considerably more stable than RK5 whilst requiring 2 fewer stages.

5 Experiments↩︎

In 5.1, we first isolate the role of trajectory regularity. The reconstruction experiments show that the EES reconstruction error grows with vector-field irregularity (i.e. high guidance scale), and that smoothing the vector field substantially reduces this error. This is consistent with the dependence of reversibility error on trajectory regularity discussed in 3.1. In the editing experiments, smoothing also improves background preservation for EES and yields gains for several other solvers.

We then evaluate the editing performance of each solver on the small edits PIE-Bench dataset in 5.2. 4 and ¿tbl:tab:solver95metrics? show the trade-off between background preservation and alignment with the intended edit. The optimal solver choice therefore depends on the user’s priorities, and the qualitative examples in 1 make this trade-off visible.

Finally, in 5.3, we test the solvers’ robustness under large edits. ¿tbl:tab:clip95whole95sd95vs95smooth? shows that solvers with smaller stability regions visibly degrade in edit quality when the sampling trajectory deviates substantially from the inverted path, whereas EES remains the most reliable of all (near) reversible solvers. Additional results and ablations can be found in 11.

Image editing setup. We use Stable Diffusion v1.5 [5] as the base model in all experiments. To compare methods under matched compute, we fix a budget of 48 model evaluations per sample and adjust the number of inference steps accordingly: 48 steps for BDIA, BELM, and DDIM; 24 steps for EDICT and Reversible Heun; 16 steps for EES(2,5); and 12 steps for EES(2,7). Rex and McCallum–Foster require twice as many model evaluations as their base solvers, making higher-order or adaptive-step variants too expensive for our 48-evaluation setup. Hence, we choose to benchmark against Rex/McCallum–Foster (Euler) and Rex/McCallum–Foster (Midpoint), using 24 and 12 steps, respectively. We use the standard inversion strength \(s=0.8\), as defined by EDICT, for the editing experiments in 5.1.2 and 5.2, and \(s=1\) in the stability study in 5.3, where stronger edits are required. Following previous work, we fix the editing guidance scale at \(g=3.0\). We keep the recommended hyperparameters for EDICT (\(p=0.93\)), BDIA \((\gamma=0.96)\), and Rex/McCallum–Foster (\(\zeta=0.999\)).

Editing benchmark and metrics. We evaluate on PIE-Bench [9], which contains 700 images spanning 10 edit types and provides a human-annotated editing mask for each example, together with source and target prompts. We report four metrics grouped into two aspects: (i) background preservation, measured outside the editing mask using LPIPS [36]; (ii) prompt–image consistency, measured by CLIP Similarity [37] on the masked region, PickScore [38], and ImageReward [39]. In extended results in 11, we also report PSNR as another background metric, and a CLIP Similarity on the whole image. Full implementation details are deferred to 12.

5.1 The Impact of Vector-Field Smoothness↩︎

We first study image reconstruction to isolate inversion error in EES schemes, and show that, as indicated in 3.1, swapping to a model version fine-tuned to produce smoother trajectories (Smooth Diffusion; [13]) substantially improves EES reversibility, which translates to better background preservation in image editing.

5.1.1 Image reconstruction↩︎

In image reconstruction, given an image–caption pair, we invert the image to obtain a latent \(x_T\) and then reconstruct by running the solver back to \(x_0\) with the same caption. We report pixel-space mean squared error (MSE) computed on pixels normalised to \([-1,1]\), averaged over 100 images from the MS COCO 2014 [40] Validation set. To match the image-editing setup, we fix a budget of 48 model evaluations per sample for all solvers.

Supporting [14], which observes that classifier-free guidance can induce vector-field roughness, 2 shows that the EES schemes incur increasing reconstruction error as guidance grows, whereas the exactly reversible solvers remain largely unaffected. Repeating the experiment with the Smooth Diffusion [13] fine-tuned Stable Diffusion 1.5 checkpoint substantially reduces this guidance sensitivity, suggesting that sufficiently smooth trajectories lead to reliable EES inversion.

5.1.2 Image editing↩︎

We now show that the importance of trajectory smoothness for EES inversion observed in 5.1.1 translates to image editing quality. In 3, we compare EES under Stable Diffusion 1.5 and its Smooth Diffusion [13] fine-tuned checkpoint. Using Smooth Diffusion largely preserves the background while still applying the intended edit. For quantitative evidence, we report full PIE-Bench results for both checkpoints across all solvers in ¿tbl:tab:solver95metrics95PIEBench95all?, and we also evaluate alternative smoothing heuristics that do not require changing the model, namely NPI and Proximal Guidance. Part 1 of 7 visualises how Smooth Diffusion shifts each solver’s editing metrics. Since Smooth Diffusion does not benefit every solver equally, in subsequent sections we report, for each solver, the best-performing variant.

5.2 Small Edits: Performance on PIE-Bench↩︎

We compare all solvers on PIE-Bench using the metrics in ¿tbl:tab:solver95metrics?. 4 summarises the main trade-off: improving prompt adherence tends to worsen background preservation. Exactly reversible solvers (e.g., EDICT) sit at the background-preserving end, while DDIM achieves strong prompt alignment but substantially degrades backgrounds. EES methods move the reversible frontier towards stronger edits, improving masked-region CLIP similarity while keeping background degradation substantially below DDIM.

We illustrate these trends qualitatively in 5, where EES preserves the background better than DDIM, and in row 1, 1 (a), where EES achieves visibly stronger edit fidelity than the other reversible solvers, with extended versions of these figures in Figures 16 and 17.

\begin{table}[t]

3.2pt

Solver	Background Quality	Edit Quality
	LPIPS\(\times 10^3\,\downarrow\)	CLIP (Edited)\(\,\uparrow\)	PickScore\(\,\uparrow\)	ImageReward\(\,\uparrow\)
(Near) reversible solvers
EDICT + Smooth	45.21\(^{\star}\)	21.26	21.34	0.08
Reversible Heun	52.45	21.41	21.18	0.05
BDIA	50.52	21.41	21.21	0.04
BELM + Smooth	75.24	21.28	20.97	0.02
MCF (Euler)	36.80	20.50	21.17	-0.17
MCF (Midpoint) + Smooth	41.37	20.68	21.20	-0.09
Rex (Midpoint) + Smooth	67.88	21.62	21.15	0.11
Rex (Euler) + Smooth	60.31	20.64	20.87	-0.18
EES(2,5) + Smooth	59.30	21.54\(^{\star}\)	21.30	0.11\(^{\star}\)
EES(2,7) + Smooth	62.52	21.64	21.30\(^{\star}\)	0.12

\vskip

-0.10in \end{table}

5.3 Large Edits and Stability↩︎

Here we highlight the main advantage of EES schemes over other reversible solvers: stability. We evaluate all solvers in regimes that induce large deviations from the original trajectory, and find that most exactly reversible solvers proposed in recent literature degrade substantially in edit quality, whereas EES remains stable and achieves the strongest performance across all metrics.

We construct a large-prompt-deviations experiment from the random images category of PIE-Bench (140 images). For each image, we shift the target prompt by one position in the dataset, so the edit prompt is typically unrelated to the source image and may require a large semantic change. Since the original edit masks are no longer meaningful, we evaluate prompt alignment using CLIP similarity on the full image as our main metric, alongside PickScore and ImageReward. Here, we report all results using the Smooth Diffusion checkpoint.

¿tbl:tab:clip95whole95sd95vs95smooth? shows that EES attains the strongest performance across metrics among the (near) reversible solvers under these large prompt deviations. Many exactly reversible solvers produce implausible outputs in this setting, failing to satisfy the new prompt condition when the required trajectory change is large. Rex (Midpoint) also does notably well, which is consistent with its non-trivial stability region. 1 (b) provides representative examples, with additional solvers in 18. Results for the base model and for the other smoothing methods are provided in ¿tbl:tab:clip95whole95by95setting?.

\begin{table}[t]

4.0pt

Solver	CLIP \(\uparrow\)	PickScore \(\uparrow\)	ImageReward \(\uparrow\)
Reversible solvers
EDICT	21.88	19.58	-0.97
Reversible Heun	20.12	19.20	-1.29
BDIA	20.77	19.27	-1.22
BELM	22.19	19.36	-0.94
McCallum-Foster (Euler)	11.49	17.49	-2.16
McCallum-Foster (Midpoint)	16.05	18.25	-1.97
Rex (Midpoint)	22.77\(^{\star}\)	19.68\(^{\star}\)	-0.85\(^{\star}\)
Rex (Euler)	15.17	17.50	-2.14
EES(2,5)	23.63	20.09	-0.57
EES(2,7)	23.66	20.09	-0.58

\vskip

-0.10in \end{table}

6 Conclusion and Limitations↩︎

We study reversible diffusion ODE solvers for inversion-based editing through the lens of editing stability, and show that exact reversibility alone is not enough: when an edit induces a large deviation from the inversion trajectory, existing reversible schemes can become numerically unstable and suffer sharp drops in quality. We address this with near-reversible EES solvers, which trade exact reversibility for substantially improved numerical stability. Empirically, EES is competitive with exactly reversible solvers on standard PIE-Bench edits and is the best-performing (near) reversible family in our study under large edits.

While solver design is a crucial building block, making (near) reversible solvers production-quality image editors will require integrating them into more powerful pipelines. We aim to move reversible solvers closer to this goal by connecting them with existing image editing work: incorporating smoothing tricks, exploring ODE parametrisations, and benchmarking on PIE-Bench. Many directions remain open for future work, such as combining EES with attention-preservation methods like Prompt-to-Prompt [29] or MasaCtrl [30] and extending evaluation beyond inversion-based methods (e.g., [32], [41], [42]).

Impact Statement↩︎

This paper presents work whose goal is to advance the field of machine learning. There are many potential societal consequences of our work, none of which we feel must be specifically highlighted here.

Acknowledgments↩︎

Barbora Barancikova is supported by UK Research and Innovation [UKRI Centre for Doctoral Training in AI for Healthcare grant number EP/S023283/1].

7 EES Schemes↩︎

In this section, we provide a brief account of Explicit and Effectively Symmetric (EES) Runge–Kutta schemes [18] and provide the general forms for \(\mathrm{EES}(2,5)\) and \(\mathrm{EES}(2,7)\) methods.

7.1 Runge–Kutta Schemes↩︎

Consider solving an ODE \(y' = f(t,y)\) numerically using a one-step method \[\label{1-stepmethod} y_{n+1} = y_n + h \Psi_h(t_n, y_n).\tag{17}\] The method \(\Psi_h\) is an \(s\)-stage Runge–Kutta (RK) method if \(\Psi\) can be written in the form \[\begin{align} y_{n+1} &= y_n + h \sum_{i=1}^s b_i k_i,\\ k_i &= f\left(t_n + c_i h, \, y_n + h\sum_{j=1}^{s} a_{ij} k_j\right), \quad i=1,\ldots,s, \end{align}\] with RK matrix \(A = (a_{ij})_{1 \leq i,j \leq s}\), weights \(b = (b_i)_{1 \leq i \leq s}\) and nodes \(c = (c_i)_{1 \leq i \leq s}\). These coefficients are typically collected in the Butcher tableau of the scheme \[\begin{array}{c|ccccc} c_1 &a_{11} & a_{12} &\cdots& a_{1s}&\\ c_2 & a_{21} & a_{22}&\cdots&a_{2s}&\\ \vdots & \vdots & \vdots & \ddots & \vdots\\ c_s & a_{s1} & a_{s2} & \cdots & a_{s, s} &\\ \hline & b_1 & b_2 & \cdots & b_s \end{array}\]

In the case of an explicit scheme, the coefficients must satisfy \(a_{ij} = 0\) for all \(i \leq j\). In this case, the Butcher tableau takes the form

\[\begin{array}{c|cccccc} 0 &&&&&&\\ c_2 & a_{21} &&&&&\\ c_3 & a_{31} & a_{32} &&&&\\ c_4 & a_{41} & a_{42} & a_{43} &&&\\ \vdots & \vdots & \vdots & \vdots & \ddots &\\ c_s & a_{s1} & a_{s2} & a_{s3} & \cdots & a_{s, s-1} &\\ \hline & b_1 & b_2 & b_3 & \cdots & b_{s-1} & b_s \end{array}\]

7.2 Explicit and Effectively Symmetric (EES) Schemes↩︎

Following [18], we refer to the scheme with parameter \(x\) as \(\mathrm{EES}(2,5;x)\). In particular, \(\mathrm{EES}(2,5;1/10)\) has the Butcher tableau:

\[{\renewcommand{1.15}{1.2} \begin{array}{c|ccc} 0 &&&\\ 1/3 & 1/3 &&\\ 5/6 & -5/48 & 15/16 &\\ \hline & 1/10 & 1/2 & 2/5 \end{array} } \label{eq:butcher95ees9525}\tag{18}\]

Following [18], we will refer to \(\mathrm{EES}(2,5;1/10)\) as the \(\mathrm{EES}(2,5)\) method.

Following [18], we refer to the scheme with positive \(\sqrt{2}\) and parameter \(x\) as \(\mathrm{EES}(2,7;x)\). In particular, \(\mathrm{EES}(2,7;\frac{1}{14}(5-3\sqrt{2}))\) has the Butcher tableau:

\[{\renewcommand{1.15}{2} \begin{array}{c|cccc} 0&&&\\ \frac{1}{3}(2-\sqrt{2}) & \frac{1}{3}(2-\sqrt{2})&&&\\[7pt] \frac{1}{6}(2 + \sqrt{2}) & \frac{1}{24}(-4+\sqrt{2}) & \frac{1}{8}(4 + \sqrt{2})\displaystyle &&\\[7pt] \frac{1}{6}(4 + \sqrt{2}) &\frac{1}{168}(-176+145\sqrt{2}) &\frac{3}{56}(8-5\sqrt{2})&\frac{3}{7}(3-\sqrt{2})&\\[7pt] \hline & \frac{1}{14}(5-3\sqrt{2}) & \frac{1}{14}(3 + \sqrt{2}) & \frac{3}{14}(-1+2\sqrt{2}) & \frac{1}{14}(9-4\sqrt{2}) \end{array} } \label{eq:butcher95ees9527}\tag{19}\]

Following [18], we will refer to \(\mathrm{EES}(2,7;\frac{1}{14}(5-3\sqrt{2}))\) as the \(\mathrm{EES}(2,7)\) method.

8 Stability↩︎

8.1 Linear Stability of EES Methods↩︎

The stability domains of \(\mathrm{EES}(2,5)\) and \(\mathrm{EES}(2,7)\) are shown in Figure 6.

9 Reversible Heun↩︎

The Reversible Heun scheme introduced in [25] is an algebraically reversible analogue of the classical Heun Runge-Kutta scheme. The scheme is efficient, requiring only one function evaluation per step, but it suffers from particularly low linear stability, as noted in 4.

We maintain three quantities at each step, \(x_n\), \(\hat{x}_n\), and \(k_n\), where \(k_n = f(\hat{x}_n, t_n)\). We initialise \(\hat{x}_0 = x_0\) and \(k_0 = f(x_0, t_0)\). The forward update from \(t_n\) to \(t_{n+1}\) is \[\hat{x}_{n+1} = 2x_n - \hat{x}_n + hk_n,\] \[k_{n+1} = f(\hat{x}_{n+1}, t_{n+1}),\] \[x_{n+1} = x_n + \frac{h}{2}\bigl(k_n + k_{n+1}\bigr).\] To step backwards from \(t_{n+1}\) to \(t_n\), we use \[\hat{x}_n = 2x_{n+1} - \hat{x}_{n+1} - hk_{n+1},\] \[k_n = f(\hat{x}_n, t_n),\] \[x_n = x_{n+1} - \frac{h}{2}\bigl(k_n + k_{n+1}\bigr).\] Therefore, in addition to storing \(x_N\) (and the endpoint time \(t_N\)), we also need to store the endpoint values \(\hat{x}_N\) and \(k_N\).

10 McCallum–Foster↩︎

The McCallum–Foster scheme [28] gives a general construction for turning any explicit single-step ODE solver into an algebraically reversible solver. The order of the resulting method is inherited from the chosen base solver. The method also has improved linear stability over Reversible Heun, controlled by a coupling parameter \(\zeta\).

Let \(\Psi_h(t,x)\) denote the one-step increment of the chosen base solver, so that the corresponding non-reversible step is \(x_{n+1}=x_n+\Psi_h(t_n,x_n)\). We maintain two quantities at each step, \(x_n\) and \(\hat{x}_n\), and initialise \(\hat{x}_0=x_0\). For \(\zeta\in(0,1]\), the forward update from \(t_n\) to \(t_{n+1}\) is \[x_{n+1} = \zeta x_n + (1-\zeta)\hat{x}_n + \Psi_h(t_n,\hat{x}_n),\] \[\hat{x}_{n+1} = \hat{x}_n - \Psi_{-h}(t_{n+1},x_{n+1}).\] To step backwards from \(t_{n+1}\) to \(t_n\), we use \[\hat{x}_n = \hat{x}_{n+1} + \Psi_{-h}(t_{n+1},x_{n+1}),\] \[x_n = \zeta^{-1}x_{n+1} + (1-\zeta^{-1})\hat{x}_n - \zeta^{-1}\Psi_h(t_n,\hat{x}_n).\] Therefore, in addition to storing \(x_N\) and the endpoint time \(t_N\), we also need to store the endpoint value \(\hat{x}_N\).

10.1 Linear stability↩︎

[28] characterise the linear stability region of the McCallum–Foster method. Consider the scalar test equation \(\dot{y}=\lambda y\), with \(\lambda<0\), and let \(z=h\lambda\). Following their notation, let \(R\) denote the transfer function of the base solver increment, so that \[\Psi_h(t_n,y_n)=R(z)y_n .\] Then the reversible scheme is linearly stable if and only if \[|\Gamma(z)| < 1+\zeta, \qquad \Gamma(z) = 1+\zeta - (1-\zeta)R(-z) - R(-z)R(z).\] Thus, for any explicit Runge–Kutta base method, the stability region is obtained by substituting the corresponding \(R\). The resulting region is smaller than that of the base method, but remains non-trivial.

11 Additional Experiments↩︎

Beyond the experiments in the main paper, in 11.1 we report the full results of our image editing experiments, with and without Smooth Diffusion, and with three additional vector-field smoothing variants. In 11.2, we report the results of a large ablation over the ODE parametrisation, the step discretisation schedule, and whether the solver is applied in a semilinear integrating-factor form or a black-box form. This ablation justifies the solver forms proposed in 3 and highlights alternative forms that may also be used.

We provide additional results for greyscale image editing in 11.3, experiments using SDXL in 11.4, results across different numbers of function evaluations in 11.5, and alternative EDICT and BDIA hyperparameter settings in 11.6. We also characterise the distribution of the inverted variable in 11.7 and study the effect of varying the guidance scale in 11.8.

11.1 Smoothing Method Ablation↩︎

Here, we study the impact of vector-field smoothing methods previously proposed to improve DDIM inversion and DDIM-based editing, and evaluate them on reversible and near-reversible solvers. To our knowledge, this has not been previously reported. We hope this study helps position reversible solvers within the broader DDIM inversion literature, where smoothing methods are widely used but typically treated as orthogonal to solver design.

It is well known that DDIM inversion error typically increases with the classifier-free guidance scale, and several works propose inference-time tricks to mitigate this effect. Unlike Smooth Diffusion, these approaches do not modify model parameters. Instead, they change how conditioning is applied during inversion and/or sampling.

11.1.0.1 Vector-field smoothing and guidance tricks.

Negative Prompt Inversion (NPI) [12] sets \(c_{\texttt{null}} := c_{\texttt{src}}\), so the reverse-direction guidance cancels and the inversion becomes guidance-free: \(\hat{\epsilon}_\theta(x_t, t, c_{\texttt{src}})=\epsilon_\theta(x_t, t, c_{\texttt{src}}).\) Proximal Guidance (Prox) [11] further reduces guidance in the forward (editing) direction by setting the guidance scale to \(g=1\) at spatial locations where the conditional predictions for the source and target prompts are already similar, that is, where \(\left\lVert \epsilon_\theta(x_t,t,c_{\texttt{trg}})-\epsilon_\theta(x_t,t,c_{\texttt{src}})\right\rVert_2\) is small. Intuitively, Prox suppresses unnecessary conditional forcing in regions that are unlikely to change, which can reduce background drift. Both NPI and Prox were originally introduced in the context of DDIM-based editing. Here, we apply them across all solvers. Smooth Diffusion [13] fine-tunes Stable Diffusion to produce smoother trajectories and reports improved DDIM inversion and editing. Since it changes the underlying model dynamics, it is complementary to NPI and Prox.

Throughout this appendix, we use “smoothing method” as an umbrella term for both model-based smoothing (Smooth Diffusion) and inference-time guidance tricks (such as NPI and Proximal Guidance) that are designed to reduce inversion error and background drift.

11.1.0.2 Results and qualitative examples.

We report PIE-Bench image-editing results for each smoothing method in ¿tbl:tab:solver95metrics95PIEBench95all?. In 7, we visualise the corresponding metric shifts for each solver under smoothing. We also report CLIP scores for the large prompt-deviation editing task (5.3) in ¿tbl:tab:clip95whole95by95setting?.

\begin{table}[tbp]

6.0pt

Solver	Stable Diffusion 1.5	Stable Diffusion 1.5 + Smooth Diffusion	Stable Diffusion 1.5 + Negative Prompt Inversion	Stable Diffusion 1.5 + Proximal Guidance	Stable Diffusion 1.5 + Smooth Diffusion + Proximal Guidance
EDICT	24.15	24.17	24.51	24.48	24.19
Reversible Heun	24.27	23.89	24.28	24.19	23.86
BDIA	24.33	24.07	24.34	24.25	24.02
BELM	23.91	24.21	24.32	24.28	24.25
DDIM	23.85	24.53	24.49	24.42	24.38
Rex (Euler)	22.67	23.57	23.93	23.99	23.72
Rex (Midpoint)	22.93	24.54	24.50	24.51	24.52
McCallum–Foster (Euler)	23.24	23.18	23.20	23.14	23.08
McCallum–Foster (Midpoint)	23.49	23.59	23.68	23.65	23.63
EES(2,5)	24.21	24.37	24.47	24.38	24.25
EES(2,7)	24.36	24.47	24.60	24.52	24.35
CLIP Similarity: Edited\(\,\uparrow\)
EDICT	21.45	21.26	21.73	21.66	21.26
Reversible Heun	21.41	21.05	21.43	21.33	20.99
BDIA	21.41	21.11	21.38	21.33	21.08
BELM	21.02	21.28	21.56	21.51	21.41
DDIM	21.33	21.59	21.78	21.71	21.41
Rex (Euler)	20.16	20.64	20.78	20.85	20.87
Rex (Midpoint)	20.56	21.62	21.86	21.72	21.62
McCallum–Foster (Euler)	20.50	20.42	20.44	20.39	20.31
McCallum–Foster (Midpoint)	20.70	20.68	20.85	20.85	20.80
EES(2,5)	21.57	21.54	21.77	21.65	21.44
EES(2,7)	21.80	21.64	21.89	21.83	21.51
EDICT	25.18	28.12	26.18	26.54	28.45
Reversible Heun	27.59	28.89	28.22	28.52	29.29
BDIA	27.99	28.91	28.33	28.59	29.25
BELM	22.55	25.90	24.17	24.55	27.01
DDIM	22.36	26.20	24.27	24.61	27.06
Rex (Euler)	21.74	26.37	23.97	23.78	26.69
Rex (Midpoint)	21.79	26.35	23.90	24.02	27.17
McCallum–Foster (Euler)	29.54	29.80	29.75	29.87	30.02
McCallum–Foster (Midpoint)	27.74	28.81	28.32	28.45	29.00
EES(2,5)	23.38	27.26	25.25	25.58	27.97
EES(2,7)	22.75	26.89	24.64	24.98	27.70
LPIPS\(\times 10^3\,\downarrow\)
EDICT	79.91	45.21	66.55	61.71	43.05
Reversible Heun	52.45	39.50	46.44	43.63	37.11
BDIA	50.52	40.86	47.76	44.82	38.58
BELM	131.14	75.24	104.48	97.65	61.93
DDIM	148.43	81.43	116.97	109.76	70.60
Rex (Euler)	136.31	60.31	96.05	110.52	65.41
Rex (Midpoint)	143.03	67.88	105.77	105.92	59.80
McCallum–Foster (Euler)	36.80	34.50	35.55	34.85	33.62
McCallum–Foster (Midpoint)	52.33	41.37	46.38	46.51	41.46
EES(2,5)	117.03	59.30	87.63	81.32	50.83
EES(2,7)	126.89	62.52	96.16	89.09	53.10

\vskip

-0.10in \end{table}

\begin{table}[tbp]

3.0pt

Solver	CLIP Similarity (Whole) \(\uparrow\)
	Stable Diffusion 1.5	Stable Diffusion 1.5 + Smooth Diffusion	Stable Diffusion 1.5 + Negative Prompt Inversion	Stable Diffusion 1.5 + Proximal Guidance	Stable Diffusion 1.5 + Smooth Diffusion + Proximal Guidance
EDICT	23.11	21.88	23.85	23.57	22.11
Reversible Heun	21.74	20.12	21.58	21.03	19.51
BDIA	21.09	20.77	21.11	20.55	20.39
BELM	20.18	22.19	22.98	22.71	22.28
Rex (Euler)	15.39	15.17	15.29	15.54	15.22
Rex (Midpoint)	18.45	22.77	22.42	20.22	20.95
McCallum–Foster (Euler)	12.44	11.49	11.85	11.42	10.95
McCallum–Foster (Midpoint)	16.02	16.05	15.02	14.65	15.12
EES(2,5)	24.12	23.63	25.15	24.77	23.31
EES(2,7)	24.40	23.66	25.05	24.83	23.39
DDIM	23.97	23.90	25.30	25.12	23.78

\vskip

-0.10in \end{table}

11.2 ODE Formulation Ablations↩︎

In this section, we summarise the design choices underlying our proposed diffusion samplers—namely the ODE parametrisation (11.2.1), the step discretisation schedule (11.2.3), and whether the solver is applied in a semilinear integrating-factor form or a black-box form (11.2.2). We then report, in 11.2.4, a systematic evaluation of these variants for each proposed solver.

11.2.1 ODE Parametrisation↩︎

For an unknown data distribution \(q_0(x_0)\) of \(d\)-dimensional images \(x_0 \in \mathbb{R}^d\), we consider a variance-preserving (VP) diffusion model whose forward perturbation marginals at time \(t \in [0, T]\), \(T>0\) satisfy \[q_{t}(x_t\mid x_0)=\mathcal{N}(x_t\mid \alpha_t x_0,\sigma_t^2 I), \qquad \alpha_t^2+\sigma_t^2=1, \qquad \alpha_t, \sigma_t>0\] so that \(x_t=\alpha_t x_0+\sigma_t\epsilon\) with \(\epsilon\sim\mathcal{N}(0,I)\). The corresponding probability-flow ODE can be written in the standard form \[\frac{dx_t}{dt}=f(t)\,x_t+\frac{g(t)^2}{2\sigma_t}\,\epsilon_\theta(x_t,t), \qquad f(t)=\frac{d\log \alpha_t}{dt}, \quad g(t)^2=\frac{d\sigma_t^2}{dt}-2f(t)\sigma_t^2.\]

From \(\alpha_t^2+\sigma_t^2=1\), we then have \[\frac{d\sigma_t^2}{dt}=-\frac{d\alpha_t^2}{dt}=-2\alpha_t\frac{d\alpha_t}{dt}=-2\alpha_t^2 f(t), \quad\Longrightarrow\quad g(t)^2=-2f(t),\] and therefore \[\frac{dx_t}{dt} = f(t)\Bigl(x_t-\epsilon_\theta(x_t,t)/\sigma_t\Bigr) = \frac{d}{dt}\bigl[\log \alpha_t\bigr]\, \Bigl(x_t-\epsilon_\theta(x_t,t)/\sigma_t\Bigr). \label{eq:ode95t95original}\tag{20}\]

11.2.1.1 Discrete-time schedules.

The above ODE form does not prevent us from supporting discrete-time diffusion models, for which the noise schedule is defined at a discrete set of times \(\alpha_0, \alpha_1\ldots,\alpha_T\). Following the implementation in DPM [33], we construct a continuous \(\alpha_t\) by linearly interpolating \(\log\alpha_t\) between neighbouring discrete timesteps. We then set \(\sigma_t=\sqrt{1-\alpha_t^2}\). While 20 is convenient conceptually, it requires approximating the gradient \(d(\log\alpha_t)/dt\), as part of the vector field. We therefore consider the following equivalent reparametrisations.

11.2.1.2 Half-logSNR parametrisation (\(\epsilon\)-prediction).

Define the variable \(\lambda_t\) as \[\lambda_t:=\log\frac{\alpha_t}{\sigma_t}=\log\alpha_t-\log\sigma_t,\] which is strictly decreasing in \(t\) and hence invertible. For VP schedules one can show \(\frac{d\log \alpha_\lambda}{d\lambda}=\sigma_\lambda^2\), and by change-of-variables the ODE becomes \[\frac{dx_\lambda}{d\lambda} = \sigma_\lambda^2\,x_\lambda-\sigma_\lambda\,\epsilon_\theta(x_\lambda,\lambda). \label{eq:ode95lambda95eps}\tag{21}\] This is the \(\lambda\)-domain diffusion ODE used by DPM-Solver [33].

11.2.1.3 Half-logSNR parametrisation (\(x_0\)-prediction).

DPM-Solver++ [34] instead solves the equivalent ODE expressed in terms of the data predictor \[x_\theta(x_t,t):=\frac{x_t-\sigma_t\epsilon_\theta(x_t,t)}{\alpha_t}.\] Substituting \(\sigma_\lambda\epsilon_\theta=x_\lambda-\alpha_\lambda x_\theta\) into 21 gives \[\frac{dx_\lambda}{d\lambda} = -\alpha_\lambda^2\,x_\lambda+\alpha_\lambda\,x_\theta(x_\lambda,\lambda). \label{eq:ode95lambda95x0}\tag{22}\]

11.2.1.4 Scaled-noise parametrisation.

One can also define the integration variable \[u_t:=\frac{\sigma_t}{\alpha_t}=e^{-\lambda_t}, \qquad z_t:=\frac{x_t}{\alpha_t}.\] Then \(z_t=x_0+u_t\epsilon\), and using \(x_\theta=z_t-u_t\epsilon_\theta\) we obtain the DDIM-style ODE used in BELM [16] \[\frac{dz}{du} = \epsilon_\theta(x_t,t) = \frac{z-x_\theta(z,u)}{u}, \qquad x_t=\alpha_t z. \label{eq:ode95u95ddim}\tag{23}\] Notably, this parametrisation removes the linear drift term entirely, so it can be treated as a purely non-linear ODE.

11.2.2 Semilinear vs.black-box↩︎

A semilinear ODE in a variable \(\lambda\) has the form \[\frac{dx_\lambda}{d\lambda}=a_\lambda x_\lambda+b(x_\lambda,\lambda),\] where \(b\) is non-linear (and in our setting contains a neural network). Black-box solvers (e.g.standard Runge–Kutta) discretise the full right-hand side, introducing discretisation error in both the linear and non-linear terms. In contrast, one can also solve such ODE using the integrating factor method, which solves the linear part exactly and leaves only a weighted integral of the non-linear part.

11.2.2.1 The integrating factor method.

Define \[I_\lambda=\exp\!\Bigl(-\int^{\lambda} a_u\,du\Bigr), \qquad y_\lambda=I_\lambda x_\lambda.\] Then \(y_\lambda\) satisfies \[\frac{dy_\lambda}{d\lambda} = I_\lambda\,b\!\Bigl(\frac{y_\lambda}{I_\lambda},\lambda\Bigr), \qquad x_\lambda=\frac{y_\lambda}{I_\lambda}.\]

Since equations 21 and 22 are semilinear and the integrating factors simplify to \(\frac{1}{\alpha_\lambda}\) and \(\frac{1}{\sigma_\lambda}\), this method is of great convenience. We now present the solutions of the respective equations using the integrating factor method.

11.2.2.2 The solution to \(\epsilon\)-prediction in \(\lambda\).

For 21 , we have \(a_\lambda=\sigma_\lambda^2\) and \(b(x,\lambda)=-\sigma_\lambda\epsilon_\theta(x,\lambda)\). Using \(d\log\alpha_\lambda/d\lambda=\sigma_\lambda^2\), the integrating factor is \(I_\lambda = 1/\alpha_\lambda\), so taking \[y_\lambda=\frac{x_\lambda}{\alpha_\lambda}\] gives \[\frac{dy_\lambda}{d\lambda} = -\frac{\sigma_\lambda}{\alpha_\lambda}\,\epsilon_\theta(x_\lambda,\lambda) = -\,e^{-\lambda}\,\epsilon_\theta(x_\lambda,\lambda), \qquad x_\lambda=\alpha_\lambda y_\lambda. \label{eq:ode95lambda95eps95semilinear}\tag{24}\] Integrating over \([\lambda_s,\lambda_t]\) yields \[y_{\lambda_t}=y_{\lambda_s}-\int_{\lambda_s}^{\lambda_t} e^{-u}\,\epsilon_\theta(x_u,u)\,du,\] and mapping back to \(x_\lambda\) recovers the DPM-Solver exact-solution form \[x_{\lambda_t} = \frac{\alpha_{\lambda_t}}{\alpha_{\lambda_s}}\,x_{\lambda_s} -\alpha_{\lambda_t}\int_{\lambda_s}^{\lambda_t} e^{-u}\,\epsilon_\theta(x_u,u)\,du. \label{eq:ode95lambda95eps95exact}\tag{25}\]

11.2.2.3 The solution to \(x_0\)-prediction in \(\lambda\).

For 22 , we have \(a_\lambda=-\alpha_\lambda^2\) and \(b(x,\lambda)=\alpha_\lambda x_\theta(x,\lambda)\). Since \(d\log\sigma_\lambda/d\lambda=-\alpha_\lambda^2\), we get \(I_\lambda= 1/\sigma_\lambda\), and with \[y_\lambda=\frac{x_\lambda}{\sigma_\lambda}\] we obtain \[\frac{dy_\lambda}{d\lambda} = \frac{\alpha_\lambda}{\sigma_\lambda}\,x_\theta(x_\lambda,\lambda) = e^{\lambda}\,x_\theta(x_\lambda,\lambda). \label{eq:ode95lambda95x095semilinear}\tag{26}\] Hence, the corresponding exact-solution form is \[x_{\lambda_t} = \frac{\sigma_{\lambda_t}}{\sigma_{\lambda_s}}\,x_{\lambda_s} +\sigma_{\lambda_t}\int_{\lambda_s}^{\lambda_t} e^{u}\,x_\theta(x_u,u)\,du, \label{eq:ode95lambda95x095exact}\tag{27}\] which is precisely the DPM-Solver++ reformulation.

11.2.2.4 “Semilinear” solvers.

When we report the metrics for a semilinear solver in 11.2.4, we apply the numerical method to the transformed ODE in \(y\) (i.e. 24 , 26 ) and then map back to \(x\). When we report a black-box solver, we apply the same numerical method directly to the original ODE in \(x\) (i.e.@eq:eq:ode95lambda95eps , 22 ). Finally, the scaled-noise parametrisation 23 has no linear drift term, so it does not require an integrating factor.

11.2.3 Step discretisation schedule↩︎

For each ODE parametrisation, we consider two choices of step schedule.

11.2.3.1 Uniform steps in the integration variable.

Given an integration variable \(\tau\) (such as \(\lambda, u\)), we take \(\tau\)-uniform steps by linearly spacing the grid \(\{\tau_0,\dots,\tau_N\}\) between the endpoints and applying the solver with constant step size \(\Delta\tau=(\tau_N-\tau_0)/N\).

11.2.3.2 Steps induced by a uniform \(t\)-grid.

Alternatively, we start from a uniform grid in the original diffusion time \(t\), i.e.\(t_i=i/N\), and map it to the integration variable \(\tau\) via \(\tau_i:=\tau(t_i)\). This yields a non-uniform step size \(\Delta\tau_i=\tau_{i+1}-\tau_i\).

11.2.4 Results↩︎

To evaluate a given ODE configuration, we run the 140 editing tasks in the random images category of PIE-Bench and report CLIP and LPIPS. 8 shows a systematic evaluation over the three design dimensions introduced above and motivates the configurations used in 3. For the EES schemes, edit fidelity is already strong across settings, so we select the variant that most consistently improves background preservation. This corresponds to the semilinear formulation with \(\lambda\)-uniform discretisation and the half-logSNR \(x\)-parameterisation for both EES(2,5) and EES(2,7). Across solvers, \(\lambda\)-uniform discretisation tends to yield better reversibility than \(t\)-uniform discretisation, while the remaining design dimensions have a smaller effect.

For Reversible Heun, which is already strong in reversibility relative to other solvers, we choose the configuration with the best overall balance of edit alignment and background preservation. This is the black-box formulation with \(t\)-uniform discretisation and the half-logSNR \(x\)-parameterisation. The difference between half-logSNR \(x\)- and \(\epsilon\)-parameterisations is minor in this setting. We also observe that, for Reversible Heun, the black-box formulation generally outperforms the semilinear one. We use the same choices for our implementation of McCallum-Foster (Euler) and McCallum-Foster (Midpoint).

We have observed slow convergence for the semilinear formulation when using the half-logSNR in \(x\) parametrisation with a \(t\)-uniform discretisation, and the scaled-noise parametrisation with a \(u\)-uniform discretisation. They do not produce satisfactory images in our setting of \(48\) model evaluations. We therefore omit these combinations from further study.

11.3 Greyscale↩︎

We additionally observe failures of non-EES reversible solvers even when the edit prompt is semantically close to the source prompt but requires a large structured visual change in the image (e.g., removing colour). In the greyscale conversion task, these solvers often retain residual colour or introduce artefacts, whereas EES produces a more consistent greyscale edit. 1 shows a representative example, and an extended grid with all solvers and additional examples is provided in 9.

11.4 Stable Diffusion XL↩︎

To show consistency across models, we reproduce the main results in 4, ¿tbl:tab:solver95metrics?, and ¿tbl:tab:clip95whole95sd95vs95smooth? using the Stable Diffusion XL (SDXL) [43] model instead of Stable Diffusion 1.5. In 10, we show the background preservation and edit quality trade-off on the small edits task. Since there is no Smooth Diffusion checkpoint for SDXL, we instead use NPI as our smoothing method of choice, which we have shown in 11.1 to have a similar effect. As in 5.2, we use the smoothing method only for the solvers for which it is beneficial. In ¿tbl:tab:main95solver95metrics95sdxl95npi?, we show the equivalent of ¿tbl:tab:solver95metrics? and ¿tbl:tab:clip95whole95sd95vs95smooth? with all metrics for SDXL. For large edits, we use NPI with all solvers. We run all the experiments in this section on Category 0 of PIE-Bench.

\begin{table}[tbp]

2.6pt

(Near) Reversible Solver	Small Edits					Large Edits
2-6 (lr)7-9	Background Preservation		Edit Quality			Edit Quality
2-3 (lr)4-6 (lr)7-9	PSNR\(\,\uparrow\)	LPIPS\(\times 10^3\,\downarrow\)	CLIP (Edited)\(\,\uparrow\)	PickScore\(\,\uparrow\)	ImageReward\(\,\uparrow\)	CLIP (Whole)\(\,\uparrow\)	PickScore\(\,\uparrow\)	ImageReward\(\,\uparrow\)
EDICT\(^{\dagger}\)	30.17	50.89	22.28	21.09\(^{\star}\)	0.03	23.59\(^{\star}\)	20.01\(^{\star}\)	-0.49\(^{\star}\)
Reversible Heun	31.66\(^{\star}\)	43.88	21.68	20.97	-0.06	21.06	19.00	-1.35
BDIA	32.01	48.90\(^{\star}\)	21.82	21.00	-0.15	19.93	18.73	-1.58
BELM\(^{\dagger}\)	27.03	121.78	21.17	20.22	-0.34	18.37	18.09	-1.67
McCallum-Foster (Euler)	33.25	40.22	20.90	20.78	-0.37	13.13	17.42	-2.15
McCallum-Foster (Midpoint)\(^{\dagger}\)	30.77	78.19	21.03	20.57	-0.38	13.96	17.36	-2.16
Rex (Midpoint)\(^{\dagger}\)	27.26	97.75	21.72	20.52	-0.16	20.30	18.36	-1.57
Rex (Euler)\(^{\dagger}\)	26.74	105.70	20.41	20.08	-0.52	14.39	17.14	-2.16
EES(2,5)\(^{\dagger}\)	29.55	63.72	22.22\(^{\star}\)	21.21	0.01\(^{\star}\)	25.01	21.07	0.12
EES(2,7)\(^{\dagger}\)	28.48	74.39	22.31	21.26	0.08	25.11	21.09	0.18

\vskip

-0.10in \end{table}

11.5 Varying the Number of Function Evaluations↩︎

In 11, we report how the trade-off described in 4 behaves under varied model evaluations budgets.

11.6 EDICT and BDIA hyperparameters↩︎

EDICT and BDIA include a hyperparameter controlling how strongly the solver follows the edited prompt, with recommended values in \([0.9,1.0]\). One might expect that tuning these values could recover stability under large edits. However, we find that varying \(\gamma\) (BDIA) and \(p\) (EDICT) does not resolve the failures above. 12 illustrates this on an example from the task in 5.3.

11.7 Terminal Latent Distribution under Inversion↩︎

Motivated by recent observations that diffusion inversion can suffer from numerical singularities, causing the inverted terminal latent \(x_T\) to deviate substantially from the intended isotropic Gaussian prior \(\mathcal{N}(0,I)\) [17], [44], we visualise the empirical distribution of the terminal latents \(x_T\) for the image shown in 3. 13 compares all solvers across three NFE settings against the standard normal density. While most methods including EES remain well aligned with \(\mathcal{N}(0,1)\), EDICT and BDIA become increasingly unstable as the NFE increases, with the variance of the inverted latent growing by several orders of magnitude. This provides a possible explanation for their degradation in CLIP score at higher NFE, as shown in 11.5. See [17] for further discussion about this phenomenon.

11.8 Varying the Guidance Scale↩︎

In 14, we study how the edit quality and background preservation trade-off changes as the guidance scale is varied. We evaluate guidance scales \(1.0\), \(2.0\), and \(3.0\) on Category 0 of PIE-Bench, using Smooth Diffusion for all solvers. As expected, increasing the guidance scale generally improves prompt alignment, but worsens background preservation.

12 Experiments Supplement↩︎

12.1 Pretrained Models↩︎

We use the following pretrained models in all experiments:

Stable Diffusion 1.5:

https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5

Smooth Diffusion:

https://huggingface.co/shi-labs/smooth-diffusion-lora

Stable Diffusion XL:

https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0

12.2 Code Implementations↩︎

We implement BELM, EDICT, DDIM, and BDIA using the public BELM codebase: https://github.com/zituitui/BELM/tree/main. We implement Rex using the code provided in [17]. We implement McCallum–Foster directly from the update equations in 10 using Euler and Midpoint base solvers.

We note that the BELM repository contains a bug in the BDIA implementation, which has been reported in an open issue (#13). We correct this error in our code.

12.3 Wall-Clock Time Comparison↩︎

As stated in the image editing setup in 5, we align all methods by the number of function evaluations (NFE), so that higher-order solvers do not receive an unfair compute advantage. Wall-clock time is dominated by model evaluations, while the numerical overhead of each solver is comparatively small. Using the Smooth Diffusion SD 1.5 checkpoint introduces negligible overhead. We report wall-clock timings for the standard 48-evaluation editing setup in 1, measured on a single NVIDIA GeForce RTX 4070 Ti GPU.

12.4 Supplemental Figures↩︎

We present the following supplemental figures.

• 15: Extended small-edit example (retriever).

• 16: Extended small-edit example (storm trooper).

• 17: Extended small-edit example (owl).

• 18: Extended large-edit example (retriever).

12.5 Dataset↩︎

We use PIE-Bench [9] for image editing evaluation. Its annotations are licensed under CC-BY-NC-SA 4.0. The qualitative examples in this paper are shown for non-commercial academic use only.

References↩︎