Training ডিবাগ করা — এক batch overfit, learning curve আর সাধারণ ভুল

আগের পর্বগুলোতে training loop লিখেছেন (পর্ব ১০), DataLoader বানিয়েছেন (পর্ব ১১), আর এই মডিউলে loss, initialization, optimizer, regularization আর gradient-এর সমস্যা দেখছেন (পর্ব ১৩ থেকে ১৭)। কিন্তু বাস্তবে প্রথম চেষ্টায় model প্রায় কখনো ঠিকমতো শেখে না। এই পর্বে শিখব কীভাবে খুঁজবেন ভুলটা কোথায়। একই বাজারঘর customer segment task-এ (৫টি feature, ৩টি segment, ৪০০টি train আর ২০০টি validation উদাহরণ) ছয়টি পরিকল্পিত বাগ বসিয়ে প্রতিটির সত্যিকারের লক্ষণ মাপা হয়েছে (ডেস্কটপ, CPU, লেখার সময়ে torch 2.15.0, Python 3.14.4). পাতায় চালানো যায় এমন চারটি NumPy ব্লক একই ধারণা দেখায় (প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে)।

১ · কেন training-এর বাগ চুপচাপ থাকে — একটি ক্রম

সাধারণ প্রোগ্রামে ভুল হলে প্রায়ই error আসে। Neural network-এ বেশিরভাগ ভুল silent bug: shape মিলে যায়, loss নামে, accuracy-ও কিছুটা আসে। Label এলোমেলো, ইনপুট normalise করা নেই, loss-এর ভুল জোড়, এর কোনোটাই error দেয় না। তার ওপর ফল খারাপ হওয়ার "স্বাভাবিক" কারণও অনেক (কম ডেটা, ভুল hyperparameter), তাই বাগকে সহজেই "model-টা হয়তো দুর্বল" বলে ভুল বোঝা যায়।

সমাধান হলো একটি ক্রম, যেখানে প্রতিটি ধাপ একটি sanity check: সস্তা পরীক্ষা, যার সঠিক উত্তর জানা। Andrej Karpathy তাঁর ২০১৯ সালের ব্লগ লেখা “A Recipe for Training Neural Networks”-এ এই ধরনের ক্রম জনপ্রিয় করেন; নিচের ছবি সেই ধারার একটি সরল রূপ।

এই ক্রম কেন কাজ করে, আর আমাদের ছয়টি বাগের কোনটি কোন ধাপে ধরা পড়ল, তা নিচের stepper-এ। সংখ্যাগুলো পরের অংশগুলোর সত্যিকারের run থেকে।

২ · প্রথমে ডেটা আর label — একটি batch নিজের চোখে

Karpathy-র রেসিপির প্রথম কথা ছিল: model-এ হাত দেওয়ার আগে ডেটার সঙ্গে সময় কাটান। Tabular ডেটায় এর মানে তিনটি ছোট হিসাব: প্রতিটি শ্রেণিতে কতটি উদাহরণ, প্রতিটি feature-এর গড় আর sd, আর শ্রেণি অনুযায়ী কয়েকটি feature-এর গড়। ছবির ডেটায় একটি batch ছবিসহ label আঁকা, লেখার ডেটায় কয়েকটি উদাহরণ পড়া। এগুলো পরীক্ষা করা উচিত DataLoader থেকে বেরোনোর পরে, ঠিক যে tensor model-এ ঢুকছে সেটাতে, কারণ ভুল প্রায়ই pipeline-এর মাঝে ঢোকে।

প্রথম বাগ: কোনো pipeline-এ X আর y আলাদাভাবে এলোমেলো করা হয়েছে (যেমন দুটি আলাদা sort বা দুটি আলাদা seed-এর shuffle), তাই প্রতিটি সারির label অন্য কারও। সত্যিকারের run:

~/bazarghar-dl$ uv run python data_check.py
label count: [124, 121, 155]
ঠিক      orders_pm/app_share per class: 2.31/0.31 | 5.87/0.68 | 4.10/0.56
এলোমেলো  orders_pm/app_share per class: 4.33/0.55 | 4.08/0.52 | 3.88/0.50
feature mean: [4.08, 976.05, 18.94, 0.35, 0.52]
feature sd:   [2.76, 647.08, 29.87, 0.32, 0.35]

ঠিক ডেটায় তিনটি segment স্পষ্ট আলাদা: "occasional" ক্রেতা মাসে গড়ে ২.৩১টি অর্ডার দেন, "regular" ৫.৮৭টি। এলোমেলো label-এ তিন শ্রেণির গড় প্রায় এক (৪.৩৩, ৪.০৮, ৩.৮৮), কারণ প্রতিটি শ্রেণিতে এখন সব ধরনের ক্রেতা মিশে আছে। Label-এর গোনা দুই ক্ষেত্রেই হুবহু এক, তাই শুধু গোনা দেখলে বাগটি ধরা পড়ত না। শেষ দুই লাইন আরেকটি সমস্যা দেখায়: basket_tk-এর sd ৬৪৭, discount_share-এর ০.৩২, অর্থাৎ feature-গুলো তুলনীয় মাপে নেই। এর ফল পরের অংশে।

