Lesson 155 — Intermediate

The Generative Model Family: VAEs & GANs

Generative models ka poora khandan aaj ke diffusion pipelines ke peeche khada hai — bas unke tareeke alag hain. Is lesson mein tum do mental models ghar le jaoge: Compress → perturb → reconstruct (VAE) aur generate → judge → improve (GAN). Dono ek hi kaam karte hain — apne data ki distribution seekhna — aur har concept ke saath hand-checkable chhote numbers rahenge, taaki formula ratne ki zarurat na pade.

Generative family — distribution seekhna hi asli kaam hai

Funda ek line mein: ye sab models apne data ki distribution ko andar approximate karte hain, aur generation ka matlab hai us approx distribution se ek naya sample kheenchna. Classifier ka sawaal hai "ye kis class ka hai", generative ka "aise data ke niyam kya hain" — isi farq se loss bhi badal jaata hai: reconstruction, adversarial ya denoising, teeno ek hi jagah point karte hain, data ki shakal samajhna.

Autoencoder recap — bottleneck ka compression side effect hai

# autoencoder ka kaam — 4 values -> bottleneck 2 -> 4 (hand-checkable)
x     = [1.0, 0.0, 0.8, 0.2]
enc   = [0.9, 0.5]                 # bottleneck z
dec   = [0.95, 0.05, 0.75, 0.25]   # decoder ka reconstruction

# reconstruction loss (MSE, 4 values pe)
err  = [(a - b) ** 2 for a, b in zip(x, dec)]
loss = sum(err) / 4                # (4 * 0.0025) / 4 = 0.0025
print(loss)                        # chhota = bottleneck ne shakal rakh li

• Encoder: input ko chhote bottleneck (z) mein dabata hai. Capacity kam hai toh majboori mein sirf zaroori structure bachta hai — yahin se feature learning shuru hoti hai.
• Decoder: z se wapas poora input banata hai — dono ka loss reconstruction se judta hai.
• Compression ek side effect hai: objective reconstruction tha, feature learning free mein mili. Isliye bottleneck vectors (embeddings) downstream tasks mein bhi chal jaate hain.
• Generator nahi hai: bottleneck ek fixed point hai — uske beech mein kya hai wo plain autoencoder nahi jaanta. Random z daala toh decoder garbage de sakta hai.

VAE — latent space ko point ki jagah distribution bana do

from math import exp

# encoder ab do cheezein deta hai: mean (mu) aur spread (logvar)
mu, logvar = 0.4, -1.4

# reparameterization: z = mu + sigma * eps (sampling ko differentiable rakhta hai)
sigma = exp(0.5 * logvar)        # exp(-0.7) ~ 0.50
z     = mu + sigma * 0.3         # eps = 0.3 -> 0.4 + 0.5 * 0.3 = 0.55

# KL term: encoded distribution ko N(0,1) ke paas rakhta hai (hand-check)
kl = -0.5 * (1 + logvar - mu ** 2 - exp(logvar))   # ~ 0.40
print(round(z, 2), round(kl, 2))  # 0.55 0.40

• Do outputs: mu aur logvar — har input ke liye ek cloud milti hai, point nahi. Sampling isi cloud se hoti hai.
• KL term kyun hai: sirf reconstruction se encoder har input ko alag-isolated point pe rakh deta aur beech ki jagah khaali chhodta. KL distributions ko overlap karwata hai, taaki z1 aur z2 ke beech ka raasta bhi meaningful ho.
• Generation: N(0,1) se z sample karo, decoder se output — ab "koi bhi random vector" chalne laga.
• Interpolation: do z ka average lo aur beech wali cheej milti hai — smooth latent space ka sabse practical proof.
• Output par asar: VAE loss per-pixel average karta hai, isliye images aksar soft ya blurry lagti hain — ye bug nahi, objective ka side effect hai.

GAN — generate karne wala aur judge karne wala ek hi game mein

# GAN ka scoreboard — sample batches ke saath
d_real, d_fake = 0.9, 0.2   # D: real pe 0.9 confident, fake pe 0.2
# D ka target: real -> 1, fake -> 0        (score abhi bilkul sahi hai)
# G ka target: d_fake ko 1 ke paas laana   (D ko fool karna)

