Latent diffusion আর guidance — text-to-image, CFG আর sampler

পর্ব ৭৯ (Diffusion model — DDPM, noise schedule আর denoising)-এ diffusion model ছবি বানায় সরাসরি পিক্সেলে, noise থেকে ধাপে ধাপে noise সরিয়ে। এই পর্বে দুটি ধারণা: ছোট latent space-এ diffusion চালানো, আর guidance দিয়ে নমুনাকে একটি শর্তের (শ্রেণি বা text) দিকে ঠেলা। Autoencoder পর্ব ৭৫-এ (Autoencoder), attention-এর Q, K, V পর্ব ৩৩-এ (Self-attention), আর KL divergence AI-এর ভিত্তি কোর্সের পর্ব ৩৮-এ; এখানে শুধু এক লাইনে মনে করিয়ে দেওয়া হবে। PyTorch আর diffusers পাতায় চলে না, তাই তাদের সব আউটপুট ডেস্কটপের সত্যিকারের run থেকে; পাতায় চালানো যায় এমন চারটি ব্লক NumPy, pandas আর matplotlib দিয়ে (প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে)।

১ · কেন latent space-এ diffusion — পিক্সেলের বদলে সংক্ষিপ্ত রূপ

Diffusion model প্রতিটি ধাপে পুরো ছবির ওপর একটি বড় network (সাধারণত U-Net) চালায়, আর একটি ছবি বানাতে লাগে কয়েক ডজন থেকে কয়েকশো ধাপ। অথচ পিক্সেলের বড় অংশ চোখে প্রায় অদৃশ্য খুঁটিনাটি: পাশাপাশি পিক্সেল প্রায় একই রকম। Latent diffusion-এর মূল ধারণা হলো কাজটি দুই ভাগে ভাগ করা। প্রথমে একটি autoencoder ছবিকে একটি ছোট latent space-এ চেপে আনে আর সেখান থেকে ফিরিয়ে আনতে শেখে; তারপর diffusion model শেখে শুধু সেই latent-এর বণ্টন। Diffusion-এর মূল কাঠামো (forward noising, ε ভবিষ্যদ্বাণী, DDPM আর DDIM, time embedding-সহ U-Net) পর্ব ৭৯-এর বিষয়; এখানে সেটি জানা ধরে নিচ্ছি।

খরচ কতটা কমে, তা হিসাব করা সহজ। Stable Diffusion v1-এর model card বলে তার autoencoder ছবিকে f = ৮ গুণ ছোট করে আর latent-এ ৪টি channel রাখে: H × W × 3 ছবি → H/8 × W/8 × 4 latent. নিচের stepper-এ একটি denoising ধাপের খরচ দুই জায়গায় পাশাপাশি দেখুন। (FLOP মানে floating-point operation; একটি গুণ আর একটি যোগ মিলে ২ FLOP ধরা হয়েছে।)

একই হিসাব পাতায় চালিয়ে দেখুন। ব্লকটি conv আর attention-এর FLOP দুই জায়গায় গোনে আর ৫০ ধাপে যোগ করে।

import numpy as np

def conv_flops(h, w, cin, cout, k=3):      # একটি k×k conv layer: গুণ + যোগ = 2 FLOP
    return 2 * h * w * cin * cout * k * k

def attn_flops(h, w, d):                   # self-attention: QKᵀ আর (softmax)·V, n = h·w
    n = h * w
    return 2 * (2 * n * n * d)

spaces = {"pixel 512x512x3": (512, 512, 3), "latent 64x64x4": (64, 64, 4),
          "MNIST pixel 28x28x1": (28, 28, 1), "MNIST latent 7x7x4": (7, 7, 4)}
for name, (h, w, c) in spaces.items():
    print(f"{name:20s}: {h * w * c:>9,} সংখ্যা | {h * w:>7,} অবস্থান")

px, lt = (512, 512), (64, 64)
r_num = (512 * 512 * 3) / (64 * 64 * 4)
r_conv = conv_flops(*px, 320, 320) / conv_flops(*lt, 320, 320)
r_attn = attn_flops(*px, 320) / attn_flops(*lt, 320)
print(f"\nসংখ্যার অনুপাত {r_num:.0f}x | conv-এর FLOP অনুপাত {r_conv:.0f}x | attention-এর {r_attn:,.0f}x")

for name, hw in [("pixel", px), ("latent", lt)]:
    c = conv_flops(*hw, 320, 320) * 50 / 1e12
    a = attn_flops(*hw, 320) * 50 / 1e12
    print(f"{name:6s}: 50 ধাপে একটি conv layer {c:8.2f} TFLOP | একটি attention layer {a:10.2f} TFLOP")

n_px, n_lt = 512 * 512, 64 * 64            # একটি head-এর n × n score matrix, fp16 = 2 byte
print(f"\nscore matrix (fp16): পিক্সেলে {n_px ** 2 * 2 / 2**30:.0f} GiB | latent-এ {n_lt ** 2 * 2 / 2**20:.0f} MiB")

pixel 512x512x3     :   786,432 সংখ্যা | 262,144 অবস্থান
latent 64x64x4      :    16,384 সংখ্যা |   4,096 অবস্থান
MNIST pixel 28x28x1 :       784 সংখ্যা |     784 অবস্থান
MNIST latent 7x7x4  :       196 সংখ্যা |      49 অবস্থান

সংখ্যার অনুপাত 48x | conv-এর FLOP অনুপাত 64x | attention-এর 4,096x
pixel : 50 ধাপে একটি conv layer    24.16 TFLOP | একটি attention layer    4398.05 TFLOP
latent: 50 ধাপে একটি conv layer     0.38 TFLOP | একটি attention layer       1.07 TFLOP

score matrix (fp16): পিক্সেলে 128 GiB | latent-এ 32 MiB

২ · Autoencoder ধাপ — KL-regularised latent, f আর scaling factor

