RugvAI Labs

Diffusion Models

DALL-E 3, Midjourney v7, Stable Diffusion XL, FLUX.1, Sora — all the same core algorithm. Add noise step-by-step, then learn to remove it step-by-step. A single A100 trains a competitive model in days; a $0.001 inference call generates a 1024×1024 image in 2 seconds. By the end of this lesson, you'll understand exactly how Sora and Veo 3 work under the hood.

Learning Objectives

After this lesson, you will be able to:

Walk through the forward diffusion process — gradually destroying an image with Gaussian noise — and the reparameterization that lets you sample any timestep in one step
Train a denoising network with the simplified loss L_simple from Ho 2020 — the practical objective that powers every modern diffusion model
Use classifier-free guidance to control fidelity vs diversity, and DDIM to cut sampling steps from 1000 to 20 without quality loss
Pick the right sampler for your task — DDPM for theory, DDIM for speed, DPM-Solver++ / Euler for production

Prerequisites

Before You Start

Review

Why

Why This Matters

Why diffusion replaced GANs as the dominant generative model in 2022 -- DALL-E 2, Imagen, and Stable Diffusion all dropped within months of each other and made diffusion the new default; the field went from "GANs vs autoregressive vs flows" to "diffusion + transformer" almost overnight
How Ho et al.'s 2020 DDPM paper became the most-cited generative-modeling paper of the decade -- DDPM took the messy 2015 Sohl-Dickstein theory and turned it into a clean, working recipe with one elegant simplified loss
Why classifier-free guidance is the single most important sampling trick in diffusion -- Ho & Salimans 2022 showed you can boost prompt-following 2-3x by mixing conditional and unconditional predictions at sampling time; every modern T2I model relies on it
Build this --> Train a tiny diffusion model on MNIST, sample with both DDPM (1000 steps) and DDIM (20 steps), apply classifier-free guidance with different weights, and watch how diversity collapses as guidance strength increases

Don't worry if the math feels heavy — once you see the model work in code (a 100-line training loop on MNIST), the equations stop being intimidating and start being mechanical recipes.

#The Two-Direction Setup

Intuition

Diffusion is two processes in opposite directions

The forward process is fixed and not learned. You take a clean image, add a tiny bit of Gaussian noise, repeat for 1000 steps, and end up with pure noise. There's nothing to learn here — it's deterministic random noise addition.

The reverse process is learned. You train a neural network to go the other way: given a noisy image, predict what noise was added so you can subtract it. Apply this 1000 times in reverse, and pure noise turns into a clean image.

The genius of diffusion is that the forward process — which we don't have to learn — gives us infinite training pairs. Sample any image x_0 from the dataset, sample any timestep t, run the forward process once to get x_t, and now you have a training example: "given x_t, predict the noise we added". The dataset is effectively infinite.

#The Forward Process: Destroying Information

The forward process q(x_t | x_) adds Gaussian noise according to a variance schedule β_t (a small positive number, growing from ~10⁻⁴ at t=1 to ~0.02 at t=T):

q(x_t \mid x_{t-1}) = \mathcal{N}(x_t; \sqrt{1 - \beta_t}\, x_{t-1}, \beta_t \mathbf{I})

The killer trick: thanks to the Gaussian closure under composition, you can sample any x_t directly from x_0 in one step (no need to iterate t times):

q(x_t \mid x_0) = \mathcal{N}(x_t; \sqrt{\bar{\alpha}_t}\, x_0, (1 - \bar{\alpha}_t)\mathbf{I}) \quad \text{where } \bar{\alpha}_t = \prod_{s=1}^{t} (1 - \beta_s)

Variance schedules matter. Linear (used in DDPM) is simple but spends too many steps near pure noise. Cosine schedule (Nichol & Dhariwal 2021) keeps signal alive longer; sigmoid is yet another option. Modern training cares about the signal-to-noise ratio at each step.

Drag the timestep slider to watch the forward process destroy an image and the reverse process rebuild it.

Loading visualization...

#The Reverse Process: Learning to Denoise

The reverse process is parameterized by a neural network θ:

p_\theta(x_{t-1} \mid x_t) = \mathcal{N}(x_{t-1}; \mu_\theta(x_t, t), \Sigma_\theta(x_t, t))

