Latent diffusion mechanics

Neither config sets beta_schedule, so both take the "linear" default from the DDPM.__init__ signature at ldm/models/diffusion/ddpm.py line 38. That name is misleading and worth flagging: the function it selects is linear in the square root of beta, not in beta.

# ldm/modules/diffusionmodules/util.py:14
if schedule == "linear":
    betas = (
        torch.linspace(linear_start ** 0.5, linear_end ** 0.5,
                       n_timestep, dtype=torch.float64) ** 2
    )

# ldm/models/diffusion/ddpm.py:106  register_schedule
alphas          = 1. - betas
alphas_cumprod  = np.cumprod(alphas, axis=0)
sqrt_alphas_cumprod           = sqrt(alphas_cumprod)
sqrt_one_minus_alphas_cumprod = sqrt(1. - alphas_cumprod)
sqrt_recip_alphas_cumprod     = sqrt(1. / alphas_cumprod)
sqrt_recipm1_alphas_cumprod   = sqrt(1. / alphas_cumprod - 1)

Squaring a linear ramp puts most of the schedule’s small betas early, so signal survives much longer than a plain linear ramp would let it. The sandbox above ports those seven lines to TypeScript, endpoint for endpoint, and the ported betas land on the config values exactly at both ends. The three preset chips differ only in those two endpoints, and they behave visibly differently: at t = 999 the txt2img schedule still holds a measurable trace of the signal, and cin256 has effectively none.

A reverse step needs two things: the noisy field, and an estimate of the noise inside it. The trained U-Net supplies the second one, and that is the only part of a diffusion model the weights are for. Everything around it is fixed arithmetic:

# ldm/models/diffusion/ddpm.py:195
def predict_start_from_noise(self, x_t, t, noise):
    return (sqrt_recip_alphas_cumprod[t]   * x_t -
            sqrt_recipm1_alphas_cumprod[t] * noise)

There are no weights on this page, so the demo hands that step the noise it added itself. Read the right panel as the arithmetic, never as model output. The interesting part is the second coefficient. It is the error gain: whatever the predictor gets wrong, this step multiplies it by that number, and on the txt2img schedule it climbs from 0.57 at t = 200 to 14.6 at t = 999. That is why sampling walks back in many small steps instead of jumping. Late in the trajectory almost nothing is left of the signal, so a small mistake about the noise becomes a large mistake about the image. Switch the predictor to 5 percent off and drag t: the RMS error in the banner tracks the gain, because that is what the multiplication does.

The source is the CompVis latent-diffusion tree. It was copied in rather than forked with history: the repository holds two commits, 1 minute and 59 seconds apart on 4 December 2024. The first carries a LICENSE and a two-line README. The second adds all 12,646 lines of the upstream tree in one move, under the title Saving Model Weights, and adds no weights.

The lineage is not in doubt: environment.yaml pins CompVis/taming-transformers and openai/CLIP as editable installs, which is upstream’s own dependency list, setup.py declares the package as latent-diffusion 0.0.1, and the eight images in assets/ are the upstream fire prompts. Credit for the architecture, the configs, and the code on this page belongs to the CompVis authors of the latent diffusion paper. The work in this unit is the reading of it.

• It runs no model. There are no weights on this page and no inference of any kind. The 24x24 field is a toy pattern, not a latent produced by the autoencoder.
• It shows one reverse step, not a sampling loop. DDIM and PLMS chain hundreds of these with a guidance term; none of that is modeled here.
• The compression table is exact arithmetic on config values. It says nothing about reconstruction quality, which is what the KL and LPIPS terms in the autoencoder configs actually trade against.
• No generated images appear anywhere on this page. The eight in the repo’s assets/ folder are upstream CompVis samples and are not this project’s output.