Autoencoder-কে দুটি বিপরীত চাহিদা মেটাতে হয়। এক, decoder যেন latent থেকে ছবি প্রায় হুবহু ফেরত আনে, নইলে diffusion যত ভালোই শিখুক, শেষ ছবি ঝাপসা হবে। দুই, latent space যেন “ভদ্র” হয়: মান যেন অসীমে না ছড়ায় আর কাছাকাছি latent যেন কাছাকাছি ছবি দেয়, কারণ diffusion এই space-এ Gaussian noise যোগ করবে আর সরাবে। পর্ব ৭৫-এর সাধারণ autoencoder-এ দেখেছেন, এলোমেলো latent decode করলে অর্থহীন ছবি আসে; সাধারণ AE-র latent নিজে ভালো sampling space নয়। পর্ব ৭৬ (Variational autoencoder)-এর KL divergence পদ latent-কে N(0, I)-এর দিকে টেনে space গুছিয়ে রাখে।

Latent diffusion-এর প্রবন্ধ এখানে একটি মাঝামাঝি পথ নেয়। পুরো VAE-র মতো শক্ত KL নয় (তাতে ছবি ঝাপসা হয়), বরং খুব ছোট ওজনের একটি KL পদ, যাকে প্রবন্ধ “KL-reg” বলে; বিকল্প হিসেবে VQ-VAE-ধরনের codebook (“VQ-reg”) নিয়েও পরীক্ষা আছে। ছবি ধারালো রাখতে autoencoder-কে শুধু পিক্সেলের MSE দিয়ে নয়, একটি perceptual loss আর একটি patch-ভিত্তিক adversarial loss দিয়েও train করা হয়েছিল বলে প্রবন্ধ লেখে (adversarial loss-এর খেলা পর্ব ৭৭-এ দেখেছেন)। ফলে autoencoder সামলায় খুঁটিনাটি, আর diffusion শেখে অর্থপূর্ণ গঠন।

আরেকটি ছোট কিন্তু জরুরি বিষয়: scaling factor. Encoder-এর latent-এর মান যেকোনো পরিসরে থাকতে পারে, অথচ diffusion-এর noise schedule ধরে নেয় ডেটার variance প্রায় ১. তাই latent-কে একটি স্থির সংখ্যা দিয়ে গুণ করে নেওয়া হয়। Stable Diffusion v1.5-এ scaling_factor = 0.18215 (অংশ ৭-এর run-এ ছাপা): diffusion-এর আগে গুণ, decode-এর আগে ভাগ। এই ভাগ ভুলে গেলে ছবি অদ্ভুত রঙের দাগে ভরে যায়।

নিজের ছোট model-এর জন্য MNIST-এ একটি ছোট KL-regularised convolutional autoencoder train করা হলো: ২৮ × ২৮ × ১ → ৭ × ৭ × ৪ (f = ৪), stride-2 convolution দিয়ে নামা আর transposed convolution দিয়ে ওঠা, KL ওজন খুব ছোট। এখানে MNIST নেওয়া হয়েছে, কারণ অঙ্কের ১০টি শ্রেণি guidance মাপার পরিষ্কার মাপকাঠি দেয় (MNIST: LeCun, Cortes আর Burges; লাইসেন্স সাধারণত CC BY-SA 3.0 বলে উল্লেখ করা হয়, তবু ব্যবহারের আগে নিজে যাচাই করুন)। সত্যিকারের run (ডেস্কটপ, GPU-তে; torch 2.15.0, Python 3.14.4):

~/bazarghar-dl$ uv run python train_ae.py
AE params 200,329 | latent 7x7x4 = 196 numbers (pixels 784) | KL weight 0.0001
epoch 1: train rec(sum/img)  11.39 | KL/img    88.8 | test MSE/pixel 0.00266
epoch 2: train rec(sum/img)   4.28 | KL/img    83.9 | test MSE/pixel 0.00249
epoch 3: train rec(sum/img)   3.95 | KL/img    79.7 | test MSE/pixel 0.00237
epoch 4: train rec(sum/img)   3.79 | KL/img    77.6 | test MSE/pixel 0.00241
epoch 5: train rec(sum/img)   3.67 | KL/img    76.2 | test MSE/pixel 0.00228
epoch 6: train rec(sum/img)   3.56 | KL/img    75.2 | test MSE/pixel 0.00234
epoch 7: train rec(sum/img)   3.50 | KL/img    74.5 | test MSE/pixel 0.00226
epoch 8: train rec(sum/img)   3.44 | KL/img    73.9 | test MSE/pixel 0.00227
latent mean 0.0085 std 0.5204 -> scale factor 1/std = 1.9216
time 25.8 s (GPU) | peak GPU memory 3307 MiB

কয়েকটি জিনিস লক্ষ্য করুন। ৭ × ৭ × ৪ = ১৯৬টি সংখ্যা থেকে test ছবি ফেরত আসে প্রতি পিক্সেলে গড় বর্গ-ত্রুটি (MSE) প্রায় ০.০০২৩ নিয়ে ([০, ১] পরিসরে), অর্থাৎ গড়ে প্রায় ০.০৫ পিক্সেল-মানের তফাত: চোখে প্রায় হুবহু। KL পদ প্রতি ছবিতে প্রায় ৭৪ nat-এ থেমেছে, শূন্যের কাছে নয়: ওজন ছোট বলে latent N(0, I) হয়নি, শুধু লাগাম টানা হয়েছে। Latent-এর standard deviation ০.৫২০৪, তাই এখানে scaling factor ১/০.৫২০৪ ≈ ১.৯২; Stable Diffusion-এর ০.১৮২১৫ ঠিক একই কাজ করে, শুধু তার latent-এর ছড়ানো বেশি বলে সংখ্যাটি ১-এর নিচে। পুরো train set আগেভাগে একবার latent-এ এনে রাখা হলো; এরপর diffusion আর পিক্সেল দেখে না।

৩ · Conditioning — শ্রেণির লেবেল থেকে text, আর cross-attention

“একটি লাল মগ” লিখলে model লাল মগ বানাবে কীভাবে? Diffusion-এর denoiser ε_θ(x_t, t)-কে একটি তৃতীয় input দেওয়া হয়: শর্ত c. তখন model শেখে ε_θ(x_t, t, c), অর্থাৎ conditional generation. শর্ত সবচেয়ে সহজ রূপে একটি শ্রেণির লেবেল (“অঙ্ক ৭”); এটিকে একটি embedding vector বানিয়ে time embedding-এর সঙ্গে যোগ করে দিলেই চলে। আমাদের MNIST model ঠিক এটাই করে।

Text-এ শব্দের ক্রম আর সম্পর্ক আছে, একটি vector-এ চাপলে তা হারায়। তাই latent diffusion text-কে প্রথমে একটি text encoder দিয়ে token-প্রতি একটি করে vector-এর সারিতে রূপান্তর করে, আর U-Net-এর ভেতরে cross-attention layer দিয়ে ছবির প্রতিটি অবস্থানকে সেই সারির দিকে “তাকাতে” দেয়। পর্ব ৩৩-এর self-attention-এর সঙ্গে একমাত্র পার্থক্য হলো query আর key/value আসে দুই আলাদা উৎস থেকে:

Q = W_Q·φ(z_t),  K = W_K·τ(y),  V = W_V·τ(y),  Attention = softmax(QK^T/√d)·V

এখানে φ(z_t) U-Net-এর feature map (প্রতিটি অবস্থান একটি token), τ(y) text encoder-এর output, d query/key-এর মাত্রা। ছবির প্রতিটি অবস্থান prompt-এর প্রাসঙ্গিক শব্দের তথ্য নিজের feature-এ মেশায়। Stable Diffusion v1-এর text encoder হলো OpenAI-এর CLIP ViT-L/14-এর text অংশ, যা train-এর সময় স্থির (frozen) রাখা হয়েছিল বলে model card জানায়। CLIP-এর বিস্তারিত পর্ব ৮২ (Multimodal model — CLIP, image captioning আর vision-language model)-এ আসবে।

Prompt একবারই encode হয়; প্রতি ধাপের প্রতিটি cross-attention layer সেই একই K, V ব্যবহার করে। Stable Diffusion v1.5-এর U-Net config-এ cross-attention-ওয়ালা block আছে ৬৪ × ৬৪, ৩২ × ৩২ আর ১৬ × ১৬ মাপে (আর মাঝের ৮ × ৮ block-এ), তাই prompt বড় গঠন আর খুঁটিনাটি দুটোতেই প্রভাব ফেলে।

৪ · Guidance — classifier guidance থেকে classifier-free guidance

শুধু শর্ত দিলেই model শর্ত পুরো মানে না। Conditional model-এর নমুনা প্রায়ই prompt-এর সঙ্গে আলগাভাবে মেলে: অংশ ৭-এর run-এ guidance ছাড়া “লাল মগ” চাইলে এসেছে মাটির ওপর একটি হালকা রঙের কাপ। তাই নমুনা নেওয়ার সময় শর্তের দিকে একটু বাড়তি ঠেলা দেওয়া হয়, যার নাম guidance.

Classifier guidance (Dhariwal আর Nichol, “Diffusion Models Beat GANs on Image Synthesis”, NeurIPS ২০২১) প্রথম জনপ্রিয় পথ। Noisy ছবিতে train করা একটি আলাদা classifier-এর gradient ∇_x log p(c | x_t), একটি scale s দিয়ে গুণ করে, প্রতি ধাপে নমুনাকে শ্রেণির দিকে ঠেলে। সমস্যা: noisy ছবির জন্য আলাদা classifier train করতে হয়, আর text-এর মতো খোলা শর্তে তা কঠিন।

Classifier-free guidance (CFG; Jonathan Ho আর Tim Salimans, NeurIPS ২০২১-এর একটি workshop-এ প্রথম, পরে arXiv ২০২২) আলাদা classifier ছাড়াই একই কাজ করে। Training-এ কিছু নমুনায় (যেমন ১০%) শর্ত মুছে “শূন্য শর্ত” ∅ দেওয়া হয়, তাই একই network শর্তসহ ε_θ(x_t, c) আর শর্তহীন ε_θ(x_t, ∅) দুটোই শেখে। Stable Diffusion v1.5-এর model card-ও বলে, text conditioning ১০% সময় বাদ দেওয়া হয়েছিল। নমুনা নেওয়ার সময় দুটিকে মেলানো হয়:

ε̃ = ε_θ(x_t, ∅) + w · ( ε_θ(x_t, c) − ε_θ(x_t, ∅) )

এখানে w হলো guidance scale. বন্ধনীর ভেতরের পার্থক্যটি হলো “শর্ত দিলে noise-এর অনুমান কোন দিকে সরে”। w = ০ মানে শর্তহীন model, w = ১ মানে সাধারণ conditional model, আর w > ১ মানে সেই দিকে আরও বেশি দূর যাওয়া (extrapolation). diffusers-এর guidance_scale ঠিক এই w; তার ডকুমেন্টেশন বলে guidance চালু হয় guidance_scale > 1 হলে, আর Stable Diffusion pipeline-এ ডিফল্ট মান ৭.৫ (লেখার সময়ে)। কিছু প্রবন্ধ (মূল CFG প্রবন্ধসহ) সূত্রটি (1 + w) দিয়ে লেখে, তাই সেখানে তাদের w = ০ মানে এখানকার w = ১; সংখ্যা মেলানোর আগে কোন রীতি, দেখে নিন।

সংখ্যাগুলো একটি ধাপের। পুরো sampling-এ guidance কী করে, তা দেখতে একটি ২-মাত্রার খেলনা নিন, যেখানে নির্ভুল ε সূত্র থেকে হিসাব করা যায়, কোনো network লাগে না। দুই শ্রেণি: “থলে” N((−১, ০), ০.৮²I) আর “মগ” N((১, ০), ০.৮²I), সমান ভাগে। প্রতিটি শ্রেণির জন্য সঠিক ε_c জানা; শর্তহীন ε_u হলো দুই শ্রেণির ε-এর ওজনদার গড়, যেখানে ওজন হলো x_t দেখে প্রতিটি শ্রেণির posterior সম্ভাবনা। ২,০০০টি নমুনা “মগ” চেয়ে DDIM-এর ৫০ ধাপে বানানো হলো।

import numpy as np

