Destroying an Apple

Building the path out to static

In Chapter 1 we drew a path from the apple out to static. Now we build it. Not sketch it — build it, with numbers you can check on a phone calculator, because everything else in this book stands on top of this one construction.

Here is the job. We have one photograph of one apple. We want a ladder of images: at the bottom, the apple exactly as it was; at the top, pure random static with no apple left in it at all; and in between, a smooth run of rungs — one picture per rung, and that is all the word means — where the apple dissolves a little more on each one. That ladder is called the forward process — adding noise on purpose. It is the only part of this whole subject that involves no learning, no network, and no cleverness. It is a multiplication and a coin flip, repeated.

One housekeeping note before we start, because it saves confusion later: everything here happens directly on pixels. We are working directly on pixels for now; Chapter 4 moves this whole machinery into a smaller space, and not one equation here changes.

What "noise" actually is

"Noise" sounds vague. It is not. When we say we add noise to a pixel, we mean something exact: we draw one random number from a particular bell-shaped pile of possibilities and add it to that pixel's value. Do that independently for every pixel — 786,432 of them in a 512 × 512 color photograph — and you have added noise to an image.

The pile we draw from is Gaussian noise, and it has exactly two properties worth memorising. Its mean is 0: the draws are centered on zero, so they are as likely to brighten a pixel as to darken it, and a great many of them average out to nothing. Its standard deviation — its spread — is 1: about 68% of draws land between $-1$ and $+1$, about 95% land between $-2$ and $+2$, and a draw beyond $\pm 3$ is rare.

We write one such blob of noise as $\boldsymbol{\epsilon}$ — the Greek letter epsilon, which throughout this book means "the noise", one random number per pixel, the same shape as the image itself. And we write "drawn from" with a tilde:

In words: epsilon is drawn from the standard bell curve, mean zero, spread one. The $\mathbf{0}$ says every pixel's noise is centered on zero; the $\mathbf{I}$ says each pixel gets its own independent draw, with spread 1, and no pixel's draw is tied to its neighbor's.

One more piece of vocabulary, and it is the piece that will save us from the most common error in this whole subject. The variance is the spread multiplied by itself. For our standard bell curve the spread is 1 and so the variance is $1 \times 1 = 1$ — the two happen to coincide, which is convenient and also slightly treacherous, so hold on to the distinction.

One step: shrink, then add

Here is the recipe for a single rung of the ladder, in words first. Take the image as it currently stands. Shrink it slightly toward zero — multiply every pixel by a number a little below 1. Then add a little noise. That is the whole step.

Why square roots turn up

Before we write the step down, there is one move that almost every explanation of this subject skips, and skipping it is why the equations that follow look arbitrary. We are about to multiply the picture by one number and the noise by another, and both of those numbers are going to be square roots. Here is where they come from.

Take any random quantity at all and double it. Its spread doubles too, which is what you would guess. But the variance is the spread multiplied by itself, so if the spread has doubled, the variance has gone up by a factor of $2 \times 2 = 4$. Halve the quantity instead and the variance falls to a quarter. The general rule is worth putting on its own line:

In words: multiply a random quantity by some number and its variance changes by that number multiplied by itself — not by the number itself. Scale by 3 and the variance is 9 times what it was. Scale by $0.5$ and the variance is a quarter.

Variance is the quantity we want to keep control of, because it is the form of spread that does something simple when independent random pieces are combined — the chapter makes that precise later, and it is the reason we do our bookkeeping in squares rather than in spreads. So let us work the problem backwards, which is how these coefficients were actually chosen. Suppose we decide that on this rung the noise should account for a fraction $\beta_t$ of the picture's variance. The number $c$ we multiply the noise by has to satisfy $c^2 = \beta_t$, and there is exactly one way to arrange that: $c = \sqrt{\beta_t}$. The picture itself has to keep the rest, the fraction $1 - \beta_t$, so by the identical argument its multiplier is $\sqrt{1 - \beta_t}$.

That is the whole story of the square roots. They are not a convention and they are not decoration: they are what you get when you decide how the variance should be divided up and then ask what to multiply by. Now we can write the step down, with $t$ counting which rung we are on — the timestep — and $\beta_t$ standing for the share of the variance this particular rung's noise takes:

In words: the image at rung $t$ is the image from rung $t-1$, multiplied by the square root of $1 - \beta_t$, plus a fresh blob of standard bell-curve noise multiplied by the square root of $\beta_t$. The subscript on $\boldsymbol{\epsilon}_t$ is there to insist that this is a new draw at every rung, never a re-used one.

That expression $1 - \beta_t$ shows up often enough to deserve its own name, so we give it one:

In words: alpha-t is the share of the signal we keep at this rung, and beta-t is the share of noise we add; they always total 1. So the step reads: keep $\sqrt{\alpha_t}$ of what you had, add $\sqrt{1-\alpha_t}$ of something new.

