tinyflux-experts

# DDPM/DDIM sampling
for t in reversed(timesteps):  # 999 → 0
    ε_pred = model(x, t)
    x = scheduler.step(ε_pred, t, x)  # Removes predicted noise

# Start from pure noise (σ = 1)
x = torch.randn(1, 4, 64, 64)

# Sigma schedule: 1 → 0 with shift
sigmas = torch.linspace(1, 0, steps + 1)
sigmas = shift_sigma(sigmas, shift=3.0)

for i in range(steps):
    σ = sigmas[i]
    σ_next = sigmas[i + 1]
    dt = σ - σ_next  # Positive (going from 1 toward 0)
    
    timestep = σ * 1000
    v_pred = model(x, timestep)
    
    # SUBTRACT velocity (v points toward noise, we go toward data)
    x = x - v_pred * dt

# x is now clean image latent

EPSILON:
    "There's noise hiding the image"
    "I'll predict and remove the noise layer by layer"
    → General-purpose denoising

VELOCITY (Sol):  
    "I know which direction the image is"
    "But I speak through DDPM's noise schedule"
    → Learned structure, outputs skeletons

VELOCITY (Lune):
    "Straight line from noise to image"
    "I'll walk that line step by step"  
    → Learned detail, outputs rich images

┌─────────────────────────────────────────────────────────────┐
│                    PREDICTION TYPES                         │
├─────────────────────────────────────────────────────────────┤
│ EPSILON (ε)                                                 │
│   Train: target = noise                                     │
│   Sample: scheduler.step(ε_pred, t, x)                      │
│   Output: General images                                    │
├─────────────────────────────────────────────────────────────┤
│ VELOCITY - SOL (DDPM framework)                             │
│   Train: target = α·ε - σ·x₀                                │
│   Sample: v→ε conversion, then scheduler.step(ε, t, x)      │
│   Output: Geometric skeletons                               │
├─────────────────────────────────────────────────────────────┤
│ VELOCITY - LUNE (Rectified Flow)                            │
│   Train: target = noise - data                              │
│   Sample: x = x - v·dt  (Euler, σ: 1→0)                     │
│   Output: Detailed textured images                          │
└─────────────────────────────────────────────────────────────┘