mu = np.array([[-1.0, 0.0], [1.0, 0.0]])   # দুই শ্রেণির কেন্দ্র: 0 = থলে, 1 = মগ
s2 = 0.8 ** 2                              # প্রতিটি শ্রেণির variance
abar = np.cumprod(1 - np.linspace(1e-4, 0.02, 1000))

def eps_class(x, t, c):                    # নির্ভুল ε: শ্রেণি c জানা থাকলে
    a = abar[t]; v = a * s2 + 1 - a
    return (x - np.sqrt(a) * mu[c]) * np.sqrt(1 - a) / v

def eps_uncond(x, t):                      # শ্রেণি না জানলে: দুই শ্রেণির ওজনদার গড়
    a = abar[t]; v = a * s2 + 1 - a
    d = [-((x - np.sqrt(a) * m) ** 2).sum(1) / (2 * v) for m in mu]
    p = np.exp(d[1] - np.logaddexp(d[0], d[1]))[:, None]   # P(শ্রেণি 1 | x_t)
    return (1 - p) * eps_class(x, t, 0) + p * eps_class(x, t, 1)

rng = np.random.default_rng(42)
ts = np.linspace(999, 0, 50).round().astype(int)
for w in [0, 1, 3, 7]:
    x = rng.standard_normal((2000, 2))
    for i, t in enumerate(ts):             # DDIM, 50 ধাপ, সবাই শ্রেণি 1 (মগ) চায়
        eu = eps_uncond(x, t)
        e = eu + w * (eps_class(x, t, 1) - eu)
        a, ap = abar[t], (abar[ts[i + 1]] if i + 1 < len(ts) else 1.0)
        x0 = (x - np.sqrt(1 - a) * e) / np.sqrt(a)
        x = np.sqrt(ap) * x0 + np.sqrt(1 - ap) * e
    print(f"w={w}: x>0 ভাগ {(x[:, 0] > 0).mean():.3f} | x-এর গড় {x[:, 0].mean():+.3f} | std {x.std(0).mean():.3f}")

w=0: x>0 ভাগ 0.491 | x-এর গড় -0.036 | std 1.004
w=1: x>0 ভাগ 0.908 | x-এর গড় +1.012 | std 0.771
w=3: x>0 ভাগ 1.000 | x-এর গড় +1.804 | std 0.634
w=7: x>0 ভাগ 1.000 | x-এর গড় +2.628 | std 0.578

৫ · নিজের ছোট latent diffusion — MNIST-এ CFG-এর সত্যিকারের sweep

এবার অংশ ২-এর autoencoder-এর latent-এ একটি শ্রেণি-শর্তযুক্ত diffusion model train করা হলো, আর guidance scale বদলে মাপা হলো। নকশা যতটা সম্ভব ছোট আর পরিষ্কার:

• Denoiser: ৭ × ৭ × ৪ latent-এর ওপর ৪টি residual block (১২৮ channel, GroupNorm, SiLU), কোনো downsampling নেই; time embedding আর শ্রেণির embedding যোগ করে প্রতিটি block-এ দেওয়া। মোট ১২,৯২,৮০৪টি parameter.
• CFG-এর জন্য training: শ্রেণি ০ থেকে ৯, আর একটি বাড়তি লেবেল ১০ মানে “শর্ত নেই”; প্রতিটি batch-এ এলোমেলোভাবে ১০% নমুনার লেবেল ১০ করে দেওয়া (condition dropout).
• Diffusion: T = ১,০০০, β রৈখিকভাবে ১০^−৪ থেকে ০.০২, ε-ভবিষ্যদ্বাণীর MSE loss, AdamW (lr ৩ × ১০^−৪), batch ১২৮, ২০ epoch, seed ১. Sampling: DDIM, ৫০ ধাপ, η = ০ (নির্ধারিত পথ)।
• বিচারক: আলাদা train করা একটি ছোট CNN digit classifier (৪,২১,৬৪২ parameter, ৩ epoch, MNIST test accuracy ০.৯৮৭২, CPU-তে ৫০.৮ সেকেন্ড)। প্রতিটি w-এ প্রতিটি শ্রেণির ১০০টি, মোট ১,০০০টি নমুনা; একই noise (seed ১২৩) সব w-এ, যাতে শুধু w-এর প্রভাব দেখা যায়।
• মাপকাঠি: class accuracy (চাওয়া শ্রেণি আর classifier-এর অনুমান মিলল কি না), গড় confidence, আর diversity: প্রতিটি শ্রেণির ১০০টি নমুনায় প্রতিটি পিক্সেলের standard deviation-এর গড় (০–২৫৫ মাপে), দশ শ্রেণির গড়।

সত্যিকারের run (ডেস্কটপ, GPU-তে; torch 2.15.0, Python 3.14.4; training log-এর মাঝের epoch বাদ দিয়ে সংক্ষেপিত):

~/bazarghar-dl$ uv run python train_dm.py latent 20
latent: input (4, 7, 7) | params 1,292,804 | resume at epoch 0
epoch 1: loss 0.1887 | 5.3 s
epoch 2: loss 0.1230 | 4.9 s
epoch 3: loss 0.1127 | 5.0 s
…
epoch 9: loss 0.0967 | 5.9 s
epoch 10: loss 0.0952 | 5.0 s
…
epoch 19: loss 0.0891 | 4.9 s
epoch 20: loss 0.0891 | 4.9 s
total train time 101.4 s (GPU) | peak GPU memory 153 MiB
~/bazarghar-dl$ uv run python evaluate.py latent cfg
real test 1000: acc 0.985 conf 0.984 diversity 37.7
latent: 20 epochs, train time 101.4 s
w=0.0  steps=50  | class acc 0.088 | conf 0.834 | diversity  50.0 | 1.26 s for 1000 images
w=1.0  steps=50  | class acc 0.721 | conf 0.909 | diversity  43.3 | 1.02 s for 1000 images
w=3.0  steps=50  | class acc 0.995 | conf 0.997 | diversity  33.1 | 1.98 s for 1000 images
w=7.0  steps=50  | class acc 1.000 | conf 1.000 | diversity  26.9 | 2.00 s for 1000 images
peak GPU memory 310 MiB

