লিখিত ও মৌখিক (ভাইভা) প্রশ্ন — Deep Learning, NLP আর Generative AI

চিহ্ন: X (B × d), Z₁ = XW₁ + b₁ (B × h), H = f(Z₁), Z₂ = HW₂ + b₂ (B × k), P = softmax(Z₂) সারি ধরে, Y one-hot, L = −(১/B)∑ log P_i,yi.

শেষ স্তর: একটি সারিতে L = −∑_cy_c log p_c আর ∂p_c/∂z_j = p_c(δ_cj − p_j). তাই ∂L/∂z_j = −∑_cy_c(δ_cj − p_j) = p_j∑y_c − y_j = p_j − y_j, কারণ ∑y_c = ১. গড়ের জন্য δ₂ = (P − Y)/B.

dW₂ = Hᵀδ₂, db₂ = ∑_সারিδ₂, δ₁ = (δ₂W₂ᵀ) ⊙ f′(Z₁), dW₁ = Xᵀδ₁

প্রতিটি সূত্র chain rule-এর matrix রূপ: Z₂ = HW₂-এ W₂-এর gradient আসে বাঁ দিকের H-এর transpose দিয়ে, আর H-এর gradient ডান দিকের W₂-এর transpose দিয়ে। Shape মিলিয়ে নিন: Hᵀδ₂ হলো (h × B)(B × k) = h × k, ঠিক W₂-এর shape. B-এর মাত্রা গুণের ভেতরেই যোগ হয়ে যায়। tanh-এ f′ = ১ − H², ReLU-তে Z₁ > ০-এর দরজা।

import numpy as np

rng = np.random.default_rng(89)
B, d, h, k = 4, 3, 5, 3
X, y = rng.normal(size=(B, d)), np.array([0, 2, 1, 2])
P = {"W1": rng.normal(0, 0.5, (d, h)), "b1": np.zeros(h),
     "W2": rng.normal(0, 0.5, (h, k)), "b2": np.zeros(k)}

def loss(P, back=False):
    H = np.tanh(X @ P["W1"] + P["b1"])               # (B, h)
    Z = H @ P["W2"] + P["b2"]                        # (B, k) logits
    E = np.exp(Z - Z.max(1, keepdims=True))          # stable softmax
    p = E / E.sum(1, keepdims=True)
    if not back:
        return -np.log(p[np.arange(B), y]).mean()
    D2 = p.copy(); D2[np.arange(B), y] -= 1; D2 /= B  # dL/dZ = (p - y)/B
    D1 = (D2 @ P["W2"].T) * (1 - H**2)               # tanh' = 1 - h^2
    return {"W1": X.T @ D1, "b1": D1.sum(0), "W2": H.T @ D2, "b2": D2.sum(0)}

G, eps, fwd = loss(P, back=True), 1e-6, 0
for name, W in P.items():
    num = np.zeros_like(W)
    for i in np.ndindex(W.shape):
        old = W[i]
        W[i] = old + eps; up = loss(P)
        W[i] = old - eps; dn = loss(P)
        W[i] = old; num[i] = (up - dn) / (2 * eps); fwd += 2
    rel = np.linalg.norm(G[name] - num) / (np.linalg.norm(G[name]) + np.linalg.norm(num))
    print(f"{name}: shape {W.shape}, grad {G[name].shape}, rel error {rel:.1e}")
print("finite differences:", fwd, "forward passes | backprop: 1 forward + 1 backward")

W1: shape (3, 5), grad (3, 5), rel error 1.8e-10
b1: shape (5,), grad (5,), rel error 6.1e-10
W2: shape (5, 3), grad (5, 3), rel error 6.1e-10
b2: shape (3,), grad (3,), rel error 4.5e-10
finite differences: 76 forward passes | backprop: 1 forward + 1 backward

খরচ আর সীমা: পর্ব ৪-এর মাপে backward-এর FLOP forward-এর ১.৮১ গুণ (ব্রাউজারে সময়ে ১.৯৭ গুণ), আর B = ২৫৬-এ জমা রাখা activation ১,০৪৪ KB, parameter-এর ১৭২ KB-এর প্রায় ছয় গুণ: backprop-এর আসল দাম memory. সেখানেই দুটি ইচ্ছাকৃত বাগ দেখা গিয়েছিল: ÷B ভুললে loss একই থাকে কিন্তু সব relative error ০.৯৭; তাই loss দেখে backward-এর ভুল ধরা যায় না, gradient check লাগে। সূত্র ঠিক হলেও গভীর network-এ gradient মিলিয়ে যেতে পারে (ক-০২)। Neural network-এ backprop জনপ্রিয় হয় ১৯৮৬ সালে (Rumelhart, Hinton, Williams).

পরীক্ষক যা খোঁজেন: shape-সহ চিহ্ন (১); p − y-এর derivation (২); তিনটি recursion-সূত্র (৩); যাচাই (২); খরচ ও সীমা (২)। পর্ব ৪ · পর্ব ৫ · পর্ব ১৩

যেখানে নম্বর কাটে: transpose ভুল দিকে; ÷B বাদ; f′ ভুল স্তরে; backprop আর gradient descent-কে এক বলা (একটি gradient হিসাব করে, অন্যটি ধাপ নেয়)।

কারণ: h_l = f(W_lh_l−1) হলে ∂h_l/∂h_l−1 = J_l = diag(f′)W_l, আর chain rule-এ ∂L/∂h_০ = J₁ᵀJ₂ᵀ⋯J_Lᵀ ∂L/∂h_L. গুণফলের norm ≤ ∏‖J_l‖. প্রতিটি গুণক গড়ে ১-এর নিচে হলে সূচকীয় ক্ষয় (vanishing), ওপরে হলে সূচকীয় বৃদ্ধি (exploding). Sigmoid-এ f′ ≤ ০.২৫, তাই ক্ষয় প্রায় নিশ্চিত। RNN-এ একই W প্রতি ধাপে গুণ হয়, তাই সমস্যাটি সময়ের দৈর্ঘ্যে আরও তীব্র (BPTT).

মাপা প্রমাণ: পর্ব ১৭-এ ৩০ স্তরের sigmoid network-এ প্রথম স্তরের gradient ছিল ১০⁻¹⁷, শেষ স্তরে ১৫; ReLU-তে He init (variance ২/n) দিলে সব স্তরে প্রায় সমান, আর He-এর দেড় গুণ weight-এ ৩০ স্তরে প্রায় ৩৭,০০০ গুণ বৃদ্ধি। একই ReLU, শুধু weight-এর মাপ বদলে তিন ভিন্ন ভাগ্য। পর্ব ২৮-এ tanh RNN-এ (ρ = ০.৮) ৫৯ ধাপে gradient ১.৬ × ১০⁻¹¹.

নির্ণয় আগে: প্রতিটি স্তরের gradient norm log-scale-এ আঁকুন (পর্ব ১৮); warmup বা ছোট lr শুধু উপসর্গ সামলায়।

