Diffusion model — DDPM, noise schedule আর denoising

এই মডিউলে এর আগে আরও কয়েক ধরনের generative model আসছে: পর্ব ৭৪ (Generative modeling-এর মানচিত্র) পুরো ছবি দেয়, পর্ব ৭৬ (Variational autoencoder) latent আর ELBO দেখায়, আর পর্ব ৭৭ (GAN) দুই network-এর প্রতিযোগিতা। Diffusion model এদের থেকে আলাদা একটি সরল চালাকি নেয়: ছবি বানানো কঠিন, কিন্তু ছবি নষ্ট করা খুব সহজ; তাই নষ্ট করার প্রতিটি ছোট ধাপ উল্টাতে শেখা যায় কি না। এই পর্বের তিনটি ব্লক ব্রাউজারের Python আর NumPy-তে চলে (প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে), আর একটি ব্লক ডেস্কটপের সত্যিকারের run-এর ছবি আঁকে। PyTorch-এর সব সংখ্যা ডেস্কটপে GPU-তে চালানো run থেকে।

১ · মূল ধারণা — noise মেশানো সহজ, ফেরানো শেখা

ধরুন বাজারঘরের পণ্যের একটি ছোট ধূসর ছবি x₀ (এখানে ২৮ × ২৮ pixel, মান −১ থেকে ১)। প্রতিটি ধাপে ছবিটি একটু ছোট করে (√(1 − β_t) দিয়ে গুণ) আর সামান্য Gaussian noise যোগ করুন, যার variance β_t. β_t ছোট সংখ্যা, যেমন ০.০০০১ থেকে ০.০২. হাজার ধাপ পরে x_T কার্যত একটি standard normal noise, মূল ছবির কোনো চিহ্ন নেই। এটাই forward process; এতে কোনো parameter নেই, কিছু শেখারও নেই।

Reverse দিকটাই আসল কাজ। শুরু হয় একটি নতুন এলোমেলো noise x_T থেকে, যা কোনো আসল ছবি থেকে আসেনি। প্রতিটি ধাপে একটি network দেখে “এই noisy ছবিতে noise-এর অংশ কোনটা”, আর সেই অনুমানের একটু সরিয়ে x_t−1 বানায়। হাজার ধাপ পরে একটি নতুন ছবি, যা training ডেটার মতো দেখায় কিন্তু কোনো একটির কপি হওয়ার কথা নয় (কপি হয়ে যাওয়ার ঝুঁকি পর্ব ৮১-এর বিষয়)। একটি মূল সুবিধা: প্রতিটি ধাপ ছোট, তাই প্রতিটি উল্টো ধাপকেও প্রায় Gaussian ধরা যায়, আর network-কে শুধু তার গড়ের দিক শিখতে হয়। ২০১৫ সালে Sohl-Dickstein ও সহকর্মীরা non-equilibrium thermodynamics থেকে এই ধারণা প্রস্তাব করেন; ২০২০ সালে Ho, Jain আর Abbeel-এর DDPM প্রবন্ধ একে সরল loss আর ভালো ছবির মান দিয়ে জনপ্রিয় করে।

২ · Forward process — এক লাফে যেকোনো ধাপে

এক ধাপের নিয়ম লিখি। Normal distribution-এর চিহ্ন N(গড়, variance) দিয়ে:

q(x_t | x_t−1) = N(√(1 − β_t)·x_t−1, β_t·I)

অর্থাৎ x_t = √(1 − β_t)·x_t−1 + √β_t·ε_t, যেখানে ε_t ~ N(0, I) প্রতিটি pixel-এ আলাদা standard normal noise, আর I মানে সব pixel-এর noise স্বাধীন। পরের অবস্থা শুধু এখনকার অবস্থার ওপর নির্ভর করে, তাই এটি একটি Markov chain. √(1 − β) দিয়ে ছোট করার কারণ: x-এর variance ১ হলে নতুন variance (1 − β)·১ + β = ১, তাই ধাপে ধাপে মান ফুলে ওঠে না। এজন্য একে “variance preserving” বলা হয়।

এখন সুবিধাটি। α_t = 1 − β_t আর ᾱ_t = α₁·α₂·…·α_t (শুরু থেকে t পর্যন্ত গুণফল) লিখলে দুটি ধাপ মিলিয়ে দেখা যায়: x₂ = √(α₂α₁)·x₀ + (দুটি স্বাধীন Gaussian noise-এর একটি যোগফল)। স্বাধীন Gaussian-এর যোগফল আবার Gaussian, আর variance যোগ হয়: α₂(1 − α₁) + (1 − α₂) = 1 − α₁α₂. একইভাবে আরোহ (induction) দিয়ে:

q(x_t | x₀) = N(√ᾱ_t·x₀, (1 − ᾱ_t)·I)  ⇒  x_t = √ᾱ_t·x₀ + √(1 − ᾱ_t)·ε

