➡️ Forward Process

Forward diffusion adalah proses Markov chain yang menambahkan Gaussian noise secara bertahap ke data bersih x₀.

🔍 Noise Schedule β_t

β_t mengontrol seberapa banyak noise ditambahkan di step t:

• 📈 Linear schedule: β_t increases linearly from β₁ to β_T
• 📉 Cosine schedule: Smoother transition, better performance
• 📊 Custom schedules: Optimized untuk dataset tertentu

⚡ Direct Sampling: q(x_t | x₀)

Kita tidak perlu iterasi T kali! Ada closed-form solution:

📅 Diffusion Timeline

🎬 Forward Diffusion Animation

⬅️ Reverse Process

Reverse diffusion adalah proses yang dipelajari untuk menghilangkan noise secara bertahap, starting dari pure noise x_T → clean data x₀.

🏗️ U-Net Noise Predictor

Diffusion models menggunakan U-Net untuk memprediksi noise ε_θ(x_t, t):

• 📥 Input: Noisy image x_t + timestep embedding t
• 🎯 Output: Predicted noise ε_θ that was added
• 🏛️ Architecture: Encoder-decoder dengan skip connections
• ⏰ Time embedding: Sinusoidal positional encoding

🔄 Denoising Step

Given x_t, untuk mendapatkan x_{t-1}:

🎬 Reverse Diffusion Animation

📐 DDPM Training Objective

DDPM (Ho et al., 2020) mempelajari reverse process dengan memaksimalkan variational lower bound:

⚡ Simplified Loss (Actually Used)

In practice, kita gunakan simplified objective:

🎲 Sampling Algorithm (DDPM)

💡 Key Insights

• 🎯 Noise prediction easier than direct x₀ prediction
• 🔄 Reparameterization allows direct sampling of any x_t
• 📊 Simple MSE loss works better than complex VLB
• ⏱️ T=1000 steps typical for high-quality generation

⚡ DDIM (Denoising Diffusion Implicit Models)

Problem dengan DDPM: Sampling memerlukan T=1000 steps (slow!)
Solution: DDIM (Song et al., 2020) - deterministic sampling dengan fewer steps.

🚀 Faster Sampling

DDIM allows skipping timesteps without retraining:

• 🏃 10-50 steps instead of 1000 (20-100x faster!)
• 🎯 Deterministic: same noise → same image
• 🔄 Interpolation: smooth latent space
• ✏️ Inversion: encode real images to latent

📊 Noise Schedules

Berbagai noise schedules untuk performa lebih baik:

• 📈 Linear: Original DDPM, simple
• 📉 Cosine: Better for high-res, less noise at extremes
• 📊 Custom: Learned or hand-tuned for specific data

🎨 Classifier-Free Guidance

Untuk conditional generation (e.g., text-to-image):

🎯 Score Matching

Alternative perspective: learn the score function ∇_x log p(x).

🌊 Langevin Dynamics

Sampling dengan Langevin dynamics:

📐 SDE Formulation

Song et al. unified view: diffusion as Stochastic Differential Equation:

🔗 Connection to Diffusion

• 🎯 Score-based: ∇_x log p(x) perspective
• 🌊 Diffusion: Forward/reverse process perspective
• 🔄 Equivalent: Different views of same model!
• ⚡ Unified: SDE framework combines both

💻 DDPM PyTorch Implementation

import torch
import torch.nn as nn
import torch.nn.functional as F

class DiffusionModel(nn.Module):
    def __init__(self, unet, noise_steps=1000, beta_start=1e-4, beta_end=0.02):
        super().__init__()
        self.unet = unet  # Noise prediction network
        self.noise_steps = noise_steps
        
        # Noise schedule (linear)
        self.beta = torch.linspace(beta_start, beta_end, noise_steps)
        self.alpha = 1 - self.beta
        self.alpha_hat = torch.cumprod(self.alpha, dim=0)
        
    def add_noise(self, x_0, t, noise):
        """
        Add noise to x_0 to get x_t.
        
        Args:
            x_0: clean images (batch, C, H, W)
            t: timesteps (batch,)
            noise: Gaussian noise (batch, C, H, W)
        
        Returns:
            x_t: noisy images
        """
        sqrt_alpha_hat = torch.sqrt(self.alpha_hat[t])[:, None, None, None]
        sqrt_one_minus_alpha_hat = torch.sqrt(1 - self.alpha_hat[t])[:, None, None, None]
        
        x_t = sqrt_alpha_hat * x_0 + sqrt_one_minus_alpha_hat * noise
        return x_t
    
    def forward(self, x, t):
        """Predict noise."""
        return self.unet(x, t)