পরীক্ষক যা খোঁজেন: Jacobian-এর গুণফল আর norm-এর সীমা (৩); sigmoid′ ≤ ০.২৫ বা RNN-এ একই W (১); পাঁচটি প্রতিকার, কারণসহ (৫); নির্ণয়ের পথ (১)। পর্ব ১৭ · পর্ব ১৪ · পর্ব ২৯

যেখানে নম্বর কাটে: clipping-কে vanishing-এর প্রতিকার বলা; “ReLU-তে vanishing হয় না” (ভুল init-এ পর্ব ১৭-এ প্রায় ৩১,০০০ গুণ ক্ষয়)।

যুক্তি: h_l = h_l−1 + F(h_l−1) হলে ∂h_l/∂h_l−1 = I + J_F. গুণফল ∏(I + J_l) খুললে I + ∑J_l + … আসে, অর্থাৎ শেষ থেকে প্রথম স্তরে gradient-এর একটি সরাসরি identity পথ থাকে, যা ছোট J-এর গুণে মরে না। Block-কে শুধু পরিবর্তনটুকু শিখতে হয়; F = ০ হলেই identity. He ও সহলেখকেরা (২০১৫) দেখিয়েছিলেন, plain network-এ গভীরতা বাড়ালে training ভুলও বাড়ে (degradation problem), residual-এ তা হয় না।

import numpy as np

rng = np.random.default_rng(89)
n, L = 16, 30
Ws = [rng.normal(0, 1 / np.sqrt(n), (n, n)) for _ in range(L)]
h0, sig = rng.normal(size=n), lambda z: 1 / (1 + np.exp(-z))

def backward_norms(act, residual):
    h, Js = h0.copy(), []
    for W in Ws:
        z = W @ h
        a = sig(z) if act == "sigmoid" else np.tanh(z)
        J = (a * (1 - a) if act == "sigmoid" else 1 - a**2)[:, None] * W
        Js.append(np.eye(n) + J if residual else J)
        h = h + a if residual else a
    g, out = np.ones(n) / np.sqrt(n), {}          # dL/dh_30, norm 1
    for l in range(L, 0, -1):
        out[l] = np.linalg.norm(g)
        g = Js[l - 1].T @ g                       # chain rule, one layer back
    out[0] = np.linalg.norm(g)
    return out, Js[0]

print("model               h30      h20      h10      h0 (input)")
for act, res in [("sigmoid", False), ("tanh", False), ("sigmoid", True)]:
    o, J0 = backward_norms(act, res)
    name = f"{act} {'residual' if res else 'plain'}"
    print(f"{name:17s} " + "  ".join(f"{o[l]:.1e}" for l in (30, 20, 10, 0)))
sJ, sR = (np.linalg.svd(M, compute_uv=False) for M in (J0 - np.eye(n), J0))
print(f"one sigmoid block: J singular values {sJ.max():.3f} .. {sJ.min():.4f}")
print(f"with skip, I + J : singular values {sR.max():.3f} .. {sR.min():.3f}")

model               h30      h20      h10      h0 (input)
sigmoid plain     1.0e+00  4.2e-07  2.0e-13  1.5e-19
tanh plain        1.0e+00  5.2e-01  2.2e-01  8.8e-02
sigmoid residual  1.0e+00  1.1e+00  1.1e+00  1.1e+00
one sigmoid block: J singular values 0.328 .. 0.0106
with skip, I + J : singular values 1.305 .. 0.778

সীমা: Residual forward-এর মাপ নিয়ন্ত্রণ করে না। পর্ব ১৭-এ ReLU residual-এ প্রথম স্তরের gradient প্রায় ৮ লাখে আর ‖h_৩০‖ প্রায় ৩৭ লাখে উঠেছিল; তাই normalization (Transformer-এ pre-norm) বা ছোট init লাগে। Shape বদলালে 1×1 projection shortcut (পর্ব ২২)।

পরীক্ষক যা খোঁজেন: I + J আর সরাসরি পথ (২); শুধু পরিবর্তন শেখা বা degradation (১); প্রমাণ (১); সীমা (১)। পর্ব ১৭ · পর্ব ২২ · পর্ব ৩৫

যেখানে নম্বর কাটে: “residual overfitting কমায়” লেখা; “gradient সবসময় ১” দাবি; normalization-এর প্রয়োজন বাদ।

Inductive bias: ডেটা দেখার আগেই model-এর ধরে নেওয়া অনুমান। CNN দুটি জোরালো অনুমান করে: locality (ছোট kernel পাশের pixel দেখে) আর weight sharing (একই filter সব জায়গায়), যার ফল translation equivariance. ViT ছবিকে patch-এর sequence ধরে, প্রথম স্তর থেকেই সব patch সব patch-কে দেখে; জ্যামিতির খবর আসে শুধু position embedding থেকে।

মাপা প্রমাণ (পর্ব ৩৮, Fashion-MNIST, প্রায় সমান parameter, ৩ seed): ১,০০০টি ছবিতে CNN ৮৩.২%, ViT ৭৪.৫%; পুরো ৬০,০০০-এ ফারাক কমে ২.৮ পয়েন্ট। ২ pixel সরানো test-এ ViT ৬৩.৯%, CNN ৮৫.৫%. আর position ছাড়া patch এলোমেলো করলে ViT-এর output কার্যত বদলায় না (পার্থক্য ১০⁻¹⁵): তার কাছে ছবি patch-এর থলে।

সিদ্ধান্ত: অল্প ডেটায় CNN, কারণ অনুমানগুলো ডেটার কাজ আগেই করে দেয় (data hunger). মূল প্রবন্ধের (Dosovitskiy ও সহলেখক, ২০২০) দাবি, বড় ডেটায় pretrain করলে ViT CNN-এর সমান বা ভালো। Attention-এর খরচ token-এ দ্বিঘাত: ছবি ২২৪ থেকে ৩৮৪ হলে জোড়া ৮.৬ গুণ।

পরীক্ষক যা খোঁজেন: দুই bias-এর নাম আর ফল (২); ViT-এ জ্যামিতি কোথা থেকে (১); অল্প বনাম বেশি ডেটার যুক্তি, প্রমাণসহ (২)। পর্ব ৩৮ · পর্ব ২০

যেখানে নম্বর কাটে: “ViT সবসময় ভালো” লেখা; convolution-কে invariant বলা (সে equivariant; pooling আংশিক invariance দেয়)।

দীর্ঘ নির্ভরতা, মাপা: পর্ব ২৯-এ ১০০ ধাপ পেছনের gradient সাধারণ tanh RNN-এ ২.১ × ১০⁻⁶, forget-gate bias ১ দেওয়া LSTM-এ ২.৬ × ১০⁻³, প্রায় হাজার গুণ বেশি; কিন্তু bias ০ দিলে LSTM RNN-এর চেয়েও খারাপ। অর্থাৎ gate সাহায্য করে, তবু পথ লম্বাই থাকে। Transformer-এ পথ এক ধাপ; দামটি দ্বিঘাত খরচ (খ-০৩)। সমান্তরালতার জন্য একই GPU সময়ে Transformer অনেক বেশি token দেখে, যা বড় pretraining-এর প্রধান সুবিধা (Vaswani ও সহলেখক, ২০১৭)।

