GAN — generator, discriminator আর প্রশিক্ষণের অস্থিরতা

পর্ব ৭৪ (Generative modeling-এর মানচিত্র), ৭৫ (Autoencoder) আর ৭৬ (Variational autoencoder)-এর model-গুলো কোনো না কোনোভাবে likelihood বা তার একটি সীমা বাড়ায়। GAN পুরো অন্য পথে হাঁটে: সে কখনো p(x) লিখে না, শুধু নমুনা বানায়, আর একটি দ্বিতীয় network তাকে বলে নমুনাগুলো আসলের মতো লাগছে কি না। এই পর্বে সেই খেলার গণিত (minimax, optimal discriminator, JS divergence), generator-এর loss কেন বদলাতে হয়, আর training কেন এত অস্থির, সবই হাতে হিসাব আর সত্যিকারের run দিয়ে দেখবেন। Binary cross-entropy আর BCEWithLogitsLoss এই কোর্সের পর্ব ১৩-এ, Adam পর্ব ১৫-এ, আর KL divergence AI-এর ভিত্তি কোর্সের পর্ব ৩৮-এ; এখানে শুধু এক লাইনে মনে করিয়ে দেওয়া হবে। PyTorch পাতায় চলে না, তাই PyTorch-এর সব আউটপুট ডেস্কটপের সত্যিকারের run থেকে; পাতায় চালানো যায় এমন চারটি ব্লক NumPy, pandas আর matplotlib দিয়ে (প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে)।

১ · জাল নোটের কারবারি আর ব্যাংকের যাচাইকারী — GAN-এর মূল ধারণা

GAN (generative adversarial network) দুটি network নিয়ে গঠিত:

• Generator G: একটি এলোমেলো latent vector z (যেমন ৬৪টি সংখ্যা, প্রতিটি N(0, 1) থেকে) নিয়ে একটি নমুনা x̃ = G(z) বানায়, যেমন একটি ২৮ × ২৮ ছবি। z বদলালে ছবি বদলায়, তাই G আসলে একটি সহজ বণ্টনকে (Gaussian) জটিল বণ্টনে (হাতে লেখা অঙ্ক) রূপান্তর করে। এই রূপান্তরিত বণ্টনের নাম p_g.
• Discriminator D: একটি ছবি x নিয়ে একটি সংখ্যা D(x) ∈ (০, ১) দেয়: “এটি আসল ডেটা থেকে এসেছে” তার সম্ভাবনা। এটি সাধারণ একটি binary classifier, শেষে sigmoid.

এখানে একটি সূক্ষ্ম কিন্তু জরুরি বিষয় আছে। G দিয়ে আমরা নমুনা বানাতে পারি, কিন্তু কোনো একটি ছবি x-এর p_g(x) কত, তা বের করার উপায় নেই। এ ধরনের model-কে বলে implicit generative model: বণ্টন আছে, কিন্তু তার সূত্র নেই। তাই GAN-কে likelihood দিয়ে train করা যায় না, আর likelihood দিয়ে মাপাও যায় না। এর বদলে একটি classifier-কে বিচারক বানানো হয়। এটাই GAN-এর সবচেয়ে বড় চালাকি, আর পরে দেখবেন এটাই তার অনেক সমস্যার উৎস।

২ · Minimax objective আর একটি training ধাপ

দুই খেলোয়াড়ের লক্ষ্য একটি সংখ্যা দিয়ে লেখা যায়। Goodfellow ও সহকর্মীদের মূল সূত্র:

min_G max_D V(D, G) = E_x∼pdata[ln D(x)] + E_z∼pz[ln(1 − D(G(z)))]

এখানে E মানে গড় (expectation), x∼p_data মানে আসল ডেটা থেকে একটি নমুনা, z∼p_z মানে noise থেকে একটি নমুনা। প্রথম পদ বড় হয় যদি D আসল ছবিতে ১-এর কাছে বলে; দ্বিতীয় পদ বড় হয় যদি D নকলে ০-এর কাছে বলে। D চায় V বড় করতে (max), G চায় V ছোট করতে (min), অর্থাৎ নকলে D(G(z))-কে ১-এর দিকে ঠেলতে। একজনের লাভ ঠিক অন্যজনের ক্ষতি, তাই এটি একটি zero-sum game, আর লক্ষ্যটি একটি minimax objective.

D-এর দিক থেকে দেখলে, −V হলো সাধারণ binary cross-entropy: আসল ছবির লেবেল ১, নকলের লেবেল ০. তাই PyTorch-এ D-এর loss হুবহু পর্ব ১৩-এর BCEWithLogitsLoss. Training একটি খেলা, তাই একটি সাধারণ loop-এ দুই খেলোয়াড় পালা করে চাল দেয়:

প্রতিটি training ধাপে:
  ১. আসল ছবির একটি batch x, আর noise z থেকে নকল x̃ = G(z)
  ২. D-এর ধাপ:  L_D = BCE(D(x), 1) + BCE(D(x̃), 0)   ← x̃ detach, G স্থির
  ৩. G-এর ধাপ:  L_G = BCE(D(x̃), 1)   ← "non-saturating" রূপ, অংশ ৪
                 gradient D-এর ভেতর দিয়ে যায়, কিন্তু শুধু G-এর weight বদলায়