এলোমেলো label নিয়ে ২০ epoch train করলে কী হয়? (পুরো script অংশ ৩-এ।) Train loss ১.১ থেকে ধীরে ০.৯৭০২-এ নামে, কিন্তু val accuracy ০.৩০০, তিন শ্রেণিতে অনুমানের চেয়েও খারাপ, আর val loss ১.৩১২. Train loss তবু নামছে কেন? কারণ বড় network এলোমেলো label-ও ধীরে ধীরে মুখস্থ করতে পারে: memorization. এই তথ্য অংশ ৪-এ খুব জরুরি হবে।

৩ · শুরুর loss যাচাই — −ln(1/C)

Training শুরুর আগে, এলোমেলো weight-এ, একবার loss মাপুন। এটিই initial loss. যুক্তি সরল: ঠিকঠাক শুরু করা classifier-এর logits ছোট আর প্রায় সমান, তাই softmax প্রতিটি শ্রেণিকে প্রায় ১/C probability দেয়। Cross-entropy হলো সঠিক শ্রেণির probability-র ঋণাত্মক log (AI-এর ভিত্তি কোর্সের পর্ব ৩৮), তাই:

L_শুরু ≈ −ln(1/C) = ln C

এখানে C শ্রেণির সংখ্যা। ৩ শ্রেণিতে ln ৩ = ১.০৯৮৬, ১০ শ্রেণিতে ২.৩০২৬, ১০০ শ্রেণিতে ৪.৬০৫২. দুই শ্রেণির BCE-তে ln ২ = ০.৬৯৩১. শ্রেণিগুলো অসমান হলে ভালো শুরু করা model-এর loss এর চেয়ে একটু বেশি বা কম হতে পারে, কিন্তু অনেক গুণ বেশি নয়। শুরুর loss অনেক বেশি হলে logits বড়: weight-এর শুরু খুব বড় (পর্ব ১৪ Weight initialization আর normalization), বা ইনপুট normalise করা নেই। নিচের ব্লকে একটি NumPy MLP তিন রকম weight-এর মাপ আর কাঁচা ইনপুটে শুরু করা হলো:

import numpy as np

rng = np.random.default_rng(42)
X = rng.normal(0, 1, (256, 5))                       # standardize করা ৫টি feature
def initial_loss(C, scale, x_scale=1.0):
    W1 = rng.normal(0, scale / np.sqrt(5), (5, 64))    # scale: init কত বড়
    W2 = rng.normal(0, scale / np.sqrt(64), (64, C))
    y = rng.integers(0, C, len(X))                   # শ্রেণি সমানভাবে ছড়ানো
    Z = np.maximum((X * x_scale) @ W1, 0) @ W2       # logits
    Z = Z - Z.max(1, keepdims=True)
    logp = Z - np.log(np.exp(Z).sum(1, keepdims=True))
    return -logp[np.arange(len(y)), y].mean()

print(" C | -ln(1/C) | init 0.01 | init 1 | init 10 | x×1000")
for C in (3, 10, 100):
    row = [initial_loss(C, s) for s in (0.01, 1.0, 10.0)] + [initial_loss(C, 1.0, 1000)]
    print(f"{C:3d} | {np.log(C):8.4f} | " + " | ".join(f"{v:7.3f}" for v in row))

 C | -ln(1/C) | init 0.01 | init 1 | init 10 | x×1000
  3 |   1.0986 |   1.099 |   1.213 |  47.001 | 534.885
 10 |   2.3026 |   2.303 |   2.555 | 103.172 | 1048.795
100 |   4.6052 |   4.605 |   4.759 | 135.022 | 1548.914

এখন দ্বিতীয় বাগ, PyTorch-এ সত্যিকারের run: বাজারঘরের ডেটা normalise না করে একই model (৫ → ৬৪ → ৬৪ → ৩, ReLU), SGD momentum ০.৯, learning rate ০.১, ২০ epoch. ছয়টি বাগের জন্য একটি script, যার মূল অংশ:

def fit(bug=None, epochs=20, lr=0.1):
    torch.manual_seed(0)
    Xtr, ytr, Xva, yva = load(norm=(bug != "no_norm"))      # শুধু train-এর গড় আর sd দিয়ে
    if bug == "shuffled": ytr = ytr[torch.randperm(len(ytr))]  # X আর y আলাদা ক্রমে
    if bug == "lr10": lr = lr * 10
    if bug == "lr100": lr = lr * 100
    model = make(); opt = torch.optim.SGD(model.parameters(), lr=lr, momentum=0.9)
    dl = DataLoader(TensorDataset(Xtr, ytr), batch_size=64, shuffle=True,
                    generator=torch.Generator().manual_seed(0))
    def lossf(out, yb):
        if bug == "softmax_nll": return F.nll_loss(torch.softmax(out, 1), yb)  # চায় log-prob
        return F.cross_entropy(out, yb)
    with torch.no_grad(): init = lossf(model(Xtr), ytr).item()  # শুরুর loss
    # … ২০ epoch training, তারপর val loss, accuracy আর dead ReLU-এর ভাগ