এটি training-কে সস্তা করে: t = ৭৩৭-এর noisy ছবি চাইলে ৭৩৭ ধাপ চালাতে হয় না, একটি গুণ আর একটি যোগ। √ᾱ_t হলো মূল ছবির কতটা “সংকেত” টিকে আছে, √(1 − ᾱ_t) হলো noise-এর ভাগ, আর দুটির বর্গের যোগফল সবসময় ১. Gaussian-এর এই যোগের নিয়ম মেশিন লার্নিং কোর্সের পর্ব ১৯-এ আর sampling-এর মূল কথা AI-এর ভিত্তি কোর্সের পর্ব ৩৬-এ আছে।

৩ · Noise schedule — linear বনাম cosine, আর SNR

β₁, …, β_T-এর তালিকাকে বলে noise schedule. DDPM প্রবন্ধ T = ১০০০ আর β-কে ০.০০০১ থেকে ০.০২ পর্যন্ত সমান ফাঁকে (linear) নিয়েছিল। Nichol আর Dhariwal (২০২১) দেখান, ছোট ছবিতে এই schedule শেষের দিকের অনেক ধাপ নষ্ট করে, কারণ ছবি অনেক আগেই প্রায় পুরো noise হয়ে যায়। তাঁদের cosine schedule সরাসরি ᾱ ঠিক করে দেয়:

ᾱ_t = f(t) ÷ f(0),   f(t) = cos²( ((t/T + s) ÷ (1 + s)) · π/2 ),   s = 0.008

ছোট s যোগ করা হয় যাতে t = ০-এর কাছে β খুব ছোট না হয়ে যায়; আর বাস্তবে β_t = 1 − ᾱ_t/ᾱ_t−1-কে ০.৯৯৯-এ কেটে দেওয়া হয়, যাতে শেষ ধাপে ভাগে সমস্যা না হয়। দুই schedule তুলনা করার সবচেয়ে কাজের মাপ হলো signal-to-noise ratio:

SNR(t) = ᾱ_t ÷ (1 − ᾱ_t)

রেডিওর অভিজ্ঞতা মনে করুন: SNR বেশি মানে গান পরিষ্কার, কম মানে শুধু ঝিরঝির। SNR = ১ মানে সংকেত আর noise সমান শক্তিশালী (ᾱ = ০.৫)। Linear schedule-এর জন্য হাতে একটি ভালো আসন্ন মান আছে: ছোট β-তে ln(1 − β) ≈ −β, তাই ᾱ_t ≈ e^−Σβ, আর সমান ফাঁকের β-এর যোগফল Σβ = t·β₁ + (β_T − β₁)·t(t − 1) ÷ (2(T − 1)).

নিচের ব্লক একই হিসাব NumPy-তে করে আর দুটি ছবি আঁকে: দুই schedule-এর ᾱ_t, আর একটি ৬৪ pixel-এর সারি (একটি জামার কাঁধ বরাবর একটি লাইন, পটভূমি −১, কাপড় ০.৮) কয়েকটি t-তে। সব t-তে একই ε ব্যবহার করা হয়েছে, যাতে শুধু ᾱ-এর প্রভাব চোখে পড়ে।

import numpy as np
import matplotlib.pyplot as plt

T, s = 1000, 0.008
beta = np.linspace(1e-4, 0.02, T)                  # DDPM-এর linear schedule
ab_lin = np.cumprod(1 - beta)                      # ᾱ_t = (1−β_1)(1−β_2)…(1−β_t)
f = np.cos((np.arange(T + 1) / T + s) / (1 + s) * np.pi / 2) ** 2
ab_cos = (f / f[0])[1:]                            # cosine schedule-এর ᾱ_t, t = 1..T
print("   t | linear: abar      SNR  | cosine: abar      SNR")
for t in [1, 100, 250, 500, 750, 900, 1000]:
    a, c = ab_lin[t - 1], ab_cos[t - 1]
    print(f"{t:4d} | {a:12.5f} {a/(1-a):9.3g} | {c:12.5f} {c/(1-c):9.3g}")
half = lambda ab: int(np.argmin(np.abs(ab - 0.5))) + 1
print("SNR = 1 (abar = 0.5) at t =", half(ab_lin), "(linear) and", half(ab_cos), "(cosine)")

rng = np.random.default_rng(7)                     # একটি সারির ছোট "ছবি": 64 pixel, [-1, 1]
x0 = np.where((np.arange(64) > 15) & (np.arange(64) < 48), 0.8, -1.0)
eps = rng.standard_normal(64)                      # সব t-তে একই ε, তুলনা সহজ করতে
fig, (a1, a2) = plt.subplots(1, 2, figsize=(10, 3.4))
a1.plot(ab_lin, label="linear"); a1.plot(ab_cos, label="cosine")
a1.set_xlabel("t"); a1.set_ylabel("alpha-bar"); a1.legend(); a1.set_title("Signal kept")
for k, t in enumerate([1, 100, 250, 500, 1000]):
    a = ab_lin[t - 1]
    xt = np.sqrt(a) * x0 + np.sqrt(1 - a) * eps    # closed form: q(x_t | x_0)
    a2.plot(xt - 3.2 * k, lw=1, label=f"t={t}")