নিচের stepper-এ সবচেয়ে ছোট একটি GAN-এর একটি পূর্ণ ধাপ হাতে করুন। ডেটা এক-মাত্রার: একটি আসল সংখ্যা x = ৪.০. Generator G(z) = μ + σz, যেখানে μ আর σ তার দুটি parameter. Discriminator D(x) = sigmoid(wx + c). Learning rate η = ০.১, সাধারণ gradient descent.

লক্ষ্য করুন G-এর gradient-এ w আছে: G কোন দিকে যাবে, তা পুরোপুরি D-এর ঢালের ওপর নির্ভর করে। D যদি এমন জায়গায় চ্যাপ্টা হয় যেখানে নকলগুলো আছে, তবে G কোনো দিক পায় না। অংশ ৪ আর ৫-এর সমস্যাগুলো এখান থেকেই জন্মায়। PyTorch-এ দুটি ব্যবহারিক কথা: D-এর ধাপে নকল ছবি xf.detach() করে দিন, যাতে D-এর loss G-এর weight-এ gradient না পাঠায়; আর G-এর ধাপে শুধু G-এর optimizer step() করে, যদিও gradient D-এর ভেতর দিয়ে আসে (দুটি আলাদা optimizer, প্রতিটির আগে আলাদা zero_grad ডাকা)।

৩ · Optimal discriminator আর JS divergence

খেলাটি শেষে কোথায় থামা উচিত? প্রথমে G স্থির রেখে প্রশ্ন করুন: সেরা D কী? V-কে একটি integral হিসেবে লিখুন (z-এর গড়কে x̃-এর বণ্টন p_g-এর গড়ে বদলে):

V(D, G) = ∫ [ p_data(x) ln D(x) + p_g(x) ln(1 − D(x)) ] dx

প্রতিটি x-এ আলাদা করে D(x) বাছা যায়। a = p_data(x), b = p_g(x) আর y = D(x) ধরলে প্রতিটি x-এ সর্বোচ্চ করতে হবে a ln y + b ln(১ − y). Derivative শূন্য করুন: a/y − b/(১ − y) = ০, অর্থাৎ a(১ − y) = by, তাই y = a/(a + b). এটিই optimal discriminator:

D*(x) = p_data(x) / ( p_data(x) + p_g(x) )

Second derivative −a/y² − b/(১ − y)² ঋণাত্মক, তাই এটি সত্যিই সর্বোচ্চ বিন্দু। এবার D* বসিয়ে দিন। একটু সাজালে (প্রতিটি ln-এর ভেতরে ২ গুণ আর ভাগ করে) আসে:

V(D*, G) = −ln 4 + KL(p_data ‖ m) + KL(p_g ‖ m) = −ln 4 + 2·JS(p_data ‖ p_g)

যেখানে m = (p_data + p_g)/২ দুই বণ্টনের গড়, KL হলো KL divergence, আর JS divergence (Jensen–Shannon) = ½KL(p ‖ m) + ½KL(q ‖ m). JS সবসময় ০ থেকে ln ২-এর মধ্যে, আর শুধু দুই বণ্টন হুবহু এক হলে ০. তাই সেরা D-এর বিপরীতে G-এর কাজ হলো JS কমানো, আর সর্বনিম্ন বিন্দু p_g = p_data, যেখানে D* = ½ সব জায়গায় আর V = −ln ৪ ≈ −১.৩৮৬৩. এটিই মূল প্রবন্ধের প্রধান তাত্ত্বিক ফল। নিচের stepper-এ দুটি Gaussian দিয়ে সংখ্যায় দেখুন।

এবার একই কথা পাতায় সংখ্যায় যাচাই করুন: D* আর sigmoid(২x − ৬) মেলে কি না, V(D*) আর −ln ৪ + ২·JS মেলে কি না, আর অন্য কোনো D কি V-কে D*-এর চেয়ে বড় করতে পারে।

import numpy as np

def pdf(x, m, s=1.0):                             # Gaussian density N(m, s²)
    return np.exp(-(x - m) ** 2 / (2 * s * s)) / (s * np.sqrt(2 * np.pi))

p_data = lambda x: pdf(x, 4.0)                    # আসল ডেটা N(4, 1)
p_g = lambda x: pdf(x, 2.0)                       # এখনকার generator N(2, 1)
D_star = lambda x: p_data(x) / (p_data(x) + p_g(x))

for x in (1.0, 3.0, 5.0):
    print(f"x={x}: D*={D_star(x):.4f} | sigmoid(2x−6)={1 / (1 + np.exp(-(2 * x - 6))):.4f}")

x = np.linspace(-6, 12, 200_001); dx = x[1] - x[0]
P, Q = p_data(x), p_g(x)

def V(D):                                         # V(D, G) = E_data[ln D] + E_g[ln(1 − D)]
    return (P * np.log(D)).sum() * dx + (Q * np.log(1 - D)).sum() * dx

M = (P + Q) / 2
JS = 0.5 * (P * np.log(P / M)).sum() * dx + 0.5 * (Q * np.log(Q / M)).sum() * dx
print(f"V(D*) = {V(D_star(x)):.4f} | −ln4 + 2·JS = {-np.log(4) + 2 * JS:.4f} | JS = {JS:.4f}")