কখন RNN-ধাঁচ: ছোট ডিভাইসে streaming (প্রতি token-এ স্থির memory), ছোট time series আর অল্প ডেটা; 1D convolution-ও শক্ত বিকল্প (পর্ব ৩১)। নতুন recurrent স্থাপত্যের দাবি নিজের কাজে যাচাই করে নেওয়া ভালো।

পরীক্ষক যা খোঁজেন: অন্তত পাঁচ সারির ছক (৫); দীর্ঘ নির্ভরতার কারণ, gradient-এর ভাষায় (২); প্রমাণ (১); কখন কোনটি (২)। পর্ব ২৮ · পর্ব ২৯ · পর্ব ৩৫ · পর্ব ৩৭

যেখানে নম্বর কাটে: “LSTM vanishing পুরো সারায়”; Transformer-এর inference-কেও পুরো সমান্তরাল বলা (decoding এক token করে); positional encoding বাদ।

খরচ: S = QKᵀ/√d_k হলো T × T; তাই সময় O(T²·d), আর সোজা পথে প্রতি head-এ T² score-এর memory. Projection-এর O(T·d²) আলাদা। Decoding-এ প্রতি নতুন token-এর জন্য আগের সব K, V আবার হিসাব করলে মোট কাজ প্রায় T³-এর মতো বাড়ে।

import numpy as np

d, W = 64, 256                       # head size, sliding-window width
print("T      full scores   window scores   fp16 T*T per head")
for T in (512, 2048, 8192, 32768):
    full, win = T * T, T * W - W * (W - 1) // 2
    print(f"{T:<6} {full:>12,}  {win:>13,}   {full * 2 / 2**20:>9.1f} MiB")

# decoding T new tokens: recompute all keys every step vs reuse a KV cache
for T in (100, 200):
    no_cache = sum(t * t * d for t in range(1, T + 1))   # t queries x t keys
    cache = sum(t * d for t in range(1, T + 1))          # 1 query x t keys
    print(f"decode {T}: no cache {no_cache:,} | cache {cache:,} | ratio {no_cache / cache:.0f}")

# online softmax (the FlashAttention idea): same answer, tile by tile
rng = np.random.default_rng(89)
q, K, V = rng.normal(size=d), rng.normal(size=(1000, d)), rng.normal(size=(1000, 4))
s = K @ q / np.sqrt(d)
full = np.exp(s - s.max()) @ V / np.exp(s - s.max()).sum()
m, z, acc = -np.inf, 0.0, np.zeros(4)
for i in range(0, 1000, 128):                        # one tile at a time
    st = s[i:i + 128]
    m_new = max(m, st.max())
    z = z * np.exp(m - m_new) + np.exp(st - m_new).sum()
    acc = acc * np.exp(m - m_new) + np.exp(st - m_new) @ V[i:i + 128]
    m = m_new
print("max |full - online| =", f"{np.abs(full - acc / z).max():.1e}")

T      full scores   window scores   fp16 T*T per head
512         262,144         98,432         0.5 MiB
2048      4,194,304        491,648         8.0 MiB
8192     67,108,864      2,064,512       128.0 MiB
32768  1,073,741,824      8,355,968      2048.0 MiB
decode 100: no cache 21,654,400 | cache 323,200 | ratio 67
decode 200: no cache 171,948,800 | cache 1,286,400 | ratio 134
max |full - online| = 4.2e-17

মাপা প্রমাণ (পর্ব ৩৭): ৩২ স্তর, d = ৪,০৯৬-এর একটি model-এ একজন ব্যবহারকারীর KV cache ৮,১৯২ token-এ ৪ GiB, ১,২৮,০০০ token-এ ৬২.৫ GiB, আর ৮টি KV head-এর GQA-তে ১৫.৬ GiB. পর্ব ৫২-এ CPU-তে ২৫০ token-এর prompt-এ ৬০টি নতুন token: cache-সহ ৪.৯৮ সেকেন্ড, ছাড়া ৫০.১৫.

পরীক্ষক যা খোঁজেন: O(T²d) আর T² memory (২); চারটি কৌশল, কী কমায় (৪); exact বনাম ফল-বদলানো আলাদা করা (২); সংখ্যা বা উদাহরণ (২)। পর্ব ৩৩ · পর্ব ৩৭ · পর্ব ৮৩

যেখানে নম্বর কাটে: FlashAttention-কে “approximate” বা “FLOP কমায়” বলা; KV cache-কে training-এর কৌশল বলা; GQA আর multi-head-কে একই memory-র ধরা।

মাপা খুঁটিনাটি (পর্ব ৪৭): BERT-এর ৮০/১০/১০ নিয়মে বাছা অবস্থানের ৮০% [MASK], ১০% এলোমেলো, ১০% অপরিবর্তিত। T5-এর হিসাবে ৫০০ token-এ ৭৫টি নষ্ট, ২৫টি টুকরো; input ৪৫০, target ১০১: target ছোট বলে training সস্তা।

পরীক্ষক যা খোঁজেন: তিনটি লক্ষ্য (২); loss-এর অবস্থান আর তার দক্ষতা (১); স্থাপত্য ও কাজ (২)। পর্ব ৪৭ · পর্ব ৪৮ · পর্ব ৪৯

যেখানে নম্বর কাটে: “BERT দিয়ে সাবলীল লেখা বানানো যায়” লেখা; causal model-এ ভবিষ্যৎ দেখার mask ভুলে যাওয়া।

মাপা প্রমাণ: পর্ব ৫৫-এ Qwen2.5-0.5B-এর full fine-tuning-এ (fp32, AdamW) শুধু weight, gradient আর optimizer state-এ ৭.৯০ GB, যার অর্ধেক Adam-এর m আর v; q, v-তে r = ৮-এর LoRA শেখে ৫,৪০,৬৭২টি parameter, মোটের ০.১১%. বাংলা রিভিউ শ্রেণিবিভাগে (bangla-bert-base): full test macro-F1 ০.৯৪২৫, LoRA r = ৮ ০.৯৩৩২, peak memory ৩,৯৬৯ থেকে ১,৭৬৭ MiB; adapter ১.১৪ MiB বনাম পুরো model ৬২৭.২ MiB. কিন্তু একই split-এ TF-IDF + logistic regression পেয়েছিল ০.৯৪১২. পর্ব ৫২-এ system বার্তায় তথ্য দিতেই বানানো উত্তর ঠিক হয়েছিল।

