Lesson 156 — Intermediate

Diffusion Fundamentals: Learning to Denoise

Diffusion ka frame ek line mein hai: Destroy data gradually → learn to undo each destruction step; sampling starts from pure noise. L12 wale multimodal level mein image-generation API ko product ke roop mein dekha tha — prompt daalo, image mili; yahan uske andar ka mechanism khulega: forward process jo sirf training ke liye noise add karta hai, reverse process jo asli model hai, loss jo "guess the noise" hai, aur sampler/steps jo output aur latency dono decide karte hain.

Diffusion — destroy karke seekhna

Do process ko alag rakho: forward process koi network nahi hai — wo ek fixed rule hai jo noise add karta hai, aur uska data sirf training ke liye hai. Reverse process hi asli model hai jo seekhta hai ki noise kaise nikaala jaaye. Generation ka poora game ulta chalta hai — noise se data.

Forward process — noise schedule aur infinite training pairs

import math
# forward rule: x_t = sqrt(abar_t) * x0 + sqrt(1 - abar_t) * eps
x0, eps = 2.0, 0.6
for abar in (0.81, 0.01):
    sig = math.sqrt(abar)            # signal ka weight
    noi = math.sqrt(1 - abar)        # noise ka weight
    xt  = sig * x0 + noi * eps
    print("sig=%.2f noi=%.2f x_t=%.2f" % (sig, noi, xt))
# sig=0.90 noi=0.44 x_t=2.06   -> abhi tak data ki jhalak hai
# sig=0.10 noi=1.00 x_t=0.80   -> noise dominant, signal gayab

• Noise schedule (beta / abar): T steps tak noise badhta hai — abar almost 1 se shuru hokar almost 0 par khatam. Schedule ka shape decide karta hai ki aakhri steps tak signal kitna bachta hai.
• Infinite training pairs: ek image + random eps + koi bhi t = naya (x_t, eps) example. Hazaaron images se naye combos har epoch mein — isliye chhoti dataset bhi kaafi chalti hai.
• Khud check karo: x0 = [[1,0],[0,1]], eps = sab 1, abar = 0.25 → coefficients 0.5 aur 0.87 — signal aadha, noise aadha. Har t pe ye balance badalta hai.
• Reverse ka target pehle se taiyaar hai: training data mein pata hai ki kaunsa noise daala gaya tha — isliye prediction ka sahi jawab built-in hai, label alag se banana nahi padta.

Reverse process — denoiser ek chhota correction har step deta hai

# reverse step (DDPM-style, simplified) — model (x_t, t) -> noise ka andaza
def step(x_t, eps_pred, alpha_t, beta_t, abar_t, z):
    mean = (x_t - beta_t / ((1 - abar_t) ** 0.5) * eps_pred) / (alpha_t ** 0.5)
    return mean + ((1 - alpha_t) ** 0.5) * z   # z = nayi randomness (stochastic)

# ek step -> thoda saaf; 50 baar dohrao -> image (coefficients schedule se aate hain)
x_prev = step(x_t, eps_pred, alpha_t=0.99, beta_t=0.01, abar_t=0.9, z=noise)

• Denoiser network: input x_t + time step t, output noise ka prediction. t zaroori hai kyunki step 5 pe layout set ho raha hai, step 45 pe texture — same weights, alag kaam.
• Noise predict vs clean predict: do tareeke hain parameterization ke — dono ka target ek hi hai (x0 wapas lana). Practically scheduler batata hai kaunsa chal raha hai.
• Iterative refinement: har step chhota correction hai. Pehle shape/layout, aakhir mein detail — isliye kam steps par output dhang se saaf nahi hota, sirf poora nahi banta.
• Output dikhta kaisa hai: starting pe noisy blob, middle pe shape, end pe chikna result. Ye trend pakka hai, exact step numbers sampler pe depend karte hain.

Training objective — "guess the noise" wala loss

Loss ka poora khel: data lo, kahin se bhi t uthao, noise daalo, model ko x_t do — wo eps predict kare aur MSE se compare karo. Ismein koi do network nahi, koi judge nahi, koi feedback loop nahi — ek fixed regression hai. Isi wajah se ye GAN se kai zyada stable chalta hai: loss bhi hai aur gradient bhi milta hai, oscillation wali tension nahi.

# guess-the-noise loss — chhote numbers se dekho
eps_true = [0.10, -0.40, 0.25, 0.05]
eps_pred = [0.15, -0.20, 0.25, 0.05]

