Generative modeling-এর মানচিত্র — likelihood, latent আর sampling

১ · Generative model কী — p(x) বনাম p(y | x)

বাজারঘরের গুদামে প্রতিদিন হাজারো পণ্যের ছবি তোলা হয়। দুই রকম প্রশ্ন করা যায়। প্রথমটি: “এই ছবিটা জুতার না ব্যাগের?” দ্বিতীয়টি: “জুতার ছবি দেখতে সাধারণত কেমন হয়, আর একটা নতুন, বিশ্বাসযোগ্য জুতার ছবি এঁকে দাও।” প্রথম প্রশ্নের উত্তর দেয় discriminative model, দ্বিতীয়টির generative model.

গণিতের ভাষায়: ডেটা x (যেমন ৭৮৪টি pixel-এর একটি ছবি) একটি অজানা বণ্টন p_data(x) থেকে এসেছে। Discriminative model শেখে শর্তসাপেক্ষ probability p(y | x) — x দেওয়া থাকলে লেবেল y. Generative model শেখে p(x) নিজেই, অথবা লেবেলসহ p(x, y). AI-এর ভিত্তি কোর্সের পর্ব ৩৫-এ conditional আর joint probability দেখেছেন; এখানে সেই ধারণাকে ৭৮৪ মাত্রায় নিয়ে যাওয়া হচ্ছে। আর AI-এর ভিত্তি কোর্সের পর্ব ৪-এ যে “Generative AI”-এর নাম শুনেছিলেন, তার গাণিতিক কেন্দ্র এই p(x).

একটি generative model-এর তিন কাজ

সব মডেল তিনটি কাজ সমান ভালো পারে না। কোনোটি দ্রুত নমুনা দেয় কিন্তু p(x) বলতে পারে না; কোনোটি p(x) একদম নিখুঁত বলে কিন্তু নমুনা তুলতে ধীর। এই পর্বের মানচিত্র মূলত এই ভাগাভাগিরই মানচিত্র।

২ · মানচিত্র — likelihood কে কীভাবে সামলায়

সবচেয়ে কাজের প্রশ্ন একটি: “এই মডেল কি একটি x-এর জন্য q_θ(x) একটি সংখ্যা হিসেবে দিতে পারে?” উত্তর অনুযায়ী পরিবারগুলো সাজানো যায়। নিচের ছবিটি ওপর থেকে নিচে পড়ুন।

এই মডিউলের পরের পর্বগুলো শুধু এক লাইনে: পর্ব ৭৫ (Autoencoder — compression, denoising আর representation) দেখাবে কীভাবে ছবি ছোট কোডে চাপা যায়; পর্ব ৭৬ (Variational autoencoder) সেই কোডকে সম্ভাবনার ভাষা দেবে; পর্ব ৭৭ (GAN) আর ৭৮ (GAN-এর রূপ) likelihood ছাড়া শেখার খেলা; পর্ব ৭৯ (Diffusion model) আর ৮০ (Latent diffusion আর guidance) আজকের text-to-image-এর ভিত্তি; পর্ব ৮১ (Generative model-এর মূল্যায়ন আর নিরাপত্তা) মাপা আর অপব্যবহার ঠেকানো। এই পর্বে সেগুলোর কোনোটি শেখানো হবে না; এখানে শুধু সাধারণ ভাষাটা তৈরি হচ্ছে, যা সবগুলোতে লাগবে।

৩ · Maximum likelihood মানে KL কমানো

শেখার নিয়মটা প্রথমে। আমাদের হাতে N টি নমুনা x₁, …, x_N. Maximum likelihood (মেশিন লার্নিং কোর্সের পর্ব ১৮) বলে: এমন θ বাছুন, যাতে দেখা ডেটার গড় log-likelihood সবচেয়ে বড় হয়:

θ* = argmax_θ (১/N) ∑_i log q_θ(x_i)

এখন ডেটার নিজস্ব “অভিজ্ঞতামূলক” বণ্টন p̂ ধরুন: প্রতিটি দেখা x-এর ওপর ১/N ওজন। KL divergence (AI-এর ভিত্তি কোর্সের পর্ব ৩৮) খুলে লিখলে:

KL(p̂ ‖ q_θ) = ∑_x p̂(x) log p̂(x) − ∑_x p̂(x) log q_θ(x) = −H(p̂) − ℓ(θ)