~/bazarghar-dl$ uv run python bugs.py
torch 2.15.0+cpu | ln(3) = 1.0986
None        init 1.114 | train ep1/2/10/20: 1.022 0.6463 0.492 0.4264
            val loss 0.7472 acc 0.755 | dead ReLU L1 0.02 L2 0.08
shuffled    init 1.099 | train ep1/2/10/20: 1.1 1.091 1.044 0.9702
            val loss 1.312 acc 0.300 | dead ReLU L1 0.00 L2 0.06
no_norm     init 18.67 | train ep1/2/10/20: 1.585e+33 1.124 1.094 1.094
            val loss 1.119 acc 0.300 | dead ReLU L1 0.00 L2 1.00
softmax_nll init -0.33 | train ep1/2/10/20: -0.3408 -0.4187 -0.799 -0.8112
            val loss 1.959 acc 0.770 | dead ReLU L1 0.00 L2 0.06
lr10        init 1.114 | train ep1/2/10/20: 0.8936 1.052 1.072 1.103
            val loss 1.193 acc 0.380 | dead ReLU L1 0.12 L2 0.94
lr100       init 1.114 | train ep1/2/10/20: 1.042e+19 nan nan nan
            val loss nan acc 0.320 | dead ReLU L1 0.03 L2 0.00

সঠিক run-এর শুরুর loss ১.১১৪, ln ৩-এর খুব কাছে। Normalise ছাড়া শুরু ১৮.৬৭, তারপর প্রথম epoch-এ গড় loss ১.৫৮৫ × ১০^৩৩: বিশাল gradient weight ছুড়ে ফেলেছে। পরে loss ১.০৯৪-এ, প্রায় ln ৩-এ, আটকে গেল আর দ্বিতীয় layer-এর সব ReLU মৃত (L2 1.00): network এখন সব ক্রেতার জন্য একই উত্তর দেয়। শুরুর loss দেখলে training-এর আগেই এই বাগ ধরা যেত। বাকি সারিগুলো পরের অংশে একে একে দেখব। Standardization-এর নিয়ম মনে রাখুন: গড় আর sd শুধু train থেকে।

৪ · এক batch overfit — কেন সবার আগে

Overfit one batch মানে একটি ছোট batch (১৬ থেকে ৬৪টি উদাহরণ) বেছে বারবার শুধু তাতেই train করা। যথেষ্ট বড় network-এর পক্ষে কয়েক ডজন উদাহরণ মুখস্থ করা খুব সহজ, তাই কোড ঠিক থাকলে loss প্রায় ০-তে নামবে আর batch accuracy ১.০০ হবে। না নামলে সমস্যা ডেটার পরিমাণ, regularization বা hyperparameter-এ নয়, কোডে: model, loss, gradient বা optimizer-এর সংযোগে। নিচের ব্লকে NumPy-তে হাতে লেখা backward (পর্ব ০৪-এর P − Y) চারটি অবস্থায়:

import numpy as np

rng = np.random.default_rng(42)
X = rng.normal(0, 1, (16, 5)); y = rng.integers(0, 3, 16)   # এক batch: ১৬টি উদাহরণ

def overfit(y, bug=None, steps=500, lr=0.5):
    r = np.random.default_rng(0)
    W1 = r.normal(0, np.sqrt(2 / 5), (5, 32)); W2 = r.normal(0, 0.1, (32, 3))
    out = []
    for t in range(steps):
        H = np.maximum(X @ W1, 0); Z = H @ W2
        Z = Z - Z.max(1, keepdims=True); S = np.exp(Z).sum(1, keepdims=True); P = np.exp(Z) / S
        loss = (np.log(S[:, 0]) - Z[np.arange(16), y]).mean()       # স্থির cross-entropy
        G = P.copy(); G[np.arange(16), y] -= 1; G /= 16           # ∂L/∂Z = (P − Y)/N
        dH = G @ W2.T
        if bug != "no_mask": dH = dH * (H > 0)                     # ReLU-এর ঢাল
        gW1, gW2 = X.T @ dH, H.T @ G
        if bug == "sign": gW1, gW2 = -gW1, -gW2                    # ভুল দিকে ধাপ
        W1 -= lr * gW1; W2 -= lr * gW2
        if t in (0, 99, 499): out.append(loss)
    acc = (Z.argmax(1) == y).mean()
    return " → ".join(f"{v:.4g}" for v in out) + f" | batch acc {acc:.2f}"