চারটি সারি পাশাপাশি পড়ুন। w = ০: শর্তহীন model; class accuracy ০.০৮৮, অর্থাৎ দশ শ্রেণির আন্দাজের (০.১০) কাছাকাছি, যেমন হওয়ার কথা। Diversity ৫০.০, আসল ছবির ৩৭.৭-এর চেয়ে বেশি, কারণ এখানে একটি “শ্রেণি”-র ১০০টি ছবি আসলে নানা অঙ্কের মিশ্রণ। w = ১: guidance ছাড়া conditional model; accuracy মাত্র ০.৭২১. ছোট model শর্তকে পুরো মানতে শেখেনি। w = ৩: accuracy ০.৯৯৫, confidence ০.৯৯৭, আসল test ছবির (০.৯৮৫, ০.৯৮৪) চেয়েও বেশি “স্পষ্ট”; কিন্তু diversity ৩৩.১, আসলের ৩৭.৭-এর নিচে। w = ৭: accuracy ১.০০০, কিন্তু diversity ২৬.৯: একই অঙ্কের ছবিগুলো একে অপরের মতো হয়ে যাচ্ছে। অংশ ৪-এর খেলনার একই ছবি, এবার আসল network-এ। সময়ের দিকে, w = ১-এ ১,০০০টি ছবি ১.০২ সেকেন্ডে, আর w = ৩ ও ৭-এ প্রায় ২.০ সেকেন্ডে: CFG-এর দুই শাখা প্রায় দ্বিগুণ কাজ। (w = ০-এর প্রথম সারিতে ১.২৬ সেকেন্ডে GPU-র প্রথমবারের গরম হওয়ার সময়ও মিশে আছে।)

পিক্সেল বনাম latent. তুলনার জন্য একই diffusion নিয়ম, একই লেবেল-ড্রপ আর একই ২০ epoch দিয়ে সরাসরি ২৮ × ২৮ পিক্সেলে একটি ছোট U-Net (২৮ → ১৪ → ৭ → ১৪ → ২৮, ১৯,৮২,৩৩৭ parameter) train করা হলো। সংক্ষেপিত সত্যিকারের run:

~/bazarghar-dl$ uv run python train_dm.py pixel 10   # দুই ভাগে, মাঝে checkpoint
pixel: input (1, 28, 28) | params 1,982,337 | resume at epoch 0
epoch 1: loss 0.0688 | 25.7 s
epoch 2: loss 0.0310 | 24.5 s
…
pixel: input (1, 28, 28) | params 1,982,337 | resume at epoch 10
…
epoch 20: loss 0.0219 | 24.7 s
total train time 496.7 s (GPU) | peak GPU memory 963 MiB
~/bazarghar-dl$ uv run python evaluate.py pixel cfg   # 250টি করে চার ভাগে
pixel: 20 epochs, train time 496.7 s
w=0.0  steps=50  | class acc 0.111 | conf 0.865 | diversity  47.1 | 7.19 s for 1000 images
w=1.0  steps=50  | class acc 0.940 | conf 0.970 | diversity  38.8 | 6.97 s for 1000 images
w=3.0  steps=50  | class acc 1.000 | conf 0.999 | diversity  33.6 | 13.84 s for 1000 images
w=7.0  steps=50  | class acc 1.000 | conf 1.000 | diversity  30.5 | 14.06 s for 1000 images
peak GPU memory 1118 MiB

ফলটি সৎভাবে পড়ুন। খরচে latent এগিয়ে: ২০ epoch-এ training ১০১ বনাম ৪৯৭ সেকেন্ড (প্রায় ৫ গুণ), আর w = ৩-এ ১,০০০টি ছবি ১.৯৮ বনাম ১৩.৮৪ সেকেন্ড (প্রায় ৭ গুণ; পিক্সেল model মেমরির জন্য চার ভাগে চলেছে)। মানে পিক্সেল এগিয়ে: guidance ছাড়া (w = ১) accuracy ০.৯৪০ বনাম ০.৭২১, আর w = ৩-এ ১.০০০ বনাম ০.৯৯৫. এই ছোট পরীক্ষায় latent model-এর দাম হলো autoencoder-এর হারানো তথ্য আর একটি ছোট denoiser; guidance সেই ঘাটতির বড় অংশ পূরণ করেছে। দুই model-এ একই প্রবণতা: w বাড়লে accuracy বাড়ে, diversity কমে। একটি seed-এর একটি run, তাই সংখ্যাগুলো সাধারণ নিয়ম নয়।

নিচের ব্লক একই run-এর আসল নমুনা আঁকে: প্রতিটি w-এর জন্য ০ থেকে ৯ প্রতিটি অঙ্কের প্রথম নমুনা, একই শুরুর noise থেকে। ছবি ছোট রাখতে প্রতিটি পিক্সেল ১৬টি ধূসর স্তরে (৪ bit) রেখে base64 করে পাতায় বসানো হয়েছে (প্রায় ২১ KB). Classifier-এর সংখ্যাগুলো desktop run থেকে নেওয়া।

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

raw = np.frombuffer(base64.b64decode(open("mnist_cfg.b64").read()), np.uint8)
px = np.stack([raw >> 4, raw & 15], axis=1).reshape(40, 28, 28).astype(int) * 17   # 4 bit → 0..255
ws = [0, 1, 3, 7]
res = pd.DataFrame({"w": ws, "acc": [0.088, 0.721, 0.995, 1.000], "conf": [0.834, 0.909, 0.997, 1.000],
                    "div": [50.0, 43.3, 33.1, 26.9]})       # desktop run: 1,000 samples per w
print(res.to_string(index=False))
print("real test 1000: acc 0.985 | conf 0.984 | div 37.7")
for i, w in enumerate(ws):
    g = px[i * 10:(i + 1) * 10]
    print(f"w={w}: কালির ভাগ {(g > 128).mean():.3f} | গড় উজ্জ্বলতা {g.mean():5.1f}")

fig = plt.figure(figsize=(8, 5.2))
for i in range(40):
    ax = fig.add_subplot(5, 10, i + 1)
    ax.imshow(px[i], cmap="gray", vmin=0, vmax=255); ax.set_xticks([]); ax.set_yticks([])
    if i % 10 == 0: ax.set_ylabel(f"w={ws[i // 10]}", fontsize=8)