a2.set_yticks([]); a2.set_title("One row noised (linear)"); a2.legend(fontsize=7, loc="lower left")
plt.show()

   t | linear: abar      SNR  | cosine: abar      SNR
   1 |      0.99990     1e+04 |      0.99996  2.42e+04
 100 |      0.89702      8.71 |      0.97209      34.8
 250 |      0.52409       1.1 |      0.84701      5.54
 500 |      0.07859    0.0853 |      0.49384     0.976
 750 |      0.00335   0.00336 |      0.14427     0.169
 900 |      0.00028  0.000275 |      0.02409    0.0247
1000 |      0.00004  4.04e-05 |      0.00000  3.75e-33
SNR = 1 (abar = 0.5) at t = 259 (linear) and 496 (cosine)

৪ · Training-এর লক্ষ্য — noise অনুমান করা

Reverse ধাপ q(x_t−1 | x_t) সরাসরি জানা নেই, কারণ তার জন্য পুরো ডেটার distribution জানতে হয়। কিন্তু x₀ জানা থাকলে q(x_t−1 | x_t, x₀) একটি সুনির্দিষ্ট Gaussian, Bayes-এর নিয়মে হিসাব করা যায়। DDPM-এর পুরো derivation একটি variational bound থেকে আসে, যা পর্ব ৭৬ (Variational autoencoder)-এর ELBO-র মতো, আর মেশিন লার্নিং কোর্সের পর্ব ৪৮-এর ধারণার ওপর দাঁড়ানো। Bound-এর প্রতিটি পদ দুটি Gaussian-এর KL divergence, আর সেটি শেষ পর্যন্ত দুটি গড়ের দূরত্বে নামে। Ho ও সহকর্মীরা দেখান, গড়টিকে noise-এর অনুমান দিয়ে লিখলে আর পদগুলোর ওজন বাদ দিলে loss অসাধারণ সরল হয়:

L_simple = E_{x₀, t, ε} [ ‖ ε − ε_θ( √ᾱ_t·x₀ + √(1 − ᾱ_t)·ε, t ) ‖² ]

এখানে ε_θ হলো network (θ তার weight), যে noisy ছবি আর ধাপ t দেখে noise অনুমান করে; ‖·‖² মানে সব pixel-এর বর্গের যোগ, অর্থাৎ একটি সাধারণ mean squared error. Training-এর একটি ধাপ তাই:

1. ডেটা থেকে একটি ছবি x₀ (batch-এ অনেকগুলো) নিন।
2. ১ থেকে T-এর মধ্যে সমান সম্ভাবনায় একটি t বাছুন।
3. ছবির মাপের একটি noise ε ~ N(0, I) টানুন।
4. x_t = √ᾱ_t·x₀ + √(1 − ᾱ_t)·ε বানান।
5. Loss = (ε − ε_θ(x_t, t))²-এর গড়; gradient নিয়ে optimizer-এর একটি ধাপ।

এটি পর্ব ১০-এর training loop-ই, শুধু লেবেল নিজেরাই বানানো: “উত্তর” হলো যে noise আমরা নিজেরা মিশিয়েছি। কোনো adversary নেই, যেমন GAN-এ থাকে, তাই training সাধারণত স্থির; loss একটি সরল regression. কেন ছবি নয়, noise অনুমান? গাণিতিকভাবে দুটি সমতুল্য: ε̂ জানলে x̂₀ = (x_t − √(1 − ᾱ_t)·ε̂) ÷ √ᾱ_t. কিন্তু loss-এর ওজন আলাদা দাঁড়ায়, আর DDPM প্রবন্ধে ε-prediction-এ ছবির মান ভালো এসেছিল। পরে x₀-prediction আর দুটির মিশ্রণ (“v-prediction”, Salimans আর Ho, ২০২২)-ও প্রচলিত হয়েছে।

৫ · DDPM-এর reverse ধাপ — গড়ের দিকে একটু, তারপর নতুন noise

Sampling-এ x_T ~ N(0, I) থেকে শুরু করে t = T, T − 1, …, ১ পর্যন্ত প্রতিটি ধাপে:

x_t−1 = (1 ÷ √α_t) · ( x_t − (β_t ÷ √(1 − ᾱ_t)) · ε_θ(x_t, t) ) + σ_t·z,   z ~ N(0, I)

প্রথম অংশ হলো উল্টো ধাপের গড়: network-এর অনুমিত noise-এর একটি ছোট ভাগ বাদ দিয়ে, তারপর √α_t দিয়ে ভাগ করে আগের মাপে ফেরানো। দ্বিতীয় অংশ নতুন noise; DDPM প্রবন্ধে σ_t² = β_t আর আরেকটি পছন্দ β̃_t = β_t(1 − ᾱ_t−1) ÷ (1 − ᾱ_t), দুটিতে প্রায় একই ফল আসার কথা বলা হয়েছে। শেষ ধাপে (t = ১) noise যোগ করা হয় না। প্রতিটি ধাপে নতুন noise টেনে এগোনোকে বলে ancestral sampling. নিচে একটি pixel-এর একটি ধাপ, সংখ্যায়।

