Phase 1: Diffusion Model Fundamentals · 50 min · Python · PyTorch · Hugging Face Diffusers

How Diffusion Works

Diffusion models generate images by learning to reverse the process of adding noise — denoising step by step.

Hiring signal: Understanding diffusion fundamentals is tested in every generative media technical interview — if you can't explain forward/reverse diffusion, you won't pass the screening round.

What you will learn

Explain forward diffusion: progressively adding Gaussian noise to an image over T steps
Explain reverse diffusion: learning to denoise step by step from pure noise
Describe noise prediction networks: the model predicts the noise added at each step
Articulate why diffusion models replaced GANs for image generation

The Problem

Before 2020, image generation was dominated by GANs (Generative Adversarial Networks). GANs were fast but unstable — training collapses, mode dropping, and limited diversity were constant problems. Then in 2020, a paper called DDPM (Denoising Diffusion Probabilistic Models) changed everything. Diffusion models were slower, but they were stable, diverse, and produced higher quality images. By 2022, Stable Diffusion brought latent diffusion to consumer GPUs, and by 2024, FLUX and Sora pushed diffusion to production quality.

If you're building generative media systems, you need to understand how diffusion works — not at a PhD level, but at an engineering level. You need to know what the model is doing when you set num_inference_steps=4 and what guidance_scale=7.5 actually controls.

What you'll build
A visualization of forward diffusion (adding noise to an image step by step) and reverse diffusion (denoising from pure noise to a coherent image). You'll implement forward diffusion from scratch and use a pre-trained model for reverse diffusion.

Forward Diffusion: Adding Noise

Forward diffusion is simple: take an image and progressively add Gaussian noise over T steps. At step 0, you have the original image. At step T, you have pure noise.

import torch

def forward_diffusion(image, num_steps=1000, beta_start=0.0001, beta_end=0.02):
    """
    Forward diffusion: progressively add noise to an image.
    
    Args:
        image: tensor of shape (C, H, W) with values in [0, 1]
        num_steps: total diffusion steps (T)
        beta_start, beta_end: noise schedule parameters
    
    Returns:
        List of noisy images at each step
    """
    betas = torch.linspace(beta_start, beta_end, num_steps)
    alphas = 1.0 - betas
    alpha_bars = torch.cumprod(alphas, dim=0)
    
    noisy_images = []
    for t in range(num_steps):
        noise = torch.randn_like(image)
        # x_t = sqrt(alpha_bar_t) * x_0 + sqrt(1 - alpha_bar_t) * noise
        noisy = torch.sqrt(alpha_bars[t]) * image + torch.sqrt(1 - alpha_bars[t]) * noise
        noisy_images.append(noisy)
    
    return noisy_images

The key formula at each step t:

x_t = √(ᾱ_t) · x_0 + √(1 - ᾱ_t) · ε

where:
  x_0 = original image
  ε = Gaussian noise (sampled from N(0, I))
  ᾱ_t = cumulative product of (1 - β_t)
  β_t = variance schedule (small → large)

At early steps (t near 0), the image is mostly intact. At later steps (t near T), the image is dominated by noise. At step T, the image is pure Gaussian noise — the original structure is completely destroyed.

Forward diffusion is not learned
Forward diffusion is a fixed mathematical process — no neural network is involved. It's just adding noise according to a schedule. The learning happens in reverse diffusion.

Unlock the full lesson

You've read the first 2 sections. The rest of this lesson covers Reverse Diffusion: Denoising, Why Diffusion Replaced GANs, Noise Schedules, Using Pre-trained Diffusion Models, Key Takeaways, What's Next — plus a hands-on lab, quiz, and project artifact.

Create a free account to unlock Phase 0 and Phase 1 of every course — no credit card.