There and Back Again: On the relation between Noise and Image Inversions in Diffusion Models

## Abstract

Abstract Diffusion Models achieve state-of-the-art performance in generating new samples but lack a low-dimensional latent space that encodes the data into editable features. Inversion-based methods address this by reversing the denoising trajectory, transferring images to their approximated starting noise. In this work, we thoroughly analyze this procedure and focus on the relation between the initial noise , the generated samples , and their corresponding latent encodings obtained through the DDIM inversion. First, we show that latents exhibit structural patterns in the form of less diverse noise predicted for smooth image areas (e.g., plain sky). Through a series of analyses, we trace this issue to the first inversion steps, which fail to provide accurate and diverse noise. Consequently, the DDIM inversion space is notably less manipulative than the original noise. We show that prior inversion methods do not fully resolve this issue, but our simple fix, where we replace the first DDIM Inversion steps with a forward diffusion process, successfully decorrelates latent encodings and enables higher quality editions and interpolations. The code is available at https://github.com/luk-st/taba .

## 1 Introduction

Figure: Figure 1: DDIM inversion produces latent encodings that exhibit less diverse noise in the smooth image areas than in the non-plain one. We attribute this problem to the errors of noise prediction in the first inversion steps.
Refer to caption: x1.png

Diffusion-based probabilistic models (DMs), (Sohl-Dickstein et al., 2015), have achieved state-of-the-art results in many generative domains including image (Dhariwal & Nichol, 2021), speech (Popov et al., 2021), video (Ho et al., 2022), and music (Liu et al., 2021) synthesis. Nevertheless, one of the significant drawbacks that distinguishes diffusion-based approaches from other generative models like Variational Autoencoders (Kingma & Welling, 2014) is the lack of an implicit latent space that encodes the images into low-dimensional, interpretable, or editable representations.

To mitigate this issue, several works seek meaningful relations in the approximated starting noise used for generations.
This method, known as an inversion technique, was introduced by Song et al. (2021) with Denoising Diffusion Implicit Models (DDIM), and led to the proliferation of works (Garibi et al., 2024; Mokady et al., 2023; Huberman-Spiegelglas et al., 2024; Samuel et al.,; Hong et al., 2024; Parmar et al., 2023). The core idea is to use the noise predicted by the Diffusion Model and add it to the image instead of subtracting it. Repeating this process effectively traces the backward diffusion trajectory, approximating the *noise* that could have generated the *image*. However, due to approximation errors and biases introduced by the trained model, discrepancies arise between the original noise and its reconstruction – *latent* representation.