import numpy as np

T = 1000
beta = np.linspace(1e-4, 0.02, T); alpha = 1 - beta; abar = np.cumprod(alpha)
t = 500                                    # বইয়ের t = 500, array-তে index 499
b, al, a, a_prev = beta[t - 1], alpha[t - 1], abar[t - 1], abar[t - 2]
x_t, eps_hat, z = 0.60, 0.90, -0.50        # একটি pixel, network-এর অনুমান, নতুন noise
print(f"beta={b:.5f}  alpha={al:.5f}  abar={a:.5f}  abar_prev={a_prev:.5f}")

x0_hat = (x_t - np.sqrt(1 - a) * eps_hat) / np.sqrt(a)
print(f"predicted x0 = {x0_hat:.4f}")
mean = (x_t - b / np.sqrt(1 - a) * eps_hat) / np.sqrt(al)
x_prev = mean + np.sqrt(b) * z             # DDPM: sigma_t^2 = beta_t
print(f"DDPM: mean = {mean:.4f}, sigma = {np.sqrt(b):.4f}, x_499 = {x_prev:.4f}")
same = np.sqrt(a_prev) * b / (1 - a) * x0_hat + np.sqrt(al) * (1 - a_prev) / (1 - a) * x_t
print(f"same mean from the x0 form: {same:.4f}")

for s in (499, 480):                       # DDIM (eta = 0): কোনো নতুন noise নেই
    a_s = abar[s - 1]
    x_s = np.sqrt(a_s) * x0_hat + np.sqrt(1 - a_s) * eps_hat
    print(f"DDIM to t={s}: abar_s = {a_s:.5f}, x_{s} = {x_s:.4f}")

beta=0.01004  alpha=0.98996  abar=0.07859  abar_prev=0.07938
predicted x0 = -0.9414
DDPM: mean = 0.5936, sigma = 0.1002, x_499 = 0.5435
same mean from the x0 form: 0.5936
DDIM to t=499: abar_s = 0.07938, x_499 = 0.5983
DDIM to t=480: abar_s = 0.09579, x_480 = 0.5644

৬ · DDIM — একই network, noise ছাড়া, বড় লাফে

DDPM-এর বড় দাম সময়: একটি ছবির জন্য network-কে ১০০০ বার চালাতে হয়। Song, Meng আর Ermon-এর DDIM (arXiv-এ ২০২০, ICLR ২০২১) একটি গুরুত্বপূর্ণ পর্যবেক্ষণ থেকে আসে: training-এর loss শুধু q(x_t | x₀)-এর ওপর নির্ভর করে, ধাপগুলো কীভাবে শিকলে জোড়া তার ওপর নয়। তাই একই প্রান্তিক distribution দেয় এমন অন্য (non-Markovian) forward process ধরা যায়, আর একই প্রশিক্ষিত network দিয়ে অন্যভাবে sample করা যায়। Retraining লাগে না। η = ০ নিলে DDIM-এর ধাপ:

x_s = √ᾱ_s · x̂₀ + √(1 − ᾱ_s) · ε̂,   যেখানে s < t আর x̂₀ = (x_t − √(1 − ᾱ_t)·ε̂) ÷ √ᾱ_t

পড়ে দেখুন: অনুমিত পরিষ্কার ছবি x̂₀ নিয়ে, তাকে আবার s ধাপের noise-স্তরে বসানো, আর noise হিসেবে নতুন z নয়, একই ε̂. কোনো এলোমেলো অংশ নেই, তাই x_T ঠিক থাকলে ছবিও ঠিক; একে বলে deterministic sampling. আর s = t − ১ হতে হবে এমন নয়: ১০০০ থেকে ৯৮০, ৯৬০, … এভাবে ৫০ ধাপে নামা যায়। সাধারণ রূপে একটি η প্যারামিটার আছে: η = ১-এ DDPM-ধাঁচের noise, η = ০-এ DDIM. এই পর্বের দুটি কোডেই সেই সাধারণ রূপ ব্যবহার করা হয়েছে, আর η = ১-এর σ মানে উপরের β̃.

এবার একটি পুরো sampler. দুই মাত্রার একটি খেলনা ডেটা: একটি বৃত্তের ওপর ৮টি ছোট Gaussian (প্রতিটির standard deviation ০.০৮). এখানে network শেখাতে হয় না, কারণ এই ডেটার noisy রূপ q(x_t) নিজেও ৮টি Gaussian-এর মিশ্রণ, যার score সূত্রে লেখা যায়; তাই ε̂ হলো নিখুঁত denoiser (অংশ ৪-এর নোটের সূত্র)। ফলে নিচে যে পার্থক্য দেখবেন, তা শুধু sampler-এর ধাপের সংখ্যা আর ধরন থেকে, network-এর ভুল থেকে নয়। মাপ দুটি: প্রতিটি নমুনা থেকে নিকটতম কেন্দ্রের গড় দূরত্ব (আসল ডেটায় তাত্ত্বিক মান ০.০৮ × √(π/2) ≈ ০.১০০), আর প্রতিটি “mode”-এ নমুনার ভাগ (সমান হলে ১/৮ = ০.১২৫)।