print("ঠিক কোড         :", overfit(y))
print("এলোমেলো label   :", overfit(rng.permutation(y)))
print("ReLU mask নেই    :", overfit(y, "no_mask"))
print("gradient-এর চিহ্ন:", overfit(y, "sign"))

ঠিক কোড         : 1.042 → 0.03095 → 0.003118 | batch acc 1.00
এলোমেলো label   : 1.265 → 0.05818 → 0.004591 | batch acc 1.00
ReLU mask নেই    : 1.042 → 0.1177 → 0.01712 | batch acc 1.00
gradient-এর চিহ্ন: 1.042 → 1.364e+19 → 1.2e+99 | batch acc 0.25

একই পরীক্ষা PyTorch-এ, বাজারঘরের প্রথম ৩২টি train উদাহরণে, প্রতিটি বাগসহ ৩০০ ধাপ (সত্যিকারের run):

~/bazarghar-dl$ uv run python one_batch.py
None        loss step 1/50/300: 1.118 → 0.001514 → 0.0001714 | batch acc 1.00
shuffled    loss step 1/50/300: 1.1 → 0.1552 → 0.001291 | batch acc 1.00
no_norm     loss step 1/50/300: 14.8 → 1.104 → 1.075 | batch acc 0.44
softmax_nll loss step 1/50/300: -0.3278 → -0.9385 → -0.9997 | batch acc 1.00
lr100       loss step 1/50/300: 1.118 → nan → nan | batch acc 0.28

সংক্ষেপে, এক batch overfit সবার আগে কারণ এটি সবচেয়ে সস্তা পরীক্ষা যা "কোড আদৌ শিখতে পারে কি না" প্রশ্নের উত্তর দেয়। এটি পাস না করলে পূর্ণ ডেটায় ঘণ্টার পর ঘণ্টা চালানো, hyperparameter খোঁজা বা model বদলানো সব অর্থহীন। এক batch-এ dropout বা weight decay থাকলে loss হয়তো পুরো ০ পর্যন্ত নামবে না; পরীক্ষার সময় সেগুলো বন্ধ রাখাই ভালো।

৫ · Loss-এর হিসাবে চুপচাপ ভুল — ভুল জোড় আর broadcasting

অংশ ৩-এর run-এ softmax_nll সারিটি আবার দেখুন: val accuracy ০.৭৭০, সঠিক run-এর ০.৭৫৫-এর চেয়েও বেশি! শুধু accuracy দেখলে বাগটি কখনো ধরা পড়ত না। কিন্তু আসল cross-entropy-তে val loss ১.৯৫৯, সঠিক run-এর ০.৭৪৭২-এর আড়াই গুণ: −p_y কমাতে গিয়ে model ভুল উত্তরগুলোতে অতি-আত্মবিশ্বাসী হয়েছে। Probability দিয়ে সিদ্ধান্ত (কোন ক্রেতাকে কত ছাড় দেওয়া) নিলে বিপদ। PyTorch-এ সঠিক জোড়গুলো:

একটি অদ্ভুত ব্যতিক্রম: log_softmax-এর পরে CrossEntropyLoss দিলে কোনো ক্ষতি হয় না, কারণ log-probability-র log-sum-exp ঠিক ০, তাই দ্বিতীয় log-softmax কিছুই বদলায় না। তবু পড়তে বিভ্রান্তিকর, এড়িয়ে চলুন। বিভিন্ন loss-এর বিস্তারিত পর্ব ১৩ (Deep learning-এর loss)-এ।

Broadcasting-এর ফাঁদ: (N, 1) − (N,)

পঞ্চম বাগটি সবচেয়ে লুকানো। Regression model-এর শেষ layer nn.Linear(64, 1) output দেয় আকার (N, 1), আর target প্রায়ই আকার (N,). হাতে লেখা ((out - y) ** 2).mean()-এ broadcasting (এই কোর্সের পর্ব ০৭, অংশ ৫) দুটিকে (N, N) বানিয়ে দেয়: প্রতিটি অনুমান প্রত্যেক ক্রেতার target-এর সঙ্গে তুলনা হয়। কোনো error নেই। গণিতে, i-তম অনুমান p_i আর target-এর গড় ȳ হলে:

(1/N²) Σ_i Σ_j (p_i − y_j)² = (1/N) Σ_i (p_i − ȳ)² + Var(y)

ডান দিকের প্রথম অংশ ছোট হয় যখন সব অনুমান গড়ের সমান। অর্থাৎ ভুল loss model-কে শেখায় যে সবাইকে গড় বলাই সবচেয়ে ভালো। নিখুঁত অনুমানে (p_i = y_i) এই loss হয় ২ × Var(y), গড় বলায় মাত্র Var(y): ভুল loss নিখুঁত model-কে শাস্তি দেয়।

import numpy as np

rng = np.random.default_rng(42)
y = rng.normal(5, 2, 6)                          # ৬ জনের আসল খরচ, আকার (6,)
pred = y.reshape(-1, 1)                          # model-এর output: নিখুঁত, কিন্তু আকার (6, 1)
diff = pred - y                                  # (6,1) − (6,) → broadcasting → (6, 6)
print("diff-এর আকার:", diff.shape)
print("ভুল loss, নিখুঁত অনুমানে :", round((diff ** 2).mean(), 4))
const = np.full((6, 1), y.mean())                # সবার জন্য একই সংখ্যা: গড়
print("ভুল loss, শুধু গড় বললে  :", round(((const - y) ** 2).mean(), 4))
print("y-এর variance, 2×variance:", round(y.var(), 4), round(2 * y.var(), 4))
print("ঠিক loss, নিখুঁত অনুমানে :", round(((pred[:, 0] - y) ** 2).mean(), 4))
assert pred.squeeze(1).shape == y.shape          # এই এক লাইন বাগটি আগেই ধরত

diff-এর আকার: (6, 6)
ভুল loss, নিখুঁত অনুমানে : 9.6597
ভুল loss, শুধু গড় বললে  : 4.8298
y-এর variance, 2×variance: 4.8298 9.6597
ঠিক loss, নিখুঁত অনুমানে : 0.0

বাজারঘরে সত্যিকারের run: একই ৪০০ ক্রেতার পরের মাসের খরচ (হাজার টাকা, অর্ডার × basket থেকে বানানো target, noise-সহ), ৫ → ৬৪ → ১-এর MLP, Adam, ৩০০ ধাপ:

~/bazarghar-dl$ uv run python broadcast.py
target sd 4.763 | var 22.6312
bug=False | diff (400,) | train loss 0.2547 | val R2 0.981 | pred sd 4.697
bug=True  | diff (400, 400) | train loss 22.6325 | val R2 -0.003 | pred sd 0.050
nn.MSELoss: Using a target size (torch.Size([4])) that is different to the input size (torch.Size([4, 1])). …

বাগসহ train loss ২২.৬৩২৫, target-এর variance ২২.৬৩১২-এর প্রায় সমান, আর অনুমানের sd মাত্র ০.০৫০: model সবাইকে প্রায় একই সংখ্যা বলছে, val R² −০.০০৩. ঠিক কোডে R² ০.৯৮১. লক্ষ করুন, PyTorch-এর নিজের nn.MSELoss এই অমিলে UserWarning দেয়; হাতে লেখা loss কিছুই বলে না। তাই warning কখনো উপেক্ষা করবেন না, আর হাতে loss লিখলে shape নিজে যাচাই করুন। Loss-এর মান target-এর variance-এর সমান হয়ে আটকে থাকা এই বাগের চেনা লক্ষণ।

৬ · Learning rate, gradient norm আর dead ReLU

Learning rate সবচেয়ে সংবেদনশীল hyperparameter (পর্ব ১৫ Optimizer আর learning-rate schedule). খুব ছোট হলে loss ধীরে নামে, দেখতে underfitting-এর মতো। খুব বড় হলে দুই রকম ব্যর্থতা হয়, আর অংশ ৩-এর run দুটোই দেখিয়েছে:

দুটিই ধরা যায় দুটি সংখ্যা নিয়মিত লগ করে। প্রথমটি gradient norm: সব parameter-এর gradient এক লম্বা vector ধরে তার দৈর্ঘ্য। torch.nn.utils.clip_grad_norm_(model.parameters(), float("inf")) কিছু কাটে না, শুধু মোট norm ফেরত দেয়, তাই মাপার সহজ উপায়। সুস্থ run-এ এটি মোটামুটি স্থির পরিসরে থাকে; ধাপে ধাপে দশ গুণ বাড়লে বিস্ফোরণ, প্রায় ০ হলে শেখা থেমে গেছে। Clipping দিয়ে বিস্ফোরণ সামলানো আর gradient-এর মাপ layer ধরে দেখা পর্ব ১৭ (Vanishing আর exploding gradient)-এর বিষয়।

দ্বিতীয়টি dead ReLU-এর ভাগ: প্রতিটি hidden unit-এর output সব train উদাহরণে দেখে, যার সর্বোচ্চ মানও ০, সে মৃত। আমাদের script-এ মাপার কোড দুই লাইন:

def dead_frac(model, X):                          # সব train input-এ ০ দেয় এমন ReLU unit
    with torch.no_grad():
        h1 = model[1](model[0](X)); h2 = model[3](model[2](h1))
    return (h1.amax(0) == 0).float().mean().item(), (h2.amax(0) == 0).float().mean().item()

সঠিক run-এ ভাগ ২% আর ৮%: কিছু মৃত unit স্বাভাবিক। LR ১০ গুণে ১২% আর ৯৪%, normalise ছাড়া দ্বিতীয় layer-এ ১০০%. বড় model-এ একই হিসাব forward hook দিয়ে করা যায় (পর্ব ০৮-এ hook). প্রতিকার সাধারণত ছোট learning rate, ঠিক normalise আর init; Leaky ReLU বা GELU-এর মতো activation-এ ঢাল কখনো পুরো ০ হয় না (পর্ব ০৩)। Learning rate কত হওয়া উচিত তা খুঁজতে LR range test আর schedule পর্ব ১৫-এ; optimizer-গুলোর গণিত মেশিন লার্নিং কোর্সের পর্ব ১৪-এ।