ax = fig.add_axes([0.12, 0.05, 0.8, 0.17])
ax.plot(ws, res["acc"], "o-", label="class accuracy")
ax.plot(ws, res["div"] / 50, "s--", label="diversity / 50")
ax.axhline(37.7 / 50, color="gray", lw=0.8, ls=":", label="real test diversity / 50")
ax.set_xlabel("guidance scale w"); ax.legend(fontsize=7, loc="lower right")
fig.suptitle("Latent diffusion on MNIST: same noise, columns = digits 0..9 (seed 123)")
plt.show()

w   acc  conf  div
 0 0.088 0.834 50.0
 1 0.721 0.909 43.3
 3 0.995 0.997 33.1
 7 1.000 1.000 26.9
real test 1000: acc 0.985 | conf 0.984 | div 37.7
w=0: কালির ভাগ 0.159 | গড় উজ্জ্বলতা  40.3
w=1: কালির ভাগ 0.155 | গড় উজ্জ্বলতা  39.5
w=3: কালির ভাগ 0.163 | গড় উজ্জ্বলতা  41.3
w=7: কালির ভাগ 0.176 | গড় উজ্জ্বলতা  44.3

৬ · Sampler আর ধাপের সংখ্যা — এবং negative prompt, img2img, inpainting

একটি train করা diffusion model থেকে নমুনা নেওয়ার পথ একটাই নয়। Model শুধু ε অনুমান করে; x_T থেকে x₀-এ কোন পথে, কত বড় লাফে যাবেন, তা ঠিক করে sampler (diffusers-এ এর নাম scheduler). একই model-এ sampler বদলাতে নতুন training লাগে না। diffusers-এর ডকুমেন্টেশনে (লেখার সময়ে) পরিচিত কয়েকটি:

• DDIM (DDIMScheduler; Song, Meng আর Ermon, ICLR ২০২১): পর্ব ৭৯-এর নির্ধারিত sampler; ধাপের একটি উপ-সেট বেছে লাফ দেয়।
• DPM-Solver (DPMSolverMultistepScheduler; Lu ও সহকর্মীরা, NeurIPS ২০২২, আর পরে DPM-Solver++): diffusion-এর ODE-কে একটি বিশেষ উচ্চ-ক্রমের পদ্ধতিতে সমাধান করে; প্রবন্ধগুলো প্রায় ১০ থেকে ২০ ধাপে ভালো নমুনার দাবি করে।
• Euler (EulerDiscreteScheduler): Karras ও সহকর্মীদের “Elucidating the Design Space of Diffusion-Based Generative Models” (NeurIPS ২০২২)-এর কাঠামো থেকে আসা সরল প্রথম-ক্রমের ODE ধাপ।

ধাপ কমালে সময় প্রায় সমানুপাতে কমে, কারণ প্রতিটি ধাপে U-Net-এর একই খরচ। প্রশ্ন হলো মান কতটা পড়ে। নিজের latent model-এ w = ৩ রেখে DDIM-এর ধাপ বদলে দেখা হলো (একই ১,০০০টি noise, একই classifier; সত্যিকারের run):

~/bazarghar-dl$ uv run python evaluate.py latent steps
w=3.0  steps=10  | class acc 0.994 | conf 0.997 | diversity  31.2 | 0.70 s for 1000 images
w=3.0  steps=25  | class acc 0.995 | conf 0.997 | diversity  32.6 | 1.06 s for 1000 images
w=3.0  steps=50  | class acc 0.995 | conf 0.997 | diversity  33.1 | 2.09 s for 1000 images
w=3.0  steps=100 | class acc 0.995 | conf 0.997 | diversity  33.3 | 4.15 s for 1000 images
peak GPU memory 310 MiB

১০ থেকে ১০০ ধাপে সময় ০.৭০ থেকে ৪.১৫ সেকেন্ড, প্রায় রৈখিক; অথচ class accuracy ০.৯৯৪ থেকে ০.৯৯৫, প্রায় অপরিবর্তিত। Diversity সামান্য বাড়ে (৩১.২ → ৩৩.৩): খুব কম ধাপে ছবিগুলো একটু বেশি মসৃণ আর একরকম। এই সহজ ডেটায় ১০ ধাপই যথেষ্ট; বড় রঙিন ছবিতে তা নয় (অংশ ৭)। ধাপ আর sampler নিজের মাপকাঠিতে মাপুন।

একই কাঠামোয় আরও কয়েকটি পরিচিত কৌশল আসে, সবই sampling-এর পথ বদলে, model বদলে নয়:

• Negative prompt: CFG-এর শর্তহীন শাখার খালি prompt-এর বদলে একটি অবাঞ্ছিত বর্ণনা (যেমন “blurry, watermark”) বসানো; নমুনা সেদিক থেকে দূরে ঠেলা খায়। বিস্তারিত ভাবনার প্রশ্ন ৩-এ।
• img2img: শুদ্ধ noise থেকে নয়, একটি বিদ্যমান ছবির latent-এ কিছুটা noise যোগ করে মাঝের একটি ধাপ থেকে denoise শুরু করা (SDEdit, Meng ও সহকর্মীরা, ICLR ২০২২-এর ধারণা)। diffusers-এ strength ঠিক করে কতটা noise: কম হলে মূল ছবি বেশি টিকে থাকে।
• Inpainting: একটি mask দেওয়া অংশ নতুন করে বানানো, বাকিটা রেখে। বিশেষ inpainting checkpoint mask আর ঢাকা ছবির latent বাড়তি input হিসেবে নেয়।
• LoRA: পর্ব ৫৫-এর LoRA diffusion-এর U-Net-এর attention layer-এ বসিয়ে কয়েকটি ছবি থেকে নতুন ধরন বা বস্তু শেখানো যায়; diffusers-এর pipeline-এ load_lora_weights আছে।

৭ · Stable Diffusion-এর ভেতরে — একটি সত্যিকারের text-to-image call

