generative

DDPM — Denoising Diffusion Probabilistic Models — defines a latent variable generative model through a pair of Markov chains. The forward (noising) chain progressively corrupts data $x_0 \sim q(x_0)$ over $T$ steps with a fixed Gaussian schedule $\{\beta_t\}_{t=1}^{T}$:

A world model has to answer $p(x_{t+1} \mid x_{\leq t}, a_{\leq t})$. DIAMOND answers it with a conditional diffusion model over the image, dropping the discrete latent bottleneck its predecessors relied on.

A diffusion model needs a network that maps a noised latent and a timestep to a prediction of the noise. Nothing about that job requires convolutions, and DiT tests the claim directly: patchify the latent into a sequence, run a standard Vision Transformer over it, and decode back.

Dreamer inherits PlaNet's recurrent state-space model and throws away its planner. Where PlaNet searches over action sequences at every step — thousands of imagined trajectories to choose one action — Dreamer learns a policy, so acting costs a single forward pass.

DreamerV2 keeps its predecessor's shape — a recurrent state-space model, an actor and a critic trained on imagined trajectories — and changes what the stochastic latent is. Where Dreamer draws $s_t$ from a diagonal Gaussian, this draws a grid of categorical variables: 32 of them, 32 classes each, sampled as one-hots. The state is then a sparse binary vector of length 1024 with exactly 32 bits set.

DreamerV3's contribution is that its hyperparameters stop mattering. Its predecessors needed a different divergence scale for Atari than for continuous control, a different entropy bonus, a different discount; this one setting spans them, and the paper's headline result — collecting diamonds in Minecraft from scratch — is run with the same numbers as everything else.

A continuous normalizing flow is defined by a vector field: push samples of a simple distribution along $d\mathbf{x}/dt = v_t(\mathbf{x})$ and read off what arrives. Training one by maximum likelihood, as Neural ODE does, means solving that ODE on every gradient step — the cost that kept continuous flows off the scale diffusion models reached.

Genie turns unlabelled video into a playable environment. A user gives it one image and presses one of $|A| = 8$ buttons; it answers with the next frame, and keeps answering. Nothing in its training data says what the buttons are --- the meaning of each is learned, and emerges as left, right, jump and no-op on the platformer games it was trained on.

Flow Matching models the instantaneous velocity $v(z_t, t)$ — the tangent of the path at one instant — and recovers a sample by integrating it. MeanFlow models the average velocity over an interval, defined as that integral divided by its width:

NCSN — Noise-Conditional Score Network — is the score-based counterpart of DDPM. Rather than predicting noise inside a discrete Markov chain, it directly learns the (Stein) score function $s_\theta(x, \sigma) \approx \nabla_x \log p_\sigma(x)$, where $p_\sigma$ is the data distribution convolved with Gaussian noise of standard deviation $\sigma$.

A residual network updates its state in discrete jumps, $h_{t+1} = h_t + f(h_t, \theta_t)$. Shrink the jump and add a step size and that recurrence is Euler's method; take the step to zero and the network stops being a sequence of layers and becomes a differential equation,

NICE is the first normalizing flow trained on images: instead of bounding the likelihood (VAE) or factorising it over pixels (autoregressive models), it learns an invertible map $h = f(x)$ onto a latent space with a factorised prior, so the exact data log-density falls straight out of the change-of-variables formula

PlaNet learns the dynamics of an environment in latent space and plans there, never reconstructing a frame in order to choose an action. The difficulty it addresses is that pixels are a partial observation: the agent must both remember what it has seen and stay uncertain about what it has not.

RealNVP takes the coupling layer of NICE and makes it scale as well as shift, which is what finally let exact-likelihood flows model natural images. An affine coupling layer splits the input with a binary mask $b$ and rescales the unmasked half by a learned, input-dependent factor:

Given any coupling of two distributions — in the generative case $X_0 \sim \pi_0$ noise and $X_1 \sim \pi_1$ data, drawn independently — the rectified flow induced by that pair is the ODE

Score-SDE's contribution is that two families which looked separate are the same object viewed at different resolutions.

Diffusion in pixel space spends most of its capacity on detail the eye discards. Latent diffusion splits the problem in two: an autoencoder learns a perceptually equivalent space at a fraction of the resolution, and the diffusion model runs entirely inside it.

The Variational Auto-Encoder defines a latent-variable generative model $p_\theta(x, z) = p_\theta(x \mid z)\, p(z)$ with a standard-normal prior $p(z) = \mathcal{N}(0, \mathbf{I})$ and a neural decoder $p_\theta(x \mid z)$. Because the marginal likelihood $p_\theta(x) = \int p_\theta(x \mid z)\, p(z)\, dz$ is intractable, training maximises the evidence lower bound (ELBO) instead:

The Vector-Quantised Variational Auto-Encoder replaces the continuous Gaussian bottleneck of a VAE with a discrete one. An encoder $z_e(x)$ maps an image to a spatial grid of $D$-dimensional vectors, and each grid position is snapped to its nearest neighbour in a learned codebook $e \in \mathbb{R}^{K \times D}$: