DDPM,
explained.

Imagine dropping ink into water. It disperses until the glass is a uniform haze — an easy, predictable process to run forward. Now imagine running it backward: reassembling that haze into the original drop. Impossible to do exactly, but if you learned, at every tiny moment, how to nudge the haze one step back toward order, you could reverse the whole thing.

That's diffusion. The forward direction gradually destroys an image into noise — trivial. The reverse direction rebuilds an image from noise — hard, and exactly what we train a network to do. Generate by starting from pure noise and running the learned reverse steps until a picture appears.

The forward process is a fixed Markov chain with no learnable parameters. Over T steps (the paper uses T = 1000), it repeatedly adds a little Gaussian noise. A noise schedule β₁ … β_T — small numbers that grow over time — sets how much noise each step injects:

In words: each step shrinks the current image slightly and sprinkles in fresh noise. Start with a clean image x₀; after enough steps you reach x_T, which is indistinguishable from pure Gaussian noise. This process is a given — its only purpose is to define the corruption the network must learn to undo.

Adding noise a thousand times to make one training example would be painfully slow. A neat property of Gaussians rescues it: you can jump straight to any timestep in one shot. Define α_t = 1−β_t and ᾱ_t = α₁·α₂·…·α_t, and then

So to make a training example at noise level t, you take a clean image, pick a random t, sample one blob of noise ε, and combine them by the formula above — no thousand-step loop needed. This closed form is what makes DDPM training efficient, and it's the key to the objective coming up.

Reversing the chain means going from x_t to a slightly cleaner x_{t-1}. The true reverse step is intractable, but if each forward step adds only a little noise, each reverse step is well-approximated by a Gaussian too — so we train a network to predict its mean.

That network is a U-Net: an encoder-decoder with skip connections, well suited to images, that also takes the timestep t as input so it knows how noisy things currently are. Apply it repeatedly — x_T → x_{T-1} → … → x₀ — and noise becomes an image. All the model's intelligence lives in this one denoising network.

Earlier diffusion work derived a complicated variational bound and tried to predict full distributions — fiddly and unstable. DDPM's decisive move was to reparameterize the problem. Since x_t = √(ᾱ_t)x₀ + √(1−ᾱ_t)ε, knowing the noise ε is equivalent to knowing the clean image. So just predict ε. The training loss collapses to plain mean-squared error:

The recipe is almost embarrassingly simple: take a clean image, add a known amount of noise, and ask the network to guess the noise you added. Penalize the squared error. That's it. This "simple objective" trained far more stably than the full variational bound and produced dramatically better samples — the entire reason diffusion suddenly worked.

To generate, start from pure noise x_T ~ 𝒩(0, I). At each step, run the network to predict the noise, subtract off a scaled portion to get a cleaner estimate, add a touch of fresh noise for stochasticity, and repeat down to x₀. After all T steps you have a fresh image the model has effectively imagined from static.

DDPM produced image quality competitive with the best GANs of the time — without the instability or mode collapse — establishing diffusion as a serious, and soon dominant, family of generative models.

The obvious cost is speed. Generating one image means running the network hundreds or a thousand times — orders of magnitude slower than a GAN's single pass. DDPM also operates directly in pixel space, so high-resolution generation is very expensive in both compute and memory.

Both limits drove the follow-up work. DDIM and other fast samplers cut the step count dramatically; latent diffusion moved the whole process into a compressed space to slash the per-step cost. DDPM is the sturdy foundation those improvements were built on, not the final, efficient product.

DDPM is the paper that made diffusion work, and it launched the generation era we're living in. Every major image and video generator — DALL·E 2, Imagen, Midjourney, Stable Diffusion — descends from the forward/reverse framework and the noise-prediction objective defined here. When a model "denoises" its way to a picture, it's running DDPM's idea.

Its deeper lesson is about the power of the right reframing: a hard generative problem became a simple supervised one by choosing to predict noise. That move dethroned GANs as the default for high-fidelity generation and reoriented the whole field around iterative denoising.