এবার একটি আসল, বড় latent diffusion model. বেছে নেওয়া হয়েছে Hugging Face-এর stable-diffusion-v1-5/stable-diffusion-v1-5 (revision 451f4fe), কারণ লেখার সময়ে (নভেম্বর ২০২৬; পরিবর্তন হতে পারে) এটি token ছাড়া ডাউনলোড করা যায় (gated নয়), তার লাইসেন্স CreativeML OpenRAIL-M (ব্যবহারের নিষেধাজ্ঞাসহ একটি খোলা লাইসেন্স), আর fp16 রূপে তিনটি অংশ মিলে প্রায় ২.১ GB: U-Net ১.৭২ GB, text encoder ২৪৬ MB, VAE ১৬৭ MB. Model card জানায়: এটি একটি latent diffusion model, text encoder স্থির CLIP ViT-L/14, autoencoder-এর f = ৮ আর latent-এ ৪ channel, LAION-এর ইংরেজি ক্যাপশনের ছবিতে train করা, আর ৫১২ × ৫১২ মাপে চূড়ান্ত প্রশিক্ষণ। Card একে “intended for research purposes only” বলে। তাই prompt শুধু বাজারঘরের তিনটি সাধারণ পণ্যের: একটি লাল সিরামিক মগ, একটি পাটের ব্যাগ আর এক জোড়া চামড়ার স্যান্ডেল; কোনো মানুষ, লোগো বা ব্র্যান্ড নয়। ডাউনলোড ছোট রাখতে safety checker নামানো হয়নি; তার বদলে প্রতিটি ছবি চোখে দেখে যাচাই করা হয়েছে।

প্রথমে একটি call হাতে ভাঙা হলো: tokenizer, text encoder, U-Net-এর প্রথম cross-attention layer-এ একটি hook দিয়ে query আর key-এর আকার, sampler, আর decoder. সত্যিকারের run (ডেস্কটপ, GPU-তে, fp16; progress bar আর library-র সতর্কবার্তা বাদ দিয়ে):

~/bazarghar-dl$ uv run python sd_run.py
torch 2.15.0+cu132 | diffusers 0.42.1 | transformers 5.22.2
params: unet 859.5M | text_encoder 123.1M | vae 83.7M
vae scaling_factor 0.18215 | latent_channels 4 | unet sample_size 64 | cross_attention_dim 768
default scheduler: PNDMScheduler
[1] tokenizer: input_ids (1, 77) | real tokens incl. start/end 13 | first ids [49406, 320, 736, 15112, 9722, 525, 320, 9057, 2175, 267, 4306, 1125, 49407]
    tokens: ['<|startoftext|>', 'a</w>', 'red</w>', 'ceramic</w>', 'mug</w>', 'on</w>', 'a</w>', 'wooden</w>', 'table</w>', ',</w>', 'product</w>', 'photo</w>', '<|endoftext|>']
[2] text encoder: last_hidden_state (1, 77, 768) torch.float16
[3] cross-attention (first down block): query in (2, 4096, 320) -> (2, 4096, 320) | key in (2, 77, 768) -> (2, 77, 320)
[4] sampler: 30 steps x 2 (CFG batch) U-Net calls -> latents (1, 4, 64, 64) | 3.91 s
[5] VAE decoder: (1, 4, 64, 64) -> image (1, 3, 512, 512) | 0.15 s
    peak GPU memory 2667 MiB

এরপর একই seed (৭) রেখে guidance scale আর sampler বদলানো হলো (একই run-এর বাকি অংশ, সংক্ষেপিত: peak মেমরির কলাম এক লাইনে আনা; prompt 0 মগ, 1 পাটের ব্যাগ, 2 স্যান্ডেল, আর শেষ সারিতে স্যান্ডেলের সঙ্গে negative prompt):

… (warm-up call omitted)
prompt 0 | pndm  | steps  30 | guidance  1.0 |  2.32 s | p0_pndm_s30_g1.0
prompt 0 | pndm  | steps  30 | guidance  3.0 |  3.93 s | p0_pndm_s30_g3.0
prompt 0 | pndm  | steps  30 | guidance  7.5 |  3.91 s | p0_pndm_s30_g7.5
prompt 0 | pndm  | steps  30 | guidance 12.0 |  3.91 s | p0_pndm_s30_g12.0
prompt 0 | ddim  | steps  10 | guidance  7.5 |  1.38 s | p0_ddim_s10_g7.5
prompt 0 | ddim  | steps  25 | guidance  7.5 |  3.20 s | p0_ddim_s25_g7.5
prompt 0 | ddim  | steps  50 | guidance  7.5 |  6.27 s | p0_ddim_s50_g7.5
prompt 0 | dpm   | steps  10 | guidance  7.5 |  1.39 s | p0_dpm_s10_g7.5
prompt 0 | dpm   | steps  25 | guidance  7.5 |  3.19 s | p0_dpm_s25_g7.5
prompt 0 | dpm   | steps  50 | guidance  7.5 |  6.25 s | p0_dpm_s50_g7.5
prompt 0 | euler | steps  10 | guidance  7.5 |  1.37 s | p0_euler_s10_g7.5
prompt 0 | euler | steps  25 | guidance  7.5 |  3.21 s | p0_euler_s25_g7.5
prompt 0 | euler | steps  50 | guidance  7.5 |  6.23 s | p0_euler_s50_g7.5
prompt 1 | dpm   | steps  25 | guidance  7.5 |  3.19 s | p1_dpm_s25_g7.5
prompt 2 | dpm   | steps  25 | guidance  7.5 |  3.19 s | p2_dpm_s25_g7.5
prompt 2 | dpm   | steps  25 | guidance  7.5 |  3.19 s | p2_dpm_neg
(every run: peak 2669 MiB)

