Skip the
steps.

Rung 4 needs many steps because its reverse process is a Markov chain that injects fresh noise at every step — each step is a small stochastic move, and you cannot take a large one without leaving the distribution the model was trained on.

The change is to notice that the training objective does not actually require that particular sampler. A family of reverse processes is consistent with the same trained noise-prediction network, and one member of that family injects no noise at all. Set the added variance to zero and sampling becomes deterministic: from a given starting noise, one image, every time. The step is then a clean two-part operation — use the predicted noise to estimate the fully denoised image, then move back toward the noise level of the next step you care about.

Because that move is a deterministic jump to an arbitrary noise level, you can skip most of the schedule. Stated in rung 4's units, sampling goes from around a thousand steps to something in the region of twenty to fifty for good results — a speed-up of one to two orders of magnitude from reinterpreting the sampler, with the same weights and no retraining. A single parameter interpolates between this sampler and rung 4's, so the two are endpoints of one family rather than rivals.

Determinism buys a second thing that mattered as much: the map from noise to image is now invertible. You can run it backwards to find the noise that produces a given image, and that is what makes real-image editing possible — encode the photo, change the condition, decode.

A diffusion model learns to reverse a gradual noising process. To generate an image it starts from pure noise and denoises in many small steps — in the original DDPM, typically a thousand of them. Each step calls the neural network once, so a single image costs a thousand forward passes. Worse, each reverse step deliberately injects a little fresh random noise (it's sampling from a distribution), so the process is stochastic: the same starting seed doesn't map to a fixed output, and there's no clean way to invert it. Beautiful results, but painfully slow and hard to control.

DDIM (Denoising Diffusion Implicit Models, Song, Meng & Ermon, 2021) fixes both problems at once — and, remarkably, with the exact same trained network. It reformulates the reverse process so that (a) you can take big jumps across many timesteps, sampling in 10–50 steps instead of 1000, and (b) you can make each step deterministic by removing the random noise. It's not a new model; it's a smarter way to walk backward through the one you already trained.

The key reframing: at every timestep, don't think about "removing a little noise." Think about guessing the whole finished image, then stepping partway back toward it. The trained network predicts the noise ε in the current noisy image x_t; from that you can algebraically solve for an estimate of the fully clean image:

ᾱ_t (alpha-bar) is the cumulative fraction of the original signal still present at step t. This just inverts the forward noising x_t = √ᾱ_t·x0 + √(1−ᾱ_t)·ε to recover x0 from x_t and the predicted ε.

Once you have a guess x̂₀ for the destination, you don't have to crawl there one timestep at a time — you can re-project it forward to any earlier noise level you like, jumping over dozens of intermediate steps. That's what breaks the thousand-step tyranny: because each step is anchored to a prediction of the final image rather than a purely local nudge, big jumps stay coherent. Pick a sub-sequence of, say, 50 timesteps out of 1000, and denoise along just those. The predict-then-re-project structure is what makes the skipping valid.

The full DDIM step re-projects the predicted clean image with three ingredients:

The random term is scaled by σ. DDIM's move is simply to set σ = 0. With no random noise injected, the next state is a fixed, deterministic function of the current one — the same starting noise always produces the same image. That determinism is not just about speed; it unlocks real capabilities. You get reproducibility (a seed maps to exactly one output), meaningful interpolation (blend two seeds and the images blend smoothly, because latents and outputs are one-to-one), and inversion — run the deterministic map backward to recover the latent of a real image, then edit it. None of that is possible when every step rolls fresh dice.

The full DDIM update, with the stochasticity controlled by σ:

x̂₀ is the predicted clean image; ε is the network's noise prediction; z is fresh standard noise. The middle term keeps just enough noise to land at level ᾱ_{t−1}, minus whatever σ re-injects.

The magic is that a single parameter σ spans a whole family of samplers. The paper writes it as:

η = 1 gives σ its full value, a stochastic DDPM-style sampler with the posterior variance (not the larger σ² = β setting behind the DDPM paper's FID 3.17); η = 0 gives σ = 0 and the fully deterministic DDIM. Intermediate η blends the two.

So DDPM and DDIM aren't rival models — they're the two endpoints of one parameterized family, with η the dial between "diverse and stochastic" and "deterministic and invertible." The runnable version below implements the clean-image prediction, the σ formula, and a deterministic step — and shows the noise term vanishing when σ = 0.

Song, Meng and Ermon start from what DDPM's training loss actually depends on. The objective is built only from the marginals q(x_t | x₀), one noise level at a time, never from the joint distribution of the whole forward chain. Any forward process with the same marginals therefore has the same training objective and the same optimal network. DDIM builds a family of such processes, most of them not Markov chains, and derives a sampler from each.

A note on notation: the DDIM paper writes α_t for the cumulative product that DDPM calls ᾱ_t. This page uses ᾱ_t throughout.

1. Keep the trained network. Start from ε_θ(x_t, t) trained with DDPM's simple loss on a 1,000-step schedule. Every sampler compared in the paper runs on the same weights for a given dataset; nothing is retrained.
2. Define a non-Markovian forward process. Choose a variance σ_t^² for every step and define q_σ(x_t−1 | x_t, x₀) as a Gaussian whose mean mixes x₀ with the noise direction implied by x_t. By construction every marginal q_σ(x_t | x₀) equals DDPM's N(√ᾱ_t x₀, (1 − ᾱ_t) I). The implied forward step from x_t−1 to x_t depends on x₀ as well, which is what makes the process non-Markovian.
3. Turn it into a sampler. At generation time x₀ is unknown, so substitute the estimate x̂₀ = (x_t − √(1 − ᾱ_t) ε_θ)/√ᾱ_t and sample from q_σ(x_t−1 | x_t, x̂₀). At the final step the output is x̂₀ itself.
4. Choose how much noise. One number, η, sets every σ_t. At η = 1 the process becomes Markovian again and the sampler is DDPM's with the posterior variance. At η = 0 no noise is added at all: this is the denoising diffusion implicit model, a deterministic map from x_T to x₀.
5. Skip timesteps. Pick an increasing sub-sequence τ of the 1,000 training timesteps, S of them, spaced linearly or quadratically. The same construction defined only over τ still has matching marginals, so the same network applies, and each update jumps from τ_i to τ_i−1 using ᾱ at those two indices. The paper tested S from 10 up to the full 1,000.
6. Optionally run it backward. With η = 0 the update is invertible in the limit of small steps, so applying it from t = 0 upward encodes a real image into the x_T that regenerates it.

Why the same network is valid for every member

For each choice of σ, the variational objective of the new process equals a DDPM loss with some per-step weights, plus a constant. If the network's parameters were not shared across timesteps, the optimum of such a weighted loss would not depend on the weights at all, so the network trained with equal weights is the right network for every σ. The paper uses this argument to justify reusing DDPM checkpoints. DDIM is a statement about sampling, not a new model.

The ODE reading

Divide the deterministic update by √ᾱ and it becomes one Euler step of an ordinary differential equation in the rescaled variable x/√ᾱ, integrated against the noise level √((1 − ᾱ)/ᾱ). That explains why larger steps work as long as the trajectory is smooth, why a fixed x_T gives consistent images across different step counts, and why later samplers such as DPM-Solver could improve on it with higher-order integration of the same equation.

• (xt − √ᾱt x0)/√(1 − ᾱt) — the exact unit noise that produced x_t from x₀; the sampler replaces it with ε_θ.
• √(1 − ᾱt−1 − σt^2) — how much of that same noise to keep. Kept noise variance plus fresh noise variance σ_t^² always total 1 − ᾱ_t−1, which is how the marginal is preserved.
• Jσ = Lγ + C — each member's variational objective equals a DDPM loss with some per-step weights γ, plus a constant.
• the last line — the deterministic update rewritten as one Euler step of an ODE in x/√ᾱ.

Extremes: σ_t^² = 1 − ᾱ_t−1 keeps none of the old noise, so x_t−1 forgets x_t except through x̂₀. σ_t = 0 keeps all of it, so the trajectory is deterministic and fresh noise never enters. η = 1 sits between them, at the DDPM posterior variance.

The main experiment fixes one trained network per dataset and varies only the sampler: η ∈ {0, 0.2, 0.5, 1} and the number of steps S ∈ {10, 20, 50, 100, 1000}, on CIFAR-10 (32×32), CelebA (64×64) and LSUN Bedroom and Church (256×256). An extra baseline, written σ̂, uses the larger variance σ_t^² = β_t of the original DDPM CIFAR-10 sampler. Scores are FID, lower is better. CIFAR-10:

The pattern held on the other datasets: at short schedules η = 0 was best, and its lead widened as S fell. The paper summarizes the result as high-quality samples 10× to 50× faster in wall-clock time than DDPM.

The negative result is in the last column. With all 1,000 steps, the original DDPM sampler with σ̂ beats DDIM, 3.17 against 4.04, so determinism is not free when you can afford the full chain. The σ̂ row also shows how badly a high-variance stochastic sampler tolerates skipping: an FID of 367 at 10 steps means noise, not images.

Three further results follow from determinism. Samples generated from the same x_T with different S share their high-level content, so x_T behaves like a latent code. Spherical interpolation between two x_T values gives smooth, semantically meaningful transitions. And encoding CIFAR-10 test images to x_T and decoding them back gives a reconstruction error that falls steadily as S grows, something DDPM's stochastic sampler cannot offer at all.

Quality does degrade as the step count falls, and the paper reports it rather than presenting the speed-up as free — there is a knee, and very aggressive schedules show it. The deterministic sampler also gives up some of the diversity that the injected noise supplied, which is a real trade even though it is usually a good one.

Inversion is exact in theory and approximate in practice: round-tripping a real image through the reverse and forward processes accumulates error, especially with strong conditioning, and a great deal of subsequent editing research is about controlling that drift.

How it held up: nobody runs a thousand steps. This rung made diffusion usable, and the direction it opened — treat sampling as solving a differential equation and bring better solvers to it — produced a steady march down to a handful of steps, and then to distilled samplers that need one or two. The invertibility is the quieter contribution and arguably the more important one, since it turned a generator into an editor.

DDIM's reframing of sampling as following a deterministic trajectory — effectively solving an ordinary differential equation — kicked off the entire fast-sampler research line. DPM-Solver and its successors treat the reverse process as an ODE and use higher-order numerical integrators to get comparable quality in even fewer steps, sometimes under ten. Nearly every modern diffusion tool ships with a menu of these samplers, and DDIM is the historical root and still a common default.

Its determinism became foundational for control. "DDIM inversion" — running the deterministic map backward to find the latent that would generate a given real image — underpins a large family of diffusion-based image-editing methods. The deterministic latent space also pairs naturally with classifier-free guidance for prompt control, and the whole approach carries over to the compressed latent space of latent diffusion that powers today's text-to-image systems. What began as a cleverer way to walk backward through a diffusion model became one of the load-bearing pieces of the generative-imaging stack.

Work each one out before you open it — a number, a prediction or a reason, not a definition. Producing the answer is what makes it stick. Your progress is kept on this device.

Ten papers from the first latent-variable generator to video and real-time 3D. The diffusion half is strictly cumulative — each rung removes a cost the last one paid.

1. 1VAE2014
2. 2GANs2014
3. 3VQ-VAE2017
4. 4DDPM2020
5. 5DDIM2021
6. 6Classifier-Free Guidance2021
7. 7Latent Diffusion2022
8. 8Sora2024
9. 9NeRF2020
10. 103D Gaussian Splatting2023

All 110 papers, in 19 ladders →