An Introduction to Flow Matching & Diffusion Models

Chapter 1: Generation Is Sampling

Before any differential equation, we need to say precisely what "generate" means. The notes make this move in four key ideas; we restate each with its reasoning.

Objects as vectors

A computer stores numbers, so every object we generate is first flattened to a vector z in R^d (d-dimensional real space). The notes give three concrete encodings:

"Good" means "likely"

There is no single best dog image; there is a spectrum. Machine learning realizes this spectrum as a probability distribution over the space of images, the data distribution p_data — a density p_data : R^d → R_≥0 assigning each candidate object a likelihood. A crisp dog photo gets high density; random static gets near-zero density.

We only ever have a dataset

The catch — and the reason the entire field exists — is that we do not know the density p_data. Nobody can write down "the probability that this exact arrangement of 196,608 pixels is a real internet image." All we get is a finite pile of samples already drawn from it.

Conditioning on a prompt

"A dog" and "a cat" are different distributions. A conditioning variable y (a prompt, a class label, a caption) selects a guided data distribution p_data(· | y).

A terminology landmine, flagged now. The word "conditional" gets two meanings in these notes. From Chapter 4 onward, "conditional" almost always means conditioning on a clean data point z (the conditional probability path p_t(x|z)). To avoid collision, the notes reserve the word guided for conditioning on a prompt y. We follow that convention strictly.

Chapter 2: ODEs, Vector Fields, and Flows

The generative recipe is: pick an easy p_init (the standard Gaussian, written N(0, I_d)), then continuously transport a sample of p_init at t = 0 into a sample of p_data at t = 1. "Continuous transport" is the job of an ordinary differential equation (ODE). Three objects describe it from three angles.

Trajectory, vector field, ODE

A trajectory is the path of a single point, a function X : [0,1] → R^d, t ↦ X_t. A vector field assigns a velocity arrow to every location and time:

Think of u_t(x) as a wind map that can change over the day. The ODE then ties the trajectory to the field: at every instant the trajectory's velocity must equal the arrow at its current location.

The first equation says "go where the arrow at your feet points." The second pins down where you start — without it the path is not determined.

So vector fields define ODEs whose solutions are flows — three names, one underlying object. The field is the wind; the ODE is the law "drift with the wind"; the flow is the resulting warp of all of space.

Theorem 3 — existence and uniqueness

Why you can file this away as good news. We will parameterize u with a neural network, and neural networks always have bounded derivatives. So in every case we care about, the flow exists and is unique. Theorem 3 is reassurance, not an obstacle.

Worked example: the linear field, solved exactly

Take the simplest non-trivial field, a contraction toward the origin, u_t(x) = −θx with θ > 0. Claim: the flow is ψ_t(x₀) = exp(−θt)·x₀. We verify both defining properties:

Plug in numbers: θ = 1, x₀ = 2 gives ψ_t(2) = 2 exp(−t); at t = 1, 2⁄e ≈ 0.7358 — a clean ground truth for testing a numerical integrator.

Simulating an ODE — the Euler method

A neural-net field has no closed-form flow, so we simulate: approximate the journey by many tiny straight steps. The Euler method initializes X₀ = x₀ and updates

where h is the step size and n the number of steps. The derivative is the limit of a difference quotient, d⁄dt X_t ≈ (X_t+h − X_t)/h; setting that equal to u_t(X_t) and rearranging gives the update. The arrow is only exactly right at the start of each step, so a finite h leaves an error that shrinks with h — Euler is first-order.

The flow model and Algorithm 1

A flow model makes two changes to the ODE machinery: the field becomes a neural network u^θ_t with parameters θ, and the start becomes random, X₀ ∼ p_init. Randomness enters once, at t = 0; the journey afterward is deterministic. The goal of training is X₁ ∼ p_data.

# Algorithm 1 — Sampling from a flow model with the Euler method
# Input: trained vector-field network u_theta(x, t); number of steps n
t = 0.0
h = 1.0 / n                      # step size
x = sample_gaussian()            # X_0 ~ p_init = N(0, I)
for i in range(n):
    x = x + h * u_theta(x, t)    # one Euler step along the learned arrows
    t = t + h
