GAN-এর রূপ — DCGAN, WGAN, StyleGAN আর conditional GAN

পর্ব ৭৭ (GAN — generator, discriminator আর প্রশিক্ষণের অস্থিরতা) মূল খেলাটি শিখিয়েছে: generator নকল বানায়, discriminator আসল-নকল আলাদা করে, দুজনের minimax খেলায় optimal discriminator-এর বিপরীতে generator আসলে JS divergence কমায়; আর বড় বিপদ mode collapse. এখানে প্রশ্ন: সেই ধারণাকে কীভাবে ছবির জন্য কাজের, বেশি স্থিতিশীল আর নিয়ন্ত্রণযোগ্য করা হলো। পর্ব ৭৪ (Generative modeling-এর মানচিত্র) দেখিয়েছে GAN likelihood দেয় না, তাই মান মাপতে বাইরের “বিচারক” লাগে। Transposed convolution-এর মাপের সূত্র পর্ব ৭৫ (Autoencoder)-এ। Convolution আর stride পর্ব ২০ (Convolution)-এ, BatchNorm পর্ব ১৪ (Weight initialization আর normalization)-এ, আর KL divergence AI-এর ভিত্তি কোর্সের পর্ব ৩৮-এ আছে।

ডেটা Fashion-MNIST (Zalando Research, MIT লাইসেন্স): ২৮ × ২৮ মাপের ধূসর পোশাক, জুতা আর ব্যাগের ছবি, ১০টি শ্রেণি। বাজারঘরের পণ্যের ছবির বদলে এটি ব্যবহার করছি; এগুলো আসল দোকানের ছবি নয়। Desktop-এর run লেখার সময়ে (নভেম্বর ২০২৬) এই version-এ: Python 3.14.4, torch 2.15.0, NumPy 2.5.4. GAN-গুলো GPU-তে, বিচারক classifier CPU-তে (৩টি thread) শেখানো হয়েছে। সময়গুলো এই এক যন্ত্রের একটি run-এর, সাধারণ নিয়ম নয়। এই পর্বে কোনো মানুষের মুখের ছবি বানানো হয়নি, আর হবেও না।

১ · DCGAN — convolution দিয়ে GAN-এর নকশার নিয়ম

২০১৪ সালের মূল GAN-এ দুটি network ছিল সাধারণ MLP, যা পাশের pixel-এর সম্পর্ক কাজে লাগায় না। ছবির স্বাভাবিক যন্ত্র convolution, কিন্তু প্রথম দিকে convolution-যুক্ত GAN শেখানো খুব অস্থির ছিল। Radford, Metz আর Chintala ২০১৫ সালে (DCGAN, “Deep Convolutional GAN”) অনেক পরীক্ষা করে কয়েকটি নিয়ম দেন, যাতে শেখা তুলনামূলক স্থির হয়। পেপার অনুযায়ী নিয়মগুলো মোটামুটি এই:

এগুলো তত্ত্ব থেকে প্রমাণিত নয়, পরীক্ষা থেকে পাওয়া অভিজ্ঞতা; তবু ছোট ছবিতে আজও ভালো শুরু। এই পর্বের সব GAN একই generator ব্যবহার করে।

PyTorch-এ generator-টি এরকম (সংক্ষিপ্ত করা; পুরো কোড desktop lab-এ চালানো হয়েছে):

G = nn.Sequential(                                        # input: z, আকার (B, 100, 1, 1)
    nn.ConvTranspose2d(100, 256, 7, 1, 0, bias=False),    # → (B, 256, 7, 7)
    nn.BatchNorm2d(256), nn.ReLU(True),
    nn.ConvTranspose2d(256, 128, 4, 2, 1, bias=False),    # → (B, 128, 14, 14)
    nn.BatchNorm2d(128), nn.ReLU(True),
    nn.ConvTranspose2d(128, 1, 4, 2, 1),                  # → (B, 1, 28, 28)
    nn.Tanh())

মাপের সূত্র পর্ব ৭৫ থেকে: H_out = (H_in − ১)·s − ২p + k + output_padding, যেখানে s stride, p padding, k kernel-এর মাপ। এবার স্তরে স্তরে হিসাব করুন।

একটি সতর্কতা। Transposed convolution-এ kernel-এর মাপ যদি stride দিয়ে বিভাজ্য না হয় (যেমন kernel ৩, stride ২), তাহলে output-এর কিছু pixel বেশি ছাপ পায়, কিছু কম। ফলে ছবিতে দাবার ছকের মতো দাগ (checkerboard artifact) আসতে পারে (Odena ও সহলেখক, Distill, ২০১৬)। Kernel ৪, stride ২ বাছার একটি কারণ এটি; আরেকটি পথ হলো আগে upsample, তারপর সাধারণ convolution.