for name, D in [("D* থেকে একটু সরানো", np.clip(D_star(x) + 0.05, 1e-9, 1 - 1e-9)),
                ("ঢাল কম sigmoid(x−3)", 1 / (1 + np.exp(-(x - 3)))),
                ("সব জায়গায় 0.5", np.full_like(x, 0.5))]:
    print(f"{name:20s}: V = {V(D):.4f}")

x=1.0: D*=0.0180 | sigmoid(2x−6)=0.0180
x=3.0: D*=0.5000 | sigmoid(2x−6)=0.5000
x=5.0: D*=0.9820 | sigmoid(2x−6)=0.9820
V(D*) = -0.7126 | −ln4 + 2·JS = -0.7126 | JS = 0.3368
D* থেকে একটু সরানো  : V = -0.8480
ঢাল কম sigmoid(x−3) : V = -0.8137
সব জায়গায় 0.5     : V = -1.3863

৪ · Non-saturating loss — generator-এর gradient কেন মরে যায়

Minimax সূত্রে G কমায় ln(১ − D(G(z))). সমস্যা training-এর শুরুতে: G-এর ছবি তখন হিজিবিজি, আর D সহজেই শেখে যে এগুলো নকল, তাই D(G(z)) ≈ ০. কিন্তু ln(১ − D) ফাংশনটি D ≈ ০-এর কাছে প্রায় সমতল। D-এর logit s ধরে (D = sigmoid(s)) chain rule:

• Saturating (মূল minimax): L_G = ln(১ − D), ∂L_G/∂s = −D. D ≈ ০ হলে gradient ≈ ০.
• Non-saturating: L_G = −ln D, ∂L_G/∂s = −(১ − D). D ≈ ০ হলে gradient ≈ −১, পূর্ণ জোর।

দুটির লক্ষ্য একই দিকে: D(G(z)) বাড়ানো। পার্থক্য শুধু gradient-এর আকারে, ঠিক সেই সময়ে যখন G সবচেয়ে খারাপ আর সংশোধন সবচেয়ে দরকার। মূল প্রবন্ধই এই সমস্যার কথা বলে আর −ln D বাড়ানোর পরামর্শ দেয়। PyTorch-এ এটি খুব সরল: নকল ছবিকে “আসল” লেবেল দিয়ে BCE, BCEWithLogitsLoss(D(G(z)), 1). নিচের stepper-এ D যত নিশ্চিত হয়, দুই gradient-এর ফারাক কত দ্রুত বাড়ে দেখুন।

এবার অংশ ২-এর খেলনা আরেকটু বড় করে দুই loss পাশাপাশি চালান। আসল ডেটা N(৪, ১.২৫²), G(z) = μ + σz শুরু করে μ = −২ থেকে, অর্থাৎ ভুল জায়গায়। D এবার একটু শক্তিশালী: logit s = a·u² + b·u + c, যেখানে u = x/৪, যাতে দুটি Gaussian-এর log অনুপাত (একটি quadratic) পুরোপুরি ধরতে পারে। আগে ৩০০ ধাপ শুধু D শেখে, যাতে শুরুতে D নিশ্চিত থাকে; তারপর প্রতিটি G-ধাপে D-এর ৫ ধাপ।

import numpy as np

sig = lambda s: 1 / (1 + np.exp(-s))
feat = lambda x: np.stack([(x / 4) ** 2, x / 4, np.ones_like(x)])   # D: s = a·u² + b·u + c, u = x/4

def d_step(th, mu, sd, rng, lr=0.5):             # একটি discriminator ধাপ (batch 256)
    xr = rng.normal(4.0, 1.25, 256)               # আসল ডেটা N(4, 1.25²)
    xf = mu + sd * rng.normal(size=256)           # নকল: x = μ + σ·z
    gr = sig(th @ feat(xr)) - 1                   # ∂L_D/∂s, আসল
    gf = sig(th @ feat(xf))                       # ∂L_D/∂s, নকল
    return th - lr * (feat(xr) @ gr + feat(xf) @ gf) / 256

def train(kind, steps=600, lr_g=0.05, k=5):
    rng = np.random.default_rng(42)
    th, mu, sd = np.zeros(3), -2.0, 1.0           # generator শুরু করে ভুল জায়গায়
    for _ in range(300):                          # আগে D-কে দক্ষ করে তোলা
        th = d_step(th, mu, sd, rng)
    for t in range(steps + 1):
        z = rng.normal(size=256); x = mu + sd * z
        D = sig(th @ feat(x))
        if t % 100 == 0:
            print(f"{kind:3s} ধাপ {t:3d}: μ={mu:5.2f} σ={sd:4.2f} গড় D(G(z))={D.mean():.3f}")
        ds = (D - 1) if kind == "ns" else -D      # ∂L_G/∂s: −ln D বনাম ln(1 − D)
        dx = ds * (2 * th[0] * x / 4 + th[1]) / 4  # chain rule: ∂s/∂x
        mu -= lr_g * dx.mean()
        sd = abs(sd - lr_g * (dx * z).mean())
        for _ in range(k):                        # প্রতি G ধাপে D-এর k ধাপ
            th = d_step(th, mu, sd, rng)