এখানে H(p̂) হলো ডেটার entropy, যা θ-এর ওপর নির্ভর করে না; আর ℓ(θ) = ∑ p̂(x) log q_θ(x) হুবহু সেই গড় log-likelihood. তাই ℓ বাড়ানো আর KL কমানো একই কাজ। −ℓ(θ)-কে বলা হয় cross-entropy, যা পর্ব ১৩ (Deep learning-এর loss)-এ classification-এর loss হিসেবে দেখেছেন। এবার ছোট একটি উদাহরণে সংখ্যা দিয়ে দেখুন।

এই ছোট হিসাবের একটা বড় পরিণতি আছে। KL(p̂ ‖ q) অসমমিত। যেখানে ডেটা আছে (p̂ > ০) অথচ q প্রায় শূন্য, সেখানে log q-এর দণ্ড অসীমের দিকে যায়। তাই maximum likelihood মডেলকে বাধ্য করে সব ডেটা-অঞ্চলে কিছু না কিছু probability রাখতে: একে বলে mode-covering. দাম হলো, দুই চূড়ার মাঝখানের ফাঁকা জায়গাতেও কিছু probability ছড়িয়ে পড়ে, ফলে নমুনা ঝাপসা হতে পারে। উল্টো দিকের KL(q ‖ p) কমালে আচরণ হয় mode-seeking (মেশিন লার্নিং কোর্সের পর্ব ৪৮): একটি চূড়া ধরে বাকিগুলো ছেড়ে দেওয়া। GAN-এর প্রশিক্ষণ (পর্ব ৭৭) কোন divergence কমায় আর তাতে কী হয়, সেটি তখন বিস্তারিত দেখবেন।

৪ · এক মাত্রায় শুরু — histogram, Gaussian mixture আর নমুনা

৭৮৪ মাত্রার আগে এক মাত্রা। বাজারঘরের অর্ডার পৌঁছাতে কত ঘণ্টা লাগে, তার ১,০০০টি বানানো (seeded) রেকর্ড: ঢাকার ভেতরে প্রায় ২০ ঘণ্টা, বাইরে প্রায় ৬০ ঘণ্টা। দুটি density estimation পদ্ধতি পাশাপাশি: একটি histogram, আর একটি Gaussian mixture model (মেশিন লার্নিং কোর্সের পর্ব ৩৯ আর পর্ব ৪০-এ বিস্তারিত)। দুটোই একই প্রশ্নের উত্তর দেয়: test-এর ২০০টি অর্ডারে গড় log p কত? যার বেশি, সে ডেটাকে ভালো বোঝে। scikit-learn প্রথমবার লোড হতে প্রায় ১০ সেকেন্ড লাগতে পারে।

import numpy as np
from sklearn.mixture import GaussianMixture
import matplotlib.pyplot as plt

rng = np.random.default_rng(42)            # বাজারঘর: ডেলিভারির সময় (ঘণ্টা)
x = np.concatenate([rng.normal(20, 5, 700),     # ঢাকার ভেতরে
                    rng.normal(60, 12, 300)])   # ঢাকার বাইরে
rng.shuffle(x)
tr, te = x[:800], x[800:]

edges = np.linspace(0, 120, 25)                 # ২৪টি bin, প্রতিটি ৫ ঘণ্টা
cnt, _ = np.histogram(tr, edges)
dens = (cnt + 1) / ((len(tr) + len(cnt)) * 5)   # add-one, তারপর প্রস্থ দিয়ে ভাগ
def hist_logp(v):
    i = np.clip(np.searchsorted(edges, v) - 1, 0, len(cnt) - 1)
    return np.log(dens[i])
print("histogram   test avg log p =", round(hist_logp(te).mean(), 3))

for K in (1, 2, 3):
    g = GaussianMixture(K, init_params="random_from_data",
                        random_state=0).fit(tr[:, None])
    print(f"GMM K={K}     test avg log p = {g.score(te[:, None]):.3f}")

g = GaussianMixture(2, init_params="random_from_data", random_state=0).fit(tr[:, None])
print("weights", g.weights_.round(2), "means", g.means_.ravel().round(1))
new, comp = g.sample(5)
print("৫টি নতুন নমুনা:", new.ravel().round(1), "component:", comp)