return x                        # X_1, a sample of p_data

Chapter 3: SDEs, Brownian Motion, and the OU Process

Flow models are deterministic after the start. Diffusion models add randomness at every step. The canonical source of continuous randomness is Brownian motion (also called the Wiener process, hence the symbol W — after Norbert Wiener, who taught at MIT).

Brownian motion

A stochastic process is a random trajectory: run it twice from the same start and you get two different paths. Brownian motion W is the continuous-time limit of a random walk.

To simulate, discretize time into steps of size h and add a Gaussian kick whose variance is h. Since standard normal noise has variance 1, scaling by √h gives variance h:

From ODEs to SDEs

An SDE is an ODE with Brownian noise stirred in. Because a random path is too jagged to differentiate, we first rewrite the ODE without derivatives. Using the difference-quotient definition:

where R_t(h) → 0 as h → 0. This restates Euler with no derivatives. Now amend it with a Brownian kick scaled by a diffusion coefficient σ_t ≥ 0:

This is the Euler–Maruyama update. Since the Brownian increment is √h·ε, in code it reads X_t+h = X_t + h·u_t(X_t) + σ_t·√h·ε. Mathematicians write the same thing in compact symbolic form (shorthand for the limit of the update above):

Here u_t is the drift (deterministic pull) and σ_t the diffusion (noise strength). Two facts keep SDEs friendly:

The Ornstein–Uhlenbeck process

The cleanest non-trivial SDE is the Ornstein–Uhlenbeck (OU) process: constant linear drift u_t(x) = −θx (a spring toward 0, θ > 0) and constant diffusion σ.

Two forces fight: the drift pulls in, the noise pushes out. Their balance produces a stationary distribution — a steady-state spread the process settles into and never leaves:

Sanity-check the extremes. More noise σ → wider spread (σ² on top). Stronger pull θ → tighter spread (2θ on the bottom). If σ = 0, the variance is 0 — every path collapses to the origin, recovering the contracting flow from Chapter 2.

Now assemble everything: implement the OU drift and the full Euler–Maruyama step, then verify the stationary variance.

Chapter 4: Flow Matching — Conditional & Marginal Probability Paths

Chapters 2–3 built the machine (ODEs/SDEs and how to simulate them) but assumed the vector field was handed to us. Flow matching is the algorithm for training the field so that simulating the ODE produces samples from p_data. We restrict to flow models: X₀ ∼ p_init, dX_t = u^θ_t(X_t) dt, and we want X₁ ∼ p_data. The question "how to train" is really "how do we pick θ so the endpoint lands on the data?"

Step 1 — specify a probability path

The trajectory must satisfy X₀ ∼ p_init and X₁ ∼ p_data, but we have freedom in what distribution the points pass through at intermediate times. A probability path formalizes that freedom — a trajectory in the space of distributions.

Let δ_z denote the Dirac delta at z: sampling it always returns z (it is the deterministic "all mass at one point" distribution). A conditional (interpolating) probability path is a family of distributions p_t(x|z) with

In words: conditioned on a fixed data point z, the path gradually converts noise into a spike on that exact z. (This is why we call it conditional — conditioned on the data point, not the prompt.)

Because of the endpoint conditions on p_t(·|z), the marginal path automatically interpolates noise and data: at t = 0 every conditional path is p_init, so p₀ = p_init; at t = 1 each conditional is δ_z, so the mixture over z ∼ p_data reassembles p₁ = p_data. That is the entire point.

The Gaussian probability path (the one that matters)

Almost all state-of-the-art models use the Gaussian probability path. Choose two noise schedulers α_t, β_t — continuously differentiable, monotonic functions with α₀ = β₁ = 0 and α₁ = β₀ = 1 — and define

Check the endpoints: at t = 0, N(0·z, 1·I) = N(0, I) = p_init; at t = 1, N(1·z, 0·I) = δ_z (a Gaussian with zero variance and mean z is the spike at z). Both conditions hold, so it is a valid conditional path. Sampling the marginal Gaussian path is the one-liner everyone implements:

This is just "take a data point, scale it down by α_t, and add Gaussian noise of scale β_t." More noise for lower t, until at t = 0 there is only noise.

Chapter 5: Conditional & Marginal Vector Fields — The Marginalization Trick

A probability path says what distribution the points should have at each time. But "should" is a wish — we need an actual vector field whose ODE trajectories realize it. Flow matching constructs one explicitly.

Conditional vector field

For each data point z, a conditional vector field u^target_t(x|z) is any field whose ODE follows the conditional path:

We can usually write this down by hand. For the Gaussian path, build the conditional flow first: ψ^target_t(x|z) = α_t z + β_t x. If X₀ ∼ N(0,I), then X_t = α_t z + β_t X₀ ∼ N(α_tz, β_t²I) = p_t(·|z) — correct distribution. To extract the field, use the flow defining property and the chain rule (writing α̇_t, β̇_t for time derivatives):

Why a conditional field looks useless — and is not. Following u^target_t(·|z) always lands on the same fixed z — you would just re-generate a known data point. The payoff is that conditional fields are building blocks for a field that generates genuinely new samples.

Theorem 9 — the marginalization trick

Read the weight. By Bayes' rule, p_t(x|z) p_data(z) ⁄ p_t(x) is the posterior over clean data points z given the noisy point x — "given I see this noisy x at time t, how plausible is it that it came from z?" So the marginal field is intuitive: for every candidate z it takes the velocity that would steer toward z, and averages those velocities, weighting each by how much we believe x came from that z.

The continuity equation and the proof

The proof rests on the continuity equation, the conservation law of probability mass. Define the divergence div(v_t)(x) = ∑_i ∂vⁱ_t/∂x_i (the net outflow of the field at a point).

Proof of Theorem 9. By Theorem 11 it suffices to show the marginal field satisfies the continuity equation. Direct calculation, with each step labeled:

The first and last lines are precisely the continuity equation for u^target_t. By Theorem 11 this implies X_t ∼ p_t, finishing the proof. (The Fokker–Planck equation in Chapter 8 generalizes Theorem 11 to SDEs.)

Chapter 6: The Flow Matching Loss — Conditional = Marginal in Gradient

We now have the training target: make the network u^θ_t equal the marginal vector field u^target_t. If it does, then by Theorem 9 the endpoints X₁ ∼ p_data are exactly what we want. The obvious objective is a mean-squared error, the flow matching loss (with Unif the uniform distribution on [0,1] and E expectation):

The conditional flow matching loss

The conditional field u^target_t(x|z) is tractable (we wrote it in closed form in Chapter 5). So define the conditional flow matching loss, regressing against the conditional field instead:

This is computable: draw a data point z, draw a time t, sample x ∼ p_t(·|z) (just noise z), evaluate the network, take an MSE against the known conditional velocity. But why should regressing the conditional field give us the marginal field we actually care about?

Theorem 12 — the two losses share a gradient

Proof sketch (the load-bearing step). Expand the MSE with ‖a−b‖² = ‖a‖² − 2a·b + ‖b‖². The ‖u^target‖² term has no θ, so it is a constant C₁. The ‖u^θ‖² term is identical under both sampling schemes (sampling x ∼ p_t equals sampling z then x ∼ p_t(·|z)). The only term that mixes the network with the target is the cross term, and there the magic happens:

The intractable p_t(x) in the denominator cancels the p_t(x) from writing the expectation as an integral — the cross term, started with the marginal field, ends as an expectation over the conditional field. Substituting back and re-completing the square gives L_FM = L_CFM + C. Since C is independent of θ, the gradients coincide. □

Algorithm 3 — flow matching training

For the Gaussian path, the conditional field is u^target_t(x|z) = (α̇_t − (β̇_t/β_t)α_t)z + (β̇_t/β_t)x, and substituting x = α_tz + β_tε simplifies the loss to a regression against α̇_tz + β̇_tε. For the CondOT path α_t = t, β_t = 1 − t, that target is just z − ε:

# Algorithm 3 — Flow Matching Training (Gaussian CondOT path p_t(x|z) = N(t·z, (1-t)^2))
for each mini-batch in dataset:
    z   = sample_data()              # a real data point z ~ p_data
    t   = uniform(0, 1)              # random time
    eps = sample_gaussian()          # noise ~ N(0, I)
    x   = t*z + (1 - t)*eps          # x ~ p_t(·|z): noise the data point
    loss = norm(u_theta(x, t) - (z - eps))**2   # regress against z - eps
    grad_update(loss)

Chapter 7: Score Functions — the Conditional & Marginal Score

So far our central object was the vector field u_t(x). Diffusion models take a different but equivalent perspective built on score functions. This chapter rephrases everything in that language — and shows the two are linked by a single conversion formula.

The score function

For any distribution q(x), the score function is the gradient of the log-density, ∇ log q(x). It points in the direction of steepest ascent of log-likelihood — "which way should I nudge x to make it more probable?" At a mode it is zero; in the tails it points back toward the bulk.

Returning to probability paths, define the conditional score ∇ log p_t(x|z) and the marginal score ∇ log p_t(x). They are related just like the vector fields:

The same posterior weight appears. The derivation uses ∂_y log y = 1/y and the chain rule: ∇ log p_t(x) = ∇p_t(x)/p_t(x) = [∫ ∇p_t(x|z)p_data(z)dz]/p_t(x), and writing ∇p_t(x|z) = p_t(x|z)∇ log p_t(x|z) gives the weighted average.

The Gaussian conditional score

For the Gaussian path p_t(x|z) = N(α_tz, β_t²I), the log-density is −‖x − α_tz‖²/(2β_t²) plus a constant in x. Its gradient is the clean linear form:

Notice: the score points from the noisy point back toward the (scaled) clean point, scaled by 1/β_t². Since x = α_tz + β_tε, this equals −ε/β_t — the score is, up to scale, the negative of the noise that was added. That is why learning the score and "predicting the noise" are the same task (next chapter).

Proposition 1 — field and score are interchangeable

This is striking: once you have learned the marginal vector field, you have also learned the score — and vice versa. Many diffusion models therefore learn the score instead of the field; for Gaussian paths it makes no difference. (To carry the conditional identity to the marginal one, integrate against the posterior weight and use that the posterior integrates to 1.)

The denoiser (posterior mean)

A third equivalent quantity is the denoiser D_t(x) = E[z | x] — the expected clean data point given the noisy x. Field, score, and denoiser are all linear reparameterizations of this posterior mean, so any one recovers the others. Predicting the denoiser is often preferred for numerical stability; models that do are called denoising diffusion models.

Now confirm the Gaussian conditional-score formula numerically — verify the analytic gradient against a finite-difference of the actual log-density, with no spoiler of the formula in the check.

Chapter 8: Score Matching & Sampling with SDEs

Two jobs remain. First, learn the marginal score directly (for paths where we cannot just convert from the field). Second, turn the deterministic ODE sampler into a stochastic SDE sampler — which often produces better, self-correcting samples.

Denoising score matching

To approximate ∇ log p_t(x), use a score network s^θ_t. As with flow matching there is an intractable score matching loss (regress against the marginal score) and a tractable denoising score matching loss (regress against the conditional score):

For the Gaussian path, plugging ∇ log p_t(x|z) = −ε/β_t into L_CSM shows the network is learning to predict the noise that corrupted the data. This is unstable as β_t → 0 (the 1/β_t² blow-up you saw in the lab), so DDPM dropped the constant and reparameterized into a noise predictor ε^θ_t:

This is the loss behind the original Denoising Diffusion Probabilistic Models. Algorithm 4 is Algorithm 3 with "predict the velocity" replaced by "predict the noise" — noise a data point, regress against ε.

Theorem 17 — the SDE extension trick

The marginal field gives an ODE that follows the path. Can we follow the same marginal path with an SDE? Yes — and we get to choose the noise level after training.

