How is a diffusion model trained on one step without simulating the whole noising chain?

## What the forward process is A denoising diffusion model defines a **fixed** corruption process that turns a data sample into noise over `T` steps. Each step is ``` x_t = sqrt(1 - beta_t) * x_(t-1) + sqrt(beta_t) * z, z ~ N(0, I) ``` where `beta_t` is a small positive number from a predefined sequence that grows with `t`. Nothing here has parameters: no weights, no gradients, no learning. The scaling by `sqrt(1 - beta_t)` is what makes the process *variance preserving* - if `x_0` has roughly unit variance per dimension, so does every `x_t`, which keeps the network's inputs on one scale across the whole chain. ## The closed form, and why it matters Composing Gaussian steps gives another Gaussian. Define `alpha_t = 1 - beta_t` and `abar_t = alpha_1 * alpha_2 * ... * alpha_t`. Then the marginal of step `t` given the original sample is ``` q(x_t | x_0) = N( sqrt(abar_t) * x_0 , (1 - abar_t) * I ) ``` which you sample as `x_t = sqrt(abar_t) * x_0 + sqrt(1 - abar_t) * eps` with a single standard-normal draw `eps`. The two coefficients are a signal/noise mix whose squares sum to one. At `t = 0` the mix is essentially all signal. Mid-chain the sample is a visible blend - the coarse structure of `x_0` survives while fine detail is gone. As `abar_t` approaches zero the sample is indistinguishable from a draw from `N(0, I)`, which is the tractable prior that sampling starts from. This closed form is the reason diffusion training is cheap. Without it, producing a training input at step 500 would mean running 500 sequential noising operations. With it, every step index is one line of arithmetic, and the steps are trained in random order rather than in sequence. ## The training loop One optimisation step is: 1. Take a clean example `x_0` from the dataset. 2. Draw a step index `t` uniformly from `1..T`. 3. Draw `eps ~ N(0, I)` and build `x_t = sqrt(abar_t) * x_0 + sqrt(1 - abar_t) * eps`. 4. Predict `eps_theta(x_t, t)` - the network sees the noisy sample **and** the step index, usually injected as a positional-style embedding added inside the blocks so one set of weights serves all noise levels. 5. Minimise the squared error against the `eps` you drew. The label is free and exact, which is what distinguishes this from adversarial training: there is no discriminator, no minimax, and no mode-collapse dynamic - just a regression with a stationary target. ## Why regress the noise rather than the clean sample The two are algebraically interchangeable: given `x_t` and a predicted `eps`, the implied clean estimate is `x0_hat = (x_t - sqrt(1 - abar_t) * eps_hat) / sqrt(abar_t)`. What differs is the implicit weighting across noise levels. The `eps` target is a unit-variance quantity at every `t`, so the loss is naturally comparable across the chain, whereas an `x_0` target is nearly trivial at small `t` and dominated by scale factors at large `t`. The simplified unweighted `eps` objective drops the variational weighting terms and, in practice, this reweighting is what makes the objective favour perceptually important noise levels. ## The score-matching view The same object has a second reading. The **score** of a density is the gradient of its log with respect to the input. For the noised conditional above, ``` grad_{x_t} log q(x_t | x_0) = -(x_t - sqrt(abar_t) * x_0) / (1 - abar_t) = -eps / sqrt(1 - abar_t) ``` so a network that predicts the added noise is, up to the factor `-1/sqrt(1 - abar_t)`, estimating the score of the noise-corrupted data density. This is denoising score matching: you cannot compute the score of the data distribution directly, but you can regress the noise you added, and that regression converges to the score of the smoothed density. It is why diffusion models and score-based generative models are two descriptions of one method, and why the reverse chain can be read as Langevin-style movement up the score field. ## What the loss value does and does not tell you The reported loss is an average over randomly drawn `t`, so most of its variance is the step draw, not model progress; it flattens early and then barely moves while samples keep improving. Per-step behaviour is uneven by construction: at large `t` the input is mostly noise, so echoing it back is nearly correct and the loss is low, while at small `t` the little noise present is hard to separate from real detail and the loss is high. Neither pattern indicates a bug. Judging a diffusion model by its training loss curve is the classic mistake - you evaluate by sampling.