grid = np.linspace(0, 120, 400)
plt.hist(tr, edges, density=True, alpha=0.4, label="train histogram")
plt.plot(grid, np.exp(g.score_samples(grid[:, None])), label="GMM K=2")
plt.xlabel("delivery time (hours)"); plt.ylabel("density"); plt.legend()
plt.show()

এক মাত্রায় histogram বেশ চলে। কিন্তু ২৮×২৮ ছবিতে প্রতি pixel-এ মাত্র দুটি bin (০ আর ১) ধরলেও মোট ঘর ২^৭৮৪ — মহাবিশ্বের পরমাণুর আনুমানিক সংখ্যার চেয়েও অনেক বড়। প্রতিটি ঘর গুনে probability বসানো অসম্ভব। উচ্চ মাত্রায় তাই দুটি পথ: (১) ডেটাকে আগে কম মাত্রায় নামিয়ে সেখানে mixture বসানো (PCA + GMM, সেকশন ৭-এ সত্যিকারের run), অথবা (২) probability-কে টুকরো করে গুণফল হিসেবে লেখা — autoregressive পথ, যা পরের সেকশনের বিষয়।

৫ · Autoregressive model — chain rule আর ancestral sampling

Probability-র chain rule কোনো অনুমান ছাড়াই সব সময় সত্য:

p(x₁, …, x_D) = p(x₁) · p(x₂ | x₁) · p(x₃ | x₁, x₂) ⋯ p(x_D | x_<D)

এখানে x_<d মানে d-তম pixel-এর আগের সব pixel, ওপর থেকে নিচে, বাঁ থেকে ডানে পড়ার ক্রমে। Autoregressive model প্রতিটি শর্তসাপেক্ষ অংশকে একটি ছোট classifier দিয়ে শেখে। পর্ব ৪৬ (Language modeling)-এ ঠিক এটাই করেছেন অক্ষরের জন্য, আর পর্ব ৪৯ (GPT আর decoder-only model)-এ token-এর জন্য। ছবিতে token-এর জায়গায় pixel, এটুকুই পার্থক্য।

নমুনা তোলাও এই ক্রম মেনে: আগে x₁ তুলুন, সেটি জেনে x₂, তারপর x₃… একে বলে ancestral sampling — প্রতিটি চলক তার “পূর্বপুরুষদের” মান জেনে তোলা হয়। তিন pixel-এর একটি খেলনা মডেলে ধাপে ধাপে দেখুন। প্রতিটি ধাপে একটি uniform সংখ্যা u (০ থেকে ১) তোলা হয়েছে; u যদি p-এর চেয়ে ছোট হয়, pixel = ১.

এবার একই মডেল NumPy-তে। প্রথমে ধাপে ধাপে দেখা নমুনাটি আবার তোলা হয়েছে, তারপর ১,০০,০০০টি নমুনা একসাথে (vectorised), আর আটটি ঘরের ভাগ হুবহু probability-র সঙ্গে মেলানো হয়েছে।

import numpy as np
from itertools import product

P1 = 0.3                                    # p(x1 = 1)
P2 = np.array([0.2, 0.7])                   # p(x2 = 1 | x1)
P3 = np.array([[0.1, 0.5], [0.4, 0.9]])     # p(x3 = 1 | x1, x2)

def ancestral(U):                           # U: (n, 3) uniform সংখ্যা
    a = (U[:, 0] < P1).astype(int)
    b = (U[:, 1] < P2[a]).astype(int)       # a জানার পরেই b
    c = (U[:, 2] < P3[a, b]).astype(int)    # a, b জানার পরেই c
    return np.stack([a, b, c], axis=1)

def joint(a, b, c):                         # chain rule: তিনটি গুণ
    pa = P1 if a else 1 - P1
    pb = P2[a] if b else 1 - P2[a]
    pc = P3[a, b] if c else 1 - P3[a, b]
    return pa * pb * pc

print("u = (0.25, 0.62, 0.81) থেকে:", ancestral(np.array([[0.25, 0.62, 0.81]]))[0])

rng = np.random.default_rng(7)
S = ancestral(rng.random((100_000, 3)))
freq = np.bincount(S @ np.array([4, 2, 1]), minlength=8) / len(S)

print("x1x2x3  exact p   sampled")
for k, (a, b, c) in enumerate(product((0, 1), repeat=3)):
    print(f"  {a}{b}{c}    {joint(a, b, c):.4f}   {freq[k]:.4f}")