While recent works (Garibi et al., 2024; Mokady et al., 2023; Parmar et al., 2023; Huberman-Spiegelglas et al., 2024; Zheng et al., 2024) try to improve the inversion procedure from the perspective of tasks such as image reconstruction, editing, or interpolation, in this work, we focus on the inversion process itself and analyze the errors DDIM inversion introduces. To that end, we analyze the relation between sampled noise, generated images, and their inverted latent encodings. First, we review existing studies and conduct additional analyses demonstrating that the reverse DDIM technique produces latent representations with pixel correlations that deviate significantly from a Normal distribution. As presented in [Figure 1](https://arxiv.org/html/2410.23530v4#S1.F1), we experimentally show that this deviation manifests as lower diversity in latents, particularly in regions corresponding to smooth image surfaces. We further attribute this discrepancy to the noise approximations in the first few inversion steps. We demonstrate that the inversion error is significantly higher and the predictions are notably less diverse for smooth image areas than for other regions.

To highlight the consequences of the observed divergence, we show that the DDIM-inversion-based latent space is less *manipulative* than the ground truth noise. This limitation is particularly noticeable in lower-quality image interpolations and less expressive edits, especially in smooth input image regions. Furthermore, we demonstrate that prior inversion methods, although designed to improve image reconstruction, fail to preserve the Gaussian properties of the latents. However, based on our analyses, we evaluate a simple fix, where we replace the first steps of the DDIM inversion process with a forward diffusion. In the final experiments, we show that such an approach successfully decorrelates the resulting latents, mitigating observed limitations without degrading the reconstruction quality. Our main contributions can be summarized as follows:

- •
We show that DDIM latents deviate from the Gaussian distribution, mostly because of less diverse noise predictions for the plain image surfaces during the first inversion steps.
- •
We show that, consequently, the DDIM latents are less manipulative, leading to the lower quality of image interpolations and edits.
- •
We demonstrate that prior inversion methods do not address this issue and propose a simple and effective fix by substituting early inversion steps with a forward diffusion.

## 2 Background and Related Work

#### Denoising Diffusion Implicit Models.

The training of DMs consists of forward and backward diffusion processes, where, in the context of Denoising Diffusion Probabilistic Models (DDPMs, Ho et al. (2020)), the former one with training image $x_{0}$ and a variance schedule $\{\beta_{t}\}_{t=1}^{T}$, can be expressed as
$x_{t}=\sqrt{\bar{\alpha}_{t}}x_{0}+\sqrt{1-\bar{\alpha}_{t}}\epsilon_{t},$
with $\alpha_{t}=1-\beta_{t}$, $\bar{\alpha}_{t}=\prod_{s=1}^{t}\alpha_{s}$, and $\epsilon_{t}\sim\mathcal{N}(0,\mathcal{I})$.

In the backward process, the noise is gradually removed starting from a random noise $x_{T}\sim\mathcal{N}(0,\mathcal{I})$ for $t=T\dots 1$, with intermediate steps defined as:

$$ $\begin{split}x_{t-1}&=\sqrt{\bar{\alpha}_{t-1}}\cdot\underbrace{(x_{t}-\sqrt{1-\bar{\alpha}_{t}}\cdot\epsilon^{(t)}_{\theta}(x_{t},c))/\sqrt{\bar{\alpha}_{t}}}_{x_{0}\text{ prediction}}+\underbrace{\sqrt{1-\bar{\alpha}_{t-1}-\sigma_{t}^{2}}\cdot\epsilon^{(t)}_{\theta}(x_{t},c)}_{\text{direction pointing to }x_{t}}+{\sigma_{t}z_{t}},\end{split}$ (1) $$

where $\epsilon^{(t)}_{\theta}(x_{t},c)$ is an output of a neural network (such as U-Net), and can be expressed as a combination of clean image ($x_{0}$) prediction, a direction pointing to previous denoising step ($x_{t}$), and a stochastic factor $\sigma_{t}z_{t}$, where $\sigma_{t}=\eta\sqrt{\beta_{t}(1-\bar{\alpha}_{t-1})/(1-\bar{\alpha}_{t})}$ and $z_{t}\sim\mathcal{N}(0,\mathcal{I})$.
In the standard DDPM model, the $\eta$ parameter is set to $\eta=1$. However, changing it to $\eta=0$ makes the whole process a deterministic Denoising Diffusion Implicit Model (DDIM, Song et al. (2021)), a class of DMs we target in this work.

One of the advantages of DDIM is that by making the process deterministic, we can encode images back to the noise space. The inversion can be obtained by rewriting [Eq. 1](https://arxiv.org/html/2410.23530v4#S2.E1) as

$$ $x_{t}={\sqrt{\alpha_{t}}}{x_{t-1}}+{(\sqrt{1-\bar{\alpha}_{t}}-{\sqrt{\alpha_{t}-\bar{\alpha}_{t}}})}\cdot{\epsilon^{(t)}_{\theta}(x_{t},c)}.$ (2) $$

However, due to circular dependency on $\epsilon^{(t)}_{\theta}(x_{t},c)$, Dhariwal & Nichol (2021) propose to approximate this equation by assuming the local linearity between directions $(x_{t-1}\rightarrow x_{t})$ and $(x_{t}\rightarrow x_{t+1})$, so that the model’s prediction in $t$-th inversion step can be approximated using $x_{t-1}$ as an input, i.e.,

$$ $\epsilon^{(t)}_{\theta}(x_{t},c)\approx\epsilon^{(t)}_{\theta}(x_{t-1},c).$ (3) $$

While such approximation is often sufficient to obtain good reconstructions of images, it introduces the error dependent on the difference $(x_{t}-x_{t-1})$, which can be detrimental for models that sample images with a few diffusion steps or use the classifier-free guidance (Ho & Salimans, 2021; Mokady et al., 2023) for better prompt adherence.
As a result, also noticed by recent works (Garibi et al., 2024; Parmar et al., 2023), latents resulting from DDIM inversion do not follow the definition of Gaussian noise because of the existing correlations. In this work, we empirically study this phenomenon and explain its origin. We discuss the relations between the following three variables: Gaussian noise (${\mathbf{x_{T}}}$, an input to generate an image through a backward diffusion process), image sample (${\mathbf{x_{0}}}$, the outcome of the diffusion model generation process), and latent encoding (${\mathbf{\hat{x}_{T}}}$, the result of the DDIM inversion procedure as introduced in [Eq. 2](https://arxiv.org/html/2410.23530v4#S2.E2)).

#### Image-to-noise inversion techniques.

The DDIM inversion, despite the noise approximation errors, forms the foundation for many applications, including inpainting (Zhang et al., 2023a), interpolation (Dhariwal & Nichol, 2021; Zheng et al., 2024), and edition (Su et al., 2022; Kim et al., 2022a; Hertz et al., 2022; Ceylan et al., 2023; Deja et al., 2023). Several works (Mokady et al., 2023; Garibi et al., 2024; Huberman-Spiegelglas et al., 2024; Samuel et al.,; Hong et al., 2024; Miyake et al., 2023; Han et al., 2024; Cho et al., 2024; Dong et al., 2023; Zhang et al., 2023b; Parmar et al., 2023; Tang et al., 2024; Wallace et al., 2023; Pan et al., 2023; Wang et al., 2024; Brack et al., 2024; Lin et al., 2024; Ju et al., 2024) aim to reverse the denoising process in text-to-image models, where prompt embeddings can strongly affect the final latent representation through Classifier-free-guidance (CFG) (Ho & Salimans, 2021). Null-text inversion (Mokady et al., 2023) extends the DDIM inversion with additional null-embedding optimization, reducing the image reconstruction error. Other techniques improve inversion for image editing through seeking embeddings (Miyake et al., 2023; Han et al., 2024; Dong et al., 2023) or leveraging DDIM latents (Cho et al., 2024) for guidance. On the other hand, some works leverage additional numerical methods (Samuel et al.,; Pan et al., 2023; Garibi et al., 2024) to minimize inversion error. In particular, Renoise (Garibi et al., 2024) iteratively improves the estimation of the next point along the forward diffusion trajectory by averaging multiple noise predictions, incorporating an additional patch-level regularization term that penalizes correlations between pixel pairs to ensure the editability of the latents. Huberman-Spiegelglas et al. (2024) followed by Brack et al. (2024) propose inversion methods for DDPMs, enabling the creation of various image edition results via inversion. Finally, to reduce the discrepancy between DDIM latents and Gaussian noises, Parmar et al. (2023) propose to additionally regularize final DDIM Inversion outputs for better image editing, Lin et al. (2024) introduce an alternative noise scheduler to improve inversion stability, while Hong et al. (2024) propose an exact inversion procedure for higher-order DPM-Solvers, solving the optimization problem at each step.

## 3 Analysis

**Table 1: Overview of diffusion models used for our experiments. We study both unconditioned and conditioned models, operating in pixel and latent spaces. More details on models are provided in [Appendix G](https://arxiv.org/html/2410.23530v4#A7).**
|  | ADM-32 | ADM-64 | ADM-256 | LDM | DiT | IF |
| --- | --- | --- | --- | --- | --- | --- |
| Diffusion | Pixel | Pixel | Pixel | Latent | Latent | Pixel |
| Image res. | $32\times 32$ | $64\times 64$ | $256\times 256$ | $256\times 256$ | $256\times 256$ | $64\times 64$ |
| Latent res. | - | - | - | $3\times 64\times 64$ | $4\times 32\times 32$ | - |
| Trainset | CIFAR-10 | ImageNet | ImageNet | CelebA | ImageNet | LAION-A |
| Cond? | ✗ | ✗ | ✗ | ✗ | ✓ | ✓ |
| Backbone | U-Net | U-Net | U-Net | U-Net | DiT | U-Net |

In our experiments, we employ six different diffusion models, which we compare in [Table 1](https://arxiv.org/html/2410.23530v4#S3.T1). For both generation and inversion processes, we use the DDIM sampler with, unless stated otherwise, $T=100$ steps. We provide more details on the number of diffusion steps in [Appendix F](https://arxiv.org/html/2410.23530v4#A6).

### 3.1 Latents vs. noise

The inversion process provides the foundation for practical methods in many applications, with
the underlying assumption that by encoding the image back with a denoising model, we can obtain the original noise that can be used for reconstruction. However, this assumption is not always fulfilled, which leads to our first question:

Figure: Table 2: Mean of top-20 Pearson correlation coefficients inside $8\times 8$ patches for random Gaussian noises, latent encodings, and generations. DDIM Latents are much more correlated than noises.
Refer to caption: x2.png

#### Prior work and findings.

This question relates to several observations from the existing literature, which highlight that outputs of the DDIM inversion differ from the standard Gaussian noise (Parmar et al., 2023; Garibi et al., 2024) and that the difference can be attributed to the approximation error (Hong et al., 2024; Wallace et al., 2023). While these works notice the divergence between noise and latent encodings, they do not validate them or study the source of this issue.

#### Experiments.

First, we consolidate existing observations on the presence of correlations in the latent encodings (${\mathbf{\hat{x}_{T}}}$) and validate them by running an initial experiment that compares latents to images (${\mathbf{x_{0}}}$) and noises (${\mathbf{x_{T}}}$) across diverse diffusion architectures. In [Table 2](https://arxiv.org/html/2410.23530v4#S3.T2), we calculate a mean of top-$20$ Pearson correlation coefficients (their absolute values) inside $C\times 8\times 8$ pixel patches, where $C$ is the number of channels (pixel RGB colors or latent space dimensions for latent models).
The results confirm that latent representations have significantly more correlated pixels than the noise.
In [Fig. 2](https://arxiv.org/html/2410.23530v4#S3.F2), we show how the measured correlations visually manifest themselves in the latents.
For pixel models such as Deepfloyd IF, we observe clear groups of correlated pixels as presented in [Fig. 2](https://arxiv.org/html/2410.23530v4#S3.F2)a.
For latent diffusion models, we can highlight the inversion error by plotting the difference between the latent and the noise, as presented in [Fig. 2](https://arxiv.org/html/2410.23530v4#S3.F2)b. This property also holds for LDMs with a $4$-channel latent space, with the use of PCA ([Fig. 2](https://arxiv.org/html/2410.23530v4#S3.F2)c).

#### Conclusion.

Our initial experiments numerically validate observations from recent studies and demonstrate that latent representations computed using the DDIM inversion deviate from the expected characteristics of independent Gaussian noise. Specifically, both visual analysis and quantitative evaluations reveal significant correlations between the neighboring pixels.

### 3.2 Location of latent encodings space

To delve deeper, we first propose to empirically analyze the nature of this issue, posing a question:

Figure: Figure 3: $l_{2}$-distances between intermediate denoising steps $x_{t}$ and points on the linear interpolation path from noise ${\mathbf{x_{T}}}$ to the inverted latents ${\mathbf{\hat{x}_{T}}}$. The consecutive intermediate generation steps along the sampling trajectory consequently approach the latent.
Refer to caption: x5.png

#### Experiments.

To answer this question, we first geometrically investigate the location of the latents with respect to the generation trajectory. To that end, we analyze the distance between the following steps $\{x_{t}\}_{t=T\dots 1}$ of the backward diffusion process and intermediate points on the linear interpolation path between the noise and the DDIM latent. We present the results of this experiment in [Fig. 3](https://arxiv.org/html/2410.23530v4#S3.F3), where each pixel, with coordinates $(t,\lambda)$, is colored according to the $l_{2}$ distance between the intermediate trajectory step $x_{t}$ and the corresponding interpolation step. This distance can be expressed as $\lVert(1-\lambda){\mathbf{x_{T}}}+\lambda{\mathbf{\hat{x}_{T}}}-x_{t}\rVert_{2}$.

We observe that, while moving from the initial noise (${\mathbf{x_{T}}}$) towards the final sample (${\mathbf{x_{0}}}$), the intermediate steps $x_{t}$ approach the DDIM inversion latent (${\mathbf{\hat{x}_{T}}}$), while after the transition point around 50-70% (timesteps 50-30) of the generative trajectory, the distance to the latent becomes lower than the distance to the starting noise. This observation reveals that latents retain some characteristics of the original samples and contain information about the source generation.

**Table 3: Average per-pixel absolute error (between noise and latent) and standard deviation of the latents’ pixels corresponding to the plain and non-plain image areas. The error for plain pixels, where latents are less diverse, is higher than for other regions.**
| Model | Absolute Error | Standard Deviation |  |  |
| --- | --- | --- | --- | --- |
| Plain | Non-plain | Plain | Non-plain |  |
| Noise (def.) | – | – | $1.0$ | $1.0$ |
| ADM-$32$ | $0.49$ | $0.43$ | $0.34$ | $0.46$ |
| ADM-$64$ | $0.22$ | $0.15$ | $0.49$ | $0.64$ |
| ADM-$256$ | $0.39$ | $0.29$ | $0.53$ | $0.66$ |
| IF | $0.56$ | $0.40$ | $0.46$ | $0.72$ |
| LDM | $0.13$ | $0.03$ | $0.45$ | $0.59$ |
| DiT | $0.12$ | $0.06$ | $0.43$ | $0.54$ |

Similar observation can be made on the basis of visualizations in [Fig. 2](https://arxiv.org/html/2410.23530v4#S3.F2), where we can distinguish the coarse shape of the original objects in the latents. In particular, while the pixels associated with the objects have high diversity, the areas related to the background are much smoother. This leads to the hypothesis that the most significant difference between the initial noises and latent encodings is the limited variance in the areas corresponding to the background of the generated images. To validate it, we compare the properties of the latents between plain and non-plain areas in the image. We determine binary masks $\mathcal{M}_{p}$ that select smooth surfaces in the image, such as sky, sea, plain backgrounds, or surfaces (see [Fig. 12](https://arxiv.org/html/2410.23530v4#A9.F12) for examples), according to the neighbor differences as described in [Appendix I](https://arxiv.org/html/2410.23530v4#A9). In [Table 3](https://arxiv.org/html/2410.23530v4#S3.T3), we show that the error between the starting noise ${\mathbf{x_{T}}}$ and the latent ${\mathbf{\hat{x}_{T}}}$ resulting from the DDIM inversion is higher for pixels corresponding to the plain areas. Across the models, this trend goes along with a decrease in the standard deviation of the latents’ pixels related to those regions. It suggests that DDIM inversion struggles with reversing the plain image areas, bringing them to mean (0) and reducing their diversity.

#### Conclusion.

Latent encodings resulting from the DDIM Inversion deviate from the Gaussian noise towards zero values. This is especially true for parts of the latents corresponding to the plain image surfaces. This observation reveals that latent encodings retain some characteristics of the original input samples and contain information about the source generation.

### 3.3 Origin of the divergence

Given the observation from the previous section, we now investigate the source of the correlations occurring in latent encodings, posing the question:

#### Experiments.

We first recall that the DDIM Inversion error can be attributed to the approximation of the diffusion model’s output at step $t\in{1\dots T}$ with the output from step $t-1$ (see [Eq. 3](https://arxiv.org/html/2410.23530v4#S2.E3)). Hence, we can define the inversion approximation error for step $t$ as the difference between DM’s output for the target and previous timesteps ${t}$ and ${t-1}$ as:

$$ $\xi(t)=\lvert\underbrace{\epsilon^{(t)}_{\theta}(x_{t-1},c)}_{\mathcal{E}_{t}^{I}}-\underbrace{\epsilon^{(t)}_{\theta}(x_{t},c)}_{\mathcal{E}_{t}^{S}}\rvert,$ (4) $$

where $\mathcal{E}_{t}^{S}$ is the true model prediction at step $t$, and $\mathcal{E}_{t}^{I}$ is the inversion’s approximation using the previous step’s output.
Based on the observations from the previous section, we propose to investigate how the inversion approximation error $\xi(t)$ differs for pixels associated with plain and non-plain image areas throughout the inversion process. To that end, we average the approximation errors for $4000$ images for each of the $T=50$ diffusion timesteps. To measure the error solely for the analyzed step $t$, we start the inversion procedure from the exact latent from step $(t-1)$ (cache from the sampling path). We split the latent pixels into plain and non-plain areas according to the masks calculated for clean images. More details on this setup can be found in [Appendix J](https://arxiv.org/html/2410.23530v4#A10).

In [Fig. 4](https://arxiv.org/html/2410.23530v4#S3.F4.fig1)a, we present the visualization of calculated differences for each inversion step. There is a significant difference in the prediction errors for plain and non-plain areas, especially in the initial steps of the inversion process. Notably, for pixels associated with plain image areas, the error predominantly accumulates within the first 10% of the inversion steps. Additionally, in [Fig. 4](https://arxiv.org/html/2410.23530v4#S3.F4.fig1)b, we present that this error discrepancy is strongly connected to a decrease in the diversity of diffusion models’ predictions.
More precisely, we calculate a ratio of the predictions’ standard deviations

Figure: Figure 4: Discrepancy of the DDIM noise predictions for plain and non-plain image pixels. We show that, in the first inversion steps, the approximations are significantly (a) more erroneous and (b) less diverse for plain regions than for the rest of the image.
Refer to caption: x6.png

between the sampling and inversion processes for the associated timesteps. We show that, for plain image regions, there is a significant decrease in the fraction of predictions’ variance preserved during the first inversion steps.
Those observations can be related to recent works (Lee et al., 2023; Lin et al., 2024) analyzing why numerical solvers incur significant errors during the earliest diffusion steps (as $t\rightarrow 0$). Specifically, Lee et al. (2023) trace the error to the $1/t$ curvature blow-up of the reverse-time ODE trajectory, whereas Lin et al. (2024) attribute the predominance of early DDIM inversion approximations to a singularity arising from commonly used noise schedules. Our experiments extend those studies by showing that the error can be mainly attributed to the plain regions in the original images.

#### Conclusion.

Early approximations during the DDIM Inversion procedure result in unequally distributed errors for pixels related to the plain and non-plain image areas, making it the origin of the structural patterns and correlations in the latents.

## 4 Consequences of the divergence and how to mitigate them?

After identifying the differences between the noises and latents, and highlighting the origin of this phenomenon, we finally pose the last question:

Our findings in [Section 3.3](https://arxiv.org/html/2410.23530v4#S3.SS3) indicate that the initial inversion steps predominantly contribute to the divergence between DDIM latent variables and Gaussian noise, in the form of insufficiently diverse approximations of diffusion model predictions. Therefore, as a simple fix to this issue, we propose to replace the first inversion steps with random noise, as in a forward diffusion process. The rationale behind this decision is twofold:

- •
Substituting initial steps with Gaussian noise allows us to recover the noise variance exactly when the DDIM inversion fails to do so.
- •
Recent studies (Deja et al., 2022; Liu et al., 2025; Li & Chen, 2024; Fesl et al., 2025) have shown that final steps of the backward diffusion do not contribute additional generative information, instead functioning as a data-agnostic denoising process. Therefore, exact inversion of those steps is less important from the perspective of accurate reconstruction.

The proposed inversion step is therefore defined as follows (see [Appendix K](https://arxiv.org/html/2410.23530v4#A11) for pseudocode):

$$ $x_{t}=\begin{cases}\sqrt{\bar{\alpha}_{t}}x_{0}+\sqrt{1-\bar{\alpha}_{t}}\epsilon,&\text{if }t\leq t^{\prime}\quad\text{(forward diffusion)}\\ \sqrt{\alpha_{t}}{x_{t-1}}+(\sqrt{1-\bar{\alpha}_{t}}-\sqrt{\alpha_{t}-\bar{\alpha}_{t}})\cdot\epsilon^{(t)}_{\theta}(x_{t-1},c),&\text{if }t>t^{\prime}\quad\text{(DDIM inversion)}\end{cases}\vskip-3.99994pt$ (5) $$

Before moving to practical applications, we first evaluate the effectiveness of this approach, with $N=10000$ images generated with $T=50$ steps using DiT and IF models. For such generations, we first noise them with a forward diffusion to the intermediate step $t^{\prime}$, followed by the DDIM inversion for $T-t^{\prime}$ steps, ending up with an approximation of the initial noise. In [Table 4](https://arxiv.org/html/2410.23530v4#S4.T4), we show that by replacing just $4\%$ of the inversion steps, we can completely remove correlations in the latents, up to the level of random Gaussian noise. To further evaluate this effect, in [Table 5](https://arxiv.org/html/2410.23530v4#S4.T5), we measure the size of the different parts of images (plain vs non-plain) after saving them with the PNG lossless compression. Compression is most effective in the parts related to plain images generated from the DDIM latents, which incline low diversity of their values. At the same time, replacing only 4% of inversion steps significantly reduces this issue. While our simple fix appears to effectively decorrelate the inversion latents, in the following sections, we showcase the consequences of the divergence between noise and latents in several practical use cases.

Figure: Table 4: Structures can be removed from DDIM latents by replacing inversion steps with forward diffusion. Using forward diffusion instead of the first $4\%$ of inversion steps brings the resulting latents closer to Gaussian noise without a major degradation in the image reconstruction.

### 4.1 Interpolation quality

We start with the task of image interpolation, where the goal, for two given images, is to generate a sequence of semantically meaningful intermediary frames.
Numerous methods (Dhariwal & Nichol, 2021; Song et al., 2021; Samuel et al., 2023; Zheng et al., 2024; Zhang et al., 2024b; Bodin et al., 2025) Diffusion Models with DDIM inversion technique, to calculate latents, interpolate them, and reconstruct the target image. Song et al. (2021) propose to use the spherical linear interpolation (SLERP, Shoemake (1985)), that, for two objects $x$ and $y$, with a coefficient $\lambda\in[0;1]$, is defined as $z^{(\lambda)}=\frac{\sin{(1-\lambda)\theta}}{\sin{\theta}}x+\frac{\sin{\lambda\theta}}{\sin{\theta}}y$, where $\theta=\arccos\left((x\cdot y)/(\lVert x\rVert\lVert y\rVert)\right)$.

Figure: Figure 5: The quality and diversity of images generated from interpolations of latents ${\mathbf{\hat{x}_{T}}}$ deteriorate along the path, as indicated by, accordingly, the FID peak and Recall decrease. In contrast, the quality of generations from noise ${\mathbf{x_{T}}}$ interpolations remains stable. Our simple fix, which is replacing 4% of the first inversion steps with forward diffusion, alleviates this issue.
Refer to caption: x7.png

In our experiment, we compare the quality of interpolations in the noise and latent spaces. To this end, we sample $N=20$k noises, use DDIM with $T=50$ diffusion steps to generate images, and invert those images back into their latents. Next, we randomly assign pairs, which we interpolate with SLERP for $\lambda\in\{0,\frac{1}{6},\frac{1}{3},\frac{1}{2},\frac{2}{3},\frac{5}{6},1\}$ and denoise. In [Fig. 5](https://arxiv.org/html/2410.23530v4#S4.F5), we show that, by calculating FID-10k, generations starting from interpolations between random noises (in orange) preserve consistent quality along the entire path – meaning that all interpolated images fall into the real images manifold. In contrast, this property collapses for the setting with DDIM latents as inputs (in purple). In the following rows, we show that worse interpolation results for latents stem from the decline in the variety of produced generations, as indicated by a lower recall (Kynkäänniemi et al., 2019), especially when getting closer to the middle of the interpolation path. Nevertheless, as presented in [Fig. 5](https://arxiv.org/html/2410.23530v4#S4.F5), using our fix for the first 4% of steps mitigates this issue, enabling higher-quality interpolations with better diversity of the intermediate points. In [Section P.2](https://arxiv.org/html/2410.23530v4#A16.SS2), we present qualitatively that the proposed fix leads to more diverse interpolations, especially in the image background.

### 4.2 Diversity and quality of image edition

Apart from image interpolations, text-to-image diffusion models with DDIM inversion are often used for text-based edition, where a source image is first inverted and then reconstructed with a different target prompt (Hertz et al., 2022; Mokady et al., 2023; Garibi et al., 2024; Huberman-Spiegelglas et al., 2024). However, knowing that DDIM latents are less diverse in plain areas, we hypothesize that using them as a starting point might reduce the diversity and quality of the edited samples. To evaluate this, we use DiT (Peebles & Xie, 2023) and IF (StabilityAI, 2023) as conditional DMs with $T=50$ diffusion steps. For each model, we construct two sets of $1280$ randomly selected (1) source prompts $P_{S}$, used during the generation and inversion, and (2) target prompts $P_{T}$, used for edition. Using source prompts $P_{S}$, we generate images $I_{S}$ from Gaussian noise ${\mathbf{x_{T}}}$ and invert them back into the latents ${\mathbf{\hat{x}_{T}}}$. Next, we regenerate images $\hat{I}_{T}$ from the latents, changing the conditioning to the target prompts $P_{T}$. We compare the edits with ground truth targets $I_{T}$ generated from the original noise ${\mathbf{x_{T}}}$ with $P_{T}$. In [Fig. 6](https://arxiv.org/html/2410.23530v4#S4.F6), we present the drawback of leveraging latents as starting points for the denoising, where the structures for $I_{S}$ images’ backgrounds limit editing performance in $\hat{I}_{T}$ target images.

Figure: Figure 6: Image editing by reversing the original image with a source prompt and reconstructing it with a target one. DDIM Inversion produces less diverse image changes when the manipulation is related to plain regions in source images, contrary to when using ground-truth Gaussian noise. Replacing the first inversion steps with forward diffusion leads to more editable latents.
Refer to caption: x8.png

**Table 6: Diversity of editions (generations from noise ${\mathbf{x_{T}}}$ and latents ${\mathbf{\hat{x}_{T}}}$, conditioned on target prompt) in relation to source images $I_{S}$ and their alignment with source and target prompts. The arrows ($\uparrow$/$\downarrow$) indicate greater generation diversity and higher text alignment to the target prompt.**
| Property | Metric | DiT | Deepfloyd IF |  |  |
| --- | --- | --- | --- | --- | --- |
| Noise ${\mathbf{x_{T}}}$ | Latent ${\mathbf{\hat{x}_{T}}}$ | Noise ${\mathbf{x_{T}}}$ | Latent ${\mathbf{\hat{x}_{T}}}$ |  |  |
| Diversity | DreamSim $\uparrow$ | $0.71_{\pm 0.12}$ | $0.68_{\pm 0.13}$ | $0.67_{\pm 0.10}$ | $0.61_{\pm 0.11}$ |
| against $I_{S}$ | LPIPS $\uparrow$ | $0.59_{\pm 0.12}$ | $0.56_{\pm 0.12}$ | $0.38_{\pm 0.11}$ | $0.33_{\pm 0.11}$ |
| SSIM $\downarrow$ | $0.23_{\pm 0.13}$ | $0.26_{\pm 0.14}$ | $0.34_{\pm 0.15}$ | $0.41_{\pm 0.15}$ |  |
| DINO $\downarrow$ | $0.17$ | $0.22$ | $0.34$ | $0.42$ |  |
| Text | CLIP-T ($P_{S}$) $\downarrow$ | $0.465$ | $0.480$ | $0.273$ | $0.649$ |
| alignment | CLIP-T ($P_{T}$) $\uparrow$ | $0.681$ | $0.662$ | $0.353$ | $0.614$ |

In [Table 6](https://arxiv.org/html/2410.23530v4#S4.T6), we quantitatively measure this effect. First, we calculate the diversity of target generations ($I_{T}$,$\hat{I}_{T}$) against source images ($I_{S}$). We use DreamSim distance (Fu et al., 2023), LPIPS (Zhang et al., 2018), SSIM (Wang et al., 2004), and cosine similarity of DINO features (Darcet et al., 2024) to measure the distance between two sets of generations.
The experiment shows that edits resulting from latent encodings $\hat{I}_{T}$ are characterized by higher similarity (SSIM, DINO) and lower diversity (DreamSim, LPIPS)
relative to starting images $I_{S}$ than the one resulting from noises $I_{T}$. At the same time, in the bottom rows of [Table 6](https://arxiv.org/html/2410.23530v4#S4.T6), we show that the correlations occurring in the latent encodings induce lower performance in text-alignment to target prompts $P_{T}$, which we measure by calculating cosine similarity between text embeddings and resulting image embeddings, both obtained with the CLIP (Radford et al., 2021) encoder.

Figure: Figure 7: Replacing first DDIM inversion steps with forward diffusion improves editions’ pixel diversity (a) and prompt-alignment (b). For IF and DiT models, diversity of generations can be improved by leveraging the forward diffusion process in the first inversion steps, and denoising resulting latents with a different prompt. Additionally, we observe a boost in generations’ alignment to the target prompts, as indicated by the larger CLIP-T value for $P_{T}$ and the smaller one for $P_{S}$. We present details of the experiment in [Appendix L](https://arxiv.org/html/2410.23530v4#A12).
Refer to caption: x9.png

We further evaluate how replacing the first inversion steps with the forward diffusion affects the diversity and text alignment of generated outputs. As shown in [Fig. 7](https://arxiv.org/html/2410.23530v4#S4.F7)a, swapping the first $4\%$ of DDIM inversion steps with forward diffusion improves the diversity of images generated from latents almost to the level of the samples from original noise.
At the same time, as presented in [Fig. 7](https://arxiv.org/html/2410.23530v4#S4.F7)b, replacing the first inversion steps leads to a significant decrease in generations’ alignment to the source prompt ($P_{S}$) and an increase in similarity to the target one ($P_{T}$). This can also be observed in visualizations ([Fig. 6](https://arxiv.org/html/2410.23530v4#S4.F6)).
Moreover, because of the random noise added as the initial inversion steps, as presented in [Appendix M](https://arxiv.org/html/2410.23530v4#A13), our approach enables stochastic image editing, producing diverse manipulations of the same image.

### 4.3 Do existing inversion methods fix the correlations?

Finally, we investigate whether inversion methods introduced in prior work resolve the issue of selectively reduced latents diversity. To this end, we employ the Stable Diffusion XL (Podell et al., 2024) model, and using $2000$ generations from COCO-30K prompts, we measure resulting inversions’ normality, editability, and image reconstruction performance. Results in [Table 7](https://arxiv.org/html/2410.23530v4#S4.T7) indicate that methods based on predicted noise regularization, such as Pix2Pix-Zero (Parmar et al., 2023) and ReNoise (Garibi et al., 2024), while slightly improving the latents’ quality, do not offer significantly better editability, while being two times slower than DDIM. On the other hand, replacing DDIM approximation ([Eq. 3](https://arxiv.org/html/2410.23530v4#S2.E3)) with reverse DPMSolver (Lu et al., 2022) leads to decorellated latents at the cost of high image reconstruction error. We show that our fix offers the best editability of latents with minimal reconstruction loss, all at the lowest computational cost. To be more precise, thanks to the fact that selected inversions steps replaced with the randomly sampled noise are the least important in terms of accurate reconstruction, we can observe no increase in the reconstruction error when replacing 2% of forward steps (up to the 2nd decimal point of MAE), while for 4% of steps the additional error is around 1% of pixel deviations - a value below the threshold usually employed by adversarial attacks as being not noticeable by a human eye (Madry et al., 2017).

**Table 7: Evaluation of inversion methods across multiple metrics: latents normality, image reconstruction, prompt alignment, and speed. DDIM with the proposed fix offers a good trade-off between latent editability and image reconstruction, while increasing the inversion speed.**
| Prior | NFEs | Normality | Image Reconstruction | CLIP Text Alignment | Inv. time |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Corr. $\downarrow$ | KL $\times 10^{-2}\downarrow$ | MAE $\downarrow$ | LPIPS $\downarrow$ | PSNR $\uparrow$ | Source $\downarrow$ | Target $\uparrow$ | [s/image] $\downarrow$ |  |  |
| Gaussian Noise | — | $0.08_{\pm.01}$ | 0.10 | – | – | – | $31.88_{\pm 11.66}$ | $73.34_{\pm 9.65}$ | – |
| DDIM Inv. | 50 | $0.16_{\pm.02}$ | 0.89 | 0.03 | 0.10±.05 | 27.58 | $34.99_{\pm 11.36}$ | $69.58_{\pm 10.17}$ | $7.17_{\pm.01}$ |
| Pix2Pix-Zero | 50 | $0.15_{\pm.02}$ | 0.85 | 0.03 | 0.10±.05 | 27.35 | $34.86_{\pm 11.39}$ | $69.73_{\pm 10.12}$ | $22.07_{\pm 1.84}$ |
| ReNoise ($T=50,K=1$) | 50 | $0.14_{\pm.02}$ | 0.73 | 0.04 | 0.09±.05 | 25.64 | $34.89_{\pm 11.46}$ | $69.87_{\pm 10.07}$ | $19.86_{\pm.22}$ |
| ReNoise ($T=25,K=2$) | 50 | $0.14_{\pm.02}$ | 0.59 | 0.04 | 0.09±.04 | 24.81 | $35.21_{\pm 11.61}$ | $69.68_{\pm 10.09}$ | $15.36_{\pm.51}$ |
| ReNoise ($T=17,K=3$) | 51 | 0.13±.02 | 0.47 | 0.06 | $0.13_{\pm.05}$ | 22.35 | $35.79_{\pm 11.65}$ | $69.04_{\pm 9.98}$ | $14.31_{\pm.49}$ |
| DPMSolver-1 ($T=50$) | 50 | 0.09±.01 | 0.50 | 0.06 | $0.30_{\pm.10}$ | 22.55 | $34.81_{\pm 11.40}$ | $70.26_{\pm 10.42}$ | $7.06_{\pm.00}$ |
| DPMSolver-2 ($T=25$) | 50 | 0.09±.01 | 0.26 | 0.06 | $0.14_{\pm.07}$ | 24.76 | $34.69_{\pm 11.55}$ | 71.24±9.91 | $7.06_{\pm.00}$ |
| Ours (forward 2%) | 49 | $0.14_{\pm.02}$ | 0.71 | 0.03 | 0.10±.05 | 27.12 | 34.32±11.49 | $70.21_{\pm 10.13}$ | 7.00±.00 |
| Ours (forward 4%) | 48 | 0.09±.01 | 0.38 | 0.04 | $0.14_{\pm.04}$ | 25.68 | $\mathbf{33.62}_{\pm 11.63}$ | $\mathbf{72.17}_{\pm 9.94}$ | 6.86±.01 |

## 5 Conclusions

This work demonstrates that DDIM inversion errors cause latent representations to systematically deviate from a Gaussian distribution, particularly in smooth regions of the source image. We trace this to high inversion error and insufficiently diverse noise during the early noising steps, and demonstrate that this divergence degrades the quality of image editing and interpolation. We propose a simple fix by replacing initial inversion steps with forward diffusion, which successfully decorrelates the latents and significantly improves sample quality in practical applications.

## References

- Bodin et al. (2025)
Erik Bodin, Alexandru I Stere, Dragos D Margineantu, Carl Henrik Ek, and Henry Moss.
Linear combinations of latents in generative models: subspaces and beyond.
In *The Thirteenth International Conference on Learning Representations*, 2025.
- Brack et al. (2024)
Manuel Brack, Felix Friedrich, Katharina Kornmeier, Linoy Tsaban, Patrick Schramowski, Kristian Kersting, and Apolinário Passos.
Ledits++: Limitless image editing using text-to-image models.
*CVPR*, 2024.
- Ceylan et al. (2023)
Duygu Ceylan, Chun-Hao P. Huang, and Niloy J. Mitra.
Pix2video: Video editing using image diffusion.
In *Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV)*, pp. 23206–23217, October 2023.
URL [https://openaccess.thecvf.com/content/ICCV2023/html/Ceylan_Pix2Video_Video_Editing_using_Image_Diffusion_ICCV_2023_paper.html](https://openaccess.thecvf.com/content/ICCV2023/html/Ceylan_Pix2Video_Video_Editing_using_Image_Diffusion_ICCV_2023_paper.html).
- Cho et al. (2024)
Hansam Cho, Jonghyun Lee, Seoung Bum Kim, Tae-Hyun Oh, and Yonghyun Jeong.
Noise map guidance: Inversion with spatial context for real image editing.
In *The Twelfth International Conference on Learning Representations*, 2024.
URL [https://openreview.net/forum?id=mhgm0IXtHw](https://openreview.net/forum?id=mhgm0IXtHw).
- Darcet et al. (2024)
Timothée Darcet, Maxime Oquab, Julien Mairal, and Piotr Bojanowski.
Vision transformers need registers.
In *The Twelfth International Conference on Learning Representations, ICLR 2024, Vienna, Austria, May 7-11, 2024*. OpenReview.net, 2024.
URL [https://openreview.net/forum?id=2dnO3LLiJ1](https://openreview.net/forum?id=2dnO3LLiJ1).
- Deja et al. (2022)
Kamil Deja, Anna Kuzina, Tomasz Trzcinski, and Jakub Tomczak.
On analyzing generative and denoising capabilities of diffusion-based deep generative models.
*Advances in Neural Information Processing Systems*, 35:26218–26229, 2022.
- Deja et al. (2023)
Kamil Deja, Georgi Tinchev, Marta Czarnowska, Marius Cotescu, and Jasha Droppo.
Diffusion-based accent modelling in speech synthesis.
In *Interspeech 2023*, 2023.
URL [https://www.amazon.science/publications/diffusion-based-accent-modelling-in-speech-synthesis](https://www.amazon.science/publications/diffusion-based-accent-modelling-in-speech-synthesis).
- Dhariwal & Nichol (2021)
Prafulla Dhariwal and Alexander Nichol.
Diffusion models beat GANs on image synthesis.
*Advances in Neural Information Processing Systems*, 34, 2021.
- Dong et al. (2023)
Wenkai Dong, Song Xue, Xiaoyue Duan, and Shumin Han.
Prompt tuning inversion for text-driven image editing using diffusion models.
In *Proceedings of the IEEE/CVF International Conference on Computer Vision*, pp. 7430–7440, 2023.
- Fesl et al. (2025)
Benedikt Fesl, Benedikt Böck, Florian Strasser, Michael Baur, Michael Joham, and Wolfgang Utschick.
On the asymptotic mean square error optimality of diffusion models.
In *The 28th International Conference on Artificial Intelligence and Statistics*, 2025.
URL [https://openreview.net/forum?id=XrXlAYFpvR](https://openreview.net/forum?id=XrXlAYFpvR).
- Fu et al. (2023)
Stephanie Fu, Netanel Tamir, Shobhita Sundaram, Lucy Chai, Richard Zhang, Tali Dekel, and Phillip Isola.
Dreamsim: Learning new dimensions of human visual similarity using synthetic data.
In *Advances in Neural Information Processing Systems*, volume 36, pp. 50742–50768, 2023.
- Garibi et al. (2024)
Daniel Garibi, Or Patashnik, Andrey Voynov, Hadar Averbuch-Elor, and Daniel Cohen-Or.
Renoise: Real image inversion through iterative noising.
In *European Conference on Computer Vision*, pp. 395–413. Springer, 2024.
- Han et al. (2024)
Ligong Han, Song Wen, Qi Chen, Zhixing Zhang, Kunpeng Song, Mengwei Ren, Ruijiang Gao, Anastasis Stathopoulos, Xiaoxiao He, Yuxiao Chen, et al.
Proxedit: Improving tuning-free real image editing with proximal guidance.
In *Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision*, pp. 4291–4301, 2024.
- Hertz et al. (2022)
Amir Hertz, Ron Mokady, J. Tenenbaum, Kfir Aberman, Y. Pritch, and D. Cohen-Or.
Prompt-to-prompt image editing with cross attention control.
*International Conference on Learning Representations*, 2022.
doi: 10.48550/arXiv.2208.01626.
- Ho & Salimans (2021)
Jonathan Ho and Tim Salimans.
Classifier-free diffusion guidance.
In *NeurIPS 2021 Workshop on Deep Generative Models and Downstream Applications*, 2021.
URL [https://openreview.net/forum?id=qw8AKxfYbI](https://openreview.net/forum?id=qw8AKxfYbI).
- Ho et al. (2020)
Jonathan Ho, Ajay Jain, and Pieter Abbeel.
Denoising diffusion probabilistic models.
In H. Larochelle, M. Ranzato, R. Hadsell, M.F. Balcan, and H. Lin (eds.), *Advances in Neural Information Processing Systems*, volume 33, pp. 6840–6851. Curran Associates, Inc., 2020.
URL [https://proceedings.neurips.cc/paper_files/paper/2020/file/4c5bcfec8584af0d967f1ab10179ca4b-Paper.pdf](https://proceedings.neurips.cc/paper_files/paper/2020/file/4c5bcfec8584af0d967f1ab10179ca4b-Paper.pdf).
- Ho et al. (2022)
Jonathan Ho, William Chan, Chitwan Saharia, Jay Whang, Ruiqi Gao, Alexey Gritsenko, Diederik P Kingma, Ben Poole, Mohammad Norouzi, David J Fleet, et al.
Imagen video: High definition video generation with diffusion models.
*arXiv preprint arXiv:2210.02303*, 2022.
- Hong et al. (2024)
Seongmin Hong, Kyeonghyun Lee, Suh Yoon Jeon, Hyewon Bae, and Se Young Chun.
On exact inversion of dpm-solvers.
In *Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition*, pp. 7069–7078, 2024.
- Huberman-Spiegelglas et al. (2024)
Inbar Huberman-Spiegelglas, Vladimir Kulikov, and Tomer Michaeli.
An edit friendly ddpm noise space: Inversion and manipulations.
In *Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition*, pp. 12469–12478, 2024.
- Ju et al. (2024)
Xuan Ju, Ailing Zeng, Yuxuan Bian, Shaoteng Liu, and Qiang Xu.
Pnp inversion: Boosting diffusion-based editing with 3 lines of code.
In *The Twelfth International Conference on Learning Representations*, 2024.
URL [https://openreview.net/forum?id=FoMZ4ljhVw](https://openreview.net/forum?id=FoMZ4ljhVw).
- Kadkhodaie et al. (2024)
Zahra Kadkhodaie, Florentin Guth, Eero P. Simoncelli, and Stéphane Mallat.
Generalization in diffusion models arises from geometry-adaptive harmonic representations.
In *The Twelfth International Conference on Learning Representations, ICLR 2024, Vienna, Austria, May 7-11, 2024*. OpenReview.net, 2024.
URL [https://openreview.net/forum?id=ANvmVS2Yr0](https://openreview.net/forum?id=ANvmVS2Yr0).
- Khrulkov & Oseledets (2022)
Valentin Khrulkov and I. Oseledets.
Understanding ddpm latent codes through optimal transport.
*International Conference on Learning Representations*, 2022.
URL [https://arxiv.org/abs/2202.07477v2](https://arxiv.org/abs/2202.07477v2).
- Kim et al. (2022a)
Gwanghyun Kim, Taesung Kwon, and Jong Chul Ye.
Diffusionclip: Text-guided diffusion models for robust image manipulation.
In *Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)*, pp. 2426–2435, June 2022a.
- Kim et al. (2022b)
Gwanghyun Kim, Taesung Kwon, and Jong Chul Ye.
Diffusionclip: Text-guided diffusion models for robust image manipulation.
In *Proceedings of the IEEE/CVF conference on computer vision and pattern recognition*, pp. 2426–2435, 2022b.
- Kim & Milman (2011)
Young-Heon Kim and E. Milman.
A generalization of caffarelli’s contraction theorem via (reverse) heat flow.
*Mathematische Annalen*, 2011.
doi: 10.1007/s00208-011-0749-x.
- Kingma & Welling (2014)
Diederik P. Kingma and Max Welling.
Auto-Encoding Variational Bayes.
In *International Conference on Learning Representations*, 2014.
- Kynkäänniemi et al. (2019)
Tuomas Kynkäänniemi, Tero Karras, Samuli Laine, Jaakko Lehtinen, and Timo Aila.
Improved precision and recall metric for assessing generative models.
*Advances in neural information processing systems*, 32, 2019.
- Lavenant & Santambrogio (2022)
Hugo Lavenant and Filippo Santambrogio.
The flow map of the fokker–planck equation does not provide optimal transport.
*Applied Mathematics Letters*, 133:108225, 2022.
ISSN 0893-9659.
doi: https://doi.org/10.1016/j.aml.2022.108225.
URL [https://www.sciencedirect.com/science/article/pii/S089396592200180X](https://www.sciencedirect.com/science/article/pii/S089396592200180X).
- Lee et al. (2023)
Sangyun Lee, Beomsu Kim, and Jong Chul Ye.
Minimizing trajectory curvature of ode-based generative models.
In *International Conference on Machine Learning*, pp. 18957–18973. PMLR, 2023.
- Li & Chen (2024)
Marvin Li and Sitan Chen.
Critical windows: non-asymptotic theory for feature emergence in diffusion models.
In *Forty-first International Conference on Machine Learning*, 2024.
URL [https://openreview.net/forum?id=a8ZpjLJuKk](https://openreview.net/forum?id=a8ZpjLJuKk).
- Li et al. (2025)
Xianhang Li, Haoqin Tu, Mude Hui, Zeyu Wang, Bingchen Zhao, Junfei Xiao, Sucheng Ren, Jieru Mei, Qing Liu, Huangjie Zheng, Yuyin Zhou, and Cihang Xie.
What if we recaption billions of web images with LLaMA-3?
In *Forty-second International Conference on Machine Learning*, 2025.
URL [https://openreview.net/forum?id=Hntp7s2YfF](https://openreview.net/forum?id=Hntp7s2YfF).
- Lin et al. (2024)
Haonan Lin, Mengmeng Wang, Jiahao Wang, Wenbin An, Yan Chen, Yong Liu, Feng Tian, Guang Dai, Jingdong Wang, and Qianying Wang.
Schedule your edit: A simple yet effective diffusion noise schedule for image editing.
*Neural Information Processing Systems*, 2024.
doi: 10.48550/arXiv.2410.18756.
- Liu et al. (2025)
Haozhe Liu, Wentian Zhang, Jinheng Xie, Francesco Faccio, Mengmeng Xu, Tao Xiang, Mike Zheng Shou, Juan-Manuel Perez-Rua, and Jürgen Schmidhuber.
Faster diffusion through temporal attention decomposition.
*Transactions on Machine Learning Research*, 2025.
ISSN 2835-8856.
URL [https://openreview.net/forum?id=xXs2GKXPnH](https://openreview.net/forum?id=xXs2GKXPnH).
- Liu et al. (2021)
Jinglin Liu, Chengxi Li, Yi Ren, Feiyang Chen, and Zhou Zhao.
Diffsinger: Singing voice synthesis via shallow diffusion mechanism.
*AAAI Conference on Artificial Intelligence*, 2021.
doi: 10.1609/aaai.v36i10.21350.
- Lu et al. (2022)
Cheng Lu, Yuhao Zhou, Fan Bao, Jianfei Chen, Chongxuan Li, and Jun Zhu.
Dpm-solver: A fast ode solver for diffusion probabilistic model sampling in around 10 steps.
*Advances in neural information processing systems*, 35:5775–5787, 2022.
- Madry et al. (2017)
Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu.
Towards deep learning models resistant to adversarial attacks.
*arXiv preprint arXiv:1706.06083*, 2017.
- Meng et al. (2022)
Chenlin Meng, Yutong He, Yang Song, Jiaming Song, Jiajun Wu, Jun-Yan Zhu, and Stefano Ermon.
Sdedit: Guided image synthesis and editing with stochastic differential equations.
In *The Tenth International Conference on Learning Representations, ICLR 2022, Virtual Event, April 25-29, 2022*. OpenReview.net, 2022.
URL [https://openreview.net/forum?id=aBsCjcPu_tE](https://openreview.net/forum?id=aBsCjcPu_tE).
- Miyake et al. (2023)
Daiki Miyake, Akihiro Iohara, Yu Saito, and Toshiyuki Tanaka.
Negative-prompt inversion: Fast image inversion for editing with text-guided diffusion models.
*arXiv preprint arXiv: 2305.16807*, 2023.
- Mokady et al. (2023)
Ron Mokady, Amir Hertz, Kfir Aberman, Yael Pritch, and Daniel Cohen-Or.
Null-text inversion for editing real images using guided diffusion models.
In *Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)*, pp. 6038–6047, June 2023.
URL [https://openaccess.thecvf.com/content/CVPR2023/html/Mokady_NULL-Text_Inversion_for_Editing_Real_Images_Using_Guided_Diffusion_Models_CVPR_2023_paper.html](https://openaccess.thecvf.com/content/CVPR2023/html/Mokady_NULL-Text_Inversion_for_Editing_Real_Images_Using_Guided_Diffusion_Models_CVPR_2023_paper.html).
- Nichol & Dhariwal (2021)
Alexander Quinn Nichol and Prafulla Dhariwal.
Improved denoising diffusion probabilistic models.
In *International conference on machine learning*, pp. 8162–8171. PMLR, 2021.
- Pan et al. (2023)
Zhihong Pan, Riccardo Gherardi, Xiufeng Xie, and Stephen Huang.
Effective real image editing with accelerated iterative diffusion inversion.
In *Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV)*, pp. 15912–15921, October 2023.
- Parmar et al. (2023)
Gaurav Parmar, Krishna Kumar Singh, Richard Zhang, Yijun Li, Jingwan Lu, and Jun-Yan Zhu.
Zero-shot image-to-image translation.
In *ACM SIGGRAPH 2023 Conference Proceedings*, pp. 1–11, 2023.
- Peebles & Xie (2023)
William Peebles and Saining Xie.
Scalable diffusion models with transformers.
In *Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV)*, pp. 4195–4205, October 2023.
- Podell et al. (2024)
Dustin Podell, Zion English, Kyle Lacey, Andreas Blattmann, Tim Dockhorn, Jonas Müller, Joe Penna, and Robin Rombach.
SDXL: Improving latent diffusion models for high-resolution image synthesis.
In *The Twelfth International Conference on Learning Representations*, 2024.
URL [https://openreview.net/forum?id=di52zR8xgf](https://openreview.net/forum?id=di52zR8xgf).
- Popov et al. (2021)
Vadim Popov, Ivan Vovk, Vladimir Gogoryan, Tasnima Sadekova, and Mikhail Kudinov.
Grad-tts: A diffusion probabilistic model for text-to-speech.
In *International Conference on Machine Learning*, pp. 8599–8608. PMLR, 2021.
- Radford et al. (2021)
Alec Radford, Jong Wook Kim, Chris Hallacy, A. Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, Gretchen Krueger, and Ilya Sutskever.
Learning transferable visual models from natural language supervision.
In *ICML*, 2021.
- Rombach et al. (2021)
Robin Rombach, A. Blattmann, Dominik Lorenz, Patrick Esser, and B. Ommer.
High-resolution image synthesis with latent diffusion models.
*Computer Vision and Pattern Recognition*, 2021.
doi: 10.1109/CVPR52688.2022.01042.
- Rout et al. (2025)
Litu Rout, Yujia Chen, Nataniel Ruiz, Constantine Caramanis, Sanjay Shakkottai, and Wen-Sheng Chu.
Semantic image inversion and editing using rectified stochastic differential equations.
In *The Thirteenth International Conference on Learning Representations*, 2025.
URL [https://openreview.net/forum?id=Hu0FSOSEyS](https://openreview.net/forum?id=Hu0FSOSEyS).
- (49)
Dvir Samuel, Barak Meiri, Haggai Maron, Yoad Tewel, Nir Darshan, Shai Avidan, Gal Chechik, and Rami Ben-Ari.
Lightning-fast image inversion and editing for text-to-image diffusion models.
In *The Thirteenth International Conference on Learning Representations*.
- Samuel et al. (2023)
Dvir Samuel, Rami Ben-Ari, Nir Darshan, Haggai Maron, and Gal Chechik.
Norm-guided latent space exploration for text-to-image generation.
*Advances in Neural Information Processing Systems*, 36:57863–57875, 2023.
- Shoemake (1985)
Ken Shoemake.
Animating rotation with quaternion curves.
In *Proceedings of the 12th Annual Conference on Computer Graphics and Interactive Techniques*, SIGGRAPH ’85, pp. 245–254, New York, NY, USA, 1985. Association for Computing Machinery.
ISBN 0897911660.
doi: 10.1145/325334.325242.
URL [https://doi.org/10.1145/325334.325242](https://doi.org/10.1145/325334.325242).
- Sohl-Dickstein et al. (2015)
Jascha Sohl-Dickstein, Eric Weiss, Niru Maheswaranathan, and Surya Ganguli.
Deep unsupervised learning using nonequilibrium thermodynamics.
In *International Conference on Machine Learning*, pp. 2256–2265. PMLR, 2015.
- Song et al. (2021)
Jiaming Song, Chenlin Meng, and Stefano Ermon.
Denoising diffusion implicit models.
In *International Conference on Learning Representations*, 2021.
URL [https://openreview.net/forum?id=St1giarCHLP](https://openreview.net/forum?id=St1giarCHLP).
- StabilityAI (2023)
StabilityAI.
DeepFloyd IF: a novel state-of-the-art open-source text-to-image model with a high degree of photorealism and language understanding.
[https://github.com/deep-floyd/IF](https://github.com/deep-floyd/IF), 2023.
Retrieved on 2023-04-17.
- Su et al. (2022)
Xu Su, Jiaming Song, Chenlin Meng, and Stefano Ermon.
Dual diffusion implicit bridges for image-to-image translation.
*International Conference on Learning Representations*, 2022.
doi: 10.48550/arXiv.2203.08382.
- Tang et al. (2024)
Chuanming Tang, Kai Wang, and Joost van de Weijer.
IterInv: Iterative Inversion for Pixel-Level T2I Models .
In *2024 IEEE International Conference on Multimedia and Expo (ICME)*, pp. 1–6, Los Alamitos, CA, USA, 2024. IEEE Computer Society.
doi: 10.1109/ICME57554.2024.10687547.
URL [https://doi.ieeecomputersociety.org/10.1109/ICME57554.2024.10687547](https://doi.ieeecomputersociety.org/10.1109/ICME57554.2024.10687547).
- Wallace et al. (2023)
Bram Wallace, Akash Gokul, and Nikhil Naik.
Edict: Exact diffusion inversion via coupled transformations.
In *Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition*, pp. 22532–22541, 2023.
- Wang et al. (2024)
Fangyikang Wang, Hubery Yin, Yuejiang Dong, Huminhao Zhu, Chao Zhang, Han Zhao, Hui Qian, and Chen Li.
Belm: Bidirectional explicit linear multi-step sampler for exact inversion in diffusion models.
*Neural Information Processing Systems*, 2024.
doi: 10.48550/arXiv.2410.07273.
- Wang et al. (2004)
Zhou Wang, Alan C Bovik, Hamid R Sheikh, and Eero P Simoncelli.
Image quality assessment: from error visibility to structural similarity.
*IEEE transactions on image processing*, 13(4):600–612, 2004.
- Zhang et al. (2023a)
Guanhua Zhang, Jiabao Ji, Yang Zhang, Mo Yu, Tommi S. Jaakkola, and Shiyu Chang.
Towards coherent image inpainting using denoising diffusion implicit models.
In Andreas Krause, Emma Brunskill, Kyunghyun Cho, Barbara Engelhardt, Sivan Sabato, and Jonathan Scarlett (eds.), *International Conference on Machine Learning, ICML 2023, 23-29 July 2023, Honolulu, Hawaii, USA*, volume 202 of *Proceedings of Machine Learning Research*, pp. 41164–41193. PMLR, 2023a.
URL [https://proceedings.mlr.press/v202/zhang23q.html](https://proceedings.mlr.press/v202/zhang23q.html).
- Zhang et al. (2024a)
Huijie Zhang, Jinfan Zhou, Yifu Lu, Minzhe Guo, Liyue Shen, and Qing Qu.
The emergence of reproducibility and consistency in diffusion models, 2024a.
URL [https://openreview.net/forum?id=UkLSvLqiO7](https://openreview.net/forum?id=UkLSvLqiO7).
- Zhang et al. (2024b)
Kaiwen Zhang, Yifan Zhou, Xudong Xu, Bo Dai, and Xingang Pan.
Diffmorpher: Unleashing the capability of diffusion models for image morphing.
In *Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition*, pp. 7912–7921, 2024b.
- Zhang et al. (2018)
Richard Zhang, Phillip Isola, Alexei A Efros, Eli Shechtman, and Oliver Wang.
The unreasonable effectiveness of deep features as a perceptual metric.
In *CVPR*, 2018.
- Zhang et al. (2023b)
Yuechen Zhang, Jinbo Xing, Eric Lo, and Jiaya Jia.
Real-world image variation by aligning diffusion inversion chain.
In A. Oh, T. Naumann, A. Globerson, K. Saenko, M. Hardt, and S. Levine (eds.), *Advances in Neural Information Processing Systems*, volume 36, pp. 30641–30661. Curran Associates, Inc., 2023b.
URL [https://proceedings.neurips.cc/paper_files/paper/2023/file/61960fdfda4d4e95fa1c1f6e64bfe8bc-Paper-Conference.pdf](https://proceedings.neurips.cc/paper_files/paper/2023/file/61960fdfda4d4e95fa1c1f6e64bfe8bc-Paper-Conference.pdf).
- Zheng et al. (2024)
PengFei Zheng, Yonggang Zhang, Zhen Fang, Tongliang Liu, Defu Lian, and Bo Han.
Noisediffusion: Correcting noise for image interpolation with diffusion models beyond spherical linear interpolation.
In *The Twelfth International Conference on Learning Representations*, 2024.

## Appendix

## Contents

In the Appendix we first outline the limitations (A) of our experiments, discuss the broader impact (B) of the proposed fix, usage of LLMs (C), and list the computational resources (D) used. We then describe, in detail, the DDIM approximation error (E) and the consequences it has across varying numbers of sampling steps (F). Next, we describe our experiments: how we condition DMs (G), measuring the noise–image–latent triangles (H), identifying plain-regions pixels (I) in the image, and computing the inversion error (J). In section K, we provide the full pseudocode for the proposed fix. We demonstrate how the technique enhances image diversity and prompt alignment (L) and how it enables stochastic editing of real images (M). Finally, we compare Gaussian noise and DDIM latents in their mappings to images (N) and track how these relationships evolve during DM training (O). In section P, we include additional qualitative results: when the introduced fix might fail, and how it enhances image interpolation.

## Appendix A Limitations

In this work, we analyzed the relation between the random noise, image generations and their latent encodings obtained through DDIM Inversion. While our studies focused on DDIM approximation error from Song et al. (2021), there exist other solvers and inversion methods, as described in [Section 2](https://arxiv.org/html/2410.23530v4#S2), bringing their own advantages and limitations. The error of DDIM inversion strongly depends on the number of steps with which it is performed. In particular, performing the process very granularly, e.g., using $T=1000$ steps, can result in strong suppression of the correlation. Nevertheless, the default number of steps we have chosen, i.e., 100, is, according to previous works (Hong et al., 2024; Garibi et al., 2024; Kim et al., 2022b), a practical choice as a good balance between the reconstruction error and the speed of the algorithm. In [Appendix F](https://arxiv.org/html/2410.23530v4#A6), we present that the latents exhibit correlations when using $1000$ sampling steps, and that the proposed fix can help also in such case.

The observations from our analytical experiments (correlations in [Table 2](https://arxiv.org/html/2410.23530v4#S3.T2), interpolations in [Fig. 5](https://arxiv.org/html/2410.23530v4#S4.F5)) generalize well to all tested diffusion models, but are less evident in the LDM model trained on the CelebA-HQ images. We attribute this exemption to the specificity of the dataset on which the model was trained - photos with centered human faces, usually with uniform backgrounds. We believe that, unlike models trained on a larger number of concepts, the process of generating faces with uniform backgrounds is more stable and introduces little detail in subsequent steps, making the difference in approximation error for plain and non-plain areas less significant.

As mentioned in [Section 2](https://arxiv.org/html/2410.23530v4#S2), the DDIM inversion error can be detrimental when using a small number of steps. Even though the solution proposed in this work (involving forward diffusion in first inversion steps) drastically removes correlations in latents and, thus, improves image interpolation and editing, it does not improve the numerical inversion error resulting from using small number of steps. In our experiments with 50 steps that are commonly used for edition, we show no significant drawbacks. However, in the extreme cases, using our fix in even a single step, might result in the loss of information necessary for correct image reconstruction, hence it may be then less preferred than standard DDIM inversion. In [Section P.1](https://arxiv.org/html/2410.23530v4#A16.SS1), we present failure cases for introduced solution.

## Appendix B LLM Usage

Throughout the preparation of this manuscript, we employed a large language model (LLM) as a writing assistant. Its use was focused on improving the clarity and readability of the text, correcting grammar, and refining sentence structure. The authors carefully reviewed, edited, and take full responsibility for all content, ensuring the scientific integrity and accuracy of the final paper.

## Appendix C Broader impact

As our work is mostly analytical, we do not provide new technologies that might have a significant societal impact. However, our solution for improving the accuracy of DDIM inversion has potential implications that extend beyond technical advancements in diffusion models. As our fix enables more prompt-aligned image editing it could be misused to advance image manipulation techniques. The enhanced interpolation quality could make synthetic content more convincing and harder to detect. The authors do not endorse using the method for deceptive or malicious purposes, and discourage any application that could
erode trust or cause harm.

## Appendix D Compute resources

For the experiments, we used a scientific cluster consisting of 110 nodes with CrayOS operating system. Each node is powered by 288 CPU cores, stemming from 4 NVIDIA Grace processors, each with 72 cores and a clock speed of 3.1 GHz. The nodes are equipped with substantial memory, featuring 480 GB of RAM per node. For GPU acceleration, each node in the cluster consists of 4 NVIDIA GH200 96GB GPUs with 120 GB of RAM and 72 CPUs per GPU.

Almost all the experiments we perform are based on performing a sampling process using a diffusion model from noise, performing DDIM inversion and, possibly, image reconstruction from the latent, where each of these processes takes the same number of steps, hence the same number of GPU-hours on average. As our experiments differ in terms of number of sampling steps and images to generate, we provide average GPU time per one sampling step per batch (with $B$ denoting batch size) for each model as following: ADM-32 ($B=256$): 0.054s, ADM-64 ($B=128$): 0.093s, ADM-256 ($B=64$): 0.901s, LDM ($B=128$): 0.273s, DiT ($B=128$): 0.104s, IF ($B=64$): 0.609s. Note that some experiments, such as analyzing inversion approximation errors per step ([Fig. 4](https://arxiv.org/html/2410.23530v4#S3.F4.fig1)) or sampling from noise interpolations ([Fig. 5](https://arxiv.org/html/2410.23530v4#S4.F5)), involves performing the procedures several times. Taking into consideration all the experiments described in the main text of this work, fully reproducing them takes roughly 110 GPU hours. However, considering the prototyping time, preliminary and failed experiments, as well as the fact that most of the experiments must be performed sequentially (e.g., inversion after image generation, image reconstruction after inversion), the overall execution time of the entire research project is multiple times longer.

## Appendix E Approximation error in DDIM Inversion

Denoising Diffusion Probabilistic Models (DDPMs, Ho et al. (2020)) generate samples by reversing the forward diffusion process, modeled as a Markov Chain, where a clean image $x_{0}$ is progressively transformed to white Gaussian noise $x_{T}$ in $T$ diffusion steps. A partially noised image $x_{t}$, which serves as an intermediate object in this process, is expressed as $x_{t}=\sqrt{\bar{\alpha}_{t}}x_{0}+\sqrt{1-\bar{\alpha}_{t}}\epsilon_{t}$ where $\bar{\alpha}_{t}=\prod_{s=1}^{t}\alpha_{s}$, $\alpha_{t}=1-\beta_{t}$, $\epsilon_{t}\sim\mathcal{N}(0,\mathcal{I})$, and $\{\beta_{t}\}_{t=1}^{T}$ is a variance schedule, controlling how much of the noise is contained in the image at the specific step $t$.

To enable sampling clean images from clean Gaussian noises, the neural network $\epsilon_{\theta}$ is trained to predict the noise added to a clean image $x_{0}$ for a given intermediate image $x_{t}$. Such a trained model is further utilized in the backward diffusion process by iteratively transferring a more noisy image ($x_{t}$) to the less noisy one ($x_{t-1}$) as

$$ $x_{t-1}=\frac{1}{\sqrt{\alpha_{t}}}(x_{t}-\frac{\beta_{t}}{\sqrt{1-\bar{\alpha}_{t}}}\epsilon_{\theta}^{(t)}(x_{t}))+\sigma_{t}z,$ (6) $$

with $z\sim\mathcal{N}(0,\mathcal{I})$ being a noise portion added back for denoising controlled by $\sigma_{t}=\sqrt{\beta_{t}(1-\bar{\alpha}_{t-1})/(1-\bar{\alpha}_{t})}$.

Song et al. (2021) reformulate the diffusion process as a non-Markovian, which leads to a speed-up of the sampling process. While previously obtaining a less noisy image at $x_{t}$ required all past denoising steps from $T$ till $(t+1)$, this approach allows skipping some steps during sampling. More precisely, the backward diffusion process is defined as a combination of predictions of image $x_{0}$, next denoising step $x_{t}$, and random noise (with $\sigma_{t}=\eta\sqrt{\beta_{t}(1-\bar{\alpha}_{t-1})/(1-\bar{\alpha}_{t})}$ and $z_{t}\sim\mathcal{N}(0,\mathcal{I})$):

$$ $\displaystyle x_{t-1}=$ $\displaystyle\sqrt{\bar{\alpha}_{t-1}}\left(\frac{\mathbf{x}_{t}-\sqrt{1-\bar{\alpha}_{t}}\,\epsilon_{\theta}^{(t)}(x_{t})}{\sqrt{\bar{\alpha}_{t}}}\right)+\sqrt{1-\bar{\alpha}_{t-1}-\sigma_{t}^{2}}\cdot\epsilon_{\theta}^{(t)}(x_{t})+\sigma_{t}z_{t}.$ (7) $$

While setting $\eta=1$ makes [Eq. 7](https://arxiv.org/html/2410.23530v4#A5.E7) equivalent to [Eq. 6](https://arxiv.org/html/2410.23530v4#A5.E6), leading to a Markovian probabilistic diffusion model, setting $\eta=0$ removes the random component from the equation, making it a Denoising Diffusion Implicit Model (DDIM), which prominent ability is to perform a deterministic mapping from given noise ($x_{T}$) to image ($x_{0}$). One of the potential benefits of implicit models is the possibility of reversing the backward diffusion process to transfer images back to the original noise. Operating in such a space by modifying resulting inversions unlocks numerous image manipulation capabilities, i.a., image editing (Hertz et al., 2022; Mokady et al., 2023; Huberman-Spiegelglas et al., 2024; Parmar et al., 2023; Rout et al., 2025; Miyake et al., 2023; Brack et al., 2024; Tang et al., 2024; Hong et al., 2024; Wallace et al., 2023; Samuel et al.,; Garibi et al., 2024; Pan et al., 2023; Dong et al., 2023), image interpolation (Zheng et al., 2024; Zhang et al., 2024b; Samuel et al., 2023; Dhariwal & Nichol, 2021), or stroke-to-image synthesis (Meng et al., 2022; Rout et al., 2025). The inversion process can be derived from [Eq. 7](https://arxiv.org/html/2410.23530v4#A5.E7), leading to the formula for transferring a less noisy image $x_{t-1}$ to a more noisy one $x_{t}$:

$$ $x_{t}={\sqrt{\alpha_{t}}}{x_{t-1}}+{(\sqrt{1-\bar{\alpha}_{t}}-{\sqrt{\alpha_{t}-\bar{\alpha}_{t}}})}\cdot{\epsilon_{\theta}^{(t)}(x_{t})}$ (8) $$

Unfortunately, a perfect image-to-noise inversion is infeasible. Due to circular dependency on $x_{t}$ within [Eq. 8](https://arxiv.org/html/2410.23530v4#A5.E8), Dhariwal & Nichol (2021) propose to approximate this equation by assuming that the model’s prediction in $t$-th step is locally equivalent to the decision in $(t-1)$-th step $\epsilon_{\theta}^{(t)}(x_{t})\approx\epsilon_{\theta}^{(t)}(x_{t-1})$. The inverted trajectory is determined in multiple steps. Hence, the error propagates further away from the image, leading to the latents that deviate from the starting noise. This flaw is presented in [Fig. 8](https://arxiv.org/html/2410.23530v4#A5.F8).

Figure: Figure 8: The DDIM inversion error, derived from approximating DM’s prediction in step $t$ with the $(t+1)$ output (left), propagates with the next inversion steps, leading to a distribution of latents $\hat{x}^{T}$ that deviates significantly from the expected noise distribution $x^{T}$ (right).
Refer to caption: x10.png

## Appendix F Correlations vs. inversion steps

In this work, for the inversion process, we leverage the DDIM sampler with either $T=50$ or $T=100$ sampling steps. This choice aligns with prior works (Hong et al., 2024; Garibi et al., 2024; Kim et al., 2022b) in image edition domain, where the authors used from $50$ up to $200$ inversion steps as a proper balance between reconstruction quality and short algorithm runtime.

However, as described in Hong et al. (2024), the naïve DDIM inversion procedure (Song et al., 2021) can be reinterpreted as solving the forward diffusion ordinary differential equation (ODE) in reverse order (along the time axis) with Euler method. With this reformulation, the inversion is correct under the assumption that, with $dt$ being step size, noise predictions in $t$ and $t+dt$ steps are almost exact, thus works only when performing with many iterations.

Since the presence of image structures in DDIM latents can depend on the number of steps with which the inversion is performed, in [Table 8](https://arxiv.org/html/2410.23530v4#A6.T8) we show for ADM-64, DiT, and IF models that the observations we presented in this work generalize to cases where the number of inversion steps is several times greater (i.e., $T=1000$, as performed during the training). Additionally, in [Fig. 9](https://arxiv.org/html/2410.23530v4#A6.F9) we show qualitatively by plotting the absolute error between starting Gaussian noise and DDIM latents, that also for a large number of steps, the uniform areas on the image contribute more significantly to overall inversion error.

For a more thorough analysis, in [Table 9](https://arxiv.org/html/2410.23530v4#A6.T9) we evaluate how our fix decorraltes latents in situation where we use $T=1000$ inversion steps. As visible, replacing just $1$ step of DDIM Inversion with forward diffusion significantly reduces correlation at minimal loss in image reconstruction.

**Table 8: Latent encodings resulting from the DDIM Inversion exhibit correlations, even when the procedure is performed with a lot of steps. By dividing latent encodings into $8\times 8$ patches and calculating the mean of top-$20$ Pearson coefficients, we show that DDIM latents are correlated substantially higher than Gaussian noise, even when using $T=1000$ inversion steps.**
| Object | Model |  |  |
| --- | --- | --- | --- |
| ADM-64 | DiT | IF |  |
| Noise ${\mathbf{x_{T}}}$ (baseline) | $0.039_{\pm.00}$ | $0.039_{\pm.00}$ | $0.039_{\pm.00}$ |
| DDIM Latent $\mathbf{\hat{x}_{T=10}}$ | $0.416_{\pm.03}$ | $0.297_{\pm.01}$ | $0.783_{\pm.01}$ |
| DDIM Latent $\mathbf{\hat{x}_{T=25}}$ | $0.242_{\pm.02}$ | $0.203_{\pm.02}$ | $0.698_{\pm.02}$ |
| DDIM Latent $\mathbf{\hat{x}_{T=50}}$ | $0.177_{\pm.02}$ | $0.144_{\pm.02}$ | $0.608_{\pm.02}$ |
| DDIM Latent $\mathbf{\hat{x}_{T=100}}$ | $0.133_{\pm.01}$ | $0.106_{\pm.02}$ | $0.500_{\pm.02}$ |
| DDIM Latent $\mathbf{\hat{x}_{T=250}}$ | $0.108_{\pm.01}$ | $0.078_{\pm.01}$ | $0.366_{\pm.02}$ |
| DDIM Latent $\mathbf{\hat{x}_{T=500}}$ | $0.100_{\pm.01}$ | $0.069_{\pm.01}$ | $0.294_{\pm.02}$ |
| DDIM Latent $\mathbf{\hat{x}_{T=1000}}$ | $0.095_{\pm.01}$ | $0.065_{\pm.01}$ | $0.249_{\pm.02}$ |

**Table 9: Latent correlations, KL divergence to random Gaussian noise, and image reconstruction error across models (ADM-64, DiT, IF) when using $T=1000$ inversion steps. We show that using our simple fix in just one step of inversion process significantly decorellates DDIM latents with minimal loss in image reconstruction performance.**
| Model | Prior | Corr. $\downarrow$ | KL $\times 10^{-4}\downarrow$ | Image Recon. $\downarrow$ |
| --- | --- | --- | --- | --- |
|  | Noise (upper bound) | $0.039_{\pm.00}$ | 4.832 | 0.000 |
|  | DDIM Latent | $0.095_{\pm.01}$ | 47.015 | 0.014 |
|  | w/ our fix (4%) | $0.055_{\pm.00}$ | 5.125 | 0.033 |
| ADM-64 | w/ our fix (2%) | $0.055_{\pm.00}$ | 5.363 | 0.024 |
| (T=1000) | w/ our fix (1%) | $0.055_{\pm.00}$ | 5.679 | 0.019 |
|  | w/ our fix (0.5%) | $0.055_{\pm.00}$ | 6.057 | 0.017 |
|  | w/ our fix (0.2%) | $0.055_{\pm.00}$ | 6.662 | 0.015 |
|  | w/ our fix (0.1%) | $0.055_{\pm.00}$ | 7.228 | 0.014 |
|  | Noise (upper bound) | $0.039_{\pm.00}$ | 4.832 | 0.000 |
|  | DDIM Latent | $0.065_{\pm.01}$ | 17.931 | 0.009 |
|  | w/ our fix (4%) | $0.057_{\pm.00}$ | 5.233 | 0.060 |
| DiT | w/ our fix (2%) | $0.057_{\pm.00}$ | 5.071 | 0.041 |
| (T=1000) | w/ our fix (1%) | $0.057_{\pm.00}$ | 5.850 | 0.029 |
|  | w/ our fix (0.5%) | $0.058_{\pm.00}$ | 7.029 | 0.021 |
|  | w/ our fix (0.2%) | $0.058_{\pm.00}$ | 8.045 | 0.016 |
|  | w/ our fix (0.1%) | $0.058_{\pm.00}$ | 8.409 | 0.014 |
|  | Noise (upper bound) | $0.039_{\pm.00}$ | 4.832 | 0.000 |
|  | DDIM Latent | $0.249_{\pm.02}$ | 63.962 | 0.044 |
|  | w/ our fix (4%) | $0.055_{\pm.00}$ | 5.024 | 0.037 |
| IF | w/ our fix (2%) | $0.055_{\pm.00}$ | 5.215 | 0.031 |
| (T=1000) | w/ our fix (1%) | $0.055_{\pm.00}$ | 5.706 | 0.027 |
|  | w/ our fix (0.5%) | $0.055_{\pm.00}$ | 6.117 | 0.026 |
|  | w/ our fix (0.2%) | $0.055_{\pm.00}$ | 5.562 | 0.025 |
|  | w/ our fix (0.1%) | $0.056_{\pm.00}$ | 5.349 | 0.024 |

Figure: Figure 9: Approximation errors in DDIM inversion are significantly higher for plain image surfaces than for the rest of the image. Even when using $T=1000$ steps, we observe image structures in DDIM latents, notably for uniform image regions.
Refer to caption: x12.png

## Appendix G Conditioning Diffusion Models

For a thorough analysis, we employ both unconditional (ADM-32, ADM-64, ADM-256) and conditional (DiT, IF, SDXL) diffusion models. For conditioning, we take prompts from the Recap-COCO-30K dataset (Li et al., 2025) for IF and Stable Diffusion XL and ImageNet class names for DiT. However, as noted by Mokady et al. (2023), Classifier-Free Guidance introduces additional errors to the DDIM inversion, so to focus solely on the inversion approximation error, we disable CFG by setting the guidance scale to $w=1$.

## Appendix H Most probable triangles

In [Section 3.2](https://arxiv.org/html/2410.23530v4#S3.SS2), we analyze where the latent encodings are distributed in relation to the initial noise and generated samples. Here, we determine the most probable angles formed by noises ${\mathbf{x_{T}}}$, samples ${\mathbf{x_{0}}}$, and latents ${\mathbf{\hat{x}_{T}}}$ for each model.

### H.1 Methodology

First, we determine the vectors going from each vertex to the other vertices of the noise-sample-latent (${\mathbf{x_{T}}}$-${\mathbf{x_{0}}}$-${\mathbf{\hat{x}_{T}}}$) triangle. For sample ${\mathbf{x_{0}}}$, we obtain a vector leading to noise $\overrightarrow{{\mathbf{x_{0}}}{\mathbf{x_{T}}}}={\mathbf{x_{T}}}-{\mathbf{x_{0}}}$ and to latent $\overrightarrow{{\mathbf{x_{0}}}{\mathbf{\hat{x}_{T}}}}={\mathbf{\hat{x}_{T}}}-{\mathbf{x_{0}}}$, and calculate the angle between them using cosine similarity as

$$ $\angle{\mathbf{x_{0}}}=\arccos{\frac{\overrightarrow{{\mathbf{x_{0}}}{\mathbf{x_{T}}}}\cdot\overrightarrow{{\mathbf{x_{0}}}{\mathbf{\hat{x}_{T}}}}}{\lVert\overrightarrow{{\mathbf{x_{0}}}{\mathbf{x_{T}}}}\rVert\lVert\overrightarrow{{\mathbf{x_{0}}}{\mathbf{\hat{x}_{T}}}}\rVert}},$ (9) $$

and convert resulting radians to degrees. Similarly, we obtain the angle next to the noise $\angle{\mathbf{x_{T}}}$ and latent $\angle{\mathbf{\hat{x}_{T}}}$.

Next, we determine histograms for each angle, approximating the probability density function for every angle ($p_{\angle{\mathbf{x_{T}}}}$,$p_{\angle{\mathbf{x_{0}}}}$,$p_{\angle{\mathbf{\hat{x}_{T}}}}$) binned up to the precision of one degree, see [Fig. 11](https://arxiv.org/html/2410.23530v4#A8.F11). Finally, for all angles triples candidates (where $\angle{\mathbf{x_{T}}}+\angle{\mathbf{x_{0}}}+\angle{\mathbf{\hat{x}_{T}}}=180^{\circ}$), we calculate the probability of a triangle as the product of the probabilities and choose the triplet maximizing such joint probability:

$$ $\operatorname*{\arg\!\max}_{(\angle{\mathbf{x_{T}}},\angle{\mathbf{x_{0}}},\angle{\mathbf{\hat{x}_{T}}})}p_{\angle{\mathbf{x_{T}}}}\cdot p_{\angle{\mathbf{x_{0}}}}\cdot p_{\angle{\mathbf{\hat{x}_{T}}}}.$ (10) $$

### H.2 Results

Results of the experiment in [Table 10](https://arxiv.org/html/2410.23530v4#A8.T10) show that the angle located at the image and noise vertices (accordingly $\angle{\mathbf{x_{0}}}$ and $\angle{\mathbf{x_{T}}}$) are always acute and, in almost every case, the angle by the latent vertex ($\angle{\mathbf{\hat{x}_{T}}}$) is obtuse. This property implies that, due to approximation errors in the reverse DDIM process, latents reside in proximity to, but with a measurable offset, from the shortest-path trajectory between the noise distribution and the generated image.

**Table 10: Impact of the number of diffusion steps $T$ on angles in the noise ${\mathbf{x_{T}}}$, image ${\mathbf{x_{0}}}$, and latent ${\mathbf{\hat{x}_{T}}}$ triangle. Regardless of the number of diffusion steps, latents appear between Gaussian noise and generations.**
| Model | $T$ | $\angle{\mathbf{x_{0}}}$ | $\angle{\mathbf{x_{T}}}$ | $\angle{\mathbf{\hat{x}_{T}}}$ |
| --- | --- | --- | --- | --- |
| ADM<br>$32\times 32$ | $10$ | $44$ | $16$ | $120$ |
| $100$ | $29$ | $28$ | $123$ |  |
| $1000$ | $20$ | $45$ | $115$ |  |
| ADM<br>$64\times 64$ | $10$ | $30$ | $31$ | $119$ |
| $100$ | $11$ | $60$ | $109$ |  |
| $1000$ | $6$ | $79$ | $95$ |  |
| ADM<br>$256\times 256$ | $10$ | $24$ | $50$ | $106$ |
| $100$ | $24$ | $73$ | $83$ |  |
| $1000$ | $23$ | $73$ | $84$ |  |
| LDM<br>$256\times 256$ | $10$ | $23$ | $53$ | $104$ |
| $100$ | $2$ | $76$ | $102$ |  |
| $1000$ | $1$ | $83$ | $96$ |  |
| DiT<br>$256\times 256$ | $10$ | $27$ | $47$ | $106$ |
| $100$ | $4$ | $66$ | $110$ |  |
| $1000$ | $1$ | $80$ | $99$ |  |

In [Fig. 10](https://arxiv.org/html/2410.23530v4#A8.F10), we provide example triangles for ADM-32 (a), ADM-256 (b), and LDM (c), which we calculate using $N=1000$ images with $T=100$ diffusion steps.

Figure: (a) ADM-32 (CIFAR-10)
Refer to caption: x13.png

### H.3 Example histograms

In [Fig. 11](https://arxiv.org/html/2410.23530v4#A8.F11) we present histograms approximating probabiliy density functions for noise ${\mathbf{x_{T}}}$, image ${\mathbf{x_{0}}}$, and DDIM latent ${\mathbf{\hat{x}_{T}}}$ angles.

Figure: Figure 11: Histograms approximating probability density functions of angles values for noise, sample, and latent vertices. Example calculated for DiT model using $T=100$ diffusion steps.
Refer to caption: x16.png

## Appendix I Plain surface thresholding

During our experiments, we determine binary mask $\mathcal{M}$ to identify pixels corresponding to the plain areas in the images. We describe this process in this section.

Let $\mathbf{I}\in\mathbb{R}^{C\times H\times W}$ be the input image. For each pixel value across every channel $(c,h,w)$ in $\mathbf{I}$, we compute the absolute difference to point in the next row $D_{H}(c,h,w)=\lvert I_{c,h+1,w}-I_{c,h,w}\rvert$ and to the pixel in the next column $D_{W}(c,h,w)=\lvert I_{c,h,w+1}-I_{c,h,w}\rvert$. We obtain $D_{H}\in\mathbb{R}^{C\times H-1\times W}$ and $D_{W}\in\mathbb{R}^{C\times H\times W-1}$, which we pad with zeros (last row for $D_{H}$ and last column for $D_{W}$), making them of shape $C\times H\times W$. The difference matrix $D$, representing how a point varies from its neighbors, is computed as $D=(D_{W}+D_{H})/2$.

Finally, we determine a binary mask $\mathcal{M}_{c}$ per each channel $c$, by applying threshold $\tau$ to $D$ as

$$ $\mathcal{M}_{c}(h,w)=\begin{cases}1,&\text{if }D_{c}(h,w)<\tau\\ 0,&\text{otherwise}\end{cases}$ (11) $$

During the experiments, we set $\tau=0.025$.

The final mask $\mathcal{M}\in\{0,1\}^{W\times H}$ can be derived by evaluating the logical AND across all channels for each pixel location as

$$ $\mathcal{M}(h,w)=\prod_{c}\mathcal{M}_{c}(h,w).$ (12) $$

After obtaining the final mask for plain pixels, which we denote as $\mathcal{M}_{p}$, the according mask for non-plain image surfaces can be obtained by applying logical NOT to the mask as $\mathcal{M}_{n}=\neg\mathcal{M}_{p}$. In [Fig. 12](https://arxiv.org/html/2410.23530v4#A9.F12), we present example masks determined using our methodology.

Figure: Figure 12: Examples of samples together with their masks indicating plain areas (white). Images generated using DiT model.
Refer to caption: x19.png

## Appendix J Calculating inversion error

In [Section 3.3](https://arxiv.org/html/2410.23530v4#S3.SS3), we study how the inversion error differs for pixels related to plain and non-plain samples’ regions and investigate it across diffusion steps. In this section, we describe the method for determining the error.

First, we generate $N=4$k images with $T=50$ diffusion steps with both ADM-64 and DiT models, saving intermediate noise predictions $\{\mathcal{E}_{t}^{S}\}_{t=50\dots 1}$ during sampling. Next, we collect diffusion model outputs during the inversion process $\{\mathcal{E}_{t}^{I}\}_{t=1\dots 50}$ assuming all the previous steps were correct. While for $t=1$, $\mathcal{E}_{1}^{I}$ can be set to the diffusion model prediction from the first inversion step $\epsilon_{\theta}(x_{0})$, for further steps, more advanced methodology is necessary. To this end, for each $t^{\prime}=2\dots 50$, we map the images to latents with DDIM Inversion, replacing in $t=1\dots t^{\prime}-1$ the predicted noise $\epsilon_{\theta}(x_{t})$ with the ground truth prediction $\mathcal{E}_{t}^{S}$ from denoising process, and collect the model output for the $t^{\prime}$ step as $\mathcal{E}_{t^{\prime}}^{I}\coloneqq\epsilon_{\theta}(x_{t^{\prime}})$. For step $t$, this methodology is equivalent to starting the inversion process from $(t+1)$ denoising step and collecting the first diffusion model prediction.

In the next step, we calculate the absolute error between outputs during inversion and ground truth predictions as $\mathcal{E}_{t}^{E}=\lvert\mathcal{E}_{t}^{I}-\mathcal{E}_{t}^{S}\rvert$. This way, we obtain the inversion approximation error for each timestep.

Further, for the images in the dataset, we obtain binary masks $\mathcal{M}_{p}$ and $\mathcal{M}_{n}$ indicating, respectively, plain ($p$) and non-plain ($n$) pixels in the image, according to the procedure described in [Appendix I](https://arxiv.org/html/2410.23530v4#A9). To ensure that the level of noise that DM predicts in each step does not bias the results, we divide the absolute errors in each step by $l_{1}$-norm of model outputs, calculated separately for each diffusion step. For plain ($p$) pixels, it can be described as

$$ $\mathcal{E}_{t}^{Ep}=\nicefrac{{1}}{{\lVert\mathcal{E}_{t}^{I}\rVert_{1}}}\sum{(\mathcal{E}_{t}^{E}\odot\mathcal{M}_{p})},$ (13) $$

and adequately for non-plain ($n$) pixels as

$$ $\mathcal{E}_{t}^{En}=\nicefrac{{1}}{{\lVert\mathcal{E}_{t}^{I}\rVert_{1}}}\sum{(\mathcal{E}_{t}^{E}\odot\mathcal{M}_{n})}.$ (14) $$

In [Table 11](https://arxiv.org/html/2410.23530v4#A10.T11), we present the error differences for plain and non-plain areas and how the first $10\%$ of the diffusion steps contribute to the total inversion error. To calculate this error for plain regions in steps $t_{s},\dots,t_{e}$, we sum errors for timesteps from a given interval as

$$ $\bar{\mathcal{E}}_{(t_{s},t_{e})}^{Ep}=\sum_{t^{\prime}=t_{s}}^{t_{e}}\mathcal{E}_{t}^{Ep}.$ (15) $$

Figure: Table 11: Total per‑pixel inversion error (normalized) over different timestep ranges $\bar{\mathcal{E}}_{(t_{s},t_{e})}^{E}$ for plain and non-plain areas. Inversion approximation error is higher for pixels related to plain image areas, especially in the first 10% of inversion steps.

## Appendix K Pseudocode for DDIM Inversion with Forward Diffusion

We present in [Algorithm 1](https://arxiv.org/html/2410.23530v4#alg1) the pseudocode for the proposed solution to the decorrelation of latent encodings by replacing the first $t^{\prime}$ inversion steps with a forward diffusion process.

Figure: Algorithm 1 Finding decorrelated DDIM latent encoding ${\mathbf{\hat{x}_{T}}}$

## Appendix L Details on diversity and alignment of edition

In this section, we provide results for measuring the diversity (against source images $I_{S}$) and alignment to conditioning prompts (source $P_{S}$ and target $P_{T}$) of images generated from Gaussian noise ${\mathbf{x_{T}}}$, DDIM latents ${\mathbf{\hat{x}_{T}}}$, or the latents produced by our fix (described in [Algorithm 1](https://arxiv.org/html/2410.23530v4#alg1)) with modified prompts. We use distance-based metrics (LPIPS (Zhang et al., 2018), DreamSim (Fu et al., 2023)), similarity metrics (SSIM (Wang et al., 2004), DINO (Darcet et al., 2024)) to measure the diversity between source (input) images and target (edited) images, as well as the similarity between embeddings produced by the CLIP (Radford et al., 2021) model to calculate the alignment between the results and prompts. The results in for introduced latent decorrelation procedure are obtained with varying percentages of the first DDIM inversion steps replaced with forward diffusion. In [Table 12](https://arxiv.org/html/2410.23530v4#A12.T12), we show that by selecting a small fraction of inversion steps to replace with forward diffusion (from $2\%$ up to $6\%$), the resulting latents are more editable.

**(a) Diffusion Transformer**
| Inversion steps replaced | Diversity against $I_{S}$ | CLIP Alignment |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| by forward diff. ($\%T$) | DreamSim $\uparrow$ | LPIPS $\uparrow$ | SSIM $\downarrow$ | DINO $\downarrow$ | $P_{S}\downarrow$ | $P_{T}\uparrow$ |
| Noise ${\mathbf{x_{T}}}$ | $0.709$ | $0.591$ | $0.228$ | $0.174$ | $0.465$ | $0.681$ |
| DDIM Latent ${\mathbf{\hat{x}_{T}}}$ | $0.677$ | $0.564$ | $0.261$ | $0.223$ | $0.480$ | $0.662$ |
| $1$ ($2\%$) | $0.696$ | $0.580$ | $0.239$ | $0.187$ | $0.470$ | $0.676$ |
| $1\dots 2$ ($4\%$) | $0.701$ | $0.587$ | $0.227$ | $0.179$ | $0.469$ | $0.677$ |
| $1\dots 3$ ($6\%$) | $0.705$ | $0.594$ | $0.216$ | $0.173$ | $0.468$ | $0.678$ |
| $1\dots 5$ ($10\%$) | $0.711$ | $0.605$ | $0.198$ | $0.165$ | $0.466$ | $0.679$ |
| $1\dots 50$ ($100\%$) | $0.805$ | $0.801$ | $0.013$ | $0.085$ | $0.465$ | $0.680$ |

## Appendix M Stochastic editing of real images

In this work, we propose the solution for decorrelating latent encodings resulting from DDIM inversion by replacing its first steps with the forward diffusion. As presented in [Algorithm 1](https://arxiv.org/html/2410.23530v4#alg1), the forward diffusion process involves sampling random Gaussian noise $\tilde{\epsilon}\sim\mathcal{N}(0,\mathcal{I})$ and interpolating it with input image. Due to the fact that, when we replace a small fraction of steps ($2-4\%$), the change in image reconstruction error is insignificant, the use of different noises $\tilde{\epsilon}$ (in practice, sampled with different seeds) allows stochastic image editing, i.e. generating different manipulations of the input image, a feature not naturally available with DDIM inversion. In [Fig. 13](https://arxiv.org/html/2410.23530v4#A13.F13), we present examples of editing real images from the ImageNet-R-TI2I dataset (which we annotate using GPT-4o) with the IF model, showing various semantically correct modifications of the same image.

As preserving original image structure during editing is stated as a more difficult task for real images than the one naturally generated by diffusion model, we follow Hertz et al. (2022) by, first, denoising latent encodings with source prompt (the one used during inversion), and, after $6\%$ of the steps, using target prompt as conditioning. The examples presented in [Fig. 13](https://arxiv.org/html/2410.23530v4#A13.F13) indicate, that our fix (1) enables stochastic editing of images and (2) enables image manipulations in plain image regions, contrary to editing with naïve DDIM latents.

Figure: Figure 13: Replacing first DDIM inversion steps with forward diffusion enables stochastic image editing, resulting in multiple semantically correct manipulations of same input image. Contrary to DDIM Inversion, editing with latents produced by the solution introduced in this work, enables image manipulations in uniform input image areas.
Refer to caption: x20.png

## Appendix N Noise-to-image mapping

We showcase an additional study showing the differences that occur between noise and latent encodings, from the perspective of their mapping to the images. Several works investigate interesting properties between the initial random noise and generations that result from the training objective of DDPMs and score-based models. Kadkhodaie et al. (2024) show that due to inductive biases of denoising models, different DDPMs trained on similar datasets converge to almost identical solutions. This idea is further explored by Zhang et al. (2024a), observing that even models with different architectures converge to the same score function and, hence, the same noise-to-imape mapping. Khrulkov & Oseledets (2022) show that diffusion models’ encoder map coincides with the optimal transport (OT) map when modeling simple distributions. However, other works (Kim & Milman, 2011; Lavenant & Santambrogio, 2022) contradict this finding.

### N.1 Smallest l 2 l_{2} mapping

Diffusion models converge to the same mapping between the Gaussian noise (${\mathbf{x_{T}}}$) and the generated images (${\mathbf{x_{0}}}$) independently on the random seed, dataset parts (Kadkhodaie et al., 2024), or the model architecture (Zhang et al., 2024a). We further investigate this property from the noise-sample and latent-sample mapping perspective.

In our experimental setup, we start by generating $N=2000$ images ${\mathbf{x_{0}}}$ from Gaussian noise ${\mathbf{x_{T}}}$ with a DDIM sampler and invert the images to latents ${\mathbf{\hat{x}_{T}}}$ with naïve DDIM inversion. Next, we predict resulting images for the starting noise samples (${\mathbf{x_{T}}}\rightarrow{\mathbf{x_{0}}}$) by iterating over all the $N$ noises, and for each of them, we calculate its pixel distances to all the $N$ generations. For given noise, we select the image to which such $l_{2}$-distance is the smallest. Similarly, we investigate image-to-noise (${\mathbf{x_{0}}}\rightarrow{\mathbf{x_{T}}}$), image-to-latent (${\mathbf{x_{0}}}\rightarrow{\mathbf{\hat{x}_{T}}}$) and latent-to-image (${\mathbf{\hat{x}_{T}}}\rightarrow{\mathbf{x_{0}}}$) mappings. We calculate the distance between two objects as $l_{2}$ norm of the matrix of differences between them (with $C\times H\times W$ being the dimensions of either pixel or latent space of diffusion model) as ${||x-y||}_{2}=\sqrt{\Sigma_{i}^{C}\Sigma_{j}^{H}\Sigma_{j}^{W}(x_{i,j,k}-y_{i,j,k})^{2}}$.

In [Table 13](https://arxiv.org/html/2410.23530v4#A14.T13), we investigate the accuracy of the procedure across varying numbers of diffusion steps $T$ for both image$\leftrightarrow$noise (a) and image$\leftrightarrow$latent (b) assignments. We show that assigning initial noise to generations (${\mathbf{x_{0}}}\to{\mathbf{x_{T}}}$) through the distance method can be successfully done regardless of diffusion steps. For the reverse assignment, which is noise-to-image (${\mathbf{x_{T}}}\to{\mathbf{x_{0}}}$) mapping, we can observe high accuracy with a low number of generation timesteps ($T=10$), but the results deteriorate quickly with the increase of this parameter. The reason for this is that greater values of $T$ allow the generation of a broader range of images, including the ones with large plain areas of low pixel variance. When it comes to mappings between images and latents resulting from DDIM Inversion, assignment in both directions is infeasible for pixel diffusion, regardless of $T$.

**(a) Assigning noise to the corresponding generated image $({\mathbf{x_{0}}}\rightarrow{\mathbf{x_{T}}})$ and vice-versa $({\mathbf{x_{T}}}\rightarrow{\mathbf{x_{0}}})$.**
| T | ADM-32 | ADM-64 | ADM-256 | LDM | DiT |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| ${\mathbf{x_{0}}}\rightarrow{\mathbf{x_{T}}}$ | ${\mathbf{x_{T}}}\rightarrow{\mathbf{x_{0}}}$ | ${\mathbf{x_{0}}}\rightarrow{\mathbf{x_{T}}}$ | ${\mathbf{x_{T}}}\rightarrow{\mathbf{x_{0}}}$ | ${\mathbf{x_{0}}}\rightarrow{\mathbf{x_{T}}}$ | ${\mathbf{x_{T}}}\rightarrow{\mathbf{x_{0}}}$ | ${\mathbf{x_{0}}}\rightarrow{\mathbf{x_{T}}}$ | ${\mathbf{x_{T}}}\rightarrow{\mathbf{x_{0}}}$ | ${\mathbf{x_{0}}}\rightarrow{\mathbf{x_{T}}}$ | ${\mathbf{x_{T}}}\rightarrow{\mathbf{x_{0}}}$ |  |
| $10$ | $90.3_{\pm 6.3}$ | $94.0_{\pm 2.6}$ | $99.4_{\pm 0.0}$ | $100_{\pm 0.0}$ | $100_{\pm 0.0}$ | $39.2_{\pm 6.2}$ | $100_{\pm 0.0}$ | $100_{\pm 0.0}$ | $100_{\pm 0.0}$ | $93.7_{\pm 7.2}$ |
| $100$ | $98.9_{\pm 1.2}$ | $50.4_{\pm 1.9}$ | $100_{\pm 0.0}$ | $59.0_{\pm 7.1}$ | $100_{\pm 0.0}$ | $23.2_{\pm 4.8}$ | $100_{\pm 0.0}$ | $100_{\pm 0.0}$ | $100_{\pm 0.0}$ | $90.7_{\pm 10.1}$ |
| $1000$ | $99.1_{\pm 1.0}$ | $46.8_{\pm 3.0}$ | $99.8_{\pm 0.2}$ | $44.6_{\pm 6.3}$ | $100_{\pm 0.0}$ | $25.0_{\pm 4.4}$ | $100_{\pm 0.0}$ | $100_{\pm 0.0}$ | $100_{\pm 0.0}$ | $96.7_{\pm 4.6}$ |
| $4000$ | $99.1_{\pm 1.0}$ | $46.4_{\pm 3.0}$ | $99.5_{\pm 0.3}$ | $43.3_{\pm 6.7}$ | - | - | - | - | - | - |

For both noise $x^{T}$ and latents $\hat{x}^{T}$, their assignment to images in both directions can be successfully done when the denoising is performed in the latent space, as shown for DiT and LDM models. We hypothesize that this fact is connected with the KL regularization term that imposes a slight penalty towards a standard normal distribution $\mathcal{N}(0,I)$ on the latent during training (Rombach et al., 2021).

### N.2 Asymmetry of Noise-to-Image mapping

Results in [Table 13(a)](https://arxiv.org/html/2410.23530v4#A14.T13.st1) indicate that, even though the $l_{2}$-distance is symmetrical, the mapping cannot be done in both directions. The reason behind this is that image and noise assignments are not the same due to the one-directional many-to-one relation, e.g., there might be several noises pointing towards the same closest image.

We present examples of wrong noise-to-image (${\mathbf{x_{T}}}\rightarrow{\mathbf{x_{0}}}$) assignments in [Fig. 14](https://arxiv.org/html/2410.23530v4#A14.F14)A for ADM-64. In [Fig. 14](https://arxiv.org/html/2410.23530v4#A14.F14)B, we present the singular generations that lead to incorrect noise-to-image classification (noise attractors), along with the number of noises for which they are the closest. Interestingly, in [Fig. 14](https://arxiv.org/html/2410.23530v4#A14.F14)C, we sort all the generations used in the experiment by the variance of pixels and show 8 least variant images. We observe that the set of singular generations leading to misclassification partially overlaps with lowest-variance generations. In [Fig. 15](https://arxiv.org/html/2410.23530v4#A14.F15) we observe similar properties for experiment with ADM-32 model.

When assigning images to the initial noises, there are singular generations (with large plain areas) located close to the mean of the random Gaussian noise in the set of generated images. Such generations tend to be the closest (in $l_{2}$-distance) for the majority of the noises in our experiments.

Figure: Figure 14: Examples of incorrect assignments of initial noises to resulting images (A), two most noise-attracting images (B), and samples sorted in ascending order by variance of pixels for ADM-64 model trained on the ImageNet dataset.
Refer to caption: x21.png

Figure: Figure 15: Examples of incorrect assignments of initial noises to resulting images (A), two most noise-attracting images (B), and samples sorted in ascending order by variance of pixels for ADM-32 model trained on the CIFAR-10 dataset.
Refer to caption: x22.png

#### Conclusion.

Those findings, connected with the reduced diversity of latents ([Table 3](https://arxiv.org/html/2410.23530v4#S3.T3)), suggest that the DDIM latents, unlike noise, cannot be accurately assigned to samples, as the error brings them towards the mean, reducing their diversity and making them closest to most of the images.

## Appendix O On Noise-Image-Latent relations during diffusion training

To further explore the relationships that exist between noises, generations, and latents, we study how the relationships between them change with the training of the diffusion model. We train two diffusion models from scratch and follow the setup from Nichol & Dhariwal (2021) for two unconditional ADMs for the ImageNet ($64\times 64$) and CIFAR-10 ($32\times 32$) datasets. The CIFAR-10 model is trained for $700$K steps, while the ImageNet model – for $1.5$M steps, both with a batch size of $128$. Models employ a cosine scheduler with $4$K diffusion steps.

### O.1 Spatial relations of noise and latents over training time

We conclude our latent localization experiments ([Section 3.2](https://arxiv.org/html/2410.23530v4#S3.SS2)) by showing that our observations are persistent across the diffusion model training process. We generate $N=2048$ images with the final model, using implicit sampling with $T=100$ steps, and invert them to the corresponding latents using checkpoints saved during the training. In [Fig. 16](https://arxiv.org/html/2410.23530v4#A15.F16), we show that both the angle adjacent to the noise $\angle{\mathbf{x_{T}}}$ and the distance between the latent and noise $\lVert{\mathbf{\hat{x}_{T}}}-{\mathbf{x_{T}}}\rVert_{2}$ quickly converge to the point that remains unchanged through the rest of the training, indicating that the relation between noises, latents, and samples is defined at the very early stage of the training. Additionally, we observe that the noise reconstruction error in DDIM Inversion does not degrade with the training progress.

Figure: Figure 16: We investigate spatial relations between the noise ${\mathbf{x_{T}}}$, latents ${\mathbf{\hat{x}_{T}}}$, and generated images ${\mathbf{x_{0}}}$ over training process of diffusion model. We show that those relations are defined at the early stage of the training.
Refer to caption: x23.png

### O.2 Image-to-noise distance mapping over training time

We analyze the image-noise mapping with $l_{2}$-distance from [Appendix N](https://arxiv.org/html/2410.23530v4#A14) over diffusion model training time. We sample $N=2000$ Gaussian noises and generate images from them using ADM models with $T=100$ diffusion steps, calculating the accuracy of assigning images to corresponding noises (and vice versa) using the smallest $l_{2}$-distance. In [Fig. 17](https://arxiv.org/html/2410.23530v4#A15.F17), we can observe, for both models, that the distance between noises and their corresponding generations accurately defines the assignment of initial noises given the generated samples (${\mathbf{x_{0}}}\to{\mathbf{x_{T}}}$) from the beginning of the training till the end. At the same time, the accurate reverse assignment (${\mathbf{x_{T}}}\to{\mathbf{x_{0}}}$) can only be observed at the beginning of the training when the trained model is not yet capable of generating properly formed images. Already in the beginning phase of model training, the quality of noise to image mapping rapidly drops and does not change until the end of training.

Figure: (a) ADM-64
Refer to caption: x25.png

### O.3 Image alignment over training time

Inspired by the noise-image mapping experiment, we investigate how the generations resulting from the same noise visually change over DM training time. Thus, for each training step $n\in\{1\dots 700\text{K}\}$ for CIFAR-10 and $\{1\dots 1.5\text{M}\}$ for ImageNet, we generate $2048$ samples $\{\mathbf{x}_{i,n}^{\mathbf{0}}\}_{i=1}^{2048}$ from *the same random noise* $\mathbf{x}_{\mathbf{T}}^{\text{fixed}}\sim\mathcal{N}(0,\mathcal{I})$, and compare them with generations obtained for the fully trained model. We present the visualization of this comparison in [Fig. 18](https://arxiv.org/html/2410.23530v4#A15.F18) using CKA, DINO, SSIM, and SVCCA as image-alignment metrics. We notice that image features rapidly converge to the level that persists until the end of the training. This means that prolonged learning does not significantly alter how the data is assigned to the Gaussian noise after the early stage of the training. It is especially visible when considering the SVCCA metric, which measures the average correlation of top-$10$ correlated data features between two sets of samples. We can observe that this quantity is high and stable through training, showing that generating the most important image concepts from a given noise will not be affected by a longer learning process. For visual comparison, we plot the generations sampled from the model trained with different numbers of training steps in [Fig. 18](https://arxiv.org/html/2410.23530v4#A15.F18) (right).

Figure: Figure 18: Similarity of the generations sampled from the same random noise at different stages of diffusion model’s training to the final outputs for ADM-64 model. Only after a few epochs does the model already learn the mapping between Gaussian noise and generations. Prolonged training improves the quality of samples, adding high-frequency features without changing their content. This can be observed through different image alignment metrics (left) and visual inspection (right).
[Uncaptioned image]: x27.png

In [Fig. 19](https://arxiv.org/html/2410.23530v4#A15.F19), we visualize how the diffusion model learns the low-frequency features of the image already at the beginning of the fine-tuning when comparing generations from the next training steps against the generations after finished fine-tuning for the ADM-32 model trained on the CIFAR-10 dataset. In  [Fig. 20](https://arxiv.org/html/2410.23530v4#A15.F20) (ADM-64) and [Fig. 21](https://arxiv.org/html/2410.23530v4#A15.F21) (ADM-32), we show additional examples illustrating how generations evolve over training for the same Gaussian noise ${\mathbf{x_{T}}}$ using a DDIM sampler. Initially, low-frequency features emerge and remain relatively stable, while continued fine-tuning improves generation quality by refining only the high-frequency details.

Figure: Figure 19: Similarity of the generations sampled from the same random noise at different stages of diffusion model’s training to the final outputs for ADM-32 (CIFAR-10). We plot CKA, SVCCA, SSIM, and DINO image alignment metrics and show that the diffusion model already learns the mapping between Gaussian noise and generations at the beginning of the training.
Refer to caption: x29.png

Figure: Figure 20: Examples of images sampled using DDIM scheduler from the same noise during the training process for the ADM-64 model trained on the ImageNet dataset.
Refer to caption: x30.png

Figure: Figure 21: Examples of images sampled using DDIM scheduler from the same noise during the training process for the ADM-32 model trained on the CIFAR-10 dataset.
Refer to caption: x31.png

## Appendix P Additional results

In this section, we present qualitative results of replacing first DDIM Inversion steps with forward diffusion.

### P.1 Failure cases

As described in [Section 4](https://arxiv.org/html/2410.23530v4#S4), while replacing a higher number of inversion steps with forward diffusion enables better editability of latent encodings (through decorrelating them), it increases the image reconstruction error. In [Fig. 22](https://arxiv.org/html/2410.23530v4#A16.F22), we show that replacing $10\%$ or $20\%$ of first steps can introduce significant changes to images.

Figure: Figure 22: Replacing first DDIM inversion steps with forward diffusion increases latents editability at cost of a higher reconstruction error. By replacing from $2\%$ up to $4\%$ of steps we obtain reasonable image reconstructions while removing correlations from latents.
Refer to caption: x32.png

### P.2 Interpolation

In [Section 4](https://arxiv.org/html/2410.23530v4#S4), we presented that interpolating DDIM latents with SLERP (Shoemake, 1985) leads to decrease in image quality and diversity when compared to Gaussian noise. In [Fig. 23](https://arxiv.org/html/2410.23530v4#A16.F23), we qualitatively compare our fix for removing correlations in latent encodings with naïve DDIM inversion in the task of image interpolation.

Figure: Figure 23: Qualitative comparison of images generated from interpolated latents produced with DDIM Inversion and our fix. Contrary to naïve DDIM inversion, proposed solution enables generating high quality objects with pixel-diverse background.
Refer to caption: x33.png

## Peer Reviews

confidence: 4
contribution: 3
initial_rating: 6
presentation: 4
questions: - Have the authors tested whether similar inversion-induced correlation patterns appear in flow-matching models such as FLUX or Stable Diffusion 3?
- Can the proposed method enhance performance when combined with various editing engines such as MasaCtrl or Pix2Pix-Zero? Demonstrating improvements across multiple editing scenarios would further strengthen the paper.
- Tables 4 and 7 suggest that increasing the proportion of forward diffusion replacement decreases reconstruction fidelity, while improving editability. This appears to reflect an inherent trade-off between preserving the original image information and increasing the degree of manipulation. It would be valuable to analyze or formalize this trade-off explicitly.
soundness: 4
strengths: - The paper provides a thorough and insightful diagnosis of the underlying causes of latent distortions introduced during inversion.
- The experiments are conducted across a diverse set of diffusion models, supporting the generality of the findings.
- The proposed forward-diffusion replacement is conceptually simple, easy to integrate, and empirically improves both interpolation smoothness and the diversity of editing outcomes.
summary: This paper presents a systematic analysis of DDIM inversion in diffusion models, focusing on the discrepancy between the original Gaussian noise and the latent representation of DDIM inversion. The authors identify that inversion errors primarily accumulate in early steps and are particularly pronounced in plain image regions. Based on this observation, the paper proposes a simple method that replaces the first inversion steps with forward diffusion noise.
weaknesses: - The analysis focuses on diffusion-based models and does not provide evidence that similar problems occur in flow-matching models (e.g., FLUX, Stable Diffusion 3)
- The paper evaluates mainly interpolation and text-guided editing, but does not explore other inversion-driven applications (e.g., local editing, style transfer).

---

confidence: 4
contribution: 3
initial_rating: 4
presentation: 3
questions: Please see weakness section. Addressing the raised concerns could affect my final rating for the paper.
soundness: 2
strengths: 1.	The authors provide a nice observation regarding the statistics of inverted noise latents compared to the native noise space, and the repercussions regarding the usage of these latents for image manipulation and editing.
2.	The authors provide a simple remedy to fix the inverted latent statistics, and as such their downstream editing potential, with minimal cost of reconstruction quality.
3.	The authors provide thorough quantitative evaluation of the tasks presented (image interpolation and text-based image editing).
summary: The authors examine DDIM inversion in diffusion models, a process of recovering an approximate noise map that reconstructs a user provided image. First, they study the statistical relation between pure normal gaussian noise, the corresponding sampled image, and the noise obtained via inversion of that same image. They show that the inverted noise maps differ from the standard gaussian distribution, having especially high neighboring pixel correlations in areas where the input image is smooth. Secondly, they claim that these statistical deviations lead to higher inversion error, and worse performance when used for of text-based editing and image interpolation. Finally, the authors claim that this error stems from low accuracy in the initial inversion timesteps and propose a simple fix of using random added noise instead, which improves the inverted noise statistics and its applicability to interpolation and editing.
weaknesses: 1.	Adding random gaussian noise instead of inversion in the first steps. The authors claim that the last steps are not important for reconstruction quality, but the diffusion process acts as a coarse-to-fine spectral regressor throughout the whole process [1]. This means that the last steps should correspond to fine-grained details, such as textures. This can be observed, for example, in the results in figure 6 (top right) where the tower in the background is generated with small windows,  which did not exist in the original image.  An ablation on the effect of the added noise for different amounts of timesteps is recommended.

2.	Hard to qualitatively evaluate the results for inversion reconstruction and text-based image editing. Only a few results are present in the main paper, and the results in the supplementary section are highly compressed, while no further image files were provided in the zip. I would recommend adding more results to the paper, especially for the editing experiments, since current metrics cannot fully replace human assessment.

[1] Rissanen et al. 2023. Generative Modelling With Inverse Heat Dissipation

---

confidence: 3
contribution: 2
initial_rating: 4
presentation: 3
questions: **DDIM Inversion Formula**

There appear to be different formulations of DDIM inversion in the literature. On one hand, Null-text inversion (https://arxiv.org/pdf/2211.09794, Sec 3.1) and Dhariwal & Nichol (https://arxiv.org/abs/2102.09672) both call the denoising network on $x_{t-1}$ with timestep $t-1$, i.e. $\epsilon^{(t)}\_{\theta}(x_{t}, c) \simeq \epsilon^{(t-1)}\_{\theta}(x_{t-1}, c)$. On the other hand, the authors in Eq. (3) seem to follow ReNoise (https://arxiv.org/pdf/2403.14602, Sec 3.1) and keep the same timestep but change $x_{t}$ to $x_{t-1}$, i.e. $\epsilon^{(t)}\_{\theta}(x_{t}, c) \simeq \epsilon^{(t)}\_{\theta}(x_{t-1}, c)$. In my understanding, the former formulation (calling the network on $x_{t-1}$ with its corresponding timestep $t-1$) represents the correct reverse ODE. This leads to the following questions:

- Which version exactly did the authors implement in the experiments?
- Have the authors noted any difference in the conclusions using the other version? 
- In particular, this choice changes the definition of the approximation error $\xi(t)$ in Eq. (4). How does that change the results and conclusions?

Note that in Appendix E, the authors use the latter formulation (non-matching timesteps) in the text, but the illustration in Fig. 8 seems to show the former formulation (matching timesteps). I believe this could be further clarified to improve the reproducibility of the experiments.

**Image Editing and Reconstruction**

Overall, I am not very convinced by the validation provided to measure the quality of image editing applications.

- In Fig. 7, the explanation suggests the method is superior to standard DDIM inversion because it performs similarly to original Gaussian noise in both image diversity and prompt alignment. However, this comparison may not fully validate the editing task. While using real Gaussian noise $x_T$ with a target prompt will expectedly yield a high-quality, prompt-aligned image, it offers no guarantee of fidelity to the source image. Successful editing requires preserving significant portions of the original image while making targeted modifications. Therefore, performance closer to real Gaussian noise does not, by itself, validate superior editing performance.
- A similar remark applies to Table 7 and Sec 4.3: CLIP text alignment alone is insufficient to assess image editing quality, as it does not measure the preservation of unedited regions. I would suggest considering metrics specifically designed for editing, such as **directional CLIP similarity** (StyleGAN-NADA, https://arxiv.org/abs/2108.00946) or **AugCLIP** (https://arxiv.org/abs/2410.11374), for a more comprehensive assessment.
- Image editing performance often differs between generated and real images. I may have missed it, but are there any editing results with real images? If not, adding a few such examples would significantly strengthen the assessment of the method's practical utility.

**Result with Large Latent Diffusion Models**

Large text-to-image diffusion models like Stable Diffusion are very common in the field, yet not fully assessed in this paper.

- Considering the widespread use of Stable Diffusion models (SD2.1, SDXL, SD3), I was wondering why the authors did not include analysis with these models in the first part of the paper (beyond the results with SDXL in Sec. 4.3)?
- Did the authors observe any correlation between the quality of standard DDIM inversion and the size of the model's training dataset? One might expect that models trained on larger datasets are less prone to inversion errors, and that the proposed fix would have less impact in these cases. I would be happy to get the authors' perspective on this.

**Other questions and notes**

- What model was used in Figure 1, Figure 6 and Figure 13?
- The CFG scale can significantly impact experiment outcomes. The authors mention in Appendix G that they use a CFG scale $w=1$ for conditional diffusion models. Does this apply only to the image editing part, or to all experiments in the first part of the paper as well?
- In Sec 4.3, I believe it could be more explicitly mentioned that the results in Table 7 are based on a comparison with an equal number of function evaluations (NFEs).
- Appendix H shows interesting differences in the shape of the most probable triangles between models. Do the authors have an explanation for what might be causing these vastly different triangle shapes?
- In Fig. 3, perhaps a different color scheme or the addition of level set lines could help better visualize the intended point. If I understand correctly, the bottom-left corner (distance between $x_T$ and $x_T$) should be 0. However, its color appears similar to the top-right corner, which would suggest that the image latent $x_0$ is almost the same as the inverted noise $\hat{x}_T$. This seems counter-intuitive, and a clarification would be helpful.
- Appendix N shows an interesting experiment using the $L_2$ distance. In general, it is understood that the noise is not necessarily close to the image in an $L_2$ sense, but rather that they are correlated. Out of simple curiosity, does the mapping become feasible if a Pearson correlation metric is used instead?
- Lastly, I noted a minor citation issue: the reference to Samuel et al. appears to be missing the year, showing up as "Samuel et al." in the text instead of "Samuel et al. 2025".

I thank the authors for their time and look forward to any clarifications they can provide.
soundness: 2
strengths: The paper provides a structured analysis of the problem, which can be valuable to the community. While many of its conclusions are already well-established within the field (DDIM inversion is not a Gaussian noise etc.), the experiments presented in the methods section offer tangible evidence that reaffirms these claims. Furthermore, the paper proposes a simple solution that appears to effectively mitigate the identified issues. Overall, the presentation is clear and easy to follow.
summary: This paper sheds light on a known phenomena—the discrepancy between a real Gaussian noise and the inversion noise obtained through DDIM inversion—and provides a simple fix to mitigate it. When performing DDIM inversion on an image, the resulting noise is generally not Gaussian. The authors point out that this is particularly true in regions of the image that are flat (i.e. textureless). Through a set of experiments, they pinpoint the reason of this discrepancy to lie in the very first few steps of inversion. To solve this, the paper proposes to replace the first few steps of inversion by a forward noising step. This is generally done for only ~4% of the denoising path. 

Experiments ablate the threshold to which one should do forward noising, and validate that this fix indeed improves inversion quality for editing tasks.
weaknesses: My main concern with the paper lies in its contributions. The method is organized into three subsections, in which the authors address the following questions:

- Sec 3.1: Are there any difference between the original noise and the DDIM inversion noise? (Answer: Yes)
- Sec 3.2: How does it differ? (Answer: Loss of variance mostly in plain regions)
- Sec 3.3: Why? (Answer: Because it happens in the first few steps)

In my opinion, the first two sections primarily reiterate observations and facts that are already well known to the community, albeit supplemented with additional visualizations and plots that support these claims. The authors themselves mention prior work studying the same problem at the beginning of Sec 3.1. The third section has the potential to be more interesting; however, its conclusion appears to be based mainly on empirical observation, and the authors do not provide a convincing explanation for the observed phenomenon, which would have been the most compelling aspect of the analysis. Lastly, the proposed fix, while somewhat effective, appears ad hoc and lacks a principled justification.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: - in appendix G, the authors mention: "Classifier-Free Guidance introduces additional errors to the DDIM inversion, so to focus solely on the inversion approximation error, we disable CFG by setting the guidance scale to w = 1. To the extent of my knowledge, this is the main reason multiple "image-to-noise inversion techniques" have been explored in literature. Although setting w > 1 does drastically alter the given image, I wonder if applying the proposed fix also provide a meaningful improvement in terms of fidelity or text alignment.
soundness: 3
strengths: - The main strenghts of this paper is in its arrangement and analysis of previous work. The authors go through great lengths in analyzing the claims of previous work that have mentioned this non-gaussian property of the final latent in DDIM inversion, and structures it well with their own quantitative experiments, corroborating past claims with evidence.
- Their quantitative experiments bring a clear insight that the early inversion steps were the root cause of the issue, emphasized more in what the authors call smooth (plain) image regions. Their proposed fix is simple and easy to implement, with convincing quantitative/qualitative improvements compared to the vanilla method of simply changing the target prompt starting from $\mathbf{\hat{x}}_T$.
- The experiments are wide breadth-wise, with multiple ablations that quantitatively show improvements.
summary: This paper analyzes DDIM inversion, specifically the non-gaussian properties of the final latent $\mathbf{\hat{x}}_T$ which has been mentioned multiple times in previous literature but not explored throughoutly like the authors have done in this work. The authors show that the inverted latents quantitatively exhibit spatial correlations with the original image, especially in smooth (plain) iage regions, attributing it to the approximation errors in the early inversion steps. They propose a simple fix of replacing the first few steps with the original forward diffusion process. Their fix restores the gaussian properties of the final inverted latents, improving editability and text alignment when using DDIM inversion.

Overall, although this work has limited applicability (see weaknesses), this work is technically solid with extensive experiments that dive deep into the emprical findings that have been brushed off in previous works. Limited applicability do not outweigh its contributions in the form of empirical analyses.
weaknesses: Weaknesses:
- The main weakness of this work that I've found is the limited theoretical grounding of their explanation on why the early inversion steps causes correlation with the original image. Their explanation for why the early steps cause correlation is mostly empirical, and the connection they make to the ODE curvature could be formalized further. In order to prove why the proposed simple fix works should be first followed why the early inversion steps are theoretically the root cause. I do not see the simple, heuristic fix the authors propose as a weakness, just that the cause should be diven into deeper.
- The scope of their fix, especially in terms of image editing, is narrow as they demonstrate it on solely DDIM inversion. To the extent of my knowledge, most image editing tasks with text prompt inversion methods do not rely on plain DDIM inversion, but rather "image-to-noise inversion techniques" as described in section 2. Some of these inversion techniques might not be directly applicable to the proposed method, but when they are, I believe the proposed method should be demonstrated on them.

Comments:
- Though not strictly a weakness, It would be better if how the plain background or surfaces are mathematically calculated was included in the main text (even just a breif 2-3 liner) instead of fully allocating it to appendix I.


Decision: Accept (Poster)