Core 9 min 4 of 4

The 0.18215 nobody explains

A constant that exists so the noise schedule sees the variance it was designed for — and a division whose absence produces an image rather than an error.

What this repairs

Copying the scaling factor from a reference implementation without knowing it exists to put latents at unit variance, which the noise schedule assumes.

Assumes

An autoencoder that is not the point
Destroying an image on purpose · Diffusion

Every latent-diffusion implementation multiplies by $0.18215$ after encoding and divides by it before decoding, and almost none of them say why. It is not a tuning constant and it was not searched for. It is a measurement:

$\sigma \;\approx\; 5.49, \qquad \frac{1}{\sigma} = 0.18215,$

where $\sigma$ is the component-wise standard deviation of the raw latents this autoencoder produces on its training data. The factor exists to put the latents at roughly unit variance, and the reason that matters is the previous topic's first formula.

What an unscaled latent does to the schedule

$x_t = \sqrt{\bar{\alpha}_t}\,x_0 + \sqrt{1-\bar{\alpha}_t}\,\varepsilon, \qquad \varepsilon \sim \mathcal{N}(0, I)$

The forward process, unchanged. The noise term has unit variance by definition — that is not negotiable, it is what ε means — so the balance between the two terms is decided entirely by the scale of x₀.
$\mathrm{SNR}_{\text{eff}}(t) = \frac{\bar{\alpha}_t\,\sigma^{2}}{1-\bar{\alpha}_t} = \sigma^{2}\,\mathrm{SNR}(t)$

Feed in data of standard deviation σ instead of 1 and every signal-to-noise ratio on the schedule is multiplied by σ². The schedule was designed against the left-hand side and is being handed the right-hand one.
$\sigma^{2} = 5.49^{2} = 30.1$

And that factor is thirty. Not a rounding matter: the noise level the schedule believes it is applying at any timestep is thirty times more destructive than the one the data actually experiences.
$\mathrm{SNR}_{\text{eff}} = 1 \;\Longleftrightarrow\; \bar{\alpha} = \frac{1}{1+\sigma^{2}} = 0.0321 \;\Longleftrightarrow\; t = 816 \text{ (textbook)}$

Which moves the halfway point of the noise from t = 354 to t = 816 on the textbook curve, and from t = 337 to t = 752 on the rescaled curve the model actually trains on — the ᾱ threshold is the same 0.0321 either way, and only the timestep that reaches it moves. Four fifths of the training chain would sit in the high-signal regime, the model would almost never see genuinely destroyed data, and its first sampler steps — which start from pure noise — would be the ones it had least practice at.
$x_0 \leftarrow 0.18215\,x_0 \;\Longrightarrow\; \mathrm{SNR}_{\text{eff}} = \mathrm{SNR}$

One multiply, and the schedule means what it says again. The constant is not about the decoder, the encoder or the image — it is about making the second argument of the forward process the size the first argument assumes.

Convention It is a round trip, and both halves are silent

The factor appears in two directions and four places in sd2_joint.py: multiplied on after every encode — the sampling encoder, the deterministic encoder — and divided off before every decode, including the auxiliary depth reconstruction path. Latents are stored, passed and diffused in scaled units; the VAE is the only thing that sees unscaled ones.

Both halves fail silently, in opposite directions and with the same symptom: plausible output. Forget the multiply and the diffusion model is trained on data five times too large, so it never experiences the noisy end of its own schedule. Forget the divide and the decoder receives latents five times outside its training range, and a convolutional decoder handed out-of-range input does not raise — it saturates, and returns a clipped, over-contrasted image.

This is the property that makes it dangerous. Neither mistake produces an exception, a NaN, or noise. Both produce a picture, and a picture invites you to debug the model.

Pitfall The constant belongs to the checkpoint, not to the field

$0.18215$ is SD1.x and SD2.x's number, measured on their autoencoder. SDXL's is $0.13025$ . Other latent models differ again, and a retrained autoencoder — even the same architecture on different data — has a different one.

So read it from the checkpoint. sd2_joint.py does exactly that, reaching for vae.config.scaling_factor at every one of its four sites rather than writing the literal, which is why swapping the VAE there is a configuration change rather than a code change. A hardcoded $0.18215$ is correct right up to the day someone changes the codec, and then it is a silent five-fold scale error with no traceback attached.

The same caution applies to the other invisible conventions in the same neighbourhood: images live in $[-1, 1]$ rather than $[0, 1]$ , and the scheduler has its own init_noise_sigma multiplier on the initial latent, which happens to be $1$ for DDIM and is not for every sampler. Each of these is a number that is right by default and produces a plausible image when it is wrong.

Check yourself

Your decoded images all come out high-contrast and clipped, and the effect is identical at 5 steps and at 100. Diffusion problem or convention problem?

Show answer

Convention, and the step-count invariance is what says so. Anything wrong with the sampler or the model changes when you change the integration; a scale error between the latent and the decoder is applied once at the end and does not.

Confirm it without touching the model. Take a real image, encode it, decode it immediately, and see whether the round trip is clipped too — if it is, the bug is in your encode/decode plumbing rather than anywhere near diffusion. Then check the arithmetic directly: measure the standard deviation of the tensor you are handing the decoder. Scaled latents run around $1$ ; if you are seeing something near $5$ , you skipped the division.