train("sat"); train("ns")

sat ধাপ   0: μ=-2.00 σ=1.00 গড় D(G(z))=0.023
sat ধাপ 100: μ=-1.72 σ=1.52 গড় D(G(z))=0.047
sat ধাপ 200: μ=-0.87 σ=2.95 গড় D(G(z))=0.183
sat ধাপ 300: μ=-0.11 σ=3.48 গড় D(G(z))=0.220
sat ধাপ 400: μ= 0.52 σ=3.60 গড় D(G(z))=0.277
sat ধাপ 500: μ= 1.09 σ=3.53 গড় D(G(z))=0.298
sat ধাপ 600: μ= 1.63 σ=3.32 গড় D(G(z))=0.327
ns  ধাপ   0: μ=-2.00 σ=1.00 গড় D(G(z))=0.023
ns  ধাপ 100: μ= 3.95 σ=0.39 গড় D(G(z))=0.499
ns  ধাপ 200: μ= 4.19 σ=0.29 গড় D(G(z))=0.496
ns  ধাপ 300: μ= 4.18 σ=0.37 গড় D(G(z))=0.479
ns  ধাপ 400: μ= 4.14 σ=0.73 গড় D(G(z))=0.477
ns  ধাপ 500: μ= 4.01 σ=1.46 গড় D(G(z))=0.507
ns  ধাপ 600: μ= 3.84 σ=1.82 গড় D(G(z))=0.502

৫ · অস্থিরতার তিন রূপ — mode collapse, মরে যাওয়া gradient আর oscillation

সাধারণ classifier-এর training একটি পাহাড় বেয়ে নামা: loss কমলেই ভালো। GAN-এ দুটি network একে অপরের পাহাড় বদলে দেয়। তাই loss কমা-বাড়া দেখে অগ্রগতি বোঝা যায় না, আর তিনটি পরিচিত সমস্যা দেখা দেয়:

Oscillation-এর সবচেয়ে সরল উদাহরণ একটি খেলা: f(x, y) = x·y, যেখানে x কমাতে চায় আর y বাড়াতে চায়। সাম্যাবস্থা (০, ০). একসঙ্গে gradient ধাপ নিলে x ← x − η·y আর y ← y + η·x; প্রতি ধাপে দূরত্বের বর্গ (১ + η²) গুণ বাড়ে, তাই বিন্দুটি (০, ০)-এর চারপাশে সর্পিল পথে বাইরে চলে যায়, কখনো থামে না। GAN-এর অনেক stabilization কৌশল (দুই আলাদা learning rate, gradient penalty) এই ঘূর্ণন থামানোর চেষ্টা।

এবার একটি পরিচিত পরীক্ষা নিজে চালাই: ২-মাত্রার সমতলে একটি বৃত্তে (ব্যাসার্ধ ২) ৮টি ছোট Gaussian (প্রতিটির standard deviation ০.০৫)। প্রতিটি Gaussian একটি mode. এই খেলনাটি mode collapse দেখাতে Metz ও সহকর্মীদের “Unrolled GAN” প্রবন্ধ (ICLR ২০১৭) থেকে জনপ্রিয় হয়েছে। G: ১৬-মাত্রার z → 128 → 128 → 2, D: 2 → 128 → 128 → 1, ReLU, Adam (lr ১০^−৩, β₁ = ০.৫), batch ২৫৬, ৫,০০০ ধাপ। প্রতি ১,০০০ ধাপে ২,০০০টি নমুনা নিয়ে গোনা হলো কতগুলো mode “ধরা পড়েছে” (কোনো কেন্দ্রের ৩σ = ০.১৫-এর মধ্যে অন্তত ১% নমুনা), আর কত ভাগ নমুনা কোনো কেন্দ্রের কাছে (hq, অর্থাৎ high quality নমুনার ভাগ)। দুই loss, প্রতিটি পাঁচটি seed.

সত্যিকারের run (ডেস্কটপ, CPU-তে, ৩টি thread):

~/bazarghar-dl$ uv run python ring_gan.py
torch 2.15.0 | CPU, 3 threads | 8-Gaussian ring r=2, std=0.05
G: 16 -> 128 -> 128 -> 2, D: 2 -> 128 -> 128 -> 1, Adam lr 1e-3 betas (0.5, 0.999), batch 256
loss=ns  seed=0 modes@1k..5k: 0 8 8 8 8 | final hq 0.89 D(G(z)) 0.492 counts [168, 275, 250, 222, 202, 155, 253, 254]
loss=ns  seed=1 modes@1k..5k: 7 6 6 6 6 | final hq 0.94 D(G(z)) 0.430 counts [273, 355, 0, 312, 334, 323, 285, 0]
loss=ns  seed=2 modes@1k..5k: 3 6 3 3 3 | final hq 0.83 D(G(z)) 0.305 counts [6, 798, 0, 797, 10, 18, 9, 23]
loss=ns  seed=3 modes@1k..5k: 8 8 8 8 8 | final hq 0.93 D(G(z)) 0.527 counts [230, 170, 119, 355, 285, 230, 246, 229]
loss=ns  seed=4 modes@1k..5k: 5 7 7 7 7 | final hq 0.93 D(G(z)) 0.423 counts [310, 0, 143, 323, 478, 295, 154, 160]
loss=sat seed=0 modes@1k..5k: 8 8 8 8 8 | final hq 0.93 D(G(z)) 0.485 counts [201, 252, 215, 238, 218, 243, 244, 243]
loss=sat seed=1 modes@1k..5k: 8 8 8 8 8 | final hq 0.91 D(G(z)) 0.473 counts [226, 222, 203, 261, 252, 261, 191, 208]
loss=sat seed=2 modes@1k..5k: 8 8 8 8 8 | final hq 0.94 D(G(z)) 0.517 counts [208, 252, 219, 237, 228, 246, 236, 250]
loss=sat seed=3 modes@1k..5k: 6 8 8 8 8 | final hq 0.94 D(G(z)) 0.530 counts [269, 225, 190, 247, 253, 256, 223, 207]
loss=sat seed=4 modes@1k..5k: 8 8 8 8 8 | final hq 0.93 D(G(z)) 0.472 counts [211, 230, 251, 231, 224, 204, 252, 249]
time 117 s (CPU)