সিদ্ধান্ত: নীতির প্রশ্নে RAG (নীতি বদলায়, উৎস দেখাতে হয়), সাথে system prompt আর উত্তর না পেলে “জানি না”। অভিযোগের শ্রেণিতে আগে সস্তা baseline, তারপর দরকার হলে LoRA; full FT শুধু মাপা ফাঁক গুরুত্বপূর্ণ হলে। পর্ব ৮৬-এ ঠিক এই ভাগ, আর সেখানেও router-এ TF-IDF (০.৮৩৩) BERT-এর (০.৮১৬) চেয়ে পিছিয়ে ছিল না।

পরীক্ষক যা খোঁজেন: চার পথের ছক (৪); জ্ঞান বনাম আচরণ আলাদা করা (২); baseline আর মাপা প্রমাণ (২); কাজভেদে সিদ্ধান্ত (২)। পর্ব ৫৫ · পর্ব ৬৯ · পর্ব ৮৫

যেখানে নম্বর কাটে: “fine-tune করলে model নতুন নীতি জানবে” লেখা; baseline ছাড়া সিদ্ধান্ত; LoRA-কে “memory প্রায় শূন্য” বলা (frozen base আর activation থেকেই যায়)।

RLHF: (১) SFT: নির্দেশ-উত্তরের ডেটায় fine-tune. (২) Reward model: একই প্রশ্নের দুটি উত্তরের কোনটি মানুষ বেছেছেন, Bradley–Terry loss −log σ(r_w − r_l) দিয়ে শেখা। (৩) PPO দিয়ে policy-কে reward বাড়াতে শেখানো, reference model থেকে বেশি না সরতে KL শাস্তিসহ: max E[r(x, y)] − β·KL(π ‖ π_ref). এই ধারা জনপ্রিয় হয় InstructGPT-এর (Ouyang ও সহলেখক, ২০২২) পরে।

DPO-র derivation: এই লক্ষ্যের সর্বোত্তম সমাধান π*(y ∣ x) = π_ref(y ∣ x)·exp(r(x, y)/β)/Z(x). উল্টে লিখলে r = β log(π*/π_ref) + β log Z(x). Bradley–Terry-তে শুধু r_w − r_l লাগে, তাই Z(x) কেটে যায়:

L_DPO = −log σ(β[(log π(y_w) − log π_ref(y_w)) − (log π(y_l) − log π_ref(y_l))])

Reward model আর RL-এর লুপ লাগে না; policy নিজেই একটি implicit reward (Rafailov ও সহলেখক, ২০২৩)।

import numpy as np

sig = lambda x: 1 / (1 + np.exp(-x))
# summed log-probabilities of chosen (w) and rejected (l) answers, 4 pairs
pi_w  = np.array([-11.0, -16.0, -9.5, -20.0])   # policy being trained
pi_l  = np.array([-14.0, -13.0, -12.0, -21.0])
ref_w = np.array([-12.0, -14.5, -10.0, -20.0])  # frozen reference (SFT)
ref_l = np.array([-13.0, -13.5, -11.0, -20.5])

def dpo(beta, pw=pi_w, pl=pi_l):
    h = (pw - ref_w) - (pl - ref_l)              # log-ratio margin
    return h, -np.log(sig(beta * h)).mean(), sig(-beta * h)

for beta in (0.1, 0.5):
    h, L, wt = dpo(beta)
    print(f"beta={beta}: h={h} loss={L:.4f} push={wt.round(3)}")
print("policy = reference:", round(dpo(0.1, ref_w, ref_l)[1], 4),
      "| ln 2 =", round(np.log(2), 4))

beta = 0.1                                       # DPO = Bradley-Terry on
r_w, r_l = beta * (pi_w - ref_w), beta * (pi_l - ref_l)   # implicit rewards
print("BT on implicit rewards:", round(-np.log(sig(r_w - r_l)).mean(), 4))

# chosen gets LESS likely (-2 nats) but rejected drops more (-8 nats)
h2, L2, _ = dpo(beta, pi_w - 2, pi_l - 8)
print(f"chosen -2, rejected -8: loss {dpo(beta)[1]:.4f} -> {L2:.4f}")

beta=0.1: h=[ 2.  -2.   1.5  0.5] loss=0.6714 push=[0.45  0.55  0.463 0.488]
beta=0.5: h=[ 2.  -2.   1.5  0.5] loss=0.6473 push=[0.269 0.731 0.321 0.438]
policy = reference: 0.6931 | ln 2 = 0.6931
BT on implicit rewards: 0.6714
chosen -2, rejected -8: loss 0.6714 -> 0.4228

কেন accuracy যথেষ্ট নয়, মাপা (পর্ব ৫৭): ছোট reward model আলাদা test-এ ১০০% ঠিক, অথচ উত্তরে ভুল সংখ্যা বসালে ১১% থেকে ৩৬% ক্ষেত্রে ভুলটিকে সমান বা বেশি score দিয়েছে: সে তথ্য নয়, বাক্যের ছাঁচ শিখেছিল। সত্যিকারের DPO run-এ implicit reward accuracy ১.০০, কিন্তু policy-র নিজের লেখা ৪০টি উত্তরের বড়জোর ২টিতে তথ্য ঠিক; margin বেড়েছিল মূলত rejected-কে চাপা দিয়ে (chosen +২৩, rejected −৮১ nat), আর β = ০.০২-এ ভাষাই ভেঙে যায়। Proxy বেশি চাপলে আসল মান কমে (reward hacking).

পরীক্ষক যা খোঁজেন: তিন ধাপ আর KL-এর ভূমিকা (২); π* আর r-এর উল্টানো রূপ (৩); Z(x) কাটা আর চূড়ান্ত loss (২); accuracy বনাম আসল মানের যুক্তি (২); β-এর প্রভাব (১)। পর্ব ৫৭ · পর্ব ৫৬ · পর্ব ৫৮

যেখানে নম্বর কাটে: DPO-তে “reward model শেখানো হয়” লেখা; β-এর দিক উল্টো (ছোট β মানে বেশি সরে যাওয়ার সুযোগ); “DPO chosen-এর সম্ভাবনা বাড়ায়” নিশ্চিত বলে ধরা।

1. Token-এর দাম: একই লেখায় Qwen2.5-এর tokenizer-এ বাংলা ইংরেজির ৩.৮৬ গুণ token, SmolLM2-এ ৬.৪৯ গুণ, BanglaBERT-এ ০.৫২ গুণ (পর্ব ৬৫): বেশি খরচ, latency, ছোট কার্যকর context (token fertility). প্রতিকার: model বাছাইয়ের আগে নিজের লেখায় token গোনা।
2. Byte আর যুক্তাক্ষর: UTF-8-এ বাংলার প্রতিটি code point ৩ byte, আর merge ছাড়া BPE-র ৬০টি সীমার ২৪টি অক্ষরের ভেতরে পড়েছিল (পর্ব ৪০)। প্রতিকার: grapheme cluster মেনে টুকরো, বাংলায় যথেষ্ট ডেটায় tokenizer.
3. Unicode-এর একাধিক রূপ: “য়” এক চিহ্নে বা দুই চিহ্নে; NFC ছাড়া “শাড়ি”-র দুই রূপ সমান নয়। প্রতিকার: NFC, তবে NFKC সাবধানে (½ বদলে 1⁄2).
4. Banglish আর code-mixing: বাংলিশ প্রশ্নে বাংলা নথি খুঁজে পাওয়া যায়নি (পর্ব ৭৩); অভিধান-ভিত্তিক রূপান্তরে “product bad” হয়ে গেল “বাদ”, মতটাই উল্টো (পর্ব ৩৯)। প্রতিকার: Banglish প্রশ্ন eval set-এ রাখা, multilingual embedding.
5. সমৃদ্ধ রূপতত্ত্ব: held-out লেখায় ৩৩.৬% token আগে দেখা যায়নি (OOV); নিয়মভিত্তিক stemming “মানে”-কে “মান” বানায়। প্রতিকার: subword, BLEU-র বদলে chrF.

আরও একটি: log-probability ইংরেজিতে বানানো উত্তর আলাদা করেছিল (AUC ০.৯৮), বাংলায় কোনো সংকেত মেলেনি (পর্ব ৫২)।

পরীক্ষক যা খোঁজেন: পাঁচটি সমস্যা, প্রতিটিতে উদাহরণ আর প্রতিকার (৫)। পর্ব ৩৯ · পর্ব ৪০ · পর্ব ৬৫

যেখানে নম্বর কাটে: “বাংলায় ডেটা কম” এক লাইনে থামা; সমস্যা লিখে প্রতিকার বাদ।

সংজ্ঞা: Hallucination মানে সাবলীল কিন্তু উৎস বা বাস্তবের সঙ্গে না-মেলা লেখা। Model-এর লক্ষ্য পরের token-এর সম্ভাবনা, সত্য নয়।

যাচাইয়ের স্তর: সংখ্যা-পরীক্ষা, citation-পরীক্ষা, আর উত্তর না পেলে থামার gate. ক্যাপস্টোনে reranker gate ৪০টি প্রশ্নে সঠিক উত্তর +০.১২৫ বাড়িয়েছিল (৯৫% CI [+০.০২৫, +০.২২৫]), আর উত্তরহীন ৬টির ৬টিতেই “জানি না” (পর্ব ৮৬)। পর্ব ৫২-তে temperature scaling ECE ০.২১ থেকে ০.০৫-এ নামিয়েছিল, নির্ভুলতা না বদলে।

কেন পুরো দূর হয় না: অজানা প্রশ্নেও কিছু একটা লেখা সম্ভব, আর উৎস থাকলেও model ভুল পড়তে পারে। লক্ষ্য তাই মাপা হার কমানো আর ক্ষতি সীমিত রাখা।

পরীক্ষক যা খোঁজেন: সংজ্ঞা আর মূল কারণ (২); পাঁচটি কারণ-প্রতিকার জোড়া (৫); যাচাইয়ের স্তর বা মাপা উদাহরণ (২); কেন শূন্য নয় (১)। পর্ব ৫২ · পর্ব ৭০ · পর্ব ৮৬

যেখানে নম্বর কাটে: “RAG দিলে hallucination শেষ” লেখা; temperature ০ মানেই সত্য ভাবা।

Eval set: প্রশ্নের ধরন আগে: এক নথি, একাধিক নথি, সংখ্যা, Banglish, আর উত্তর নেই। প্রতিটির gold নথি আর gold উত্তর; dev আর test আলাদা।

স্তর ধরে মাপ: Retriever: recall@k, MRR, nDCG, gold নথির বিপরীতে। Generator: gold নথি সরাসরি দিয়ে (oracle context) faithfulness আর citation; এতে খোঁজার ভুল আর লেখার ভুল আলাদা হয়। End-to-end: সঠিকতা, আর উত্তরহীন প্রশ্নে থামা। ভুলগুলো শ্রেণিতে ভাগ করুন।

import numpy as np
from math import comb

rng = np.random.default_rng(89)

def paired(both, a_only, b_only, neither, reps=10000):
    a = np.array([1] * both + [1] * a_only + [0] * b_only + [0] * neither)
    b = np.array([1] * both + [0] * a_only + [1] * b_only + [0] * neither)
    n = a.size
    idx = rng.integers(0, n, (reps, n))           # resample questions, keep pairs
    diffs = b[idx].mean(1) - a[idx].mean(1)
    lo, hi = np.percentile(diffs, [2.5, 97.5])
    k, m = min(a_only, b_only), a_only + b_only    # exact McNemar (two-sided)
    p = min(1.0, 2 * sum(comb(m, i) for i in range(k + 1)) / 2**m)
    print(f"n={n} A {a.sum()} B {b.sum()} | better {b_only} worse {a_only} | "
          f"diff {b.mean() - a.mean():+.3f} CI [{lo:+.3f}, {hi:+.3f}] | p {p:.3f}")

paired(both=21, a_only=0, b_only=5, neither=14)   # same +5 net, all one way
paired(both=18, a_only=3, b_only=8, neither=11)   # same +5 net, mixed
paired(both=42, a_only=0, b_only=10, neither=28)  # twice the questions

n=40 A 21 B 26 | better 5 worse 0 | diff +0.125 CI [+0.025, +0.225] | p 0.062
n=40 A 21 B 26 | better 8 worse 3 | diff +0.125 CI [-0.025, +0.275] | p 0.227
n=80 A 42 B 52 | better 10 worse 0 | diff +0.125 CI [+0.062, +0.200] | p 0.002

LLM বিচারক: হাতে লেবেল করা অংশে বিচারকের মিল Cohen's kappa দিয়ে মাপুন। পর্ব ৭০-এ 1.5B বিচারকের kappa মাত্র ০.২৪৯ (৯৫% CI [০.০৫, ০.৪৫]), আর শুধু উৎস ও উত্তরের ক্রম বদলালে ৬৩টির ৩০টি রায় উল্টে যায়; সস্তা সংখ্যা-পরীক্ষার kappa ছিল ০.৩২৪. শেষে release gate আর চালুর পরে নমুনা ধরে হাতে যাচাই।

পরীক্ষক যা খোঁজেন: প্রশ্নের ধরনসহ eval set (২); তিন স্তরের metric আর oracle (৩); জোড়া তুলনা আর CI (২); বিচারকের যাচাই (২); release gate বা নজরদারি (১)। পর্ব ৭০ · পর্ব ৬৬ · পর্ব ৮৬

যেখানে নম্বর কাটে: শুধু end-to-end একটি সংখ্যা; উত্তরহীন প্রশ্ন বাদ; বিচারককে যাচাই ছাড়া মানা।