৭ · NaN শিকার — isfinite আর set_detect_anomaly

NaN একবার ঢুকলে প্রতিটি হিসাবে ছড়ায়: NaN-এর সঙ্গে যেকোনো যোগ বা গুণ NaN. তাই শেষে NaN দেখে লাভ নেই; খুঁজতে হবে প্রথম কোথায় এল। দুটি হাতিয়ার:

• torch.isfinite পরীক্ষা: প্রতি ধাপে loss আর gradient norm সসীম কি না দেখা, না হলে সেই ধাপেই থামা আর সব লগ রাখা। খরচ প্রায় নেই, তাই production training-এও রাখা যায়।
• Anomaly detection: torch.autograd.set_detect_anomaly(True) চালু করলে backward-এ কোনো function NaN ফেরত দিলেই PyTorch error তোলে, আর সেই function যে forward লাইনে তৈরি হয়েছিল তার traceback দেখায়। এটি প্রতিটি ধাপ ধীর করে, তাই শুধু ডিবাগের সময়।

LR ১০০ গুণ (SGD lr ১০, momentum ০.৯) দিয়ে প্রতি ধাপে loss, gradient norm আর সবচেয়ে বড় weight লগ করা হলো:

torch.autograd.set_detect_anomaly("--anomaly" in sys.argv)
for xb, yb in dl:
    loss = F.cross_entropy(model(xb), yb)
    opt.zero_grad(); loss.backward()
    gn = torch.nn.utils.clip_grad_norm_(model.parameters(), float("inf"))  # শুধু মাপা
    wmax = max(p.abs().max().item() for p in model.parameters())
    print(f"step {step:2d} loss {loss.item():.4g} grad_norm {gn.item():.4g} max|w| {wmax:.4g}")
    if not (torch.isfinite(loss) and torch.isfinite(gn)):
        print(f"অসীম/NaN ধরা পড়ল step {step}-এ; থামছি"); sys.exit(1)
    opt.step(); step += 1

~/bazarghar-dl$ uv run python nan_hunt.py
step  0 loss 1.125 grad_norm 0.5253 max|w| 0.447
step  1 loss 3.627 grad_norm 4.966 max|w| 0.9057
step  2 loss 161.1 grad_norm 61.42 max|w| 9.012
step  3 loss 1.18e+05 grad_norm 7997 max|w| 132.3
step  4 loss 4.93e+04 grad_norm 2.072e+04 max|w| 4.091e+04
step  5 loss 2.236e+09 grad_norm 1.88e+08 max|w| 7.773e+04
step  6 loss 2.606e+20 grad_norm 1.366e+15 max|w| 9.557e+08
step  7 loss nan grad_norm nan max|w| 6.311e+15
অসীম/NaN ধরা পড়ল step 7-এ; থামছি

Anomaly মোডের সত্যিকারের আউটপুট (পথ ছোট করা, traceback-এর মাঝের লাইন বাদ):