Why the shrink is there at all

The shrink looks like an odd extra. Why not just add noise and leave the image alone? Because then the numbers would grow without bound. Add a spread-1 blob a thousand times over and the pixel values wander off into the hundreds, and every downstream piece of machinery has to cope with quantities that get bigger the longer we run. The shrink stops that dead. Watch it happen with $\beta_t = 0.1$, so $\alpha_t = 0.9$. Why a tenth, rather than a half or a hundredth? It is round enough that you can check the arithmetic in your head, and heavy enough that the apple falls apart over four rungs instead of a thousand. Real models are far gentler than this down at the bottom of the ladder, and we will put their actual numbers on the page shortly.

That was not luck. In symbols it is an identity, true for every rung of every schedule:

In words: the two coefficients, squared and added, always give exactly 1. That is the check on the split we made a moment ago: scaling by $c$ scales variance by $c^2$, so squaring the two coefficients tells us what share of the variance each lane owns, and the two shares account for all of it with nothing left over. It is the statement that the picture's overall spread is held at 1 for as long as we care to keep going — at rung 1, at rung 500, at rung 1000. (One honest condition attached: this holds if we start from pixel values already scaled to sit around zero with a spread of roughly 1, which is what every implementation does to an image before anything else touches it.) Nothing blows up, nothing collapses. This property has a name in the literature, "variance preserving", and now you know exactly what it buys.

One more structural fact, stated plainly because it matters later: each rung looks only at the rung immediately below it. To build $\mathbf{x}_{7}$ we need $\mathbf{x}_{6}$ and nothing else — not $\mathbf{x}_{5}$, not the original photograph. A chain with that property is a Markov chain, and ours runs $\mathbf{x}_0 \to \mathbf{x}_1 \to \mathbf{x}_2 \to \dots \to \mathbf{x}_T$, where $T$ is how many rungs the ladder has in total.

The schedule: how hard to hit it, and when

We have one free choice left: the list of $\beta_t$ values, one per rung. That list is the noise schedule, and it is decided once, in advance, and then never touched again.

The choice everyone makes is: small at the start, larger at the end. The reasoning is worth spelling out, because it is genuinely about the apple. At the bottom of the ladder we hold a clean, information-rich photograph, and a heavy dose of noise there would destroy fine structure — the speckle on the skin, the edge where the fruit meets the shadow — in a single move, leaving nothing gradual to learn from. Near the top there is almost nothing left to protect, so gentle rungs there would waste effort nudging static into slightly different static. Small early, brutal late.

Time to make it concrete. Here is a four-rung toy schedule, small enough to check with a calculator, and we will use these exact numbers for the rest of the chapter. A note on rounding, made once: we round to four significant figures in the middle of a derivation.

Two things about those $\beta_t$ values before we go on. They rise — 0.1, then 0.2, then 0.3, then 0.5 — which is the small-early, brutal-late shape we argued for a paragraph ago. And every one of them is enormous compared with a real model's, where the first rung adds about a ten-thousandth. That is deliberate, because these four rungs have to do the work of a thousand, so each one has to hit far harder than any real rung ever would.

That fourth column is the star of the chapter, and the next section earns it. For now, read it as the attenuator chain reads: after four rungs, just over a quarter of the apple's signal is still on the line.

Real models use a longer ladder than four. A typical setup runs $T = 1000$ rungs with $\beta_1 \approx 10^{-4}$ rising in a straight line to $\beta_T \approx 0.02$, which is exactly the schedule plotted above. Push that all the way to the top and the surviving share is $\bar{\alpha}_T \approx 4 \times 10^{-5}$: four hundred-thousandths of the apple, which is to say, static. Treat $T = 1000$ as illustrative — it is a configuration choice, not a law, and different models pick differently. And treat it as counting one thing only: the rungs on this ladder. It is not a count of how many passes anything makes later on. One more thing about that letter: if you have come from How LLMs Actually Work, capital $T$ there is the temperature dial you turn when sampling the next word — same letter, unrelated meaning. Here $T$ counts rungs and nothing else.

The shortcut: jumping to any rung in one move

Now the payoff. Suppose we want $\mathbf{x}_{700}$ — the apple at rung 700 of a thousand-rung ladder. The recipe as written says: build rung 1, then rung 2, then rung 3, all the way up. Seven hundred multiplications and seven hundred noise draws, each one waiting on the one before it. That would make everything downstream painfully slow.

It turns out we never have to do that. Let us take two rungs and squash them into one. Start with the two rungs written out:

In words: rung 1 is built from the clean apple, and rung 2 is built from rung 1 — each by the same shrink-then-add recipe, with its own fresh noise draw.

Substitute the first line into the second, replacing $\mathbf{x}_1$ with what it is made of:

In words: rung 2 is the shrink applied to the whole of rung 1, plus rung 2's own noise.

Multiply the bracket out. Two square roots multiplied together become the square root of the product — $\sqrt{\alpha_2}\sqrt{\alpha_1} = \sqrt{\alpha_1\alpha_2}$, and $\sqrt{\alpha_2}\sqrt{1-\alpha_1} = \sqrt{\alpha_2(1-\alpha_1)}$:

In words: the clean apple now carries a single coefficient, $\sqrt{\alpha_1\alpha_2}$ — the two shrinks multiplied together. What is left over is two separate noise blobs, each with its own scale factor. If we can collapse those two into one, we are done.

The one fact you have to be told

We can collapse them, and here is the rule that lets us. Add two independent Gaussian blobs and you get a third Gaussian blob — the bell curve is closed under addition, which is the reason it is used here and not some prettier distribution. The scale of that third blob is where people go wrong, so read this next line twice.

So: our two blobs have scales $a = \sqrt{\alpha_2(1-\alpha_1)}$ and $b = \sqrt{1-\alpha_2}$, which means $a^2 = \alpha_2(1-\alpha_1)$ and $b^2 = 1-\alpha_2$. Add the variances and expand:

In words: multiply out the first bracket to get alpha-2 minus alpha-1-times-alpha-2; the plus-alpha-2 and the minus-alpha-2 cancel; what survives is 1 minus the product of the two alphas. Every trace of the individual rungs has vanished — only the product remains.

Put it back together. The two noise blobs become one blob, $\boldsymbol{\epsilon}$, scaled by $\sqrt{1 - \alpha_1\alpha_2}$:

In words: rung 2 is the clean apple faded by the square root of the product of the two alphas, plus one single blob of standard noise scaled by the square root of whatever is left. Two rungs, one line, one noise draw. And the coefficients still square-sum to 1: $\alpha_1\alpha_2 + (1 - \alpha_1\alpha_2) = 1$, so the spread is still held at 1, exactly as it was for a single rung.

From two rungs to all of them

Nothing about that argument cared that we started at rung 0 and stopped at rung 2. Suppose we have already collapsed everything up to rung $t-1$, so that $\mathbf{x}_{t-1} = \sqrt{\bar{\alpha}_{t-1}}\,\mathbf{x}_0 + \sqrt{1-\bar{\alpha}_{t-1}}\,\boldsymbol{\epsilon}$ for some running product $\bar{\alpha}_{t-1}$. Apply one more rung and repeat the same two moves — multiply out, then add the variances:

In words: identical cancellation, one level up. The leftover noise variance is 1 minus the new running product, and the new running product is the old one times this rung's alpha.

So we name the running product. It is the number that has been sitting in the fourth column of our table all along:

In words: alpha-bar-t — read "alpha bar t" — is every alpha up to rung $t$ multiplied together. The capital-pi symbol means "multiply all of these", the way the stretched S means "add all of these". It is the attenuator chain, in one symbol.

And with that, the destination:

In words: any rung of the ladder is one clean apple, faded, plus one blob of noise, scaled. Not seven hundred blobs — one. Pick a rung, look up two numbers, draw one blob, multiply, add, done. This is not an approximation or a convenient stand-in; given the recipe and the bell curve, it is exactly what chaining the rungs produces.

Let me be precise about one subtlety, since we are being careful. Running the chain by hand with particular draws and using the closed form with one draw do not give you the same picture pixel for pixel — they give you pictures drawn from the same pile of possibilities. That is all anyone ever needs, and it is why the shortcut is a genuine replacement rather than a cheat.

See it move

Where you'll meet this

The noise schedule is not an abstraction hiding in a paper. It is a short list of numbers that travels with the model file. Open the configuration that ships beside a downloaded checkpoint and you will find fields with names like beta_start, beta_end, and a count of training timesteps — typically 1000. Those three values are the amber line from our figure. Two models trained under different schedules are not interchangeable in the way you might expect, because the meaning of "rung 400" differs between them.

You will also meet $\bar{\alpha}_t$ wearing a disguise. In an image-to-image workflow, the control usually labeled denoise — a number between 0 and 1 — decides how far up this ladder your input picture is pushed before anything else happens. Set it low and your picture is carried to a rung where $\bar{\alpha}_t$ is still close to 1, so most of your composition survives. Set it to 1 and your picture goes to the very top, where $\bar{\alpha}_t$ is four hundred-thousandths, and nothing of what you supplied remains. People describe that slider as "how much the model changes my image". It is more exact than that: it is a choice of rung on the ladder we just built.

And there is the reason the closed form matters beyond elegance. Manufacturing a noisy apple at a random rung is something that has to happen enormous numbers of times, quickly, for the whole enterprise to be affordable. One multiplication and one noise draw is affordable. Seven hundred sequential ones would not be.