Stable Diffusion — Latente Diffusions-Modelle

Training:
- Trainiere auf 512x512 Bildern
- Das sind 262.144 Pixel
- Braucht ~1000 Diffusion Steps
- Sehr Memory-intensiv

Inferenz:
- 50-1000 Iterationen, um ein Bild zu erzeugen
- Auf GPU: 30+ Sekunden pro Bild
- Auf CPU: Minuten

Step 1: VAE Encoder
Input: 512x512 RGB Image
Output: 64x64x4 Latent Tensor

Step 2: Diffusion in Latent Space
Noise + Denoise (4x weniger Daten als original)

Step 3: CLIP Encoding (für Text)
Input: "A cat on a sunny beach"
Output: 768-dim Embedding

Step 4: U-Net mit Cross-Attention
Kombiniere latent + CLIP embedding

Step 5: VAE Decoder
Input: 64x64x4 Latent
Output: 512x512 Image

Encoder: 512x512 → 64x64x4
- 8x8x4 Kompression
- Verlustfrei (mit Quantization)

Decoder: 64x64x4 → 512x512
- Trainiert gemeinsam mit Encoder
- Lernt wie man aus Latents rekonstruiert

Vorteil:
- 64x weniger Parameter
- 64x schneller
- Diffusion im latenten Raum ist praktisch

Input: "A cat on a sunny beach"
Processing:
1. Tokenisiere (BPE)
2. Transformer Encoder
3. Output: 768-dim Embedding

Dieses Embedding wird als Condition für U-Net verwendet

def forward(latent, timestep, clip_embedding):
    # timestep: Sagt dem Modell "wie verrauscht ist das Bild?"
    # clip_embedding: "Was möchte der User?"
    
    # Gehe durch U-Net Blöcke
    x = latent
    for block in encoder_blocks:
        x = block(x, timestep, clip_embedding)  # Cross-Attention!
    
    # Predict noise to remove
    noise_pred = decoder(x)
    return noise_pred

Self-Attention: Token achtet auf andere Tokens
Cross-Attention: Latent attends zu CLIP embedding

Query: Latent (512x512/64 = 4096 tokens)
Key/Value: CLIP (77 tokens)

→ Effizient, weilen CLIP ist klein

Daten: LAION-5B (5 Milliarden Image-Text Paare)

1. Lade Bild, enkodiere zu Latent (VAE Encoder)
2. Sample random noise level t
3. Füge Noise hinzu: x_t = sqrt(alpha_t) * x + sqrt(1 - alpha_t) * noise
4. Sage Modell: "Entferne Noise"
5. Loss: MSE zwischen predicited noise und actual noise

Effekt: Modell lernt was "relevant" Tokens sind

1. Start: Pure noise (512x512x4 random values)
2. Loop 50 Schritte:
   - Frage Modell: "Was ist weniger Noise?"
   - Subtrahiere predict noise
   - Reduziere Varianz basierend auf Timestep
3. Nach 50 Schritten: Halbwegs sauberes Bild
4. VAE Decoder: Latent → Bild
5. Output: 512x512 Bild

Modell: 860M Parameter
Trained: LAION-5B Subset
Context: 77 Token CLIP
Größe: 4 GB

Verbesserungen:
- Fine-tuned auf bessere Daten
- +5% bessere Qualität
- Bessere Anatomie, Hände

Größer:
- 3.5B Parameter (4x größer)
- Zwei CLIP Models statt einem
- Größerer Latent Space
- Besser für 1024x1024 Images

Ergebnis: Deutlich bessere Qualität

Architektur-Änderung:
- Switched von U-Net zu Diffusion Transformer
- MMDiT (Multimodal Diffusion Transformer)
- Bessere Scaling Properties

Performance:
- Besser Text-Alignment
- Bessere Qualität

Bild-Generierung Zeit:

DALL-E 2: 30-60 Sekunden
Midjourney: ~30 Sekunden (aus API)
Stable Diffusion v1 (A100): 5-10 Sekunden
Stable Diffusion v1 (RTX 3090): 20-30 Sekunden
Stable Diffusion v1 (CPU): 5-10 Minuten

VRAM für Inference:

Optimiert: 2-4 GB (mit Quantization)
Standard: 8 GB
Nicht optimiert: 24 GB

Das ist warum Stable Diffusion "Stable" ist:
- Läuft auf consumer GPUs
- Nicht nur auf A100/H100

LoRA (Low-Rank Adaptation):
- Trainiere nur kleine Adapter
- Nur 1-10 MB Größe
- Kann neuen "Stil" lehren

Textual Inversion:
- Lerne neue "Konzepte"
- Aus 3-5 Bildern
- Als Token im Text-Space

DreamBooth:
- Personalisierung
- Lerne "wie person X aussieht"