২ · একই budget-এ তিনটি GAN — পরীক্ষার নকশা আর বিচারক

দুই ব্যাটারের তুলনায় একই পিচ আর একই সংখ্যক বল চাই; GAN-এর তুলনাও তাই। তিনটি model:

• DCGAN: উপরের generator, BatchNorm-যুক্ত discriminator, BCE loss (generator-এর জন্য non-saturating রূপ, পর্ব ৭৭-এর মতো), Adam lr ০.০০০২, β = (০.৫, ০.৯৯৯)।
• WGAN-GP: একই generator; critic একই আকারের, কিন্তু BatchNorm নেই (অংশ ৫-এ কারণ)। প্রতিটি generator ধাপের আগে critic-এর ৫টি ধাপ, λ = ১০, Adam lr ০.০০০১, β = (০, ০.৯), পেপারের সুপারিশ মেনে।
• Conditional DCGAN: DCGAN-এর মতোই, শুধু generator আর discriminator দুজনেই শ্রেণির label পায় (অংশ ৬)।

Budget সবার এক: batch ৬৪, ৩,০০০টি generator update, seed ০, ১ আর ২। WGAN-GP-র critic এতে ১৫,০০০ বার শেখে; “একই budget” মানে একই সংখ্যক generator update, একই সময় নয়।

বিচারক. GAN likelihood দেয় না, তাই মান মাপা হয় বাইরের একটি classifier দিয়ে। পর্ব ৭৫ নমুনার মান যাচাইয়ে একটি Fashion-MNIST CNN শিখিয়েছিল (test accuracy ০.৮৯৬)। এখানে আলাদা একটি classifier শেখানো হয়েছে, কারণ দুটি জিনিস লাগবে: GAN-এর output-এর মতো −১ থেকে ১ পরিসরে শেখা model, আর তার শেষের আগের স্তরের ১২৮টি feature. দুটি conv স্তর, একটি ১২৮-এর লুকানো স্তর, ৪ epoch, CPU-তে। সত্যিকারের run:

$ python train_clf.py
epoch 1 test_acc 0.8696 time 26s
epoch 2 test_acc 0.8916 time 47s
epoch 3 test_acc 0.9007 time 62s
epoch 4 test_acc 0.9038 time 81s
FID train5000 vs test10000: 0.508
FID train5000+noise0.3 vs test: 59.228

এই classifier দিয়ে দুটি মাপ:

1. Coverage: ৫,০০০টি নমুনার প্রতিটির শ্রেণি classifier দিয়ে বের করে histogram. আসল test সেটে প্রতিটি শ্রেণি ঠিক ১০%. Histogram-এর entropy (bit-এ) সর্বোচ্চ log₂ ১০ ≈ ৩.৩২২, যখন সব শ্রেণি সমান। সবচেয়ে কম শ্রেণির ভাগও দেখা হয়: mode collapse হলে কোনো শ্রেণি প্রায় শূন্যে নামে।
2. Classifier-feature FID: নমুনার ১২৮টি feature-এর গড় μ আর covariance Σ, আর test-এর ১০,০০০টি আসল ছবির একই হিসাব; দুটি Gaussian-এর Fréchet দূরত্ব: ‖μ_১ − μ_২‖² + Tr(Σ_১ + Σ_২ − ২(Σ_১Σ_২)^১/২). কম মানে কাছাকাছি। আসল train ছবি বনাম test দিলে ০.৫০৮, আর সেই ছবিতে noise দিলে ৫৯.২২৮: স্কেলটি বোঝার জন্য এই দুটি খুঁটি।

৩ · JS divergence কেন আটকে যায় — Wasserstein দূরত্ব

পর্ব ৭৭-এ দেখা গেছে, optimal discriminator থাকলে মূল GAN-এর generator আসলে আসল বণ্টন P আর নিজের বণ্টন Q-এর মধ্যে JS divergence কমায়। সমস্যা হলো, ছবির মতো উঁচু মাত্রার ডেটায় P আর Q প্রায়ই খুব সরু, নিচু মাত্রার জায়গায় থাকে, আর শুরুতে দুটি প্রায় কখনো একে অপরকে ছোঁয় না। Arjovsky আর Bottou (২০১৭) যুক্তি দেন, এমন অবস্থায় একটি নিখুঁত discriminator প্রায় সবসময় পাওয়া যায়, আর তখন generator-এর gradient প্রায় শূন্য।

একটি উপমা। উঠানের এক কোণে এক স্তূপ বালি (P), আরেক কোণে একটি গর্ত (Q). JS divergence শুধু জিজ্ঞেস করে, “দুটি কি একই জায়গায়?” স্তূপ ১ মিটার দূরে হোক বা ১০০ মিটার, উত্তর একই: “না”। Wasserstein দূরত্ব জিজ্ঞেস করে, “সব বালি গর্তে নিতে কত খাটুনি?”, অর্থাৎ ভর × দূরত্ব; তাই এর আরেক নাম Earth mover's distance. স্তূপ কাছে আনলে খরচ কমে, তাই generator বোঝে কোন দিকে সরতে হবে।

সবচেয়ে ছোট উদাহরণ: P-এর সব ভর ০ বিন্দুতে, generator-এর Q_θ-এর সব ভর θ বিন্দুতে; θ generator-এর একমাত্র parameter. WGAN পেপারের উদাহরণও এই ধারণার, দুটি সমান্তরাল রেখা দিয়ে।

এবার বিন্দুর বদলে চওড়া দুটি বণ্টন নিন, যাতে আংশিক মিল থাকে। P হলো ০-কে কেন্দ্র করে ১ চওড়া সমান উচ্চতার বণ্টন, Q একই আকারের কিন্তু θ সরানো। নিচের কোড SciPy দিয়ে দুটি দূরত্ব মাপে।

import numpy as np
from scipy.stats import wasserstein_distance
from scipy.spatial.distance import jensenshannon
import matplotlib.pyplot as plt

x = np.linspace(-1, 5, 601)                 # একটি ছোট grid
def bump(c):                                # c-কে কেন্দ্র করে চওড়া 1-এর সমান উচ্চতার বণ্টন
    p = ((x >= c - 0.5) & (x < c + 0.5)).astype(float)
    return p / p.sum()

P = bump(0.0)                               # আসল ডেটা
thetas = np.round(np.arange(0, 3.01, 0.25), 2)
js, w = [], []
for t in thetas:
    Q = bump(t)                             # generator-এর বণ্টন, θ সরে যায়
    js.append(jensenshannon(P, Q) ** 2)     # scipy দেয় JS-এর বর্গমূল, তাই বর্গ
    w.append(wasserstein_distance(x, x, P, Q))
for t, a, b in zip(thetas, js, w):
    if t in (0, 0.5, 0.75, 1, 1.5, 3):
        print(f"theta={t:4.2f}  JS={a:.4f}  W={b:.3f}")
print("log 2 =", round(np.log(2), 4))

fig, ax = plt.subplots(figsize=(5, 3))
ax.plot(thetas, js, "o-", label="JS divergence")
ax.plot(thetas, w, "s-", label="Wasserstein-1")
ax.axhline(np.log(2), ls="--", c="gray", lw=1)
ax.set_xlabel("theta (shift of generator distribution)")
ax.legend(); plt.show()

theta=0.00  JS=0.0000  W=0.000
theta=0.50  JS=0.3466  W=0.500
theta=0.75  JS=0.5199  W=0.750
theta=1.00  JS=0.6931  W=1.000
theta=1.50  JS=0.6931  W=1.500
theta=3.00  JS=0.6931  W=3.000
log 2 = 0.6931

W গণনা করা যায় কীভাবে? সংজ্ঞা অনুযায়ী W(P, Q) হলো P-এর ভর Q-তে নেওয়ার সব পরিকল্পনার মধ্যে সবচেয়ে কম খরচ, যা উঁচু মাত্রায় সরাসরি হিসাব করা অসম্ভব রকম কঠিন। Kantorovich–Rubinstein duality নামের একটি ফল একে অন্যভাবে লেখে:

W(P, Q) = max_{‖f‖L ≤ ১} [ E_x∼P f(x) − E_x∼Q f(x) ]

এখানে f যেকোনো ফাংশন যার ঢাল কোথাও ১-এর বেশি নয় (1-Lipschitz: |f(a) − f(b)| ≤ |a − b|), আর E মানে গড়। অর্থাৎ এমন f খুঁজুন যা আসল নমুনায় বড় আর নকলে ছোট মান দেয়, কিন্তু খুব খাড়া নয়। এই f-কে একটি neural network দিয়ে শেখানো হয়: সেটিই WGAN-এর critic.

৪ · WGAN — critic, Lipschitz শর্ত আর weight clipping

Arjovsky, Chintala আর Bottou ২০১৭ সালে WGAN প্রস্তাব করেন। পরিবর্তন তিনটি:

• Discriminator থেকে critic: শেষে sigmoid নেই, output যেকোনো বাস্তব সংখ্যা। এটি “আসল হওয়ার সম্ভাবনা” নয়, একটি score: আসল ছবিতে বেশি, নকলে কম। পাস-ফেল নয়, পরীক্ষার খাতার নম্বরের মতো।
• Loss: critic সর্বোচ্চ করে D(আসল)-এর গড় − D(নকল)-এর গড়, যা W-এর একটি অনুমান। Generator কমায় −D(G(z))-এর গড়। কোনো log নেই।
• Lipschitz শর্ত রাখতে weight clipping: প্রতিটি critic ধাপের পরে সব ওজন [−c, c]-এর মধ্যে কেটে দেওয়া; পেপারে c = ০.০১, RMSProp, lr ০.০০০০৫, আর প্রতিটি generator ধাপে critic-এর ৫টি ধাপ। ওজন ছোট থাকলে ফাংশনের ঢালও সীমিত থাকে।

পেপারের দুটি দাবি: critic-কে পুরোপুরি শেখালেও generator-এর gradient মরে না, আর critic-এর loss নমুনার মানের সঙ্গে মোটামুটি নামে। তবে লেখকেরা নিজেরাই বলেছেন, weight clipping “একটি স্পষ্টভাবে খারাপ উপায়”: c বড় হলে শর্ত রাখতে সময় লাগে, ছোট হলে gradient মিলিয়ে যায়, আর ওজন প্রায়ই ঠিক −c আর +c-তে জমে critic খুব সরল ফাংশন শেখে। Desktop-এ মূল WGAN (clipping, c = ০.০১, RMSProp)-ও একই generator আর ৩,০০০টি generator update-এ চালানো হয়েছে, seed ০, GPU-তে ৬০.৩ সেকেন্ড। সত্যিকারের run: FID ২৪১.৪ → ১৯৩.১ → ১৪০.৫ (১k, ২k, ৩k ধাপ), coverage entropy ৩.০৭৫; W-এর অনুমান ২৫০তম ধাপে ০.৫৩, তারপর ০.০৬৫-০.০৭৪-এর মধ্যে প্রায় স্থির। Clipping-এ critic-এর score এত ছোট পরিসরে আটকে থাকে যে অনুমানের মাপও ছোট। FID নামছে, কিন্তু অংশ ৭-এর DCGAN-এর (৩১.৯–৪১.২) চেয়ে অনেক পিছিয়ে।

৫ · WGAN-GP — gradient penalty হাতে আর কোডে

Gulrajani ও সহলেখকেরা (২০১৭, “Improved Training of Wasserstein GANs”) clipping-এর বদলে একটি নরম শর্ত দেন। একটি তথ্য কাজে লাগে: সেরা critic-এর ঢাল, আসল আর নকল নমুনার মাঝের সরলরেখাগুলোতে, প্রায় সব জায়গায় ঠিক ১। তাই ওজন না কেটে, ওই রেখার বিন্দুতে gradient-এর মাপ ১ থেকে সরে গেলে শাস্তি:

L_D = E[D(x̃)] − E[D(x)] + λ · E[(‖∇_x̂D(x̂)‖_২ − ১)²]

x আসল, x̃ নকল, x̂ = εx + (১ − ε)x̃ যেখানে ε প্রতিটি জোড়ায় ০ থেকে ১-এর মধ্যে এলোমেলো, ‖·‖_২ হলো vector-এর দৈর্ঘ্য, আর λ শাস্তির ওজন (পেপারে ১০)। শেষ অংশটিই gradient penalty. ছোট সংখ্যায় একবার পুরো হিসাব করুন। ধরুন critic একটি সরল ফাংশন D(x) = ০.৫x², তাই D′(x) = x; ডেটা এক মাত্রার, batch-এ দুটি জোড়া।

বাস্তব critic একটি neural network, আর x একটি ছবি, তাই gradient হাতে নয়, autograd দিয়ে বের হয়। PyTorch-এ মূল অংশ (desktop-এ চালানো কোড থেকে সংক্ষিপ্ত):

eps = torch.rand(B, 1, 1, 1, device=dev)               # প্রতিটি জোড়ায় একটি ε
xh = (eps * xr + (1 - eps) * xf).requires_grad_(True)
grad = torch.autograd.grad(D(xh).sum(), xh, create_graph=True)[0]
gp = ((grad.flatten(1).norm(dim=1) - 1) ** 2).mean()
lossD = D(xf).mean() - D(xr).mean() + 10.0 * gp

create_graph=True জরুরি: penalty নিজেই একটি gradient-এর ফাংশন, তাই critic-এর ওজন বদলাতে gradient-এর gradient লাগে (double backprop), আর প্রতিটি critic ধাপ ভারী হয়। Critic-এ BatchNorm নয়, কারণ BatchNorm একটি নমুনার output-কে batch-এর অন্যদের ওপর নির্ভরশীল করে, অথচ penalty প্রতিটি নমুনার নিজের gradient-এর ওপর; দরকারে পেপার LayerNorm সুপারিশ করে। নিচে একটি ছোট NumPy critic-এ penalty, gradient হাতে বের করে finite difference দিয়ে যাচাইসহ।

import numpy as np
rng = np.random.default_rng(42)
W = rng.normal(size=(3, 2)); b = rng.normal(size=3); v = rng.normal(size=3)

def critic(x, s=1.0):                      # ছোট critic: D(x) = s · v·tanh(Wx + b)
    return s * np.tanh(x @ W.T + b) @ v

