Diffusion Models Explained

# FORWARD PROCESS — turning a clean signal into noise, one step at a time.
# A diffusion model first DESTROYS data so it can later learn to REBUILD it.
# We use a tiny 1-D "signal" (think of it as 5 pixels) instead of an image.

import random
random.seed(0)                       # reproducible noise for the demo

signal = [0.9, 0.7, 0.5, 0.3, 0.1]   # the clean data we start from
steps = 4                            # how many times we add noise
noise_amount = 0.15                  # std-dev of 
...

# REVERSE PROCESS — one denoising step.
# The model's whole job is to PREDICT the noise that was added.
# Once we have that prediction, we SUBTRACT it to recover cleaner data.

import random
random.seed(1)

clean = [0.9, 0.7, 0.5, 0.3, 0.1]                 # the data we want back
true_noise = [random.gauss(0, 0.2) for _ in clean] # the noise reality added
noisy = [c + n for c, n in zip(clean, true_noise)] # what the model receives

# A REAL model is a neural net (a U-Net). Here we fake a decent 
...

# SAMPLING — generate data from scratch by denoising over many steps.
# Start from PURE NOISE, then repeatedly predict-and-subtract toward clean data.

import random
random.seed(7)

target = [0.9, 0.7, 0.5, 0.3, 0.1]      # the "shape" we are trying to recover
x = [random.gauss(0, 1) for _ in target] # step 0 = pure random noise

print("start (pure noise):", [round(v, 2) for v in x])

total_steps = 8
for step in range(total_steps, 0, -1):
    # Toy "model": guess how far each value is from the t
...

# TRAINING — the loss a diffusion model actually minimises.
# Goal: given a noisy sample, the model should PREDICT the added noise.
# Loss = mean squared error between predicted noise and true noise.

import random
random.seed(3)

clean = [0.5, 0.2, 0.8, 0.4]
true_noise = [random.gauss(0, 1) for _ in clean]
noisy = [c + n for c, n in zip(clean, true_noise)]

def mse(predicted, actual):
    diffs = [(p - a) ** 2 for p, a in zip(predicted, actual)]
    return sum(diffs) / len(diffs)

bad_guess  = 
...

# 🎯 YOUR TURN — run the FORWARD process: add Gaussian noise to a signal.
# Fill in every ___ . Run it and compare against the expected output.

import random
random.seed(0)

signal = [1.0, 0.6, 0.2]      # a tiny clean signal
steps = 3

x = list(signal)
for step in range(steps):
    # 1) Add Gaussian noise (mean 0, std 0.1) to EACH value.
    #    👉 use random.gauss(0, 0.1)
    x = [v + ___ for v in x]            # 👉 replace ___

    # 2) 👉 print the step number and the rounded values
    pr
...

# 🎯 YOUR TURN — run ONE reverse step: subtract the predicted noise.
# Fill in every ___ . The model's prediction is given to you.

noisy           = [1.1, 0.4, 0.9]   # what the model receives
predicted_noise = [0.2, 0.1, 0.3]   # what the model thinks the noise is

# 1) Denoise = noisy value MINUS predicted noise, value by value.
#    👉 subtract p from x for each pair
denoised = [x - ___ for x, p in zip(noisy, predicted_noise)]   # 👉 replace ___

# 2) 👉 print the denoised list
print("denois
...

# REAL diffusion in practice: Stable Diffusion via Hugging Face 'diffusers'.
# (Needs the diffusers + torch libraries and a GPU; shown to illustrate the API.)

from diffusers import StableDiffusionPipeline
import torch

# Load a pretrained LATENT diffusion model. "Latent" means it denoises in a
# small compressed space, not full-resolution pixels — that is why it's fast.
pipe = StableDiffusionPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    torch_dtype=torch.float16,
)
pipe = 
...