import numpy as np
import matplotlib.pyplot as plt

T = 1000
abar = np.cumprod(1 - np.linspace(1e-4, 0.02, T))   # linear schedule-এর ᾱ_t
K, s0 = 8, 0.08                                     # 8 টি ছোট Gaussian, বৃত্তের ওপর
mu = 2 * np.c_[np.cos(2 * np.pi * np.arange(K) / K), np.sin(2 * np.pi * np.arange(K) / K)]

def eps_hat(x, t):            # নিখুঁত denoiser: noisy mixture-এর score থেকে ε
    a = abar[t]; v = a * s0**2 + 1 - a              # t-তে প্রতিটি component-এর variance
    d = x[:, None, :] - np.sqrt(a) * mu[None]       # (N, K, 2)
    logw = -(d**2).sum(-1) / (2 * v)
    w = np.exp(logw - logw.max(1, keepdims=True)); w /= w.sum(1, keepdims=True)
    return np.sqrt(1 - a) * (w[..., None] * d).sum(1) / v   # ε = −√(1−ᾱ)·score

def sample(n, steps, eta, rng):   # eta=1: DDPM-ধাঁচের (noise যোগ), eta=0: DDIM (নির্ধারিত)
    ts = np.linspace(T - 1, 0, steps).round().astype(int); x = rng.standard_normal((n, 2))
    for t, s in zip(ts, list(ts[1:]) + [-1]):
        e = eps_hat(x, t); x0 = (x - np.sqrt(1 - abar[t]) * e) / np.sqrt(abar[t])
        if s < 0: x = x0; break
        sig = eta * np.sqrt((1 - abar[s]) / (1 - abar[t]) * (1 - abar[t] / abar[s]))
        x = np.sqrt(abar[s]) * x0 + np.sqrt(1 - abar[s] - sig**2) * e + sig * rng.standard_normal(x.shape)
    return x

rng = np.random.default_rng(0)
real = mu[rng.integers(0, K, 800)] + s0 * rng.standard_normal((800, 2))
runs = {"real data": real, "DDPM 1000": sample(800, 1000, 1, rng), "DDPM 50": sample(800, 50, 1, rng),
        "DDIM 50": sample(800, 50, 0, rng), "DDIM 5": sample(800, 5, 0, rng)}
fig, axs = plt.subplots(1, 5, figsize=(12, 2.8), sharex=True, sharey=True)
for ax, (name, x) in zip(axs, runs.items()):
    dist = np.linalg.norm(x[:, None] - mu[None], axis=-1)
    share = np.bincount(dist.argmin(1), minlength=K) / len(x)
    print(f"{name:9s}: mean dist to nearest centre {dist.min(1).mean():.3f}, mode share {share.min():.3f}-{share.max():.3f}")
    ax.scatter(x[:, 0], x[:, 1], s=2); ax.scatter(*mu.T, c="red", s=10); ax.set_title(name)
plt.show()

real data: mean dist to nearest centre 0.100, mode share 0.105-0.140
DDPM 1000: mean dist to nearest centre 0.092, mode share 0.107-0.140
DDPM 50  : mean dist to nearest centre 0.067, mode share 0.111-0.149
DDIM 50  : mean dist to nearest centre 0.081, mode share 0.117-0.135
DDIM 5   : mean dist to nearest centre 0.601, mode share 0.111-0.140

৭ · Denoiser network — time embedding-সহ U-Net

ε_θ-এর কাজ: ২৮ × ২৮ noisy ছবি নিয়ে ২৮ × ২৮ noise অনুমান। Input আর output-এর মাপ সমান, যেখানে বড় প্রসঙ্গ (“এটা জুতো না ব্যাগ”) আর pixel-স্তরের খুঁটিনাটি দুটিই লাগে। এটি ঠিক পর্ব ২৫-এর U-Net-এর সমস্যা, তাই DDPM থেকে শুরু করে বেশিরভাগ ছবির diffusion model-এ U-Net ব্যবহার হয়েছে। পার্থক্য একটি: একই network-কে হাজারটি আলাদা noise-স্তরে কাজ করতে হয়, তাই তাকে জানাতে হয় এখন কোন t. এজন্য time embedding: t-কে পর্ব ৩৪-এর sinusoidal সূত্রে একটি vector বানানো, একটি ছোট MLP দিয়ে বদলানো, আর প্রতিটি residual block-এ প্রতিটি channel-এ একটি করে সংখ্যা হিসেবে যোগ করা। ফলে network “t = ৯০০, প্রায় সবই noise” আর “t = ২০, শুধু হালকা দানা সরাও” আলাদা আচরণ করতে পারে।

এই পর্বের desktop run-এর network ছোট, ২৮ × ২৮-এর জন্য বানানো (condensed বিবরণ):