The architecture is almost always a U-Net: encoder downsamples through a few stages, decoder upsamples back, with skip connections preserving spatial detail. Time t is injected via sinusoidal embedding + MLP into every block. For text-to-image, the conditioning text is injected via cross-attention.

#The Training Objective: L_simple

Ho 2020's central contribution was simplifying the variational lower bound to one beautiful loss:

L_{\text{simple}} = \mathbb{E}_{t \sim U[1,T],\, x_0,\, \varepsilon \sim \mathcal{N}(0,I)}\left[ \| \varepsilon - \varepsilon_\theta(\sqrt{\bar{\alpha}_t}\, x_0 + \sqrt{1 - \bar{\alpha}_t}\, \varepsilon, t) \|^2 \right]

The simplicity is what made diffusion practical. No GAN training instability, no mode collapse, no balance between generator and discriminator. Just minimize MSE.

What Do You Think?

You train a tiny diffusion model on MNIST with T=1000 timesteps. Training loss converges nicely. What should sampling produce?

The answer: pure noise after 1 step, clean digit after ~1000 reverse steps. Each step removes a tiny slice of noise; you need to walk the entire chain. This is exactly what DDIM (next section) cuts down.

#The Math: From Variational Bound to L_simple

The MSE loss above looks magical — generative modeling reduced to noise prediction. It is not magic; it is a chain of three deliberate simplifications applied to a variational lower bound. This section walks the full derivation. The math-track lesson on stochastic calculus and SDEs already establishes the forward kernel q(x_t | x_0) and the score-matching objective ∇_x log p_t(x), so we leverage those results rather than re-derive them. For the architectural side — U-Net backbones, time-conditioning, and the engineering tricks that make denoisers train at scale — see the deep-learning track's diffusion-architecture lesson.

#1. The forward process in closed form

The forward process is a fixed Markov chain whose transition kernel is q(x_t | x_{t-1}) = N(√(1-β_t) x_{t-1}, β_t I). Because every step is linear-Gaussian, the marginal at any timestep t admits a closed form (Sohl-Dickstein 2015, Eq. 2.5; Ho 2020, Eq. 4):

q(x_t \mid x_0) = \mathcal{N}\!\left(x_t;\; \sqrt{\bar{\alpha}_t}\, x_0,\; (1 - \bar{\alpha}_t)\,\mathbf{I}\right), \quad \bar{\alpha}_t = \prod_{s=1}^{t} \alpha_s = \prod_{s=1}^{t}(1 - \beta_s)

Two corollaries we use below: (i) as t → T, ᾱ_t → 0, so q(x_T | x_0) ≈ N(0, I) — independent of x_0; (ii) the forward posterior q(x_{t-1} | x_t, x_0) is also Gaussian in closed form, with mean and variance given by Bayes' rule applied to the two Gaussians q(x_t | x_{t-1}) and q(x_{t-1} | x_0).

#2. The ELBO decomposition

Maximum likelihood asks us to maximize log p_θ(x_0), which is intractable because it integrates over all noise trajectories. Following Sohl-Dickstein 2015 (Eq. 11) and the standard variational argument, we lower-bound it:

-\log p_\theta(x_0) \leq \underbrace{D_{\mathrm{KL}}\!\big(q(x_T \mid x_0)\,\|\,p(x_T)\big)}_{L_T} + \sum_{t=2}^{T} \underbrace{D_{\mathrm{KL}}\!\big(q(x_{t-1} \mid x_t, x_0)\,\|\,p_\theta(x_{t-1} \mid x_t)\big)}_{L_{t-1}} - \underbrace{\log p_\theta(x_0 \mid x_1)}_{-L_0}

So minimizing the ELBO reduces to minimizing the KL divergences L_{t-1} for t = 2, …, T (plus the small L_0 term). That is the equation we need to simplify.

3. Collapsing L_ to a squared-norm