একটি seed, একটি run; সাধারণ নিয়ম নয়। সময়: guidance ১.০-এ ৩০ ধাপ ২.৩২ সেকেন্ড, কিন্তু ৩, ৭.৫ বা ১২-এ প্রায় ৩.৯ সেকেন্ড: কারণ guidance_scale ১-এর বেশি হলেই শর্তহীন শাখা চলে। তিন sampler-এর সময় শুধু ধাপের সংখ্যায় বাঁধা। Guidance-এর ছবি: w = ১-এ কোনো লাল মগ নেই: ওপর থেকে দেখা মাটির ওপর একটি হালকা রঙের কাপ, ভেতরে লাল কিছু, চারপাশে সবুজ পাতা; prompt-এর সঙ্গে মিল আলগা। w = ৩-এ কাঠের টেবিলে একটি লাল মগ, রং একটু নরম। w = ৭.৫-এ চকচকে উজ্জ্বল লাল মগ, কাঠের দানা স্পষ্ট। w = ১২-এ লাল আরও গাঢ় আর পটভূমি প্রায় সমতল গাঢ় বাদামি, কাঠের দানা প্রায় হারিয়ে গেছে: অতি-সম্পৃক্ত ছবির শুরু। Sampler: ১০ ধাপে DDIM-এর মগ কাত হয়ে ফ্রেমের বাইরে আংশিক কাটা আর ঝাপসা, Euler-এর পটভূমি ঝাপসা, কিন্তু DPM-Solver ১০ ধাপেই ২৫ বা ৫০ ধাপের প্রায় একই রকম পরিষ্কার মগ দিয়েছে; পাটের ব্যাগ আর স্যান্ডেলের ছবি বিশ্বাসযোগ্য। স্যান্ডেলে “blurry, text, watermark” negative prompt যোগ করলে একই seed-এ স্যান্ডেলের নকশা আর রাখার ভঙ্গি বদলে গেছে, যদিও আগের ছবিতে লেখা বা watermark ছিল না। CLIP score মাপা হয়নি (আরেকটি বড় model নামাতে হতো); সেটি পর্ব ৮১-এর বিষয়।

নিচের ব্লক এই run-এর পাঁচটি ছবির খুব ছোট রূপ (২৮ × ২৮ পিক্সেল, প্রতিটি রং ৪ bit) আঁকে, আর সময়ের টেবিল থেকে ধাপপ্রতি সময় হিসাব করে। এত ছোট ছবিতে বিশদ দেখা যায় না, শুধু রং আর গঠনের মোটা ধারণা।

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

raw = np.frombuffer(base64.b64decode(open("sd_thumbs.b64").read()), np.uint8)
px = np.stack([raw >> 4, raw & 15], axis=1).reshape(5, 28, 28, 3).astype(int) * 17
names = ["mug w=1", "mug w=3", "mug w=7.5", "mug w=12", "jute bag w=7.5"]
for n, im in zip(names, px):
    sat = (im.max(axis=2) - im.min(axis=2)).mean()        # রঙের তীব্রতা
    rgb = im.mean(axis=(0, 1)).round().astype(int)
    print(f"{n:15s}: গড় RGB {rgb} | saturation {sat:5.1f}")

# desktop GPU run: 512x512, guidance 7.5, seconds per image
t = pd.DataFrame({"sampler": ["ddim"] * 3 + ["dpm"] * 3 + ["euler"] * 3,
                  "steps": [10, 25, 50] * 3,
                  "sec": [1.38, 3.20, 6.27, 1.39, 3.19, 6.25, 1.37, 3.21, 6.23]})
t["ms/step"] = (t["sec"] / t["steps"] * 1000).round(0)
print(t.pivot(index="steps", columns="sampler", values="sec"))
print("গড় ms/ধাপ:", t.groupby("sampler")["ms/step"].mean().round(0).to_dict())

fig = plt.figure(figsize=(8, 4.2))
for i in range(5):
    ax = fig.add_subplot(2, 5, i + 1); ax.imshow(px[i].astype(np.uint8))
    ax.set_title(names[i], fontsize=8); ax.axis("off")
ax = fig.add_subplot(2, 1, 2)
for s, g in t.groupby("sampler"):
    ax.plot(g["steps"], g["sec"], "o-", label=s)
ax.set_xlabel("sampling steps"); ax.set_ylabel("seconds per image"); ax.legend(fontsize=8)
fig.suptitle("Stable Diffusion v1.5, real run (seed 7), 28x28 thumbnails")
plt.show()

mug w=1        : গড় RGB [107 113 103] | saturation  15.8
mug w=3        : গড় RGB [119 101 101] | saturation  27.6
mug w=7.5      : গড় RGB [121  91  93] | saturation  31.7
mug w=12       : গড় RGB [129  90  86] | saturation  44.6
jute bag w=7.5 : গড় RGB [153 143 133] | saturation  22.5
sampler  ddim   dpm  euler
steps                     
10       1.38  1.39   1.37
25       3.20  3.19   3.21
50       6.27  6.25   6.23
গড় ms/ধাপ: {'ddim': 130.0, 'dpm': 131.0, 'euler': 130.0}

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

“diffusers দিয়ে একটি text-to-image script লিখে দাও” বললে AI assistant কয়েক সেকেন্ডে কোড দেয়। এই ক্ষেত্রের ভুলগুলো প্রায় সবই চুপচাপ: ছবি আসে, কিন্তু রং ভুল, guidance উল্টো, বা লাইসেন্স না পড়েই model ব্যবহার। নিচের জায়গাগুলো আলাদা করে দেখুন।

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

• নিজের installed version-এর ডকুমেন্টেশনে প্রতিটি argument আর scheduler-এর নাম মিলিয়েছি
• একটি ছোট call-এ প্রতিটি ধাপের shape ছাপিয়েছি, আর decode-এর আগে scaling factor দিয়ে ভাগ আছে
• CFG-এর কোডে w = ০ আর w = ১-এ ফল শর্তহীন আর শর্তসহ অনুমানের সঙ্গে মেলে, পরীক্ষা করেছি
• Sampling torch.no_grad() আর eval()-এ চলে; একই seed-এ দুবার চালিয়ে একই ফল পেয়েছি
• Guidance আর ধাপের সংখ্যা কয়েকটি seed-এ আর একটি বাইরের মাপকাঠিতে মেপেছি, একটি ছবি দেখে নয়
• Model card আর লাইসেন্স নিজে পড়েছি; কোনো token, ব্যক্তিগত ছবি বা মানুষের মুখ ব্যবহার করিনি, আর AI-তৈরি ছবি সেভাবেই চিহ্নিত করেছি