মোট ১২,৪৭,৫২১টি parameter. Normalization-এ BatchNorm নয়, GroupNorm (৮টি দল), কারণ এটি batch-এর ওপর নির্ভর করে না, আর একই batch-এ নানা t-এর ছবি থাকায় batch-এর পরিসংখ্যান অর্থহীন হতো (পর্ব ১৪)। আরেকটি প্রায় অপরিহার্য কৌশল EMA: training-এর weight-এর একটি চলমান গড় আলাদা কপিতে রাখা (এখানে ০.৯৯৯), আর sampling করা সেই কপি দিয়ে। Diffusion-এর loss-এ noise অনেক, তাই শেষ ধাপের weight একটু এলোমেলো; গড়টি মসৃণ, আর ছবির মান সাধারণত ভালো হয়। DDPM প্রবন্ধেও EMA ছিল। পরে কিছু model U-Net-এর বদলে Transformer দিয়ে ε অনুমান করেছে (যেমন DiT, Peebles আর Xie, ২০২৩); সেই দিক আর text দিয়ে নিয়ন্ত্রণ পর্ব ৮০ (Latent diffusion আর guidance)-এর বিষয়।

৮ · সত্যিকারের run — Fashion-MNIST-এ নিজের DDPM

এবার সব মিলিয়ে একটি আসল model. ডেটা Fashion-MNIST (Zalando Research, MIT লাইসেন্স): ৬০,০০০টি ২৮ × ২৮ ধূসর ছবি, ১০ ধরনের পোশাক, জুতো আর ব্যাগ। এটি বাজারঘরের পণ্যের ছবির বদলি হিসেবে ব্যবহার হচ্ছে; আসল দোকানের ছবি নয়। ডেস্কটপে Python 3.14, torch 2.15.0 (CUDA build), GPU-তে। অংশ ৭-এর U-Net, Adam (lr 2 × 10⁻⁴), batch ১২৮, EMA ০.৯৯৯, seed ০. GPU অন্য কাজের সঙ্গে ভাগ করা, তাই প্রতিটি run-এ ১৩ মিনিটের সময়সীমা, প্রতি epoch-এ checkpoint. একই বাজেটে দুটি model: linear আর cosine schedule. সত্যিকারের run, output সংক্ষেপিত (মাঝের epoch বাদ):

~/bazarghar-dl$ uv run python train.py linear 13 60
params 1247521
epoch   1  loss 0.1019  15.4s
epoch   2  loss 0.0571  14.8s
epoch   5  loss 0.0463  14.8s
epoch  10  loss 0.0418  15.3s
epoch  20  loss 0.0390  15.1s
epoch  40  loss 0.0373  15.5s
epoch  51  loss 0.0367  15.6s
peak GPU memory allocated: 629 MiB
run wall time: 13.0 min, total epochs 51

~/bazarghar-dl$ uv run python train.py cosine 13 60
params 1247521
epoch   1  loss 0.1560  15.0s
epoch   2  loss 0.0979  14.5s
epoch   5  loss 0.0821  14.6s
epoch  10  loss 0.0747  14.7s
epoch  20  loss 0.0703  15.0s
epoch  40  loss 0.0676  15.1s
epoch  51  loss 0.0665  14.9s
peak GPU memory allocated: 629 MiB
run wall time: 12.7 min, total epochs 51

প্রতি epoch প্রায় ১৫ সেকেন্ড, ১৩ মিনিটে দুটি model-ই ৫১ epoch পেয়েছে. Loss প্রথম epoch-এ দ্রুত নামে, তারপর খুব ধীরে; diffusion-এ এটি স্বাভাবিক, কারণ বড় t-তে noise অনুমান প্রায় সহজ আর ছোট t-তে প্রায় অসম্ভব (খুব অল্প noise, আর সেটি কোনটা বোঝা কঠিন), তাই loss কখনো শূন্যের কাছে যায় না। দুই schedule-এর loss সরাসরি তুলনীয় নয়: schedule বদলালে কোন noise-স্তর কত ঘন ঘন আসে তা বদলায়, তাই একই মানের model-এর loss-ও আলাদা হয়। Training-এ peak GPU memory মাত্র ৬২৯ MiB, আর ১০০০টি ছবি একসঙ্গে sample করতে প্রায় ২ GiB: model ছোট।

মান মাপতে ছবি দেখাই যথেষ্ট নয়। একই ডেটায় একটি ছোট CNN classifier আলাদা করে শেখানো হলো (test accuracy ০.৯০৬৭)। তার শেষের আগের স্তরের ১২৮-মাত্রার feature দিয়ে generated ছবি আর ১০,০০০টি test ছবির মধ্যে Fréchet distance মাপা হলো, যাকে এখানে “FID(clf)” বলছি। এটি প্রচলিত Inception-ভিত্তিক FID নয়, তাই অন্য কোথাও প্রকাশিত FID-এর সঙ্গে তুলনা চলে না; শুধু এই পর্বের model-গুলোর মধ্যে তুলনার জন্য। কম মানে ভালো। একই classifier প্রতিটি নমুনার শ্রেণিও বলে, তাই ১০টি শ্রেণির ভাগ (সমান হলে ০.১) দেখায় কোনো ধরন বাদ পড়ছে কি না। প্রতিটি sampler-এ ১০০০টি নমুনা, seed ১২৩, x̂₀ প্রতিটি ধাপে [−১, ১]-এ কাটা।