🎓 Training Loop

def train_diffusion(model, dataloader, optimizer, device, epochs=100):
    """Train diffusion model."""
    model.train()
    
    for epoch in range(epochs):
        for x_0 in dataloader:
            x_0 = x_0.to(device)
            batch_size = x_0.shape[0]
            
            # Sample random timesteps
            t = torch.randint(0, model.noise_steps, (batch_size,), device=device)
            
            # Sample noise
            noise = torch.randn_like(x_0)
            
            # Add noise to get x_t
            x_t = model.add_noise(x_0, t, noise)
            
            # Predict noise
            noise_pred = model(x_t, t)
            
            # Simplified loss
            loss = F.mse_loss(noise_pred, noise)
            
            # Backward
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
        
        print(f"Epoch {epoch}, Loss: {loss.item():.4f}")

🎲 Sampling (DDPM)

@torch.no_grad()
def sample_ddpm(model, n_samples, img_size, device):
    """
    Sample images using DDPM algorithm.
    
    Args:
        model: trained diffusion model
        n_samples: number of images to generate
        img_size: (C, H, W)
        device: cuda or cpu
    
    Returns:
        generated images
    """
    model.eval()
    C, H, W = img_size
    
    # Start from pure noise
    x = torch.randn(n_samples, C, H, W, device=device)
    
    # Iteratively denoise
    for t in reversed(range(model.noise_steps)):
        # Create timestep tensor
        t_tensor = torch.full((n_samples,), t, device=device, dtype=torch.long)
        
        # Predict noise
        noise_pred = model(x, t_tensor)
        
        # Get schedule values
        alpha = model.alpha[t]
        alpha_hat = model.alpha_hat[t]
        beta = model.beta[t]
        
        # Denoise step
        if t > 0:
            noise = torch.randn_like(x)
        else:
            noise = torch.zeros_like(x)
        
        x = (1 / torch.sqrt(alpha)) * (x - ((1 - alpha) / torch.sqrt(1 - alpha_hat)) * noise_pred) + torch.sqrt(beta) * noise
    
    return x

⚡ DDIM Sampling

@torch.no_grad()
def sample_ddim(model, n_samples, img_size, device, ddim_steps=50):
    """Fast sampling with DDIM."""
    model.eval()
    C, H, W = img_size
    
    # Subset of timesteps
    timesteps = torch.linspace(model.noise_steps - 1, 0, ddim_steps, dtype=torch.long)
    
    # Start from noise
    x = torch.randn(n_samples, C, H, W, device=device)
    
    for i, t in enumerate(timesteps):
        t_tensor = torch.full((n_samples,), t, device=device, dtype=torch.long)
        
        # Predict noise
        noise_pred = model(x, t_tensor)
        
        # Predict x_0
        alpha_hat = model.alpha_hat[t]
        pred_x0 = (x - torch.sqrt(1 - alpha_hat) * noise_pred) / torch.sqrt(alpha_hat)
        
        if i < len(timesteps) - 1:
            t_prev = timesteps[i + 1]
            alpha_hat_prev = model.alpha_hat[t_prev]
            
            # DDIM update (deterministic)
            x = torch.sqrt(alpha_hat_prev) * pred_x0 + torch.sqrt(1 - alpha_hat_prev) * noise_pred
        else:
            x = pred_x0
    
    return x

🚀 Diffusion Model Applications

Diffusion models telah menjadi state-of-the-art untuk berbagai generative tasks:

💡 Why Diffusion Models Excel

• ✅ High Quality: State-of-the-art image/video generation
• ✅ Stable Training: No mode collapse like GANs
• ✅ Diverse Outputs: Stochastic sampling
• ✅ Flexible Conditioning: Text, class, layout, etc.
• ✅ Principled Framework: Strong theoretical foundation

🔮 Future Directions

• ⚡ Faster Sampling: 1-step diffusion models
• 📹 Longer Videos: Temporal consistency
• 🎮 3D Generation: NeRF + diffusion
• 🧠 Efficiency: Smaller models, edge deployment
• 🎨 Control: Better user control over generation

✅ Selamat!