sq   = [(a - b) ** 2 for a, b in zip(eps_true, eps_pred)]
loss = sum(sq) / 4
print(loss)   # (0.0025 + 0.04 + 0 + 0) / 4 = 0.0106 -> doosra dim hi ghalat tha

# loss girta gaya = model har step ka noise behtar pakad raha hai

Sampling & steps — quality, latency aur reproducibility

num_inference_steps = scheduler ke timesteps kitne hain
denoiser calls       = steps (CFG on -> har step do passes / batch 2)
steps kam            = tez, par refinement adhoori — shape reh jaati hai
steps zyada          = aur refinement, par har extra step ka latency fix
steps 4 se 50        = calls bhi 4 se 50 (lagbhag 12 guna compute) — ye hisaab
                       pakka hai, quality ki guarantee nahi

samplers:
  DDPM/ancestral  -> har step nayi randomness (stochastic raasta)
  DDIM/ancestral nahi wale -> deterministic: same seed = same image
seed               -> initial noise ko fix karta hai (reproducibility ka anchor)

• Deterministic vs stochastic: DDIM-jaise samplers ek hi seed pe hamesha same raasta chalte hain; DDPM-jaise har step fresh noise lete hain. Repro chahiye toh seed pin karo AUR sampler note karo — sirf seed se kaam nahi chalta.
• Steps ka decision order: pehle behtar scheduler/sampler chuno, phir steps badhao. Andhadhund steps badhana sabse mehnga tareeka hai — latency linear badhti hai.
• "Kitne steps kaafi" ka fixed answer nahi: prompt, resolution aur model pe depend karta hai. Apne task ke samples dekh kar decide karo, default pe blindly mat ruko.
• Schedule aur algorithm alag cheezein hain: ek timesteps kaise bante hain, doosra reverse mein formula kya hai — scheduler object dono ko carry karta hai, isi liye scheduler badalne par aesthetic badal jaata hai.

Diffusion ne game kyun cheena — aur uski honest price

• Coverage: model poori distribution ki taraf bhejta hai, outputs diverse rehte hain — GAN wale mode collapse ka khatra nahi.
• Stability: regression-style loss, do player nahi — chhoti team bhi train karke sambhaal sakti hai.
• Control: reverse process mein beech mein ruko, thok badlo, conditioning jod do — progressive denoising mein intervention ke mauke hain, ek-shot generation mein nahi.
• Conditioning aasaan: har step pe extra info (text embedding, depth map) dena natural hai — isi se text-to-image pipelines bane.
• Honest trade-off: har sample pe compute zyada — 1-2 forward passes wali jagah dozens. Isliye real systems steps compress karte hain, distillation karte hain, ya chhote latent grid pe kaam karte hain.

decision ka frame (qualitative — koi benchmark nahi):

stability + control chahiye + compute chal sakta hai -> diffusion
sharpness + training ka kharcha sambhalna -> GAN aaj bhi
smooth latent ops (interpolate, anomaly) -> VAE

aur latency ghatani ho toh agla kadam:
steps/scheduler chuno -> phir LATENT space (agla lesson)

Exercise

Common mistakes

• Forward aur reverse ko ek hi samajhna: Forward toh fixed noise-adding rule hai jismein kuch seekha nahi jaata; reverse hi network hai. Fix: training pairs forward se, model reverse se — dono ka role alag alag likho.
• Steps ko guaranteed quality dial samajhna: Steps sirf refinement ka waqt dete hain — behtar scheduler/conditioning ke bina output plateaus par atak jaata hai, par latency linear badhti hai. Fix: pehle scheduler, phir prompt, steps aakhri.
• Seed pin kiya par sampler/schedule badal diya: Reproducibility toot jaati hai kyunki raasta hi badal gaya. Fix: seed + steps + scheduler + checkpoint — charon ek saath log karo.
• Diffusion ko free speed samajhna: Har sample pe dozens denoiser calls — production latency budget isi se banti hai. Fix: steps, resolution aur CFG ko cost items maano, options nahi.

x0    = photo                    # asli photo
xt    = 0.90 * x0 + 0.44 * static   # forward (abar = 0.81) — signal abhi zyada

# model ka exam: xt diya gaya, usmein daala gaya static batana hai
eps_pred = model(xt, t=10)
loss     = mse(static, eps_pred)   # guess-the-noise — yahi objective

# sampling: pure static se shuru, 50 baar saaf, photo tayyar