~/bazarghar-dl$ uv run python -u nan_hunt.py --anomaly
step  0 loss 1.125 grad_norm 0.5253 max|w| 0.447
…
step  6 loss 2.606e+20 grad_norm 1.366e+15 max|w| 9.557e+08
…/torch/autograd/graph.py:1113: UserWarning: Error detected in LogSoftmaxBackward0. Traceback of forward call that caused the error:
  File "~/bazarghar-dl/nan_hunt.py", line 16, in <module>
    loss = F.cross_entropy(model(xb), yb)
  File "…/torch/nn/functional.py", line 3561, in cross_entropy
    return torch._C._nn.cross_entropy_loss(
…
Traceback (most recent call last):
  File "~/bazarghar-dl/nan_hunt.py", line 17, in <module>
    opt.zero_grad(); loss.backward()
…
RuntimeError: Function 'LogSoftmaxBackward0' returned nan values in its 0th output.

NaN-এর সাধারণ উৎসগুলোর একটি তালিকা রাখুন: খুব বড় learning rate; ০ বা ঋণাত্মক সংখ্যার log বা sqrt (যেমন হাতে লেখা loss-এ log(p), যেখানে p ০ হতে পারে); ০ দিয়ে ভাগ (sd ০ এমন কলাম normalise করা); ডেটাতেই NaN (খালি ঘর); আর mixed precision-এ float16-এর ছোট পরিসর (পর্ব ১২)। ডেটার NaN ধরতে প্রথম batch-এ torch.isfinite(xb).all() একবার দেখে নিন।

৮ · খুব ভালো ফলও বাগ — duplicate আর leakage

বেশিরভাগ বাগ ফল খারাপ করে। কিন্তু data leakage ফল ভালো দেখায়, তাই সবচেয়ে বিপজ্জনক: কেউ সেটি খোঁজে না। একটি পরিচিত রূপ duplicate: একই উদাহরণ ডেটাসেটে একাধিকবার আছে, আর এলোমেলো split-এ একটি কপি train-এ, আরেকটি validation-এ পড়ে। তখন validation আর "নতুন" ডেটা নয়, model শুধু মুখস্থ উত্তর বলে। Split আর leakage-এর ভিত্তি AI-এর ভিত্তি কোর্সের পর্ব ৫৬-এ।

বাজারঘরে ধরা যাক export-এর ভুলে (যেমন ক্রেতার টেবিল অর্ডারের টেবিলের সঙ্গে join করায়) প্রতিটি ক্রেতার সারি ১ থেকে ৩ বার এসেছে। তারপর এলোমেলো split, বড় একটি MLP (৫ → ২৫৬ → ২৫৬ → ৩), ৩০০ ধাপ, আর আসল পরীক্ষা হিসেবে ১,০০০ জন একদম নতুন ক্রেতা (সত্যিকারের run):

~/bazarghar-dl$ uv run python leak.py
leaky: rows 1235 | val rows seen in train 65% | train acc 1.000 | val acc 0.893 | new-customer test acc 0.708
dedup: rows 600 | val rows seen in train 0% | train acc 1.000 | val acc 0.750 | new-customer test acc 0.732

Duplicate-সহ val accuracy ০.৮৯৩, অথচ নতুন ক্রেতায় ০.৭০৮: ১৮ শতাংশ-বিন্দুর মিথ্যা আশা। Val-এর ৬৫% সারি হুবহু train-এও আছে, আর model train-এ ১.০০০ accuracy পেয়ে সেগুলো মুখস্থ করেছে, ১০% ভুল label-সহ। Duplicate সরিয়ে split করলে val ০.৭৫০, নতুন ক্রেতার ০.৭৩২-এর কাছে: এখন val সৎ। লক্ষণটি মনে রাখুন: val-এর ফল train-এর খুব কাছে, আর আগের অভিজ্ঞতা বা সহজ baseline-এর চেয়ে অবিশ্বাস্য ভালো।

ধরার উপায়: split-এর আগে duplicate খোঁজা (script-এ প্রতিটি সারির byte দিয়ে একটি set, r.tobytes() in seen), আর একই ক্রেতা, একই রোগী বা একই ছবির বিভিন্ন কপি থাকলে সারি নয়, ক্রেতা ধরে split (group split). ছবি আর লেখায় হুবহু নয়, প্রায়-একই কপিও সমস্যা; সেখানে embedding-এর দূরত্ব দিয়ে খোঁজা হয় (পরের মডিউলগুলোতে embedding আসবে)। আরও কয়েকটি leakage-এর উৎস: পুরো ডেটার গড় দিয়ে normalise করে তারপর split, ভবিষ্যতের তথ্য থেকে বানানো feature, আর test set দেখে বারবার hyperparameter বদলানো।

৯ · Learning curve পড়া — আর বাগ বারবার দেখানো

Learning curve মানে epoch বা ধাপ ধরে train আর validation loss-এর লেখচিত্র। এর আকার দেখে বেশিরভাগ সমস্যা চেনা যায়, অনেকটা ক্রিকেটের ওভার-প্রতি রানের ছবি দেখে ইনিংসের গল্প বোঝার মতো। Validation আর train loss-এর পার্থক্য generalization gap; সেটি বড় আর বাড়তে থাকলে overfitting (তত্ত্ব AI-এর ভিত্তি কোর্সের পর্ব ৬১-এ)। নিচের ব্লক ছয়টি বানানো curve তৈরি করে, আর একটি ছোট নিয়ম-ভিত্তিক function প্রতিটির ধরন বলে:

import numpy as np, matplotlib.pyplot as plt

rng = np.random.default_rng(42); e = np.arange(1, 61)            # ৬০ epoch
n = lambda s: rng.normal(0, s, 60)                               # epoch-এর ছোট ওঠানামা
dec = lambda k: np.exp(-e / k)
curves = {                                                       # (train loss, val loss)
    "A": (0.9 * dec(8) + 0.25 + n(.01), 0.9 * dec(8) + 0.32 + n(.01)),
    "B": (0.95 - 0.12 * (1 - dec(15)) + n(.005), 0.97 - 0.12 * (1 - dec(15)) + n(.005)),
    "C": (1.0 * dec(10) + 0.05, 0.45 + 0.6 * dec(6) + 0.0004 * (e - 12).clip(0) ** 2),
    "D": (np.where(e < 25, 1.1 * 1.9 ** (e - 1), np.nan), np.where(e < 25, 1.2 * 1.9 ** (e - 1), np.nan)),
    "E": (np.where(e < 25, 1.10, 1.10 - 0.8 * (1 - np.exp(-(e - 25) / 4))) + n(.004),
          np.where(e < 25, 1.11, 1.11 - 0.75 * (1 - np.exp(-(e - 25) / 4))) + n(.004)),
    "F": (0.8 * dec(8) + 0.35 + n(.08), 0.8 * dec(8) + 0.42 + n(.1)),
}
def diagnose(tr, va):
    if not np.all(np.isfinite(tr)) or tr[-1] > tr[0]: return "diverged: LR too high"
    if np.std(np.diff(tr[-20:])) > 0.05: return "noisy: small batch / high LR"
    if np.ptp(tr[:15]) < 0.03 * tr[0] and tr[-1] < 0.7 * tr[0]: return "plateau, then escape"
    if va[-1] - va.min() > 0.1 and va[-1] - tr[-1] > 0.2: return "overfitting"
    if tr[-1] > 0.6 * tr[0]: return "underfitting"
    return "healthy"

fig, axs = plt.subplots(2, 3, figsize=(10, 5.6))
for ax, (k, (tr, va)) in zip(axs.flat, curves.items()):
    label = diagnose(tr, va); print(k, "→", label)
    ax.plot(e, tr, label="train"); ax.plot(e, va, label="val"); ax.set_title(f"{k}: {label}", fontsize=9)
    ax.set_xlim(0, 61)
    if "diverged" in label: ax.set_yscale("log")
    else: ax.set_ylim(0, 1.5)
for ax in axs[1]: ax.set_xlabel("epoch")
for ax in axs[:, 0]: ax.set_ylabel("loss")
axs[0, 0].legend(); fig.subplots_adjust(hspace=0.35, wspace=0.3); plt.show()

A → healthy
B → underfitting
C → overfitting
D → diverged: LR too high
E → plateau, then escape
F → noisy: small batch / high LR

দুটি সতর্কতা। প্রথম, train loss সাধারণত epoch চলার সময় dropout-সহ মাপা গড়, val loss epoch শেষে eval mode-এ; তাই শুরুর দিকে val loss train-এর চেয়ে কম দেখাতে পারে, সেটি বাগ নয়। দ্বিতীয়, শুধু loss নয়, যে metric আপনার কাছে জরুরি (accuracy, F1) সেটিও আঁকুন; অংশ ৫-এ accuracy ঠিক থেকেও loss ভুল ছিল।

বাগ বারবার একইভাবে দেখানো

অংশ ৭-এর NaN প্রতিবার ঠিক ধাপ ৭-এ এসেছে, কারণ script-এ torch.manual_seed(0) আর DataLoader-এর নিজস্ব seed দেওয়া Generator আছে (পর্ব ১০)। যে বাগ মাঝে মাঝে আসে, seed ঠিক না করলে তাকে ধরা প্রায় অসম্ভব: ঠিক করার পরে সমস্যা চলে গেল, নাকি এবার ভাগ্য ভালো ছিল, বোঝা যায় না। তাই বাগ পেলে প্রথমে seed, ডেটার ক্রম আর library version লিখে রাখুন, সম্ভব হলে বাগটি একটি ছোট script-এ ছোট ডেটায় আলাদা করুন, তারপর ঠিক করুন। Seed-এর পুরো তালিকা আর deterministic মোড পর্ব ১৯ (Deep learning experiment)-এ, আর experiment লেখার অভ্যাস মেশিন লার্নিং কোর্সের পর্ব ৪-এ।

১০ · AI-এর যুগে — AI-কে দিয়ে ডিবাগ করানো, সাবধানে

Training-এর log বা কোড AI assistant-কে দেখিয়ে "কেন শিখছে না?" জিজ্ঞেস করা এখন সাধারণ অভ্যাস, আর অনেক সময় কাজেও লাগে। কিন্তু AI-এর ডিবাগ পরামর্শেরও পরিচিত দুর্বলতা আছে, আর সেগুলো এই পর্বের বাগগুলোর সঙ্গেই মেলে।

AI-এর ডিবাগ পরামর্শ হাতে পেলে — যাচাইয়ের চেকলিস্ট

• ডেটা পরীক্ষা model-এ ঢোকার ঠিক আগের tensor-এ করেছি: label গোনা, শ্রেণিভিত্তিক গড়, feature-এর sd
• শুরুর loss ln C-এর কাছে কি না দেখেছি
• Dropout আর weight decay বন্ধ রেখে একটি ছোট batch overfit করিয়েছি
• প্রতি ধাপে loss আর gradient norm লগ করছি, isfinite পরীক্ষা আছে
• Loss-এর আগে output আর target-এর shape assert করেছি; কোনো warning উপেক্ষা করিনি
• Split-এর আগে duplicate খুঁজেছি আর normalise শুধু train থেকে
• ঠিক হয়েছে কি না কয়েকটি seed-এ দেখেছি, আর কোনো আসল গ্রাহকের ডেটা বা key AI-তে পেস্ট করিনি