print("exact যোগফল =", round(sum(joint(*t) for t in product((0, 1), repeat=3)), 6))

Neural network এই টেবিলের জায়গা নেয় দুই রকমভাবে। সবচেয়ে সরল রূপে প্রতিটি pixel-এর জন্য একটি logistic regression, যার ইনপুট আগের সব pixel: একে বলে fully visible sigmoid belief network (FVSBN; নব্বইয়ের দশকে Neal আর Frey-র কাজে পাওয়া যায়)। এর weight সংখ্যা ৭৮৪ × ৭৮৩ / ২ + ৭৮৪ = ৩,০৭,৭২০, টেবিলের ২^৭৮৪-এর তুলনায় নগণ্য। আরেক রূপ MADE: একটি সাধারণ MLP-এর weight-এ ০/১ mask বসিয়ে নিশ্চিত করা হয় যে output d কখনো ইনপুট d বা তার পরের কোনো pixel “দেখতে” না পায়। তখন এক forward pass-এই ৭৮৪টি শর্তসাপেক্ষ probability একসাথে বেরিয়ে আসে। Training-এ তাই একবারেই পুরো ছবির likelihood; নমুনায় অবশ্য সেই ৭৮৪টি ধাপ থেকেই যায়।

৬ · Bits per dimension — likelihood-কে তুলনাযোগ্য করা

একটি ছবির NLL (negative log-likelihood) ধরুন ১২০ nats. এটা ভালো না খারাপ? সংখ্যাটা ছবির আকারের ওপর নির্ভর করে: বড় ছবিতে বেশি pixel, বেশি “অবাক হওয়া”। তাই প্রতি মাত্রায় ভাগ করে, log-এর ভিত্তি ২ নিয়ে লেখা হয় bits per dimension:

bits/dim = NLL_nats ÷ (D × ln ২)

এর অর্থ সরাসরি compression-এর ভাষায়: একটি ভালো entropy coder এই মডেল দিয়ে test ছবিকে গড়ে প্রতি pixel-এ প্রায় এত bit-এ চাপতে পারত। ০/১ ছবিতে মডেল ছাড়াই প্রতি pixel-এ ১ bit লাগে, তাই ১-এর নিচের যেকোনো সংখ্যা মানে মডেল কিছু শিখেছে। পর্ব ৪৬-এর bits per token আর perplexity এই একই ধারণা, শুধু ভাগ হয় token-এর সংখ্যায়।

এবার পাতার ভেতরেই একটি সত্যিকারের তুলনা। scikit-learn-এর সঙ্গে আসা ৮×৮ হাতের লেখা সংখ্যার ১,৭৯৭টি ছবি (digits), ৮-এর বেশি মানকে ১ ধরে ০/১ করা। মডেল ১: প্রতিটি pixel স্বাধীন। মডেল ২: autoregressive, যেখানে প্রতিটি pixel-এর জন্য আগের সব pixel থেকে একটি logistic regression (AI-এর ভিত্তি কোর্সের পর্ব ৫৯) — অর্থাৎ ছোট একটি FVSBN. ৬৪টি মডেল fit হয়, তাই কয়েক সেকেন্ড লাগতে পারে।

import numpy as np
from sklearn.datasets import load_digits
from sklearn.linear_model import LogisticRegression

X = (load_digits().data >= 8).astype(int)       # 8×8 ছবি, 0/1 করা
rng = np.random.default_rng(0)
idx = rng.permutation(len(X))
tr, te = X[idx[:1400]], X[idx[1400:]]
D = X.shape[1]

# মডেল ১: প্রতিটি pixel স্বাধীন Bernoulli
p = (tr.sum(0) + 1) / (len(tr) + 2)
ll_ind = (te * np.log(p) + (1 - te) * np.log(1 - p)).sum(1)

# মডেল ২: autoregressive, p(x_d | x_1..x_(d-1)) = logistic regression
ll_ar = np.zeros(len(te))
for d in range(D):
    y = tr[:, d]
    if d == 0 or y.min() == y.max():             # আগে কিছু নেই বা সব একই
        q = (y.sum() + 1) / (len(y) + 2)
        pd_ = np.full(len(te), q)
    else:
        lr = LogisticRegression(C=1.0, max_iter=500).fit(tr[:, :d], y)
        pd_ = lr.predict_proba(te[:, :d])[:, 1]
    ll_ar += np.where(te[:, d] == 1, np.log(pd_), np.log(1 - pd_))

