Diffusion-Modelle

Trainingsprozess (Forward Diffusion):
Echtes Bild → (+Rauschen) → Bild mit 10% Rauschen → ... → 100% Rauschen (Gaußsches Rauschen)

Generierung (Reverse Diffusion):
100% Rauschen → (-Rauschen vorhersagen) → Bild mit 90% Rauschen → ... → Echtes Bild

x_t = sqrt(α_t) * x_0 + sqrt(1 - α_t) * ε

wobei:
- x_0 = Original-Bild
- x_t = Bild nach t Diffusionsschritten
- α_t = Schedule-Wert (kontrolliert wie viel Rauschen)
- ε = Gaußsches Rauschen ~ N(0, 1)

t=0:   Echtes Bild (klar)
t=50:  Bild mit leichtem Rauschen (noch erkennbar)
t=500: Bild mit viel Rauschen (kaum noch erkennbar)
t=999: Pur Gaußsches Rauschen (keine Information mehr)

# Linear Schedule (einfach)
alphas = torch.linspace(0.999, 0.001, num_steps)

# Cosine Schedule (besser, wie in Improved DDPM)
def cosine_schedule(t, T=1000):
    return torch.cos((t / T + 0.008) / 1.008 * π / 2) ** 2

# Ergebnis: Anfangs langsam → schneller → am Ende schnell

# Training-Schleife (pseudocode)
for x_0 in real_images:
    t = random_timestep(1, T)
    ε = torch.randn_like(x_0)  # Zufälliges Rauschen

    x_t = sqrt(α_t) * x_0 + sqrt(1 - α_t) * ε

    # Netzwerk sagt Rauschen voraus
    ε_predicted = unet(x_t, t)

    # Loss: Wie nah ist die Vorhersage am echten Rauschen?
    loss = MSE(ε_predicted, ε)
    loss.backward()

# Sampling (Generierung)
x_T = torch.randn(batch_size, 3, 256, 256)  # Reines Rauschen

for t in range(T-1, 0, -1):  # Rückwärts durch Timesteps
    z = torch.randn_like(x_T) if t > 1 else 0  # Variance

    # Modell sagt Rauschen voraus
    ε = unet(x_T, t)

    # Entferne Rauschen
    x_T = (x_T - sqrt(1 - α_t) * ε) / sqrt(α_t)

    # Füge kontrolliertes Rauschen hinzu (für Stochastizität)
    x_T += sqrt(β_t) * z

return x_T  # Finales Bild

Input: Rauschen x_t + Timestep t
  ↓
Sinusoidal Timestep Embedding (zeitbewusst)
  ↓
U-Net mit ResNet Blöcken
  ↓
Attention (Self-Attention bei kleineren Features)
  ↓
Rauschen-Vorhersage ε

DDPM:  1000 → 999 → 998 → ... → 1 → 0  (1000 Schritte!)
DDIM:  1000 → 900 → 800 → ... → 100 → 0  (100 Schritte, 10x schneller!)

# DDIM-Schritte (deterministisch)
def ddim_step(x_t, ε_t, t, t_prev):
    # Vorhergesagtes ursprüngliches Bild
    x_0_pred = (x_t - sqrt(1 - α_t) * ε_t) / sqrt(α_t)

    # DDIM-Übergänge (implizit, kein Rauschen nötig)
    x_t_prev = sqrt(α_t_prev) * x_0_pred + sqrt(1 - α_t_prev) * ε_t

    return x_t_prev

DDPM:  Sampelt stochastisch, braucht viele Schritte
DDIM:  Deterministisch, weniger Schritte nötig (50 reichen meist)

Speed-Vergleich:
  DDPM 1000 Schritte: 30 Sekunden
  DDIM 50 Schritte:   1-2 Sekunden (15-30x schneller!)

Echtes Bild (512x512)
  ↓
VAE Encoder (komprimieren)
  ↓
Latent-Space (64x64) — 8x Kompression
  ↓
Diffusion im Latent-Space (schnell!)
  ↓
VAE Decoder (dekomprimieren)
  ↓
Generiertes Bild (512x512)