def grad_x(x, s=1.0):                      # হাতে বের করা gradient: Wᵀ (v ⊙ (1 − tanh²))
    h = np.tanh(x @ W.T + b)
    return s * ((1 - h**2) * v) @ W

real = rng.normal([2, 2], 0.3, size=(4, 2))    # আসল ডেটার ৪টি বিন্দু
fake = rng.normal([0, 0], 0.3, size=(4, 2))    # generator-এর ৪টি বিন্দু
eps = rng.uniform(size=(4, 1))
xh = eps * real + (1 - eps) * fake             # দুইয়ের মাঝের সরলরেখায় বিন্দু

g = grad_x(xh)
h = 1e-5                                       # finite difference দিয়ে যাচাই
fd = np.array([[(critic(p + h*e) - critic(p - h*e)) / (2*h) for e in np.eye(2)] for p in xh])
print("max |analytic - numeric| =", f"{np.abs(g - fd).max():.1e}")

lam = 10
for s in (1.0, 4.0):
    norms = np.linalg.norm(grad_x(xh, s), axis=1)
    gp = ((norms - 1) ** 2).mean()
    w_est = critic(real, s).mean() - critic(fake, s).mean()
    loss = -w_est + lam * gp
    print(f"scale {s}: |grad| = {np.round(norms, 2)}")
    print(f"   W_est={w_est:.3f}  GP={gp:.3f}  critic loss={loss:.3f}")

max |analytic - numeric| = 6.3e-11
scale 1.0: |grad| = [1.22 0.7  0.63 0.28]
   W_est=1.304  GP=0.198  critic loss=0.674
scale 4.0: |grad| = [4.9  2.78 2.52 1.14]
   W_est=5.216  GP=5.178  critic loss=46.565

Lipschitz শর্ত রাখার তৃতীয় জনপ্রিয় উপায় spectral normalization (Miyato ও সহলেখক, ২০১৮): প্রতিটি স্তরের ওজন-matrix-কে তার সবচেয়ে বড় singular value দিয়ে ভাগ করা, যাতে প্রতিটি স্তরের ঢাল ১-এর বেশি না হয়। খরচ কম (power iteration-এর একটি ধাপ), double backprop লাগে না, আর সাধারণ GAN loss-এও কাজ করে; PyTorch-এ torch.nn.utils.parametrizations.spectral_norm. Singular value মেশিন লার্নিং কোর্সের পর্ব ৯-এ। এটি এখানে চালানো হয়নি।

৬ · Conditional GAN — label দুই দিকেই

সাধারণ GAN-কে “একটি জুতা বানাও” বলা যায় না; z থেকে যা আসে তা-ই। বাজারঘরের ক্যাটালগের জন্য চাই নির্দিষ্ট শ্রেণির ছবি। Conditional GAN (Mirza আর Osindero, ২০১৪) এর সহজ সমাধান: শর্ত y (এখানে শ্রেণির label) দুই network-কেই দিন। Generator শেখে G(z, y), আর discriminator বিচার করে D(x, y): “এই ছবি কি আসল, আর এটি কি সত্যিই y শ্রেণির?” দর্জিকে শুধু কাপড় দিলে তিনি যা খুশি বানাবেন; সঙ্গে চিরকুট দিলে নির্দিষ্ট জিনিস, আর মালিক যাচাই করবেন জামাটি চিরকুটের সঙ্গে মেলে কি না।

এখানে উপায়টি সরল: generator-এর input-এ z-এর ১০০টি সংখ্যার পাশে one-hot label-এর ১০টি (মোট ১১০টি channel); discriminator-এ ছবির পাশে ১০টি পূর্ণ ২৮ × ২৮ channel, যার একটিতে সব ১ আর বাকিগুলোতে ০। এতে parameter বাড়ে সামান্য: generator ১৭,৮১,৫০৫ থেকে ১৯,০৬,৯৪৫ (প্রথম স্তরে ১০ × ২৫৬ × ৪৯ = ১,২৫,৪৪০ বেশি), discriminator ১,৩৮,৬৮৯ থেকে ১,৪৮,৯২৯।

Label শুধু generator-কে দিলে discriminator দেখত শুধু ছবিটি বাস্তবসম্মত কি না; জুতার label পেয়ে ব্যাগ আঁকলেও কেউ ধরত না। পরে আরও উন্নত উপায় এসেছে: discriminator-এ বাড়তি classifier মাথা (AC-GAN, Odena ও সহলেখক, ২০১৭) বা label embedding আর feature-এর গুণফল (projection discriminator, Miyato আর Koyama, ২০১৮)।