এই টেবিলটি একটু সাবধানে পড়ুন। Non-saturating loss-এ seed ০ আর ৩ আটটি mode-ই ধরেছে। Seed ১ শেষে ৬টি (দুটি কেন্দ্রে ০টি নমুনা), seed ৪ সাতটি। Seed ২ সবচেয়ে শিক্ষণীয়: mode-এর সংখ্যা ৩ → ৬ → ৩ → ৩ → ৩; শেষে প্রায় সব নমুনা মাত্র দুটি কেন্দ্রে (৭৯৮ আর ৭৯৭)। প্রতিটি নমুনা দেখতে নিখুঁত (hq ০.৮৩), কিন্তু বৈচিত্র্য নেই: এটিই mode collapse, আর মাঝে ৬-এ উঠে আবার ৩-এ নামা হলো oscillation-এর চিহ্ন। আশ্চর্যের কথা, এই খেলনায় saturating loss-এর পাঁচটি seed-ই ৮টি mode ধরেছে। কারণ এখানে G শুরু করে কেন্দ্রের কাছে, বৃত্তের ভেতরে, তাই শুরুতে D খুব নিশ্চিত হয় না (অংশ ৪-এর সমস্যাটি দেখা দেয় না)। অর্থাৎ “non-saturating সবসময় ভালো” বলা যায় না; কোন loss কখন ভালো, তা পরিস্থিতির ওপর নির্ভর করে। এটি ছোট একটি খেলনায় একটি স্থানীয় run, সাধারণ নিয়ম নয়।

৬ · MNIST-এ MLP GAN — loss, নমুনা আর classifier দিয়ে mode coverage

এবার আসল ছবি। ডেটা MNIST: ২৮ × ২৮ পিক্সেলের হাতে লেখা অঙ্ক, ৬০,০০০ train ছবি (LeCun, Cortes আর Burges; লাইসেন্স সাধারণত CC BY-SA 3.0 বলে উল্লেখ করা হয়, তবু ব্যবহারের আগে নিজে যাচাই করুন)। এখানে বাজারঘরের পণ্যের ছবি নয়, অঙ্ক নিচ্ছি, কারণ অঙ্কের ১০টি শ্রেণি mode গোনার জন্য পরিষ্কার মাপকাঠি দেয়। পিক্সেল [−১, ১]-এ আনা হয়েছে, যাতে G-এর শেষের tanh-এর পরিসরের সঙ্গে মেলে।

• G: z (৬৪-মাত্রা) → 256 → 512 → 1024 → 784, মাঝে LeakyReLU (০.২), শেষে tanh; ১৪,৭৭,১৩৬টি parameter.
• D: 784 → 512 → 256 → 1 (logit), LeakyReLU (০.২); ৫,৩৩,৫০৫টি parameter.
• Training: দুটি Adam optimizer, lr ২ × ১০^−৪, β = (০.৫, ০.৯৯৯), batch ১২৮, non-saturating loss, ৩০ epoch, seed ০.
• বিচারক: আলাদাভাবে train করা একটি ছোট CNN digit classifier (MNIST test accuracy ০.৯৮৩৬, CPU-তে ২৭ সেকেন্ড)। প্রতি ৫ epoch-এ একটি স্থির z-এর সেট থেকে ১,০০০টি নমুনা বানিয়ে classifier দিয়ে শ্রেণি গোনা হয়: কয়টি শ্রেণি অন্তত ২% নমুনা পেল, শ্রেণি-হিস্টোগ্রামের entropy (bit-এ; ১০টি সমান শ্রেণিতে সর্বোচ্চ log₂ ১০ ≈ ৩.৩২), আর classifier-এর গড় confidence.

সত্যিকারের run (ডেস্কটপ, CPU-তে, ৩টি thread; torch 2.15.0, Python 3.14.4-এ)। প্রথম সারি তুলনার জন্য আসল test set-এর ১,০০০টি ছবি; বাকি সারি প্রতি epoch-এর JSON log থেকে একটি ছোট script দিয়ে টেবিলে সাজানো, কয়েকটি epoch বাদ দিয়ে সংক্ষেপিত:

~/bazarghar-dl$ uv run python mnist_gan.py main
torch 2.15.0 | CPU | real test 1000: hist [86, 125, 111, 110, 109, 84, 86, 98, 97, 94] classes>=2% 10 entropy 3.310 bits conf 0.977
ep  lossD  lossG  D(x)   D(G(z)) | classes  entropy  conf  histogram 0..9
1   1.194  0.933  0.666  0.408
2   1.007  1.555  0.684  0.233
5   0.934  2.033  0.712  0.189   | 7        1.436    0.773 [0, 24, 44, 35, 30, 4, 36, 0, 754, 73]
9   0.835  2.027  0.739  0.184
10  0.851  2.033  0.760  0.189   | 8        2.880    0.794 [8, 15, 132, 129, 46, 36, 65, 139, 264, 166]
13  1.043  1.321  0.648  0.318
15  1.113  1.399  0.663  0.297   | 10       3.100    0.828 [41, 110, 79, 165, 94, 62, 51, 127, 230, 41]
20  1.173  1.126  0.600  0.362   | 10       3.178    0.878 [33, 116, 73, 168, 76, 55, 73, 99, 167, 140]
25  1.158  1.066  0.598  0.380   | 10       3.261    0.890 [37, 130, 75, 117, 83, 102, 99, 126, 123, 108]
30  1.210  1.072  0.590  0.376   | 10       3.251    0.901 [50, 126, 55, 152, 92, 97, 90, 130, 117, 91]
time 240.7 s

তিনটি জিনিস লক্ষ্য করুন। এক, শুরুতে collapse. ৫ম epoch-এ ১,০০০টি নমুনার ৭৫৪টিকে classifier “৮” বলেছে, আর ৭ ও ০-এর একটিও নেই। প্রথম দিকের ঝাপসা গোল আকৃতিগুলো classifier-এর চোখে ৮-এর মতো, আর G কিছু সময় সেখানেই আটকে ছিল। দুই, loss দিয়ে অগ্রগতি বোঝা যায় না. D-এর loss ১.১৯ থেকে নেমে ৯ম epoch-এ ০.৮৪, তারপর আবার উঠে ১.২১; D(G(z)) ০.৪১ থেকে ০.১৮-এ নেমে আবার ০.৩৮. Classifier-এর মাপে কিন্তু নমুনা প্রায় ধারাবাহিকভাবে ভালো হয়েছে: শ্রেণি ৭ → ৮ → ১০, entropy ১.৪৪ → ৩.২৫, confidence ০.৭৭ → ০.৯০. তিন, পুরো কভারেজ মানে সমান কভারেজ নয়. ৩০তম epoch-এ দশটি শ্রেণিই আছে, কিন্তু “৩” ১৫২টি আর “০” মাত্র ৫০টি, “২” ৫৫টি; আসল test-এ প্রতিটি ৮৪ থেকে ১২৫. Entropy ৩.২৫১, আসলের ৩.৩১০-এর একটু নিচে। Confidence ০.৯০১, আসল ছবির ০.৯৭৭-এর নিচে: কিছু নমুনা classifier-এর কাছে দ্ব্যর্থক।

নিচের ব্লক একই run-এর আসল নমুনা আঁকে: একটি স্থির z-এর সেট থেকে ১ম আর ৫ম epoch-এর ৮টি করে, আর ৩০তম epoch-এর ১৬টি। ছবিগুলো ছোট রাখতে প্রতিটি পিক্সেল ১৬টি ধূসর স্তরে (৪ bit) রাখা হয়েছে, আর base64 করে পাতায় বসানো (প্রায় ১৭ KB); শেষ লাইনে ৩০তম epoch-এর ছবিগুলোর ওপর classifier-এর অনুমান, desktop run থেকে নেওয়া।

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

raw = np.frombuffer(base64.b64decode(open("gan_samples.b64").read()), np.uint8)
px = np.stack([raw >> 4, raw & 15], axis=1).reshape(-1, 28, 28).astype(int) * 17   # 4 bit → 0..255
print("ছবি:", px.shape, "| পিক্সেলের পরিসর:", px.min(), "থেকে", px.max())

groups = {"epoch 1": px[:8], "epoch 5": px[8:16], "epoch 30": px[16:]}
for name, g in groups.items():
    ink = (g > 128).mean()                                # উজ্জ্বল পিক্সেলের ভাগ
    diff = g.reshape(len(g), -1).std(axis=0).mean()       # নমুনাগুলো পরস্পর কতটা আলাদা
    print(f"{name:8s}: কালির ভাগ {ink:.3f} | নমুনার মধ্যে গড় পার্থক্য (std) {diff:5.1f}")

pred30 = [4, 1, 3, 3, 1, 7, 9, 2, 6, 0, 3, 7, 7, 0, 7, 7]   # desktop classifier, epoch 30
print("epoch 30-এর ১৬টি ছবিতে classifier-এর অনুমান:", pred30)

fig, axes = plt.subplots(4, 8, figsize=(8, 4.6))
for i, ax in enumerate(axes.flat):
    ax.imshow(px[i], cmap="gray", vmin=0, vmax=255)
    ax.set_xticks([]); ax.set_yticks([])
for r, t in enumerate(["epoch 1", "epoch 5", "epoch 30", "epoch 30"]):
    axes[r, 0].set_ylabel(t, fontsize=9)
