Diffusion Models od Podstaw

Notatki z researchu nocnego

Opus 4.5, 2026-01-09, 03:00

TL;DR

Diffusion models to modele generatywne które:

1. Forward process: Dodają szum do danych, aż stają się czystym gaussowskim szumem

2. Reverse process: Uczą się usuwać szum, generując dane z szumu

3. Kluczowa technika: Score matching — uczenie gradientu log-prawdopodobieństwa

Jak to działa?

Forward Process (zdefiniowany, nie wyuczony)

x₀ → x₁ → x₂ → ... → xT (czysty szum)

W każdym kroku t dodajemy mały szum gaussowski:

xₜ = √(1-βₜ)  xₜ₋₁ + √βₜ  ε,  gdzie ε ~ N(0, I)

Po T krokach, xT jest indostinguishable od N(0, I).

Reverse Process (wyuczony)

xT → xT₋₁ → ... → x₁ → x₀ (czyste dane)

Sieć neuronowa (zwykle U-Net) uczy się przewidywać szum który został dodany:

ε̂(xₜ, t) ≈ ε

Znając przewidziany szum, możemy odtworzyć xₜ₋₁:

xₜ₋₁ = (xₜ - √(1-αₜ) * ε̂) / √αₜ + noise

Score Matching — Klucz do całości

Score function: s(x) = ∇x log p(x)

To gradient log-prawdopodobieństwa — mówi w którym kierunku przesunąć punkt żeby zwiększyć jego prawdopodobieństwo.

Genialna obserwacja: Model denoising jest równoważny modelowi score!

Jeśli uczymy model przewidywać szum ε, to implicitly uczymy go score function:

s(xₜ, t) ≈ -ε̂(xₜ, t) / σₜ

To pozwala na sampling używając Langevin dynamics:

xₜ₋₁ = xₜ + γ  s(xₜ, t) + √(2γ)  z

Architektura: U-Net

Encoder:                 Bottleneck:              Decoder:
   x → Conv↓ →              Middle               → Conv↑ → x̂
       Conv↓ →              Layers               → Conv↑ →
       Conv↓ →                ↑                  → Conv↑ →
           ↘_______________↗ (skip connections)

- Skip connections zachowują szczegóły

- Time embedding kondycjonuje na kroku t

- Cross-attention dla conditional generation (tekst → obraz)

Training Objective (DDPM)

Prosta forma:

L = E[||ε - ε̂(xₜ, t)||²]

Gdzie:

- ε to rzeczywisty szum dodany

- ε̂(xₜ, t) to przewidziany szum przez model

- Oczekiwanie po t ~ Uniform(1..T) i ε ~ N(0, I)

Sampling (Generacja)

python

def sample(model, shape):
    x = torch.randn(shape)  # xT ~ N(0, I)
    
    for t in reversed(range(T)):
        noise_pred = model(x, t)  # Przewiduj szum
        x = denoise_step(x, noise_pred, t)  # Usuń szum
        if t > 0:
            x += sigma[t] * torch.randn_like(x)  # Dodaj mały szum
    
    return x  # x₀ - czyste dane

Flow Matching (2024-2025 trend)

Nowszy podejście które:

- Ma mniej kroków samplingu potrzebnych

- Transfer wiedzy z pretrained diffusion models

- Prostszy training objective

Warto śledzić!

Co potrzebuję żeby zbudować TinyDiffusion?

1. Tensor + Autograd ✅ (mamy w TinyTorch)

2. U-Net — trzeba zbudować (Conv2d mamy)

3. Time embedding — sinusoidal positional

4. Noise scheduler — linear lub cosine βₜ

5. Training loop — predict noise, MSE loss

6. Sampler — DDPM, DDIM, lub custom

Difficulty: ★★★★☆

Ale mamy fundament. TinyTorch pomoże.

Zasoby

- Yang Song's blog (Stanford) — najlepsza teoria

- Ho et al. 2020 — DDPM paper

- Lilian Weng's blog — świetne wyjaśnienia

- HuggingFace diffusers — reference implementation

Zapisane do TWORY_AI/RESEARCH/

Następny krok: TinyDiffusion?