Conditional model-এর বাড়তি মাপ label accuracy: প্রতিটি শ্রেণির সমান নমুনা চেয়ে দেখা, বিচারক কতগুলোকে চাওয়া শ্রেণিতেই ফেলে। বিচারক নিজেই আসল test-এ ৯০.৪% ঠিক, তাই ১০০% আশা করা যায় না।

৭ · ফলাফল — তিনটি GAN পাশাপাশি, তিনটি seed-এ

সব run GPU-তে, প্রতিটির সর্বোচ্চ GPU মেমরি প্রায় ৩৯০ MB (torch.cuda.max_memory_allocated). প্রতিটি model-এর শেষে ৫,০০০টি নমুনা (seed ১২৩৪-এর z, conditional model-এ প্রতিটি শ্রেণির ৫০০টি করে), আর অংশ ২-এর বিচারক দিয়ে মাপ। সত্যিকারের run, JSON log থেকে সাজানো:

WGAN-GP seed ০ কি শুধু ধীর, না আটকে গেছে? একই seed-এ budget বাড়িয়ে আবার চালানো হলো। ৩,০০০ নয়, ১০,০০০টি generator update, GPU-তে ২৮৬.৩ সেকেন্ড। সত্যিকারের run, প্রতি ২,০০০ ধাপে FID: ২৬৮.৩ → ২৫৩.০ → ৭৮.৬ → ৩৯.৫ → ২৭.৪, শেষে coverage entropy ৩.২৫৫. প্রায় ৪,০০০ ধাপ পর্যন্ত আটকে থেকে ৪,০০০ আর ৬,০০০-এর মধ্যে হঠাৎ বেরিয়ে এসেছে (ঠিক কখন, তা এই log-এর ফাঁকে ধরা পড়েনি)। অর্থাৎ seed ০ ভাঙা ছিল না, ধীর ছিল। ন্যায্যতার জন্য উল্টো পরীক্ষাও: DCGAN-কে WGAN-GP-র ৩,০০০ ধাপের প্রায় সমান সময় দেওয়া হলো, ১১,৫০০টি generator update, ৮৪.৬ সেকেন্ড, seed ০: FID ৪১.৫ → ২৪.৭ → ২০.১ → ১৫.৪ → ১৪.৩. একই সময়ে এই ছোট সমস্যায় DCGAN অনেক এগিয়ে; WGAN-GP-র সুবিধা এখানে গতি নয়। দুটিই একটি seed-এর ফল।

সংখ্যার পাশাপাশি নমুনা নিজের চোখে দেখা জরুরি। নিচের কোড desktop run-এর আসল নমুনা আঁকে: DCGAN seed ০; WGAN-GP seed ০ (৩,০০০ আর ১০,০০০ ধাপে, লেবেল GP s0 3k আর 10k); WGAN-GP seed ২; আর conditional DCGAN seed ০-এর এক সারি, প্রতিটি কলামে একটি শ্রেণি (T-shirt, Trouser, Pullover, Dress, Coat, Sandal, Shirt, Sneaker, Bag, Ankle boot). প্রতিটি সারি মূল্যায়নের একই z-এর প্রথম ১০টি নমুনা। পাতা ছোট রাখতে প্রতিটি pixel ৪ bit-এ (১৬টি ধূসর ধাপ), প্রতি byte-এ দুটি, base64-এ লেখা। শেষে run-এর class histogram থেকে coverage-এর সারাংশ।

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

pics = {}
for line in open("gan_pics.txt").read().split("\n"):
    tag, b64 = line.split()
    raw = np.frombuffer(base64.b64decode(b64), dtype=np.uint8).reshape(-1, 392)
    px = np.stack([raw >> 4, raw & 15], axis=2).reshape(-1, 28, 28)   # 2টি pixel প্রতি byte-এ
    pics[tag] = px / 15.0

rows = [("DCGAN s0", pics["dcgan_s0"]), ("GP s0 3k", pics["wgangp_s0"]),
        ("GP s0 10k", pics["wgangp_long_s0"]), ("GP s2 3k", pics["wgangp_s2"]),
        ("cDCGAN", pics["cdcgan_s0"])]
fig, ax = plt.subplots(5, 10, figsize=(7.5, 4.4))
for r, (name, imgs) in enumerate(rows):
    for c in range(10):
        ax[r, c].imshow(imgs[c], cmap="gray", vmin=0, vmax=1)
        ax[r, c].set_xticks([]); ax[r, c].set_yticks([])
    ax[r, 0].set_ylabel(name, fontsize=7)
fig.subplots_adjust(wspace=0.05, hspace=0.08)
plt.show()

names = ["T-shirt", "Trouser", "Pullover", "Dress", "Coat", "Sandal", "Shirt", "Sneaker", "Bag", "Boot"]
hist = {"DCGAN s0":   [471, 606, 881, 385, 260, 265, 337, 568, 679, 548],   # desktop run, 5000 নমুনা
        "WGAN-GP s0": [33, 720, 93, 74, 21, 11, 448, 6, 3461, 133],
        "WGAN-GP s2": [476, 600, 808, 367, 312, 303, 397, 591, 623, 523]}