for name, ll in [("independent", ll_ind), ("autoregressive", ll_ar)]:
    nats = -ll.mean()
    print(f"{name:15s} test NLL = {nats:6.2f} nats/image"
          f" = {nats/np.log(2):6.2f} bits = {nats/np.log(2)/D:.3f} bits/dim")
print("প্রথম test ছবি, স্বাধীন মডেলে log p =", round(ll_ind[0], 2),
      "nats; AR মডেলে =", round(ll_ar[0], 2), "nats")

৭ · সত্যিকারের run — চার মডেল, Fashion-MNIST আর MNIST

এবার আসল আকারে। বাজারঘরের পণ্যের ছবির বদলে ব্যবহার হয়েছে Fashion-MNIST (Zalando Research, MIT licence): জামা, জুতা, ব্যাগের ২৮×২৮ ধূসর ছবি, train ৬০,০০০, test ১০,০০০. এগুলো আসল দোকানের ছবি নয়, একটি পরিচিত গবেষণা-ডেটাসেট। তুলনার জন্য MNIST-এর হাতের লেখা সংখ্যাও (এর licence সাধারণত CC BY-SA 3.0 বলা হয়; নিজের কাজে ব্যবহারের আগে উৎস দেখে নিন)। প্রতিটি pixel-কে ১২৮ সীমায় ০/১ করা হয়েছে। Train-এর শেষ ৫,০০০টি ছবি আলাদা রাখা হয়েছে val হিসেবে: hyperparameter আর সেরা epoch শুধু তা দিয়ে বাছা, test মাপা হয়েছে সবশেষে একবার।

Python 3.14.4, numpy 2.5.4, scikit-learn 1.9.1, torch 2.15.0 (CPU build), সব CPU-তে, ৩টি thread-এ (লেখার সময়ের version). AR মডেল দুটি Adam (lr ০.০০১), batch ১০০, ৩০ epoch, তিনটি seed-এ। MADE-এর মূল অংশ (genmap.py থেকে ছাঁটা):

deg = torch.randint(1, D, (h,), generator=g)        # hidden unit-এর "ক্রম" 1..D-1
inp = torch.arange(1, D + 1)
m1 = (deg[:, None] >= inp[None, :]).float()          # hidden k দেখে pixel 1..deg[k]
m2 = (inp[:, None] > deg[None, :]).float()           # output d দেখে deg < d এমন hidden
m  = torch.tril(torch.ones(D, D), -1)                # skip: output d দেখে pixel < d

def forward(x):                                      # logit of p(x_d = 1 | x_<d)
    hid = torch.relu(x @ (l1.weight * m1).T + l1.bias)
    return hid @ (l2.weight * m2).T + l2.bias + x @ (skip.weight * m).T

loss = F.binary_cross_entropy_with_logits(forward(b), b, reduction="none").sum(1).mean()

PCA + GMM-এর val খোঁজ (Fashion-MNIST, seed ৪২; সত্যিকারের run):

$ uv run python genmap.py fashion gmm 42
k= 16 K=  1 val_bpd=0.6686 params=13481 fit_s=0.5
k= 16 K= 10 val_bpd=0.6528 params=14858 fit_s=2.7
k= 16 K= 30 val_bpd=0.6500 params=17918 fit_s=7.8
k= 32 K=  1 val_bpd=0.6413 params=26433 fit_s=0.6
k= 32 K= 10 val_bpd=0.6165 params=31482 fit_s=3.3
k= 32 K= 30 val_bpd=0.6112 params=42702 fit_s=24.6
k= 64 K=  1 val_bpd=0.6216 params=53105 fit_s=0.6
k= 64 K= 10 val_bpd=0.5843 params=72410 fit_s=7.4
k= 64 K= 30 val_bpd=0.5768 params=115310 fit_s=61.4
… (scikit-learn-এর একটি RuntimeWarning-এর দুই লাইন বাদ)
{'data': 'fashion', 'model': 'gmm', 'seed': 42, 'k': 64, 'K': 30, 'params': 115310, 'sigma2': 0.12059533596038818, 'val_bpd': 0.5768246054649353, 'test_bpd': 0.5789995193481445, 'test_nats': 314.6441955566406, 'fit_s': 61.4, 'sample100_s': 0.0317}