The forward posterior q(x_{t-1} | x_t, x_0) is Gaussian (a direct consequence of Bayes' rule on linear-Gaussian conditionals; Ho 2020 Eq. 6–7):

q(x_{t-1} \mid x_t, x_0) = \mathcal{N}\!\left(x_{t-1};\; \tilde{\mu}_t(x_t, x_0),\; \tilde{\beta}_t \mathbf{I}\right), \quad \tilde{\mu}_t(x_t, x_0) = \frac{\sqrt{\bar{\alpha}_{t-1}}\,\beta_t}{1 - \bar{\alpha}_t} x_0 + \frac{\sqrt{\alpha_t}\,(1-\bar{\alpha}_{t-1})}{1-\bar{\alpha}_t} x_t

So L_{t-1} reduces to predicting the posterior mean. This is the first big simplification: we no longer match distributions, we match means.

#4. The noise-prediction reparameterization (Ho 2020)

Here is the key move from the DDPM paper. Using the forward identity x_t = √(ᾱ_t) x_0 + √(1-ᾱ_t) ε, we can solve for x_0 = (x_t - √(1-ᾱ_t) ε) / √(ᾱ_t). Substituting into μ̃_t and simplifying (Ho 2020 Eq. 10), the posterior mean becomes a clean function of x_t and ε:

\tilde{\mu}_t(x_t, x_0) = \frac{1}{\sqrt{\alpha_t}}\left( x_t - \frac{\beta_t}{\sqrt{1 - \bar{\alpha}_t}}\, \varepsilon \right) \;\;\Longrightarrow\;\; \mu_\theta(x_t, t) := \frac{1}{\sqrt{\alpha_t}}\left( x_t - \frac{\beta_t}{\sqrt{1 - \bar{\alpha}_t}}\, \varepsilon_\theta(x_t, t) \right)

The ELBO has now reduced to a weighted sum of MSEs on noise prediction across timesteps. Every term has the same form w_t · ||ε - ε_θ(x_t, t)||²; only the scalar weight w_t varies with t.

#5. Dropping the weights: L_simple

Ho 2020 ran the obvious ablation: keep the noise-prediction parameterization, but drop the w_t weights and uniformly sample t. The result is the loss you saw in the previous section:

L_{\text{simple}}(\theta) = \mathbb{E}_{t \sim U[1,T],\, x_0 \sim p_\text{data},\, \varepsilon \sim \mathcal{N}(0,I)}\!\left[ \| \varepsilon - \varepsilon_\theta(\sqrt{\bar{\alpha}_t}\, x_0 + \sqrt{1 - \bar{\alpha}_t}\, \varepsilon, t) \|^2 \right]

Intuition

Why dropping the weights helps — Ho 2020's empirical finding

The principled ELBO weight w_t = β_t² / (2 σ_t² α_t (1-ᾱ_t)) is sharply peaked at small t, where the noise level is low. At small t, the network is denoising near-clean images — an easy task that contributes little to perceptual quality but dominates the loss budget. At large t, where the network must hallucinate global structure from near-noise, the principled weight is tiny.

The simplified loss replaces this with w_t = 1 for all t. That gives every timestep equal say in the gradient, which implicitly up-weights the high-noise (large-t) steps where the model does the real generative lifting. Ho 2020 reports this gives lower FID than the principled bound — a rare case where a "looser" objective produces a tighter fit to perception. The lesson: the variational bound is a sufficient condition for likelihood, not a necessary condition for good samples.

What Do You Think?

A research team trains a DDPM with the principled ELBO (full L_T + Σ w_t · L_{t-1} + L_0) on CIFAR-10. They compare to the same model trained with L_simple. What do they observe?

#6. Connection back to score matching

The noise predictor ε_θ is, up to a deterministic scaling, the score function ∇_x log p_t(x) introduced in the math-track stochastic-calculus lesson. From the forward identity x_t = √(ᾱ_t) x_0 + √(1-ᾱ_t) ε, the marginal density q(x_t | x_0) is a Gaussian with mean √(ᾱ_t) x_0 and variance (1-ᾱ_t) I, so its score is:

\nabla_{x_t} \log q(x_t \mid x_0) = -\frac{x_t - \sqrt{\bar{\alpha}_t}\, x_0}{1 - \bar{\alpha}_t} = -\frac{\varepsilon}{\sqrt{1 - \bar{\alpha}_t}} \;\;\Longrightarrow\;\; \varepsilon_\theta(x_t, t) \approx -\sqrt{1 - \bar{\alpha}_t}\, \nabla_{x_t} \log p_t(x_t)

So L_simple is also (a weighted version of) denoising score matching — the exact training objective covered in the math-track lesson on SDEs. Same loss, same network, two derivations.

#Classifier-Free Guidance: The Sampling Superpower

For conditional generation (text → image), the model takes both x_t and a condition c (e.g., text embedding). Classifier-free guidance trains a single model that handles both conditional and unconditional inputs (by sometimes setting c = ∅ during training, ~10% of the time). At sampling time, you blend the two:

\tilde{\varepsilon}(x_t, c) = (1 + w) \cdot \varepsilon_\theta(x_t, c) - w \cdot \varepsilon_\theta(x_t, \varnothing)

This is THE knob users tune. Stable Diffusion default is cfg_scale=7.5. Push to 15+ for stronger prompt adherence; drop to 3-5 for more creative variations.

#DDIM: Fast Deterministic Sampling

Vanilla DDPM sampling needs ~1000 steps. DDIM (Song 2020) reformulates the reverse process so you can take larger steps and still get coherent results:

x_{t-1} = \sqrt{\bar{\alpha}_{t-1}} \cdot \hat{x}_0 + \sqrt{1 - \bar{\alpha}_{t-1}} \cdot \varepsilon_\theta(x_t, t) \quad \text{where } \hat{x}_0 = \frac{x_t - \sqrt{1 - \bar{\alpha}_t} \cdot \varepsilon_\theta(x_t, t)}{\sqrt{\bar{\alpha}_t}}

With DDIM you can use 20-50 steps (skipping the rest) and get quality close to 1000-step DDPM. Even better: modern samplers like DPM-Solver++ (Lu 2022), Euler-A, and Heun push down to 15-25 steps with no perceptible loss. ComfyUI / A1111 expose dozens of samplers — they're all variants of solving the same probability-flow ODE more efficiently.

#Modern Samplers Cheat Sheet

Sampler	Steps	Properties
DDPM	1000	Theoretically grounded, slow
DDIM	50	Deterministic, good baseline
Euler / Euler-A	20-30	Fast, slightly noisy results
DPM-Solver++ (2M)	15-25	Default in many production stacks
Heun	25-40	Higher quality, slower
LCM (4 steps)	4	Distilled, fastest, mild quality loss

Decision rubric: DDIM for reproducibility experiments. DPM-Solver++ for production speed. Euler-A for slight artistic randomness. LCM/Turbo for real-time interactive use cases.

#The Karras EDM unifying framework

DDPM, DDIM, SMLD, VP-SDE, VE-SDE — six years of diffusion papers each invented its own notation. Karras et al. 2022, "Elucidating the Design Space of Diffusion-Based Generative Models" (EDM), collapsed all of them into one framework where the noise level σ is the fundamental variable, not the discrete timestep t. Every modern repo — k-diffusion, ComfyUI sampling, EDM2, Stable Diffusion 3 / FLUX preconditioning — uses EDM-style parameterization. Learning it once unlocks the rest of the field.

#1. Reparameterize: predict the clean image directly

In DDPM the network predicts noise ε at timestep t. EDM instead asks the network to predict the clean image D_θ(x; σ) directly, where σ ∈ ℝ₊ is the current noise level. There are no discrete timesteps — σ is a continuous knob from σ_min ≈ 0.002 to σ_max ≈ 80. This single change makes every previous diffusion variant a special case of EDM by a coordinate change.

The input to the network is x = x_0 + σ · n (clean image plus noise of standard deviation σ, with n ~ N(0, I)), and the prediction target is x_0 itself.

#2. Four preconditioning functions

A raw network operating across σ ∈ [0.002, 80] would see wildly different input magnitudes and have to predict wildly different output magnitudes. EDM wraps a raw network F_θ with four σ-dependent scalars so the network always sees unit-variance inputs and always predicts a unit-variance target. The full denoiser is:

D_\theta(x; \sigma) = c_{\text{skip}}(\sigma)\, x + c_{\text{out}}(\sigma)\, F_\theta\big(c_{\text{in}}(\sigma)\, x;\; c_{\text{noise}}(\sigma)\big)

The four scalars are not hyperparameters — they fall out of one constraint: the input to F_θ should have unit variance for every σ, and the residual (target - c_skip · x) / c_out should also have unit variance. Solve that and you get the formulas above.

#3. The unified objective

The training loss is a weighted denoising-score-matching loss across all noise levels:

\mathcal{L}_{\text{EDM}} \;=\; \mathbb{E}_{\sigma \sim p(\sigma)}\; \mathbb{E}_{x_0,\, n \sim \mathcal{N}(0, I)} \Big[ \lambda(\sigma)\, \|\, D_\theta(x_0 + \sigma n;\, \sigma) - x_0 \,\|^2 \Big]

The weighting λ(σ) = (σ² + σ_data²) / (σ · σ_data)² is the Karras choice that makes the effective signal-to-noise gradient constant across σ — every noise level contributes the same amount of gradient signal, so the network spends training compute uniformly rather than blowing up on easy low-σ cases.

#4. Noise schedule: log-normal σ sampling

Instead of sampling discrete timesteps uniformly (DDPM's choice, which over-trains on high-noise steps that are visually trivial), EDM samples log σ ~ N(P_mean, P_std²) with P_mean = -1.2, P_std = 1.2 for natural images. Plotting that distribution puts most of the training mass right around σ ≈ 0.3 — the "interesting" mid-noise regime where most of the perceptual structure is decided. This is one of the largest free quality wins in modern training; SDXL, SD3, FLUX, and EDM2 all use it.

#5. Heun's 2nd-order sampler: halving the discretization error

For sampling, EDM uses Heun's method, a predictor-corrector ODE solver. Each step takes a forward Euler prediction at σ_i, evaluates the denoiser again at the predicted σ_, and averages the two derivatives — cutting local truncation error from O(Δσ²) to O(Δσ³).

x_{i+1} \;=\; x_i + \tfrac{1}{2}\,(\sigma_{i+1} - \sigma_i)\,\Big[ d_i + d_i^{\,\prime} \Big] \;\;\text{where}\;\; d_i = \tfrac{x_i - D_\theta(x_i; \sigma_i)}{\sigma_i},\quad d_i^{\,\prime} = \tfrac{x_{i+1}^{\text{Euler}} - D_\theta(x_{i+1}^{\text{Euler}}; \sigma_{i+1})}{\sigma_{i+1}}

EDM also specifies the σ schedule: σ_i = (σ_max^(1/ρ) + (i / (N-1)) · (σ_min^(1/ρ) - σ_max^(1/ρ)))^ρ with ρ = 7. This polynomial spacing concentrates steps where the model is most sensitive (low σ near the end of sampling).

#6. Why every modern repo uses EDM-style parameterization

When you open k-diffusion, ComfyUI's sampling code, EDM2 (Karras 2024 follow-up), Stable Diffusion 3, FLUX, or any 2023+ diffusion codebase, you see the same fingerprints: σ-conditioned networks, c_skip/c_out/c_in/c_noise preconditioning, log-normal σ sampling at train time, Heun or DPM-Solver++ sampling at inference, ρ=7 noise schedule. The EDM framework wasn't a new model — it was a coordinate system that made all the existing diffusion math composable, debuggable, and improvable. Pre-EDM papers had to invent custom training tricks per architecture; post-EDM repos just dial in σ_min, σ_max, σ_data and reuse the same machinery.

#Hands-On: Train a Tiny Diffusion Model

pythonplayground.py · Pyodide

# Minimal diffusion training loop on MNIST — runs in ~5 min on CPU
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# --- 1. Hyperparameters ---
T = 200
device = "cuda" if torch.cuda.is_available() else "cpu"

betas = torch.linspace(1e-4, 0.02, T).to(device)
alphas = 1.0 - betas
alpha_bar = torch.cumprod(alphas, dim=0)

# --- 2. Tiny U-Net (single down-up block) ---
class TimeEmbed(nn.Module):
  def __init__(self, dim):
      super().__init__()
      self.lin1 = nn.Linear(1, dim)
      self.act = nn.SiLU()
      self.lin2 = nn.Linear(dim, dim)
  def forward(self, t):
      return self.lin2(self.act(self.lin1(t.unsqueeze(-1).float())))

class TinyUNet(nn.Module):
  def __init__(self, ch=32):
      super().__init__()
      self.t_embed = TimeEmbed(ch)
      self.down = nn.Sequential(nn.Conv2d(1, ch, 3, padding=1), nn.SiLU(), nn.Conv2d(ch, ch, 3, padding=1, stride=2))
      self.mid = nn.Sequential(nn.Conv2d(ch, ch, 3, padding=1), nn.SiLU())
      self.up = nn.Sequential(nn.ConvTranspose2d(ch, ch, 3, padding=1, output_padding=1, stride=2), nn.SiLU(), nn.Conv2d(ch, 1, 3, padding=1))
  def forward(self, x, t):
      h = self.down(x)
      h = h + self.t_embed(t).unsqueeze(-1).unsqueeze(-1)
      h = self.mid(h)
      return self.up(h)

# --- 3. Forward sampling: get (x_t, eps) given (x_0, t) ---
def q_sample(x_0, t, eps=None):
  if eps is None:
      eps = torch.randn_like(x_0)
  sqrt_ab = torch.sqrt(alpha_bar[t]).view(-1, 1, 1, 1)
  sqrt_1mab = torch.sqrt(1.0 - alpha_bar[t]).view(-1, 1, 1, 1)
  return sqrt_ab * x_0 + sqrt_1mab * eps, eps

# --- 4. Training step ---
model = TinyUNet().to(device)
opt = torch.optim.AdamW(model.parameters(), lr=2e-4)

ds = datasets.MNIST("/tmp/mnist", train=True, download=True,
                 transform=transforms.Compose([transforms.Resize(16), transforms.ToTensor(), transforms.Normalize([0.5], [0.5])]))
loader = DataLoader(ds, batch_size=128, shuffle=True, num_workers=0)

print("Training tiny diffusion model on MNIST...")
for step, (x_0, _) in enumerate(loader):
  if step >= 200: break
  x_0 = x_0.to(device)
  t = torch.randint(0, T, (x_0.size(0),), device=device)
  x_t, eps = q_sample(x_0, t)
  eps_pred = model(x_t, t)
  loss = torch.mean((eps - eps_pred) ** 2)
  opt.zero_grad(); loss.backward(); opt.step()
  if step % 50 == 0:
      print(f"step {step}: loss = {loss.item():.4f}")

# --- 5. DDPM sampling ---
@torch.no_grad()
def ddpm_sample(model, n=8):
  x = torch.randn(n, 1, 16, 16, device=device)
  for t in reversed(range(T)):
      t_batch = torch.full((n,), t, device=device, dtype=torch.long)
      eps_pred = model(x, t_batch)
      coef = (1 - alphas[t]) / torch.sqrt(1 - alpha_bar[t])
      mean = (1.0 / torch.sqrt(alphas[t])) * (x - coef * eps_pred)
      if t > 0:
          x = mean + torch.sqrt(betas[t]) * torch.randn_like(x)
      else:
          x = mean
  return x.clamp(-1, 1)

samples = ddpm_sample(model, n=4)
print(f"\nGenerated {samples.shape[0]} samples, shape={tuple(samples.shape)}")
print(f"Sample value range: [{samples.min():.2f}, {samples.max():.2f}]")
print("\nCHALLENGE: Replace ddpm_sample with a 20-step DDIM sampler")
print("using only timesteps [0, 10, 20, ..., 200]. Compare visual quality.")

Tests · Verify training loss decreases. Verify samples are tensors of shape (n, 1, 16, 16) with values in [-1, 1]. Compare DDPM-1000 vs DDIM-20 visual quality.

#Key Takeaways

Diffusion = forward noising + learned reverse denoising. The forward process is fixed Gaussian noise addition; the reverse process is a U-Net (or DiT) trained to predict the noise that was added at each step
L_simple is the entire training objective. Pick random t, sample noise ε, construct x_t, predict ε from x_t — pure MSE loss, no GAN instability, no balance to maintain
The reparameterization x_t = √(ᾱ_t)·x_0 + √(1-ᾱ_t)·ε is the practical magic. Lets you sample any timestep in one shot, making training dataset-efficient and embarrassingly parallel
Classifier-free guidance is the most important sampling trick. Train one model that handles both conditional and unconditional, then linearly extrapolate at sampling. The CFG scale is the knob every user adjusts
DDIM and modern samplers cut steps from 1000 to 20-50 with no quality loss. DPM-Solver++, Euler-A, and Heun all solve the same probability-flow ODE more efficiently. LCM and Turbo distill further to 1-4 steps with mild quality cost

#Quick Check

Quick Check1 / 4

Why does the simplified DDPM loss L_simple work despite the original formulation involving a complex variational bound?

You now understand the most important generative-modeling paradigm of the 2020s. Next up: Flow Matching — the elegant generalization that replaced DDPM training in FLUX, SD3, and Stable Video Diffusion.

Your Reflection

Continue Learning

Discussion