for k, h in hist.items():
    p = np.array(h) / sum(h)
    ent = -(p * np.log2(p)).sum()
    print(f"{k:11s} entropy {ent:.3f} bits (max 3.322)  top: {names[p.argmax()]} {p.max():.1%}"
          f"  rarest: {names[p.argmin()]} {p.min():.1%}")

DCGAN s0    entropy 3.222 bits (max 3.322)  top: Pullover 17.6%  rarest: Coat 5.2%
WGAN-GP s0  entropy 1.530 bits (max 3.322)  top: Bag 69.2%  rarest: Sneaker 0.1%
WGAN-GP s2  entropy 3.256 bits (max 3.322)  top: Pullover 16.2%  rarest: Sandal 6.1%

৮ · Progressive growing আর StyleGAN — style আর truncation

বড় ছবিতে GAN শুরু থেকেই খুব অস্থির। Karras ও সহলেখকেরা (NVIDIA, ২০১৭; ICLR ২০১৮) progressive growing প্রস্তাব করেন: প্রথমে ৪ × ৪ ছবিতে শেখানো, তারপর নতুন স্তর মিশিয়ে ধীরে ধীরে ৮ × ৮, ১৬ × ১৬ … করে বড় করা, যেমন আঁকার শিক্ষক আগে মোটা দাগ, পরে খুঁটিনাটি শেখান।

একই দলের StyleGAN (২০১৮; CVPR ২০১৯) generator-এর গঠন বদলায়। পেপার অনুযায়ী মূল ধারণাগুলো:

• Mapping network: z (৫১২ মাত্রা) সরাসরি ছবিতে যায় না; ৮টি fully connected স্তরের একটি network একে আরেকটি ৫১২ মাত্রার vector w-তে নেয়। ধারণা: শেখা w-জায়গায় বৈশিষ্ট্যগুলো z-এর চেয়ে বেশি আলাদা আলাদা দিকে থাকে।
• Style modulation: generator-এর শুরু একটি শেখা ধ্রুবক tensor থেকে; প্রতিটি মাপের স্তরে w থেকে বানানো একটি “style” feature-গুলোর scale আর bias বদলায় (প্রথম সংস্করণে AdaIN, StyleGAN2-এ ওজনের modulation/demodulation). মোটা স্তরের style আকারে, সূক্ষ্ম স্তরের style রং আর টেক্সচারে প্রভাব ফেলে; সঙ্গে প্রতিটি স্তরে এলোমেলো খুঁটিনাটির জন্য noise.
• Style mixing: দুটি আলাদা w-এর একটি মোটা স্তরে, আরেকটি সূক্ষ্ম স্তরে দিলে একটির আকার আর অন্যটির রং-টেক্সচার মেশানো যায়।
• Truncation trick: w-কে গড় w̄-এর দিকে টেনে আনা: w′ = w̄ + ψ(w − w̄), যেখানে ψ ০ থেকে ১। ψ কম হলে নমুনা বেশি “গড়পড়তা” আর সাধারণত পরিষ্কার, কিন্তু বৈচিত্র্য কম; ψ = ০ দিলে সব নমুনা এক। BigGAN (Brock ও সহলেখক, ২০১৮) z-এর বড় মানগুলো আবার নমুনা নিয়ে একই রকম আপস করে।

StyleGAN-এর বিখ্যাত ফল মানুষের মুখ (FFHQ ডেটাসেট)। এই পর্বে মুখ বানানো হবে না: বানানো মুখ প্রতারণা আর deepfake-এ ব্যবহৃত হতে পারে (প্রতিরোধ পর্ব ৮১-এ)। নিচের কোডে দুই মাত্রার z একটি ছোট খেলনা mapping দিয়ে w-তে যায়, তারপর তিনটি ψ-তে truncation.

import numpy as np
import matplotlib.pyplot as plt
rng = np.random.default_rng(42)

z512 = rng.normal(size=(2000, 512))           # StyleGAN-এর মাপের latent
r = np.linalg.norm(z512, axis=1)
print(f"512-d: |z| mean {r.mean():.1f}, sqrt(512) = {np.sqrt(512):.1f}, min {r.min():.1f}")

def mapping(z):                               # খেলনা mapping network: z -> w
    return np.c_[z[:, 0] + 0.5 * np.sin(2 * z[:, 1]), 0.6 * z[:, 1] + 0.3 * z[:, 0]**2]

z = rng.normal(size=(1500, 2))
w = mapping(z)
w_bar = mapping(rng.normal(size=(100000, 2))).mean(0)   # অনেক নমুনার গড় w
print("w_bar =", np.round(w_bar, 3))

fig, axes = plt.subplots(1, 3, figsize=(7.5, 2.7), sharex=True, sharey=True)
for ax, psi in zip(axes, (1.0, 0.7, 0.3)):
    wt = w_bar + psi * (w - w_bar)            # truncation trick
    spread = np.linalg.norm(wt - w_bar, axis=1).mean()
    far = (np.linalg.norm(wt - w_bar, axis=1) > 2).mean()
    print(f"psi={psi}: mean distance to w_bar {spread:.3f}, share > 2 away {far:.3f}")
    ax.scatter(wt[:, 0], wt[:, 1], s=3, alpha=0.4)
    ax.plot(*w_bar, "r*", ms=10)
    ax.set_title(f"psi = {psi}")
fig.subplots_adjust(wspace=0.08)
plt.show()

512-d: |z| mean 22.6, sqrt(512) = 22.6, min 20.5
w_bar = [0.003 0.302]
psi=1.0: mean distance to w_bar 1.091, share > 2 away 0.083
psi=0.7: mean distance to w_bar 0.763, share > 2 away 0.019
psi=0.3: mean distance to w_bar 0.327, share > 2 away 0.000

Desktop-এ আসল DCGAN-এ truncation. DCGAN-এর (seed ০) z-কে ψ দিয়ে গুণ করে (z-এর গড় ০, তাই z′ = ψz) ৫,০০০টি নমুনা, CPU-তে। সত্যিকারের run:

$ python eval_trunc.py dcgan_s0
psi   FID    min_class  max_class  entropy_bits  mean_pair_dist  mean_max_prob
1.0    31.23  0.0488     0.1722     3.223         22.62           0.754
0.8    41.03  0.0404     0.1812     3.201         20.87           0.745
0.6    62.22  0.0274     0.1864     3.174         18.57           0.722
0.4   114.59  0.0140     0.1468     3.174         15.57           0.659
0.2   276.71  0.0024     0.3130     2.820         10.43           0.491
0.0   670.32  0.0000     1.0000     -0.000         0.00           0.229

৯ · Image-to-image GAN আর কোনটি কখন

GAN-এর শর্ত শুধু label হতে হবে, এমন নয়; শর্ত একটি পুরো ছবিও হতে পারে। pix2pix (Isola ও সহলেখক, ২০১৭) জোড়া ছবি থেকে শেখে, যেমন রেখাচিত্র → রঙিন ছবি বা মানচিত্র → উপগ্রহ-ছবি: generator একটি U-Net (পর্ব ২৫ · Detection আর segmentation), discriminator ছবির ছোট ছোট টুকরো বিচার করে (PatchGAN), আর adversarial loss-এর সঙ্গে আসল জোড়ার L1 দূরত্ব যোগ হয়। CycleGAN (Zhu ও সহলেখক, ২০১৭) জোড়া ছাড়াই শেখে, যেমন ঘোড়া ↔ জেব্রা: দুটি generator, আর একটি cycle-consistency শর্ত, অর্থাৎ A → B → A করলে আসল ছবি ফিরে আসা চাই। এগুলো এই পর্বে চালানো হয়নি; image-to-image কাজ পরে computer vision-এর আলাদা কোর্সে আরও গভীরে আসবে।

আজ text থেকে ছবি বানানোর বড় system-গুলোর বেশির ভাগ diffusion-ভিত্তিক (পর্ব ৭৯ আর ৮০)। তবু GAN এক ধাপে নমুনা দেয় বলে দ্রুত, আর adversarial loss অনেক জায়গায় সহায়ক হিসেবে বসে, যেমন latent diffusion-এর autoencoder শেখাতে।

১০ · AI-এর যুগে — GAN-এর রূপ নিয়ে AI-এর কোড আর দাবি যাচাই

GAN-এর ভুল কোড-ও চলে, শুধু খারাপ ছবি দেয়; আর “FID ১২ পেয়েছি” দাবি কোন feature, কত নমুনা আর কত seed-এ, তা না বললে অর্থহীন।

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

• একটি ছোট batch চালিয়ে প্রতিটি স্তরের আকার আর মোট parameter হাতের হিসাবের সঙ্গে মিলিয়েছি
• আসল আর নকল ছবির পরিসর (min, max) একই, আর critic-এর শেষে sigmoid নেই
• Penalty-র মান log করে দেখেছি, আর ছোট উদাহরণে হাতের হিসাবের সঙ্গে মিলিয়েছি
• নমুনা বানানোর আগে G.eval() আর torch.no_grad() আছে
• অন্তত তিনটি seed আর একটি baseline ছাড়া “এই রূপটি ভালো” দাবি করিনি
• কোনো মানুষের ছবি বা ব্যক্তিগত ডেটা দিয়ে generator শেখাইনি, assistant-কেও পাঠাইনি