~/bazarghar-dl$ uv run python evaluate.py linear
classifier test accuracy 0.9067
reference: 1000 real train images vs test set  FID(clf) 4.235  class share 0.078-0.135
== linear schedule, EMA weights after 51 epochs, 1000 samples each ==
sampler      steps   time(s)  FID(clf)  class share min-max  max-prob
DDPM         1000      83.6     5.867   0.079-0.146         0.876
DDPM          250      20.3     7.570   0.078-0.141         0.864
DDPM           50       3.9    10.779   0.075-0.133         0.861
DDIM          250      20.6     6.833   0.076-0.136         0.860
DDIM           50       4.2     8.554   0.081-0.128         0.855
DDIM           20       1.7    14.524   0.084-0.124         0.842
DDIM           10       0.8    31.624   0.061-0.124         0.819

~/bazarghar-dl$ uv run python evaluate.py cosine
== cosine schedule, EMA weights after 51 epochs, 1000 samples each ==
sampler      steps   time(s)  FID(clf)  class share min-max  max-prob
DDPM         1000      80.4     8.053   0.063-0.134         0.861
DDPM          250      20.1     5.876   0.076-0.121         0.866
DDPM           50       4.0    13.427   0.057-0.122         0.851
DDIM          250      20.2     7.617   0.085-0.136         0.851
DDIM           50       4.1     9.939   0.081-0.138         0.843
DDIM           20       1.6    16.153   0.077-0.141         0.830
DDIM           10       0.8    32.878   0.062-0.145         0.808
peak GPU memory allocated: 1948 MiB

~/bazarghar-dl$ uv run python seeds.py linear,cosine
seed sweep: FID(clf), 1000 samples per seed
linear DDPM 1000: 6.602  5.745  5.489  | mean 5.946
linear DDPM  250: 7.167  5.762  8.370  | mean 7.100
linear DDIM   50: 10.502  10.061  10.509  | mean 10.357
cosine DDPM 1000: 4.954  5.757  6.267  | mean 5.659
cosine DDPM  250: 5.076  5.692  7.483  | mean 6.083
cosine DDIM   50: 12.957  12.216  12.056  | mean 12.410
peak GPU memory allocated: 1948 MiB

প্রথমে মাপকাঠি: training সেটের ১০০০টি আসল ছবিও test সেটের সঙ্গে FID(clf) ৪.২৩৫ দেয়, শূন্য নয়। ১০০০টি নমুনা থেকে mean আর covariance অনুমানের ভুলই এই পক্ষপাত (পর্ব ৮১-এ বিস্তারিত)। তাই এই মাপে ৪-এর কাছাকাছি মানে প্রায় আসল ছবির সমান।

এবার পাঁচটি পর্যবেক্ষণ। এক, ধাপ কমালে সময় প্রায় সমানুপাতে কমে: ১০০০ ধাপে ৮৩.৬ সেকেন্ড, ৫০ ধাপে প্রায় ৪ সেকেন্ড, ১০ ধাপে ০.৮ সেকেন্ড (১০০০টি ছবির জন্য, GPU-তে)। খরচের প্রায় সবটাই network call. দুই, মান পড়ে, তবে ধীরে নয়, হঠাৎ: linear model-এ DDIM ২৫০ ধাপে ৬.৮৩, ৫০-এ ৮.৫৫, ২০-এ ১৪.৫২, ১০-এ ৩১.৬২. তিন, কম ধাপে DDIM DDPM-এর চেয়ে ভালো: ৫০ ধাপে linear-এ ৮.৫৫ বনাম ১০.৭৮, cosine-এ ৯.৯৪ বনাম ১৩.৪৩, খেলনা ব্লকের মতোই। চার, শ্রেণির ভাগ সব sampler-এ মোটামুটি ০.০৬ থেকে ০.১৫-এর মধ্যে, কোনো ধরন হারায়নি; তবে ১০ ধাপে classifier-এর গড় নিশ্চয়তা (max-prob) ০.৮৭৬ থেকে ০.৮১৯-এ নামে, ছবি ঝাপসা হলে যা প্রত্যাশিত।

পাঁচ, এবং সবচেয়ে জরুরি: একটি seed-এর সংখ্যা দিয়ে সিদ্ধান্ত নেওয়া বিপজ্জনক। Seed ১২৩-এ cosine-এর ১০০০ ধাপ (৮.০৫) linear-এর (৫.৮৭) চেয়ে খারাপ দেখায়, অথচ আরও তিনটি seed-এ cosine ৪.৯৫ থেকে ৬.২৭ আর linear ৫.৪৯ থেকে ৬.৬০; দুটির পরিসর মিলে যায়। একই model-এর DDPM ২৫০ ধাপও seed ভেদে ৫.৭৬ থেকে ৮.৩৭. তাই এই বাজেটে দুই schedule-এর ১০০০ ধাপের মানে কোনো নির্ভরযোগ্য পার্থক্য দেখা যায়নি। DDIM ৫০ ধাপে অবশ্য cosine model চারটি seed-এই খারাপ (৯.৯৪ থেকে ১২.৯৬, linear-এ ৮.৫৫ থেকে ১০.৫১); কিন্তু প্রতিটি schedule-এ একটিমাত্র training run, তাই এটি schedule-এর গুণ নাকি এই নির্দিষ্ট run-এর, বলা যায় না। এগুলো একটি ছোট model-এর একটি local run-এর সংখ্যা, সাধারণ ফল নয়।