Pixel-Level Diffusion:  512x512 = 262.144 Pixel pro Schritt
Latent Diffusion:       64x64 = 4.096 Dimensionen pro Schritt

Speedup: ~64x schneller bei gleicher Qualität

# VAE - trainiert separat
encoder = VAE_Encoder()
decoder = VAE_Decoder()

# Forward Diffusion im Latent Space
z_0 = encoder(image)  # Beispiel: [1, 4, 64, 64]
z_t = apply_diffusion(z_0, t)  # Gleiches Rauschen-Prinzip

# U-Net operiert auf Latents
ε = unet(z_t, t, text_embedding)

Text: "Ein weißes Kaninchen sitzt auf einer Blume"
  ↓
CLIP Text Encoder → Text-Embedding (768d)
  ↓
U-Net (Cross-Attention mit Text)
  ↓
VAE Decoder
  ↓
Bild

# Training mit Classifier-Free Guidance
# 10% der Zeit: Text-Embedding = NULL (unbedingte Vorhersage)
# 90% der Zeit: Normal trainieren (bedingte Vorhersage)

# Sampling mit Guidance
ε_uncond = unet(z_t, t, embedding=None)  # Ohne Bedingung
ε_cond = unet(z_t, t, embedding=text_emb)  # Mit Bedingung

# Guidance-Anwendung
ε = ε_uncond + guidance_scale * (ε_cond - ε_uncond)

# guidance_scale:
#   1.0  = ignoriere Text völlig
#   7.5  = Standard (gutes Gleichgewicht)
#   15.0 = sehr stark Text folgen (weniger Vielfalt)

Prompt: "Katze"
CFG 1.0:  Zufälliges Bild (ignoriert Prompt)
CFG 7.5:  Katze mit etwas Vielfalt
CFG 15.0: Sehr stark erkennbare Katze (aber weniger kreativ)

from diffusers import StableDiffusionPipeline
import torch

# Modell laden
pipe = StableDiffusionPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    torch_dtype=torch.float16
)
pipe = pipe.to("cuda")

# Text → Bild
prompt = "Ein futuristisches Schloss auf einem Berggipfel"
image = pipe(
    prompt,
    height=512,
    width=512,
    num_inference_steps=50,  # DDIM Schritte
    guidance_scale=7.5,       # CFG Stärke
    generator=torch.Generator().manual_seed(42)
).images[0]

image.save("output.png")

from diffusers import DDIMScheduler, PNDMScheduler

# DDIM (schnell, 50 Schritte)
pipe.scheduler = DDIMScheduler.from_config(
    pipe.scheduler.config
)

# DDPM (langsam, aber original, 1000 Schritte)
pipe.scheduler = DDPMScheduler.from_config(
    pipe.scheduler.config
)

# Diffusers mit LoRA
from diffusers import StableDiffusionPipeline
from peft import get_peft_model, LoraConfig

# LoRA auf U-Net anwenden (nur 1% der Parameter trainieren)
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["to_k", "to_v"],
    lora_dropout=0.05
)

unet = get_peft_model(pipe.unet, lora_config)

# Trainieren auf Custom Dataset
# ... Training Loop ...

# Speichern und Laden
unet.save_pretrained("custom_lora")
pipe.load_lora_weights("custom_lora")

- Transformer-basiert statt U-Net
- Noch schneller (30-50 Schritte)
- Bessere Text-Treue
- Verwendet DiT (Diffusion Transformer)

- Direktes Sampling in 1-2 Schritten
- Trainiert auf Diffusion-Modellen
- Trade-Off: Speed vs Quality

- Struktur-Kontrolle über Edges/Poses/Depth
- Composable Guidance
- Mehrere Bedingungen gleichzeitig

❌ CFG 30+: Artefakte, verfälschte Farben
✅ CFG 7-10: Gutes Gleichgewicht

❌ 10 Schritte: Körnig, unfertig
✅ 50 Schritte (DDIM): Gute Balance
✅ 100+ Schritte: Maximum Qualität

# ❌ Zu viel RAM
image = pipe("prompt", height=2048, width=2048)

# ✅ Mit Optimierungen
pipe.enable_attention_slicing()
pipe.enable_memory_efficient_attention()
image = pipe("prompt", height=768, width=768)