• লুপ আর লক্ষ্যচ্যুতি: একই tool বারবার। Guardrail: step budget, পুনরাবৃত্তিতে থামা।
• বানানো argument আর মিথ্যা দাবি: পর্ব ৭৩-এ বৈধ অনুরোধের ২৪টি উত্তরের ৬টিতে কোনো tool call ছাড়াই লেখা “পাঠিয়ে দিয়েছি”, আর প্রস্তাবিত ৮টি send_message-এর সবগুলোয় বানানো নম্বর। Guardrail: schema যাচাই, argument-কে ব্যবহারকারীর নিজের ডেটার সঙ্গে মেলানো, সফলতার দাবি শুধু tool-এর ফল থেকে।
• Indirect prompt injection: নথি বা tool-এর ফলে লুকানো নির্দেশ। Guardrail: least privilege, বাইরের লেখাকে ডেটা হিসেবে চিহ্নিত করা, output filter, canary test.
• অতিরিক্ত ক্ষমতা: রিফান্ডের মতো অপরিবর্তনীয় কাজ। Guardrail: human-in-the-loop, idempotency key, audit log.

বাস্তবতার মাপ: পর্ব ৭২-এ একটি ছোট খোলা model-এ ৮৪টি agent run-এর মাত্র ২টি সফল; পরিকল্পনা-প্রথম prompt দরকারি tool ডাকা বাড়িয়েছিল (+০.৪৫, CI [+০.২৩, +০.৬৬]), তবু কাজ শেষ হয়নি। তাই মূল্যায়ন trace ধরে।

পরীক্ষক যা খোঁজেন: চারটি ব্যর্থতা-guardrail জোড়া (৪); মূল্যায়ন বা মাপা প্রমাণ (১)। পর্ব ৭১ · পর্ব ৭২ · পর্ব ৭৩

যেখানে নম্বর কাটে: শুধু prompt-এ “নিয়ম মানো” লেখাকে guardrail বলা; কোডে নয়, model-এর ভরসায় অনুমতি যাচাই।

মাপা প্রমাণ: পর্ব ৭৭-এর run-এ lr ৫ × ১০⁻⁵-এ তিনটি seed-ই মাত্র একটি শ্রেণির ছবি বানিয়েছে, অথচ classifier-এর আত্মবিশ্বাস ০.৯৭১: নিশ্চিত দেখানো মানেই বৈচিত্র্য নয়। পর্ব ৭৯-এ নিখুঁত denoiser-এও ৫০ ধাপের DDIM-এ নমুনার নিকটতম কেন্দ্র থেকে গড় দূরত্ব ০.০৮১ (আসল ডেটায় ০.১০০), ৫ ধাপে ০.৬০১, তবে কোনো mode বাদ পড়েনি। পর্ব ৭৬-এ Fashion-MNIST-এর VAE নমুনায় জিনিস চেনা যায়, নকশা আর কিনারা ঝাপসা।

কেন এমন: VAE-র Gaussian decoder গড়ের দিকে টানে, তাই ঝাপসা। GAN-এর generator শুধু discriminator-কে ঠকাতে চায়; কয়েকটি নিশ্চিত mode-এ আটকে থাকলেও তা সফল। Diffusion প্রতিটি ধাপে একটি সরল regression শেখে, তাই স্থির।

সিদ্ধান্ত: ক্যাটালগে মান আর বৈচিত্র্য দুটিই চাই: latent diffusion, কম ধাপের sampler-সহ। ছোট latent বা anomaly score চাইলে VAE; সংকীর্ণ ডোমেইনে real-time-এ GAN.

পরীক্ষক যা খোঁজেন: ছয় সারির ছক (৫); প্রতিটির দুর্বলতার কারণ (২); প্রমাণ (১); সিদ্ধান্ত (২)। পর্ব ৭৪ · পর্ব ৭৬ · পর্ব ৭৭ · পর্ব ৮০

যেখানে নম্বর কাটে: GAN-এর likelihood আছে বলা; diffusion-কে “এক ধাপে ছবি” বলা; mode collapse আর ঝাপসা নমুনা গুলিয়ে ফেলা।

সংজ্ঞা: FID আসল আর বানানো ছবির Inception feature-এ দুটি Gaussian বসিয়ে তাদের Fréchet দূরত্ব: ‖μ_১ − μ_২‖² + tr(Σ_১ + Σ_২ − ২(Σ_১Σ_২)^½)। কম মানে কাছাকাছি (Heusel ও সহলেখক, ২০১৭)।

import numpy as np

rng = np.random.default_rng(89)
ang = np.arange(8) * np.pi / 4
centres = np.c_[np.cos(ang), np.sin(ang)] * 2          # 8 modes on a circle

def sample(n, modes, sd):
    c = centres[rng.choice(modes, n)]
    return c + sd * rng.normal(size=(n, 2))

def fd(a, b):                                           # Frechet distance
    m1, m2, S1, S2 = a.mean(0), b.mean(0), np.cov(a.T), np.cov(b.T)
    ev = np.linalg.eigvals(S1 @ S2).real.clip(0)
    return np.sum((m1 - m2)**2) + np.trace(S1 + S2) - 2 * np.sqrt(ev).sum()

def coverage(ref, x, k=3):                              # share of x inside ref's k-NN balls
    r = np.sort(np.linalg.norm(ref[:, None] - ref[None], axis=2), 1)[:, k]
    return np.mean((np.linalg.norm(x[:, None] - ref[None], axis=2) <= r).any(1))

real = sample(400, np.arange(8), 0.15)
fakes = {"good copy": sample(400, np.arange(8), 0.15),
         "4 modes only": sample(400, np.arange(4), 0.15),
         "blurry": sample(400, np.arange(8), 0.6)}
print("generator      precision  recall   FD")
for name, g in fakes.items():
    print(f"{name:13s}  {coverage(real, g):.2f}       {coverage(g, real):.2f}     {fd(real, g):.3f}")

generator      precision  recall   FD
good copy      0.93       0.96     0.005
4 modes only   0.95       0.48     2.590
blurry         0.30       0.97     0.045

সীমা: (১) নমুনার আকারে পক্ষপাত: পর্ব ৮১-এ আসল বনাম আসল ছবিতেই n = ২৫০-এ FID ৪৫.৪৭, n = ১০,০০০-এ ২.৫৩; তাই একই n-এ তুলনা। (২) Feature ImageNet-এ শেখা; অন্য ডোমেইনে অর্থ দুর্বল। (৩) মুখস্থ করা ধরে না; নিকটতম training ছবি দেখা লাগে। Prompt-এর সঙ্গে মিলে CLIP score, শেষ বিচারে মানুষ।

পরীক্ষক যা খোঁজেন: সংজ্ঞা আর সূত্র (১); তিনটি সীমা (২); precision/recall-এর যুক্তি, উদাহরণসহ (২)। পর্ব ৮১ · পর্ব ৭৭

যেখানে নম্বর কাটে: ভিন্ন n বা ভিন্ন feature extractor-এর FID তুলনা; “FID কম, তাই বৈচিত্র্য বেশি” লেখা।