fig.suptitle("Real samples from one MLP-GAN run on MNIST (seed 0, 4-bit)")
plt.show()

ছবি: (32, 28, 28) | পিক্সেলের পরিসর: 0 থেকে 255
epoch 1 : কালির ভাগ 0.204 | নমুনার মধ্যে গড় পার্থক্য (std)  13.7
epoch 5 : কালির ভাগ 0.138 | নমুনার মধ্যে গড় পার্থক্য (std)  30.8
epoch 30: কালির ভাগ 0.112 | নমুনার মধ্যে গড় পার্থক্য (std)  40.8
epoch 30-এর ১৬টি ছবিতে classifier-এর অনুমান: [4, 1, 3, 3, 1, 7, 9, 2, 6, 0, 3, 7, 7, 0, 7, 7]

৭ · Learning rate, seed আর loss — একই কোড, ভিন্ন ভাগ্য

একটি run দেখে কিছু বলা যায় না, অংশ ৫-এর বৃত্তেই তা দেখেছেন। তাই একই কোড আরও ১২ বার চালানো হলো, প্রতিটি ১৫ epoch: non-saturating loss-এ তিনটি learning rate (৫ × ১০^−৫, ২ × ১০^−৪, ১০^−৩), প্রতিটি seed ১, ২, ৩; আর saturating loss-এ lr ২ × ১০^−৪, seed ১, ২, ৩. অংশ ৬-এর seed ০-এর ১৫তম epoch-ও তুলনায় রাখা হয়েছে। সব run CPU-তে, প্রতিটি প্রায় দেড় থেকে আড়াই মিনিট।

সবচেয়ে চমকপ্রদ ফলটি সবচেয়ে ছোট learning rate-এর। তার একটি run-এর সত্যিকারের log (সংক্ষেপিত, কয়েকটি epoch বাদ):

~/bazarghar-dl$ uv run python mnist_gan.py sweep2
torch 2.15.0 | CPU | real test 1000: hist [86, 125, 111, 110, 109, 84, 86, 98, 97, 94] classes>=2% 10 entropy 3.310 bits conf 0.977
ep  lossD  lossG  D(x)   D(G(z)) | classes  entropy  conf  histogram 0..9
RUN {"lr": 5e-05, "seed": 1, "epochs": 15, "eval_every": 15}
1   1.143  0.731  0.693  0.484
3   0.800  1.428  0.760  0.245
5   0.582  2.257  0.800  0.119
8   0.175  3.461  0.937  0.037
10  0.102  4.170  0.958  0.019
12  0.004  6.519  0.998  0.002
15  0.000  9.188  1.000  0.000   | 1        -0.000    0.968 [0, 0, 0, 0, 0, 0, 0, 0, 1000, 0]
time 100.8 s
…

এখানে D ধীরে ধীরে খেলা জিতে নিয়েছে: D(x) ০.৬৯ থেকে ১.০০০, D(G(z)) ০.৪৮ থেকে ০.০০০, D-এর loss শূন্যে, G-এর loss ৯.১৯-এ। ১,০০০টি নমুনার সবকটিকে classifier “৮” বলেছে: সম্পূর্ণ mode collapse. বাকি দুটি seed-এও একই (১৫তম epoch-এ D(G(z)) ০.০১৬ আর ০.০০২)। একটি সম্ভাব্য ব্যাখ্যা: আসল আর নকল আলাদা করা সহজ কাজ, ছবি বানানো কঠিন; ছোট learning rate-এ G প্রথম দিকের ঝাপসা “৮”-এর পর্যায় থেকে বেরোনোর আগেই D নিখুঁত হয়ে যায়। Non-saturating loss-ও এখানে বাঁচায়নি, কারণ নিখুঁত D-এর চারপাশে নকলের জায়গায় D-এর ঢাল নিজেই প্রায় সমতল হয়ে যেতে পারে। ৩০ epoch চালালে G বেরিয়ে আসত কি না, তা এই পরীক্ষায় মাপা হয়নি।

পুরো sweep-এর ১৫তম epoch-এর শ্রেণি-পরিসংখ্যান নিচে একটি CSV হিসেবে বসানো (desktop run-এর log থেকে, সংখ্যা অপরিবর্তিত)। ব্লকটি প্রতিটি run দেখায়, তারপর প্রতিটি setting-এর গড় আর seed-এর বিস্তার, আর saturating loss-এ epoch অনুযায়ী ধরা পড়া শ্রেণি।

import numpy as np, pandas as pd, matplotlib.pyplot as plt

pd.set_option("display.width", 100)
df = pd.read_csv("gan_coverage.csv")                     # সত্যিকারের desktop run-এর log
e15 = df[df.epoch == 15].copy()                          # সব run-এর তুলনা ১৫তম epoch-এ
e15["run"] = e15["loss"] + " lr=" + e15["lr"].map("{:g}".format)
cols = ["run", "seed", "classes", "entropy", "conf", "top_share"]
print(e15[cols].to_string(index=False))

summ = e15.groupby("run").agg(seeds=("seed", "size"), classes=("classes", "mean"),
                              H_mean=("entropy", "mean"), H_sd=("entropy", "std"),
                              conf=("conf", "mean"))