সেরাটি খোঁজের একদম কোণে (k = ৬৪, K = ৩০), তাই আরও বড় k বা K-তে হয়তো আরেকটু কমত; সময় বাঁচাতে খোঁজ এখানেই থামানো হয়েছে। নমুনা তোলার সময় scikit-learn একটি RuntimeWarning: covariance is not symmetric positive-semidefinite দিয়েছিল (float-এর ছোট গোলমাল); নমুনা তবুও তোলা হয়েছে। MADE-এর একটি run-এর লগ (ছাঁটা):

$ uv run python genmap.py fashion ar 42 30 500
fashion ar h=500 seed=42 params=1399940
epoch  1 val_bpd 0.2674 (3 s)
epoch  5 val_bpd 0.2043 (17 s)
epoch 10 val_bpd 0.1938 (36 s)
epoch 15 val_bpd 0.1918 (54 s)
epoch 19 val_bpd 0.1915 (68 s)
epoch 25 val_bpd 0.1921 (91 s)
epoch 30 val_bpd 0.1929 (110 s)
{'data': 'fashion', 'model': 'ar_h500', 'seed': 42, 'params': 1399940, 'best_epoch': 19, 'val_bpd': 0.19152139127254486, 'test_bpd': 0.19357165694236755, 'test_nats': 105.192138671875, 'fit_s': 110.4, 'sample100_s': 1.338}

সব সংখ্যা এই যন্ত্রের সত্যিকারের run, একটি ভাগে; AR দুটির ঘরে seed ৪২, ৪৩, ৪৪-এর পরিসর, বাকি দুটি seed ৪২. Test অংশ ১০,০০০টি ছবি। দুই ডেটাসেটেই GMM-এর val খোঁজ একই k = ৬৪, K = ৩০ বেছেছে। “কার্যকর parameter” মানে mask-এ শূন্য না হওয়া weight; PyTorch-এ রাখা মোট সংখ্যা FVSBN-এ ৬,১৫,৪৪০ আর MADE-এ ১৩,৯৯,৯৪০, যার প্রায় অর্ধেক mask-এ সবসময় শূন্য। GMM-এর সংখ্যায় PCA-র ৬৪ × ৭৮৪ weight-ও ধরা। সময় CPU-তে, অন্য কাজের সঙ্গে ভাগ করা যন্ত্রে মাপা; শুধু মাত্রা হিসেবে পড়ুন।

টেবিল থেকে চারটি কথা, প্রতিটির সীমাসহ।

• প্রতিবেশী pixel জানাই আসল লাভ। স্বাধীন মডেল থেকে MADE-এ Fashion-MNIST-এ ০.৭০৫ থেকে ০.১৯৪, প্রায় ৭২% কম; MNIST-এ ০.৩৭৯ থেকে ০.১২৮. Hidden layer ছাড়া FVSBN-ই এই পথের বেশিরভাগটা পেরিয়েছে; MADE-এর hidden layer যোগ করেছে Fashion-এ প্রায় ৫%, MNIST-এ প্রায় ৯%. তবে এটি একটি ভাগ আর একটি আকারের ফল; বড় নকশায় (যেমন PixelCNN) ব্যবধান অন্যরকম হতে পারে।
• Seed-এর প্রভাব এখানে খুব ছোট। তিন seed-এর পার্থক্য ০.০০০৩ bits/dim-এর বেশি নয়। এই সরল মডেলগুলোর জন্য তা স্বাভাবিক, কিন্তু GAN-এর মতো দুই খেলোয়াড়ের প্রশিক্ষণে (পর্ব ৭৭) এমন আশা করবেন না। Fashion-এ MADE-এর সেরা val epoch ছিল ১৭–১৯, তারপর val খারাপ হতে শুরু করে (overfitting). MNIST-এ দুটি AR মডেলেরই সেরা epoch ছিল শেষটি, ৩০; আরও epoch দিলে হয়তো সামান্য কমত, যা আমরা পরীক্ষা করিনি।
• GMM-এর ফল দুই দিকে। Fashion-MNIST-এ স্বাধীন মডেলের চেয়ে ভালো (০.৫৭৯ বনাম ০.৭০৫), MNIST-এ খারাপ (০.৪৯৪ বনাম ০.৩৭৯)। মনে রাখবেন, GMM-এর সংখ্যা uniform noise যোগ করে মাপা ঊর্ধ্বসীমা; continuous Gaussian-কে ০/১ ঘরে বসানোর একটা বাড়তি জরিমানা আছে, যা ভাবনার প্রশ্ন ৪-এ হিসাব করা হয়েছে। আর খোঁজের সেরা মান কোণে পড়েছে, তাই এটি GMM-এর সেরা সম্ভাব্য ফল নয়।
• বাইরের সংখ্যার সঙ্গে মেলাবেন না। অনেক প্রবন্ধ MNIST-কে এলোমেলোভাবে ০/১ করে (প্রতিবার pixel-এর উজ্জ্বলতা অনুযায়ী তুলে)। আমাদের নির্দিষ্ট সীমার ০/১ ছবি অনেক বেশি নিয়মিত, তাই NLL-ও আলাদা মাত্রার। শুধু এই টেবিলের ভেতরের তুলনা অর্থবহ।