দুই ধাপ, দুই সীমা: Prefill (পুরো prompt একসঙ্গে) compute-bound, এটি TTFT ঠিক করে; decode (এক token করে) memory-bound, এটি TPOT. পর্ব ৬৫-এর CPU run-এ prefill প্রায় ১৯৭ token/s, decode প্রায় ১০.৩ token/s. বাংলায় token বেশি (গ-০৪), তাই দুটিই বাড়ে।

মাপা প্রমাণ: পর্ব ৮৩-এর simulation-এ যন্ত্রের ক্ষমতার কিনারে (λ = ১.০) TTFT-এর p50 static batching-এ ১৭.৮১ s, continuous-এ ৩.৪৯ s, একই যন্ত্রে শুধু scheduling বদলে; তবু continuous-এর p95 ১২.১০ s. সেখানে ৮ GiB-এর যন্ত্রে Qwen2.5-1.5B-এ ২,০৪৮ token-এর ৭৯টি অনুরোধ আঁটে, ৮,১৯২-এ মাত্র ১৯টি; KV int8-এ দ্বিগুণ। পর্ব ৬৫-এ ২,০৪৭ token-এর একই prefix cache থেকে এলে TTFT ৮.০৫ থেকে ০.৩৭ সেকেন্ড, উত্তর হুবহু এক।

চাপ বাড়লে, ক্রমে: (১) SLO ঠিক করে মাপুন: TTFT আর TPOT-এর p50/p95; Little-এর সূত্র L = λW দিয়ে সারিতে গড় অনুরোধ। (২) Continuous batching আর prefix caching. (৩) Context আর উত্তরের দৈর্ঘ্যে সীমা। (৪) Quantization, মান যাচাই করে। (৫) সহজ প্রশ্ন ছোট model-এ। (৬) তারপর আরও GPU, আর সীমার বাইরে load shedding.

পরীক্ষক যা খোঁজেন: prefill/decode আর দুই metric (২); অন্তত চারটি কৌশল, লাভ ও দামসহ (৪); প্রমাণ বা হিসাব (২); চাপ বাড়লে ক্রমিক পরিকল্পনা (২)। পর্ব ৮৩ · পর্ব ৬৫ · পর্ব ৫৯ · পর্ব ৮৫

যেখানে নম্বর কাটে: শুধু গড় latency (p95 বাদ); throughput বাড়লে latency-ও কমে বলে ধরা; quantization-এর পরে মান না মাপা।

উপপাদ্যটি শুধু অস্তিত্ব বলে: এক hidden layer-এ পর্যাপ্ত unit থাকলে যেকোনো continuous function কাছাকাছি আনা যায়, কিন্তু unit-এর সংখ্যা বিশাল হতে পারে। কিছু function গভীর network অনেক কম unit-এ প্রকাশ করে (depth separation). পর্ব ৬

পরের প্রশ্ন: উপপাদ্য কি বলে model সেটি শিখবে? — না; optimization আর generalization আলাদা প্রশ্ন।

K শ্রেণির cross-entropy-তে এলোমেলো শুরুতে loss প্রায় ln K (তিন শ্রেণিতে প্রায় ১.০৯৯)। অনেক বেশি হলে init, label বা loss-এর input-এ গোলমাল। পর্ব ১৮

পরের প্রশ্ন: তারপর কোন sanity check? — একটি ছোট batch-কে প্রায় শূন্য loss-এ overfit করানো; না পারলে কোডে বাগ।

BatchNorm একটি feature-কে batch জুড়ে normalize করে, training আর eval-এ আচরণ আলাদা (running statistics); LayerNorm প্রতিটি উদাহরণের feature জুড়ে, batch-নিরপেক্ষ, তাই Transformer-এ। পর্ব ১৪

পরের প্রশ্ন: batch ২ হলে BatchNorm? — গড় আর variance অস্থির; GroupNorm বা LayerNorm.

Training-এ এলোমেলো unit বন্ধ করে বাকিগুলোকে ১/(১ − p) দিয়ে বড় করা হয়, তাই eval-এ কিছু করতে হয় না। model.eval() ভুললে অনুমান এলোমেলো। পর্ব ১৬

পরের প্রশ্ন: eval-এও dropout রাখলে লাভ? — MC dropout: কয়েকবার চালিয়ে ছড়ানো থেকে অনিশ্চয়তার একটি মোটা আন্দাজ।

প্রতিটি pixel-এ channel-গুলোকে একটি matrix দিয়ে মেশায়; channel কমানো বা বাড়ানো যায়। ResNet-50-এর bottleneck-এ এভাবেই parameter ResNet-18-এর মাত্র দ্বিগুণের একটু বেশি। পর্ব ২২

পরের প্রশ্ন: depthwise separable-এর খরচ? — সাধারণ conv-এর প্রায় ১/C + ১/k² ভাগ; পর্ব ২২-এ ১১% থেকে ১৭%.

ডেটা কম আর ডোমেইন কাছাকাছি হলে frozen backbone-এ শুধু head; ডেটা বেশি বা ডোমেইন দূরে হলে পুরো network, ছোট lr-এ। পর্ব ২৩

পরের প্রশ্ন: পুরো fine-tune-এর ঝুঁকি? — Catastrophic forgetting আর অল্প ডেটায় overfit; শুরুর weight-এর দিকে টান বা স্তরভেদে lr.

bias ০-এ f প্রায় ০.৫, প্রতি ধাপে স্মৃতি অর্ধেক; পর্ব ২৯-এ তখন LSTM সাধারণ RNN-এর চেয়েও খারাপ ছিল। পর্ব ২৯

পরের প্রশ্ন: খুব বড় bias (৩)? — সংকেত জমে বাড়তে পারে; সেখানে ১০০ ধাপে gradient ২০-এ উঠেছিল।

Training-এ decoder আগের ধাপের আসল token পায়, নিজের অনুমান নয়; চালানোর সময় নিজের ভুলের ওপর চলতে হয়, যা সে শেখেনি। পর্ব ৩০

পরের প্রশ্ন: প্রতিকার? — Scheduled sampling, বা বড় ডেটা আর ভালো decoding; সমস্যাটি কতটা গুরুতর, তা নিয়ে মতভেদ আছে।

Self-attention permutation-equivariant: token-এর ক্রম বদলালে output-ও একইভাবে বদলায়, “কোনটি আগে” জানে না। পর্ব ৩৮-এ position ছাড়া ViT-এর কাছে ছবি patch-এর থলে। পর্ব ৩৪

পরের প্রশ্ন: RoPE-এর সুবিধা? — Query আর key ঘুরিয়ে আপেক্ষিক দূরত্ব score-এ আনে; লম্বা context-এ বাড়াতে কৌশল লাগে।

Perplexity = exp(প্রতি token-এ গড় negative log-likelihood); tokenizer আলাদা হলে “token”-এর মাপ আলাদা, তাই তুলনা অর্থহীন। তখন bits per byte বা character. পর্ব ৪৬