print(summ.round(3).to_string())

sat = df[df["loss"] == "sat"].pivot(index="epoch", columns="seed", values="classes")
print("saturating loss, ধরা পড়া শ্রেণি (সারি epoch, কলাম seed):")
print(sat.to_string())

fig, ax = plt.subplots(figsize=(7, 3.4))
for i, (name, g) in enumerate(e15.groupby("run")):
    ax.scatter(np.full(len(g), i), g["entropy"], s=40)
ax.axhline(3.310, ls="--", c="gray"); ax.text(-0.4, 3.33, "real test images", fontsize=8)
ax.set_xticks(range(e15["run"].nunique()), sorted(e15["run"].unique()), fontsize=8)
ax.set_ylabel("class entropy (bits)"); ax.set_title("Mode coverage at epoch 15, one dot per seed")
plt.show()

run  seed  classes  entropy  conf  top_share
 ns lr=0.0002     0       10    3.100 0.828      0.230
 ns lr=0.0002     1       10    3.126 0.841      0.186
 ns lr=0.0002     2       10    3.174 0.842      0.210
 ns lr=0.0002     3       10    3.180 0.838      0.177
  ns lr=0.001     1       10    3.291 0.899      0.149
  ns lr=0.001     2       10    3.292 0.889      0.147
  ns lr=0.001     3       10    3.268 0.887      0.166
  ns lr=5e-05     1        1    0.000 0.968      1.000
  ns lr=5e-05     2        1    0.000 0.991      1.000
  ns lr=5e-05     3        1    0.000 0.953      1.000
sat lr=0.0002     1       10    3.131 0.823      0.195
sat lr=0.0002     2       10    3.144 0.842      0.197
sat lr=0.0002     3       10    3.146 0.801      0.195
               seeds  classes  H_mean   H_sd   conf
run                                                
ns lr=0.0002       4     10.0   3.145  0.039  0.837
ns lr=0.001        3     10.0   3.284  0.014  0.892
ns lr=5e-05        3      1.0   0.000  0.000  0.971
sat lr=0.0002      3     10.0   3.140  0.008  0.822
saturating loss, ধরা পড়া শ্রেণি (সারি epoch, কলাম seed):
seed    1   2   3
epoch            
5       4   5   6
10      8   7   8
15     10  10  10

৮ · GAN-এর রোগনির্ণয় — লক্ষণ দেখে কারণ খোঁজা

ডাক্তার যেমন জ্বর দেখে সরাসরি ওষুধ দেন না, আগে লক্ষণ মিলিয়ে কারণ খোঁজেন, GAN-এর training-ও তেমনভাবে পড়তে হয়। নিচের টেবিল এই পর্বের পরীক্ষাগুলো থেকে পাওয়া লক্ষণগুলো একসঙ্গে রাখে। প্রথম কলামের সংখ্যাগুলো ছাপতে খরচ সামান্য, তাই প্রতি epoch-এ ছাপুন।

একটি জিনিস টেবিলে নেই কিন্তু সবচেয়ে জরুরি: প্রতিটি পরিবর্তনের পর বাইরের মাপকাঠি দেখুন। GAN-এর নিজের loss দুই খেলোয়াড়ের আপেক্ষিক শক্তি দেখায়, নমুনার মান নয়। এই পর্বে সেই মাপকাঠি ছিল একটি আলাদা classifier, যা MNIST-এর জন্য সহজ আর সস্তা। ছবির সাধারণ মূল্যায়নের পরিচিত metric (Inception Score, FID, precision/recall) পর্ব ৮১ (Generative model-এর মূল্যায়ন আর নিরাপত্তা)-এর বিষয়।

৯ · AI-এর যুগে — AI-এর লেখা GAN কোড যাচাই

“PyTorch-এ একটি GAN লিখে দাও” বললে AI assistant কয়েক সেকেন্ডে চলনসই কোড দেয়, কারণ এমন কোড ইন্টারনেটে প্রচুর। সমস্যা হলো GAN-এর ভুলগুলো প্রায় সবই চুপচাপ: কোড চলে, loss-এর সংখ্যা ছাপে, কিন্তু G কিছু শেখে না বা একটিই ছবি বানায়। নিচের জায়গাগুলো আলাদা করে দেখুন।

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

• একটি ছোট batch-এ G আর D-এর output-এর shape আর মানের পরিসর ছাপিয়ে দেখেছি (G-এর tanh, ডেটাও [−১, ১]-এ)
• D-এর ধাপে detach, দুটি optimizer, আর প্রতিটির নিজের zero_grad আছে
• Generator-এর loss non-saturating, আর D logit দেয় (দ্বিতীয় sigmoid নেই)
• Loss-এর পাশাপাশি স্থির z-এর নমুনা আর আলাদা classifier-এর শ্রেণি-হিস্টোগ্রাম দেখেছি
• অন্তত তিনটি seed-এ চালিয়েছি, আর learning rate বদলালে কী হয় দেখেছি
• প্রবন্ধের নাম, বছর আর “সেরা” hyperparameter-এর দাবি মূল সূত্রে মিলিয়েছি; কোনো আসল মানুষের ছবি বা ব্যক্তিগত ডেটা দিয়ে generator train করিনি