Why this is remarkable. One trained model gives you an entire family of samplers indexed by σ_t. At σ_t = 0 you recover the deterministic probability-flow ODE; at σ_t > 0 you get stochastic sampling that injects fresh noise (the score term steers it back), which can self-correct accumulated errors. In theory any σ_t works; in practice training error and finite step sizes mean there is an empirically best σ_t.

The Fokker–Planck equation (why it works)

The proof generalizes the continuity equation to SDEs. Define the Laplacian Δw_t(x) = ∑_i ∂²w_t/∂x_i² = div(∇w_t)(x).

Proof of Theorem 17 (sketch). Start from the continuity equation for the ODE field, ∂_t p_t = −div(p_t u^target_t). Add and subtract (σ_t²/2)Δp_t. Rewrite one copy using Δp_t = div(∇p_t) and ∇ log p_t = ∇p_t/p_t, so (σ_t²/2)Δp_t = div(p_t·(σ_t²/2)∇ log p_t). Folding it into the divergence gives ∂_t p_t = −div(p_t[u^target_t + (σ_t²/2)∇ log p_t]) + (σ_t²/2)Δp_t — the Fokker–Planck equation for the SDE in Theorem 17. By Theorem 19, X_t ∼ p_t. □

Chapter 9: Guidance — Vanilla & Classifier-Free

Everything so far was unguided: the model returns some sample of p_data. We almost always want a prompt: sample p_data(·|y) for a text prompt or class y. Recall the terminology: "conditional" means conditioning on a clean data point z; guided means conditioning on a prompt y.

Vanilla guidance

The simplest approach: feed y to the network as an extra input, u^θ_t(x|y), and train exactly as before but with data pairs (z, y) ∼ p_data. The guided conditional flow matching objective is

The only change from the unguided loss is sampling (z,y) instead of just z — in PyTorch, a dataloader returning both images and prompts. The prompt does not change the conditional path or conditional field; it just enters the network. In theory this gives faithful samples from p_data(·|y).

Classifier guidance (the stepping stone)

For Gaussian paths, write the guided field via the guided score, u^target_t(x|y) = a_t ∇ log p_t(x|y) + b_t x. By Bayes' rule (gradient in x, so ∇ log p_t(y) = 0):

Substituting gives u^target_t(x|y) = u^target_t(x) + a_t ∇ log p_t(y|x): the guided field is the unguided field plus the gradient of a classifier log p_t(y|x) (the log-likelihood of the prompt given the noisy image). Classifier guidance scales that term by a guidance scale w > 1:

It works, but needs a second network (a classifier on noisy data), and for high-dimensional y (text) p_t(y|x) is hard to learn. Note w ≠ 1 makes this a heuristic — it is no longer the true guided field.

Classifier-free guidance (CFG)

The fix that runs every modern image/video model: get the same amplifying effect without a separate classifier. Substitute the Bayes identity ∇ log p_t(y|x) = ∇ log p_t(x|y) − ∇ log p_t(x) into the classifier-guidance formula and collect terms. The score and the b_tx pieces recombine into whole vector fields, leaving the clean linear combination:

One model, not two. The trick is to augment the label set with a special null label ∅ meaning "no conditioning," and set u^target_t(x) = u^target_t(x|∅). During training (Algorithm 5) we drop the real label to ∅ with probability η, so the same network learns both the guided and unguided fields. At inference we evaluate both branches and combine them with the formula above.

Now build the CFG combination on a 2D toy and confirm the geometry: at w = 1 you recover the guided field; larger w pushes strictly further toward the prompt.

Chapter 10: Architectures & Time Embeddings

The math above never said how the network u^θ_t(x|y) is built. It has three inputs — a vector x in R^d, a prompt y, and a scalar time t — and one output, a vector u^θ_t(x|y) in R^d of the same shape as x (it is a velocity per coordinate). For toy distributions an MLP over the concatenation of x, y, t works. For images and video we need specialized architectures.

Embedding the conditioning inputs

Time. Concatenating the raw scalar t works for toys, but in practice t is lifted to a higher-dimensional Fourier feature embedding so the network can capture high-frequency time dependence:

with geometrically spaced frequencies w_i from w_min to w_max. Because sin² + cos² = 1, the embedding has unit norm. The exact form is not sacred — it is just a convenient normed embedding of the scalar time.

Class labels. For a discrete label in {0,…,N}, learn one embedding vector per class and look it up — these embeddings are part of θ.

Text. For a text prompt, use a frozen, pre-trained encoder. CLIP (Contrastive Language-Image Pre-training) learns a shared image–text embedding space and gives a single coarse vector y = CLIP(y_raw). To preserve word-level detail one also uses a pre-trained transformer (e.g. T5) to get a sequence of embeddings PromptEmbed(y_raw) of shape S × k. Models often combine several pretrained text encoders.

The U-Net

The U-Net is a convolutional network whose input and output both have image shape — ideal for parameterizing x ↦ u^θ_t(x|y). It funnels an image down through encoders (channels grow, height/width shrink) to a small latent, processes it in a bottleneck, then expands back through decoders to image shape:

U-Nets dominated the early diffusion literature; modern variants add attention layers inside the encoder/decoder stacks.

The Diffusion Transformer (DiT)

The diffusion transformer applies the attention mechanism instead of convolution. Building on Vision Transformers, it patchifies the image, embeds each patch as a token, processes the token sequence with transformer layers, then depatchifies back to image shape:

Inside a DiT block. Three operations: (i) self-attention over patches (each patch attends to all others, the same scaled dot-product attention softmax(QK^T/√d_h)V with multiple heads); (ii) cross-attention to the prompt tokens (queries from patches, keys/values from y); and (iii) time conditioning via adaptive normalization (AdaLN), where the time embedding produces per-channel scale and shift parameters (γ, β) = g(t̃) that modulate normalized activations, AdaNorm(x) = (1 + γ) ⊙ Norm(x) + β. Class-conditioned DiTs (as in the course lab) usually drop cross-attention in favor of time-and-class AdaLN.

Chapter 11: Latent Space, VAEs, and Real Systems

Modeling images directly in pixel space is brutal: a 1024×1024 RGB image is d ≈ 3 million dimensions, and a flow model's output must be just as large as its input. The fix is to model in a compressed latent space.

Autoencoders and the problem they leave open

An autoencoder pairs an encoder μ_φ : R^d → R^k with a decoder μ_θ : R^k → R^d, with k « d (e.g. downsample 1024 to a 16×16-ish latent). Trained on the reconstruction loss E[‖μ_θ(μ_φ(x)) − x‖²], it learns to compress and rebuild. But there is no control over the latent distribution p_latent(z) — compression may turn an easy data distribution into a wild latent one that is hard to model generatively.

The variational autoencoder

A VAE makes the encoder/decoder probabilistic — q_φ(z|x) = N(μ_φ(x), σ_φ²(x)), p_θ(x|z) = N(μ_θ(z), σ_θ²) — and adds a regularizer that pushes the latent distribution toward a clean Gaussian prior p_prior = N(0, I_k). The objective combines reconstruction with a prior term weighted by β:

The first term forces latents to decode back to data; the second forces the per-example encoding to look Gaussian, so the aggregate latent distribution is Gaussian-like and easy to model. The KL divergence D_KL(q ‖ p) = E_q[log(q/p)] measures dissimilarity between distributions; it is ≥ 0 and zero iff q = p. For isotropic Gaussians it has a closed form penalizing the encoder mean for being non-zero and the variance for being non-one.

Latent diffusion

Case studies: Stable Diffusion 3 and Movie Gen

Stable Diffusion 3. Uses exactly the conditional flow matching objective from Chapter 6 (the authors tested many alternatives and found flow matching best), with classifier-free guidance training, inside the latent space of a pretrained autoencoder. Text conditioning combines three embeddings — two CLIP encoders plus the sequential output of Google's T5-XXL — fed to a multi-modal DiT (MM-DiT) that attends to both image patches and text tokens. The largest model has 8 billion parameters; sampling uses 50 Euler steps with a CFG weight between 2.0 and 5.0.