পরের প্রশ্ন: কম perplexity মানেই ভালো chatbot? — না; নির্দেশ মানা, সত্যতা আর নিরাপত্তা আলাদা করে মাপতে হয়।

বাংলায় বিভক্তি আর সমাস বেশি, পুরো শব্দের n-gram সহজে মেলে না; chrF অক্ষরের n-gram মেলায়, তাই আংশিক মিলও নম্বর পায়। পর্ব ৪৫

পরের প্রশ্ন: তবু কেন মানুষের বিচার? — Metric অর্থ আর সাবলীলতা পুরো ধরে না; বিচারকদের মিল kappa দিয়ে মাপা।

Temperature logit-কে ভাগ করে বণ্টন চ্যাপ্টা বা তীক্ষ্ণ করে; top-p সবচেয়ে ছোট সেট রাখে যার মোট সম্ভাবনা অন্তত p, বাকি কেটে আবার normalize. পর্ব ৫০

পরের প্রশ্ন: greedy-তে temperature-এর প্রভাব? — নেই; argmax একই থাকে। তবে library-র ডিফল্টে sampling চালু থাকতে পারে (পর্ব ৫২).

Loss parameter, ডেটা আর compute-এর সঙ্গে প্রায় power law মেনে কমে। নির্দিষ্ট কাজে কখন কোন ক্ষমতা আসবে তা বলে না; “emergent” লাফের একাংশ metric-এর ফল বলে যুক্তি আছে। পর্ব ৫১

পরের প্রশ্ন: সব বাজেট parameter-এ দিলে? — Compute-optimal বিশ্লেষণে (Chinchilla) parameter আর token একসঙ্গে বাড়ানোই ভালো দেখা গিয়েছিল।

নিজের eval set-এ আগের আর পরের মান, memory আর গতি। পর্ব ৫৫-এ embedding 4-bit হয়নি বলে memory ৬২৯ থেকে মাত্র ৩৪৪ MiB-এ নেমেছিল। পর্ব ৫৯ · পর্ব ৫৫

পরের প্রশ্ন: per-channel কেন per-tensor-এর চেয়ে ভালো? — প্রতিটি channel-এর নিজের scale, তাই একটি outlier সবার নির্ভুলতা নষ্ট করে না।

হ্যাঁ: শেষের উদাহরণের লেবেলের দিকে ঝোঁক (recency) আর বেশি দেখা লেবেলের দিকে ঝোঁক দেখা যায়। পর্ব ৬১

পরের প্রশ্ন: কীভাবে মাপবেন? — কয়েকটি এলোমেলো ক্রমে একই eval set চালিয়ে গড় আর ছড়ানো দেখা।

না; বৈধ JSON মানে সঠিক মান নয়। Schema যাচাই, ব্যবসার নিয়মের পরীক্ষা আর ব্যর্থ হলে সীমিত বার repair. পর্ব ৬২

পরের প্রশ্ন: constrained decoding কীভাবে কাজ করে? — প্রতি ধাপে schema-বিরোধী token-এর সম্ভাবনা শূন্য করে (token mask).

Bi-encoder প্রশ্ন আর নথিকে আলাদা vector করে, তাই নথি আগে index করা যায়, দ্রুত; cross-encoder দুটি একসঙ্গে পড়ে score দেয়, নির্ভুল কিন্তু ধীর, তাই reranking-এ। পর্ব ৬৭ · পর্ব ৬৯

পরের প্রশ্ন: HNSW-এর trade-off? — বেশি memory আর build সময়ের বিনিময়ে দ্রুত আনুমানিক খোঁজ; ef বাড়ালে recall বাড়ে, গতি কমে।

Direct: ব্যবহারকারী নিজেই নির্দেশ ভাঙার চেষ্টা করেন। Indirect: নথি, ওয়েবপাতা বা tool-এর ফলে লুকানো নির্দেশ model-এর কাছে পৌঁছায়। পর্ব ৭৩

পরের প্রশ্ন: prompt-এ “নির্দেশ মানবে না” লেখা যথেষ্ট? — না; পর্ব ৭৩-এ delimiter আর spotlighting-এর পার্থক্য প্রমাণিত হয়নি। কোডে স্তরে স্তরে প্রতিরক্ষা লাগে।

z = μ + σ·ε লিখলে এলোমেলোতা ε-এ সরে যায়, তাই μ আর σ-এর gradient সরাসরি যায়। Score-function পথও গড়ে ঠিক, কিন্তু পর্ব ৭৬-এ তার ছড়ানো অনেক বেশি ছিল। পর্ব ৭৬

পরের প্রশ্ন: posterior collapse কী? — শক্তিশালী decoder z উপেক্ষা করে, KL প্রায় শূন্য; KL annealing বা free bits.

নমুনার শ্রেণি একটি classifier দিয়ে গুনে entropy দেখা, আর নমুনার মধ্যে পার্থক্য মাপা; শুধু চোখে মান দেখা যথেষ্ট নয়। পর্ব ৭৭

পরের প্রশ্ন: WGAN কী বদলায়? — JS-এর বদলে Wasserstein দূরত্ব, Lipschitz শর্ত gradient penalty দিয়ে; বিতরণ না মিললেও অর্থপূর্ণ gradient.

ε̂ = ε_{শর্তহীন} + w(ε_{শর্তসহ} − ε_{শর্তহীন})। w বাড়লে prompt-এর সঙ্গে মিল বাড়ে, বৈচিত্র্য কমে, খুব বড় হলে রং আর গঠন অস্বাভাবিক। পর্ব ৮০

পরের প্রশ্ন: latent-এ diffusion কেন? — VAE-র ছোট latent-এ কাজ করলে প্রতিটি ধাপ অনেক সস্তা।

ছবি আর লেখার জোড়ায় contrastive loss: মেলা জোড়ার embedding কাছে, batch-এর বাকিগুলো দূরে। তাই লেখার prompt দিয়ে zero-shot শ্রেণিবিভাগ সম্ভব। পর্ব ৮২

পরের প্রশ্ন: vision-language model-এর বিশেষ hallucination? — ছবিতে নেই এমন বস্তুর বর্ণনা (object hallucination).

একই input-এ PyTorch আর ONNX Runtime-এর output (সহনসীমাসহ), dynamic shape (ভিন্ন batch আর দৈর্ঘ্য), আর লক্ষ্য যন্ত্রে latency. পর্ব ৮৪

পরের প্রশ্ন: quantize করলে? — Eval set-এ মান আবার মাপা; শুধু output মেলানো যথেষ্ট নয়।

Input যাচাই আর PII মাস্ক, retrieval-এ উৎসের filter, tool-এর অনুমতি, output-এর পরীক্ষা (সংখ্যা, লিংক, canary), rate limit আর log. পর্ব ৮৫ · পর্ব ৮৬

পরের প্রশ্ন: model বা সার্ভিস বন্ধ হলে? — Fallback model বা নির্দিষ্ট বার্তা (graceful degradation), timeout আর সীমিত retry.