# match ka signal: d_fake 0.5 ke paas aa jaaye
if abs(d_fake - 0.5) < 0.1:
    print("match chal raha hai — dono ek doosre se seekh rahe hain")

# failure 1: d_fake -> 0.1 par output hamesha ek hi chehra
#            -> G ek safe shortcut pe stuck = mode collapse
# failure 2: d_fake oscillate kare 0.1 / 0.9 beech beech
#            -> dono ek doosre ke peeche bhaag rahe, koi settle nahi

• Generator: random noise z se output banata hai. Direct "sahi answer" nahi milta — sirf feedback ki uski output asli hai ya nahi.
• Discriminator: real vs fake ki binary classification karta hai — ye hi asli judge hai.
• Adversarial training: dono saath train hote hain. D strong ho toh G ko signal milta hai, D weak ho toh G garbage pe ruk jaata hai — balance hi quality decide karta hai.
• Failure modes: mode collapse (ek hi output), oscillation (stability ka tootna) aur vanishing gradient (D itna strong ki G ko feedback hi na mile). GAN ka sabse mushkil hissa isi balance ka hai.
• Kab chunna: jab output sharp chahiye (faces, textures) aur training ki instability tum utha sakte ho — warna stable chahiye toh diffusion agla option hai.

Lineage — aaj ka diffusion inhi se nikla hai

autoencoder  -> bottleneck seekhna (compression + features)
   + VAE     -> latent = distribution            (sampling + smooth space)
   + GAN     -> adversarial judge                (sharp output, hard training)
   + diffusion -> dheere-dheere denoise karo      (stable loss, zyada compute)

aaj ke pipelines mein:
Stable Diffusion ka latent autoencoder = VAE (pixels <-> latent)
Denoising UNet + scheduler             = diffusion wala hissa
sharp/aligned output ki chahat          = GAN se aayi (adversarial losses aaj bhi)

• Interview ka core: lineage bologe toh interviewer ko dikhta hai ki tum sirf API nahi, mechanism samajhte ho — VAE ka distribution, GAN ka judge, diffusion ka denoise, sab ek doosre se kaise jude hain.
• Diffusion ke andar VAE VAE hi hai: agle do lessons mein jab component list khulegi, latent autoencoder ko pehchanna isi lesson se aayega.
• GAN aaj bhi zinda hai: super-resolution, style transfer jaisi jagah jahan sharpness ka sawaal ho aur training ka kharcha chhota ho.
• Kahan kya chunna: interpolation ya anomaly jaisa smooth latent ops -> VAE; sharp synthesis jahan instability chal sakti hai -> GAN; general image generation stable tareeke se -> diffusion.

Exercise

Common mistakes

• Autoencoder ko generator samajhna: Bottleneck ke beech ke points kabhi train nahi hue, isliye random z pe output garbage hoga. Fix: VAE (distribution), GAN (adversarial) ya diffusion — generation ka apna objective chahiye.
• KL term ko wastage samajh kar hata dena: KL ke bina encoder har input ko isolated point pe rakh dega — beech ki jagah khaali, sampling toot jaayegi. Fix: KL ko rakhna hai, bas uska weight (beta) balance karna hai.
• Blurry VAE outputs ko model ki kamzori samajhna: Per-pixel loss alag-alag possible outputs ka average prefer karta hai — sharpness ka term hi loss mein nahi. Fix: samjho ye objective ka side effect hai; sharpness chahiye toh adversarial/diffusion wala rasta.
• GAN ka ek achha checkpoint dekh kar training chhod dena: Do-player game mein aaj balance, kal collapse — single snapshot jhooth bol sakta hai. Fix: D/G loss balance aur output diversity ko continuous track karo, checkpoints se pehle trend dekho.

x    = ["dal", "chawal", "sabzi"]           # asli tiffin
note = {"teekha": 0.7, "namak": 0.4}       # VAE: point nahi, andaza (mu, sigma)
menu = note_se_naya_khana(note)            # decoding se naya menu bhi ban sakta hai

dish  = naya_khana(random_noise)           # GAN: naya cook roz naya dish
score = checker(dish)                      # 0.1 = pakka asli, 0.5 = confuse
if score < 0.5: cook.seekho()              # judge feedback dega — yahi training