Meta Movie Gen Video. Data are videos in R^T×C×H×W. It uses conditional flow matching with the straight-line schedulers α_t = t, β_t = 1 − t, in the latent space of a temporal autoencoder (TAE) that compresses time and space (with temporal tiling for long videos). The backbone is a DiT patchified over time and space, with self-attention among patches and cross-attention to text. It uses three text encoders (UL2 for reasoning, ByT5 for character-level detail, MetaCLIP for shared image–text space). The largest model has 30 billion parameters.

Chapter 12: Discrete Diffusion — Language Models the Diffusion Way

Text is not a point in R^d — it is a sequence of discrete tokens. There is no continuous diffusion process on a discrete set (SDEs need a real-valued state). The principles transfer anyway, with one substitution: replace ODEs/SDEs with continuous-time Markov chains (CTMCs).

The discrete state space

Let the vocabulary be V = {v₁,…,v_V} (an alphabet, a token set, or the 4 DNA bases). The state space is S = V^d — all sequences of length d. A discrete generative process is a random trajectory X_t in S that is Markov: the future depends only on the present, p(X_t+h | X_t, past) = p(X_t+h | X_t). Such a process is a continuous-time Markov chain.

The rate matrix — the discrete vector field

In discrete space you cannot move "in a direction"; you can only jump between states. The analogue of a vector field is a rate matrix Q_t(y|x) — the instantaneous rate of jumping from state x to state y. It obeys two conditions:

Theorem 33 (existence & uniqueness): every bounded, time-continuous rate matrix corresponds to a unique CTMC — so we may parameterize Q^θ_t with a network and trust a chain exists. We simulate a CTMC with a discrete Euler step: for small h, p_t+h|t(y|x) ≈ 1_y=x + h·Q_t(y|x) — a valid categorical distribution we sample from each step.

Training mirrors flow matching exactly

The recipe is identical to continuous flow matching: (1) build a probability path interpolating noise and data; (2) derive a conditional and marginal rate matrix; (3) learn the marginal rate matrix simulation-free.

A discrete conditional probability path p_t(x|z) again satisfies p₀(·|z) = p_init, p₁(·|z) = δ_z, and the marginal path is the data-weighted mixture p_t(x) = ∑_z p_t(x|z) p_data(z). The standard choice is the factorized mixture path: independently per token, with probability κ_t keep the clean token z_j and with probability 1 − κ_t replace it with a noise token, where the scheduler runs κ₀ = 0 to κ₁ = 1. Unlike the Gaussian path it does not transport mass — it fades one distribution out and another in (there is no direction in discrete space).

So training reduces to cross-entropy. The discrete flow matching loss is the token-wise negative log-likelihood of the clean tokens given the noised sequence:

The parallel to continuous flow matching is exact: there, training reduced to regression against a velocity; here, it reduces to classification of the clean tokens. A standard sequence-to-sequence transformer with a softmax per position is enough.

Masked diffusion language models

Chapter 13: Cheat Sheet & Connections

You now hold the whole document — from "generation is sampling" to masked diffusion language models. Here it is on one page.

Cheat sheet

The five lectures (Gleams) this companion accompanies

• Lecture 1 — Flow & Diffusion Models (Ch 1–3 here): ODEs, SDEs, Brownian motion, OU, Euler/Euler–Maruyama.
• Lecture 2 — Flow Matching (Ch 4–6): probability paths, the marginalization trick, the CFM loss.
• Lecture 3 — Score Matching & Guidance (Ch 7–9): scores, SDE sampling, CFG.
• Lecture 4 — Architectures & Latent Spaces (Ch 10–11): U-Net, DiT, VAEs, SD3/Movie Gen.
• Lecture 5 — Discrete Diffusion (Ch 12): CTMCs, masked diffusion language models.

Related lessons on this site

• Diffusion Models (Gleam) — the DDPM view of the same machine.
• Flow Matching (Gleam) — a focused take on the training target.
• Diffusion (Architecture Atlas) — bird's-eye overview.
• SDEs & Continuous Diffusion (Deep-Dive) — the rigorous continuous-time treatment.