সংখ্যার পাশে চোখও লাগে। নিচের ব্লকে চারটি মডেলের সত্যিকারের নমুনা আঁকা হয় (Fashion-MNIST, seed ৪২, AR মডেলের সেরা epoch-এর weight; প্রথম সারিতে তুলনার জন্য আসল test ছবি)। প্রতিটি ছবি ৭৮৪টি bit, ৯৮ byte-এ চেপে hex আকারে পাতায় রাখা।

import numpy as np
import matplotlib.pyplot as plt

rows = []
for line in open("samples.txt"):
    name, hexes = line.strip().split(":")
    imgs = [np.unpackbits(np.frombuffer(bytes.fromhex(h), np.uint8))[:784]
            for h in hexes.split(",")]
    rows.append((name, np.array(imgs).reshape(-1, 28, 28)))

fig, axes = plt.subplots(len(rows), 8, figsize=(8, 1.15 * len(rows)))
for r, (name, imgs) in enumerate(rows):
    for c in range(8):
        ax = axes[r, c]
        ax.imshow(imgs[c], cmap="gray_r", vmin=0, vmax=1)
        ax.set_xticks([]); ax.set_yticks([])
    axes[r, 0].set_ylabel(name, rotation=0, ha="right", va="center", fontsize=9)
    on = np.array(imgs).mean()
    print(f"{name:12s} ৮টি ছবিতে কালো pixel-এর ভাগ = {on:.3f}")
fig.subplots_adjust(left=0.2, wspace=0.05, hspace=0.05)
plt.show()

৮ · মান, বৈচিত্র্য আর গতি — trilemma আর মূল্যায়নের প্রথম ধারণা

সেকশন ৭-এর টেবিলে একটি টানাপোড়েন দেখা গেছে: সবচেয়ে ভালো likelihood-এর মডেলটি নমুনা তুলতে সবচেয়ে ধীর। Xiao, Kreis আর Vahdat ২০২২ সালের ICLR-এর একটি প্রবন্ধে (“Tackling the Generative Learning Trilemma with Denoising Diffusion GANs”) এই টানাপোড়েনকে নাম দেন generative learning trilemma: একটি generative model-এর কাছে আমরা চাই উঁচু মানের নমুনা, বৈচিত্র্য (ডেটার সব ধরন ঢাকা, mode coverage), আর দ্রুত নমুনা — আর তাঁদের পর্যবেক্ষণ অনুযায়ী তখনকার প্রচলিত পরিবারগুলো সাধারণত তিনটির দুটিতে ভালো ছিল। নিচের টেবিল তাঁদের ঢালাও বর্ণনার সরলীকরণ, কোনো মাপা ফল নয়; প্রতিটি পরিবারের ভেতরে বহু ব্যতিক্রম আছে, আর পরে অনেক কাজ এই সীমা ঠেলেছে।

আমাদের নিজের সংখ্যায় গতির অক্ষটি স্পষ্ট: ১০০টি নমুনা তুলতে স্বাধীন Bernoulli-র লেগেছে প্রায় ০.০০০৫ সেকেন্ড, PCA + GMM-এর প্রায় ০.০৩ সেকেন্ড, আর MADE-এর ১.১ থেকে ১.৮ সেকেন্ড, কারণ তাকে ৭৮৪টি forward pass পরপর চালাতে হয়েছে। ছোট মডেলে পার্থক্যটা সামান্য মনে হয়, কিন্তু ৬৪×৬৪ রঙিন ছবিতে মাত্রা ১২,২৮৮, তখন ধাপও ততগুলো। মান আর বৈচিত্র্য সংখ্যায় মাপা কঠিন; সেজন্যই পর্ব ৮১-তে FID, precision/recall আর CLIP score আসবে।