নিচের ব্লক run-এর আসল নমুনা আঁকে। প্রতিটি সারিতে প্রথম ৬টি ছবি (৪৮টি ছবি ৪-bit-এ, অর্থাৎ ১৬টি ধূসর স্তরে, base64 করে পাতায় বসানো, আকারে প্রায় ২৫ KB-এর)। শেষ দুই সারি একটি নমুনার যাত্রা: x_t আর সেই ধাপের অনুমিত x̂₀, t = ৯৯৯, ৭৪৯, ৪৯৯, ২৪৯, ৯৯ আর ০-তে। সঙ্গে দুই run-এর epoch-প্রতি loss.

import base64, json
import numpy as np
import matplotlib.pyplot as plt

raw = np.frombuffer(base64.b64decode(open("samples.b64").read()), np.uint8)
q = np.stack([raw >> 4, raw & 15], 1).reshape(-1, 28, 28)   # 4-bit থেকে খোলা
imgs = q.astype(float) / 15                                  # 0 = কালো, 1 = সাদা
names = ["lin DDPM 1000", "lin DDPM 50", "lin DDIM 50", "lin DDIM 10",
         "cos DDPM 1000", "cos DDIM 50", "x_t, t=999..0", "x0-hat"]
print("images:", imgs.shape, "| rows:", len(names), "x 6")
fig, axs = plt.subplots(8, 6, figsize=(6, 8.6))
for k, ax in enumerate(axs.flat):
    ax.imshow(imgs[k], cmap="gray", vmin=0, vmax=1); ax.set_xticks([]); ax.set_yticks([])
    if k % 6 == 0: ax.set_ylabel(names[k // 6], rotation=0, ha="right", va="center", fontsize=7)
fig.subplots_adjust(left=0.24, right=0.98, top=0.95, bottom=0.02, hspace=0.15, wspace=0.08)
fig.suptitle("Real samples: Fashion-MNIST DDPM, seed 123, EMA, 51 epochs", fontsize=8)
plt.show()

loss = json.loads(open("loss.json").read())
for name, v in loss.items():
    print(f"{name:6s}: epoch 1 {v[0]:.4f} | epoch 10 {v[9]:.4f} | epoch {len(v)} {v[-1]:.4f}")
fig, ax = plt.subplots(figsize=(6, 3))
for name, v in loss.items():
    ax.plot(range(1, len(v) + 1), v, label=name)
ax.set_yscale("log"); ax.set_xlabel("epoch"); ax.set_ylabel("mean eps MSE (train)")
ax.set_title("Training loss per epoch (one run each)"); ax.legend()
plt.show()

images: (48, 28, 28) | rows: 8 x 6
linear: epoch 1 0.1019 | epoch 10 0.0418 | epoch 51 0.0367
cosine: epoch 1 0.1560 | epoch 10 0.0747 | epoch 51 0.0665

৯ · বড় ছবিতে কী বদলায় — সীমা আর সাধারণ ভুল

১০ · AI-এর যুগে — diffusion কোডে AI-এর ভুল ধরা

Diffusion-এর কোড ছোট, তাই AI assistant সহজেই পুরো DDPM লিখে দেয়। বিপদ হলো, ভুল থাকলেও কোড চলে আর loss কমে; শুধু ছবি ঝাপসা, ধূসর বা অদ্ভুত আসে, আর কারণ খুঁজে পাওয়া কঠিন। নিচের ভুলগুলো সবচেয়ে বেশি দেখা যায়:

AI-এর দেওয়া diffusion কোড — যাচাইয়ের চেকলিস্ট

• ছোট একটি batch-এ shape আর ডেটার পরিসর (−১ থেকে ১) প্রিন্ট করে দেখেছি
• একটি pixel-এ forward আর reverse এক ধাপ হাতে হিসাব করে কোডের সঙ্গে মিলিয়েছি
• প্রথমে একটি batch-এ overfit করে loss নামে কি না দেখেছি, তারপর পুরো training
• API নিজের torch/diffusers version-এর docs-এ মিলিয়েছি
• কয়েকটি seed আর একই সংখ্যক নমুনায় মাপ নিয়েছি; test ডেটা training-এ ঢোকেনি
• AI-এর বলা প্রবন্ধ, সাল আর সূত্র মূল উৎসে মিলিয়েছি; ব্যক্তিগত ডেটা বা key পেস্ট করিনি