Likelihood বনাম নমুনার মান

এই পর্বের মাপকাঠি ছিল likelihood. কিন্তু Theis, van den Oord আর Bethge (ICLR ২০১৬, “A note on the evaluation of generative models”) দেখান, উচ্চ মাত্রায় likelihood আর নমুনার চোখে-দেখা মান অনেকটাই আলাদা জিনিস। তাঁদের একটি যুক্তি হাতে মেলানো যায়: একটি ভালো মডেল q-কে ১% ওজন দিয়ে ৯৯% আজেবাজে noise-এর সঙ্গে মেশালে নমুনার ৯৯টিই noise হবে, অথচ log-likelihood কমবে বড়জোর ln ১০০ ≈ ৪.৬ nats প্রতি ছবিতে — ৭৮৪ মাত্রায় তা মাত্র প্রায় ০.০০৮৫ bits/dim. উল্টো দিকে, train ছবি হুবহু ফেরত দেওয়া একটি “মডেল” চমৎকার নমুনা দেখাবে, অথচ test likelihood হবে ভয়ানক। তাই:

• Likelihood (bits/dim) ভালো মাপে মডেল ডেটার সব অঞ্চল ঢেকেছে কি না, আর compression-এ কাজে লাগে। শুধু explicit মডেলেই মাপা যায়।
• নমুনার মান মাপতে লাগে অন্য মাপকাঠি, আর শেষ পর্যন্ত মানুষের চোখ। একটি মাপকাঠিতে জেতা মানে অন্যটিতে জেতা নয়।
• মুখস্থ আলাদা করে পরীক্ষা করতে হয়: নমুনার সবচেয়ে কাছের train ছবি খুঁজে দেখা — পর্ব ৮১-এর একটি কাজ।

৯ · AI-এর যুগে — generative model-এর কাজে AI সহকারী

AI সহকারী একটি MADE বা GMM-এর কোড কয়েক সেকেন্ডে লিখে দেবে। এই বিষয়ে তার ভুলগুলোও চেনা: পুরোনো বা বানানো API (যেমন torch-এর সরিয়ে দেওয়া function বা scikit-learn-এর বাতিল argument), mask-এ একঘর সরে যাওয়া (output d নিজের ইনপুট d দেখে ফেলছে, ফলে likelihood অবিশ্বাস্য রকম ভালো), nats আর bits গুলিয়ে ফেলা, ln ২ দিয়ে ভাগ ভুলে যাওয়া, শুধু train-এ likelihood মাপা, model.eval() আর torch.no_grad() ভুলে যাওয়া, একটি ভাগ্যবান seed-এর ফল সাধারণ সত্য বলে লেখা, আর বিশ্বাসযোগ্য কিন্তু ভুল derivation বা প্রবন্ধের নাম। আর মনে রাখবেন, ভাষার মডেল নিজেও একটি autoregressive generative model; তার উত্তর “বোঝা” থেকে আসে, এমন দাবি প্রমাণিত নয়।

AI-এর লেখা generative কোড হাতে পেলে — যাচাইয়ের চেকলিস্ট

• Mask-এর নির্ভরতা পরীক্ষা করেছি: ইনপুটের শেষ pixel বদলালে আগের সব output অপরিবর্তিত থাকে
• একটি ছোট batch-এ overfit করিয়ে দেখেছি loss প্রায় শূন্যে নামে, আর shape ও dtype মিলিয়েছি
• Likelihood test অংশে মেপেছি, বাছাই করেছি শুধু val দিয়ে
• nats, bits আর bits/dim-এর রূপান্তর একটি সংখ্যায় হাতে মিলিয়েছি
• স্বাধীন pixel-এর মতো সরল baseline-এর সঙ্গে তুলনা করেছি, একাধিক seed-এ
• প্রবন্ধের সংখ্যার সঙ্গে তুলনার আগে ডেটা, ০/১ নিয়ম আর test ভাগ একই কি না দেখেছি
• ব্যক্তিগত ডেটা বা key কোনো prompt-এ দিইনি