Training loop — loss, optimizer, train/eval mode আর checkpoint

এই কোর্সের পর্ব ০৫-এ নিজের autograd দিয়ে MLP শিখিয়েছেন, আর দেখেছেন zero_grad ছাড়া gradient জমে যায়। এই মডিউলের আগের তিন পর্ব, পর্ব ০৭ (PyTorch tensor), পর্ব ০৮ (PyTorch autograd) আর পর্ব ০৯ (nn.Module দিয়ে model বানানো), tensor, gradient আর model-এর কাঠামো দেয়। এই পর্বে সব জোড়া লাগিয়ে একটি পূর্ণ training loop লিখব, যা আপনি বাকি কোর্স জুড়ে বারবার ব্যবহার করবেন। Optimizer-এর গণিত মেশিন লার্নিং কোর্সের পর্ব ১৪-এ derive করা আছে; এখানে শুধু তার ব্যবহার। PyTorch পাতায় চলে না, তাই PyTorch-এর সব আউটপুট ডেস্কটপের সত্যিকারের run থেকে নেওয়া; পাতায় চালানো যায় এমন তিনটি ব্লক একই ধারণা NumPy দিয়ে দেখায় (প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে)।

১ · এক training ধাপের পাঁচটি কাজ

PyTorch-এ এই পাঁচটি কাজ পাঁচটি লাইন। Mini-batch-এর input xb আর label yb হাতে থাকলে:

logits = model(xb)          # ১ forward: graph তৈরি হয়
loss = loss_fn(logits, yb)  # ২ loss: একটি scalar
opt.zero_grad()             # ৩ আগের ধাপের .grad মোছা
loss.backward()             # ৪ প্রতিটি parameter-এর .grad লেখা
opt.step()                  # ৫ .grad দেখে parameter বদলানো

এখানে opt একটি optimizer: যে object model-এর parameter-গুলোর তালিকা রাখে আর step()-এ নিয়ম মেনে সেগুলো বদলায়। নিচের ছবিতে পুরো loop: বাঁ দিকে প্রতি batch-এ ঘোরা train অংশ, ডান দিকে প্রতি epoch-এ একবার validation আর সিদ্ধান্ত।

এখন পাঁচটি কাজ খুব ছোট একটি উদাহরণে দেখি, যাতে প্রতিটি সংখ্যা চোখে পড়ে: nn.Linear(2, 3), চারটি উদাহরণ, তিনটি শ্রেণি, SGD (learning rate ০.১, momentum ০.৯)। নজর রাখুন weight-এর একটি ঘর w[0,0]-এর ওপর। সব সংখ্যা নিচের সত্যিকারের run থেকে।

সংখ্যাগুলো এসেছে এই ছোট কোড থেকে (পুরো script extras.py-এর একটি অংশ; uv project তৈরির ধাপ অংশ ৭-এ):

torch.manual_seed(0)
lin = nn.Linear(2, 3)
x = torch.tensor([[0.5, -1.0], [1.5, 0.2], [-0.3, 0.8], [1.0, 1.0]]); y = torch.tensor([0, 2, 1, 2])
opt = torch.optim.SGD(lin.parameters(), lr=0.1, momentum=0.9)
print("start w[0,0] =", round(lin.weight[0, 0].item(), 4), "| grad:", lin.weight.grad)
logits = lin(x); print("1 forward: logits", tuple(logits.shape), logits.grad_fn.name())
loss = F.cross_entropy(logits, y); print("2 loss:", round(loss.item(), 4))
opt.zero_grad(); print("3 zero_grad: grad =", lin.weight.grad)
loss.backward(); print("4 backward: grad[0,0] =", round(lin.weight.grad[0, 0].item(), 4),
                       "| w[0,0] unchanged =", round(lin.weight[0, 0].item(), 4))
opt.step(); print("5 step: w[0,0] =", round(lin.weight[0, 0].item(), 4))
with torch.no_grad(): print("next loss:", round(F.cross_entropy(lin(x), y).item(), 4))

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

~/bazarghar-dl$ uv run python extras.py step
torch 2.15.0+cpu | numpy 2.5.4 | python 3.14.4
start w[0,0] = -0.0053 | grad: None
1 forward: logits (4, 3) AddmmBackward0
2 loss: 1.3007
3 zero_grad: grad = None
4 backward: grad[0,0] = 0.1648 | w[0,0] unchanged = -0.0053
5 step: w[0,0] = -0.0218
next loss: 1.2371

২ · Loss: logits, CrossEntropyLoss আর BCEWithLogitsLoss

Model-এর শেষ Linear layer যে কাঁচা সংখ্যা দেয়, সেগুলো logits: যেকোনো বাস্তব সংখ্যা, যোগফল ১ হওয়ার শর্ত নেই। শ্রেণিবিভাগে প্রচলিত loss cross-entropy, আর PyTorch-এ তার রূপ nn.CrossEntropyLoss; এটি দুটি জিনিস চায়: আকার (N, C)-এর float logits, আর আকার (N,)-এর int64 শ্রেণি-সূচক (০ থেকে C − ১)। ভেতরে সে log-softmax আর negative log-likelihood একসঙ্গে করে, log-sum-exp কৌশলে, যাতে বড় logits-এও overflow না হয় (পর্ব ০৩-এর stable softmax). Gradient-ও সরল: ∂L/∂z = p − y_one-hot, ঠিক পর্ব ০৪-এর P − Y.

দুটি লেখার ধরন আছে: module (nn.CrossEntropyLoss(), একবার তৈরি করে বারবার ডাকা; class weight, label_smoothing, reduction এর ভেতরে থাকে) আর function (F.cross_entropy(logits, y)). ফল একই। দুই শ্রেণির (হ্যাঁ/না) সমস্যায় একটি logit আর float label নিয়ে BCEWithLogitsLoss, যা sigmoid আর binary cross-entropy একসঙ্গে স্থিরভাবে করে। আলাদা sigmoid + BCELoss লিখলে কী হয়, সত্যিকারের run-এ দেখুন:

~/bazarghar-dl$ uv run python extras.py losses
torch 2.15.0+cpu | numpy 2.5.4 | python 3.14.4
nn.CrossEntropyLoss: 0.2413 | F.cross_entropy: 0.2413 | -log softmax: 0.2413
BCEWithLogitsLoss(200, 0): 200.0
BCELoss(sigmoid(200), 0): 100.0
scheduler আগে: UserWarning - Detected call of `lr_scheduler.step()` before `optimizer.step()`.

প্রথম লাইনে logits [২, ০.৫, −১] আর সঠিক শ্রেণি ০-এর জন্য তিনটি পথ একই ০.২৪১৩ দিল। পরের দুই লাইন সংখ্যাগত স্থিরতার গল্প: logit ২০০ আর আসল label ০ হলে সঠিক loss ২০০. Sigmoid(২০০) float32-এ হুবহু ১.০ হয়ে যায়, log(১ − ১) = −∞, আর BCELoss log-কে −১০০-এ কেটে দেয়; ফলে loss আটকে যায় ১০০-তে। শেষ লাইনটি অংশ ৩-এর বিষয়।

সবচেয়ে প্রচলিত ভুল: model-এর শেষে softmax বসিয়ে সেই probability CrossEntropyLoss-এ দেওয়া। তখন softmax দুবার চলে। নিচের ব্লক NumPy-তে তিনটি logits-এর জন্য দুই পথের loss আর gradient-এর আকার মাপে।

import numpy as np

def softmax(z):
    e = np.exp(z - z.max()); return e / e.sum()

def ce_and_grad(z, y, double=False):            # একটি উদাহরণ, ৩টি শ্রেণি
    p = softmax(z)
    if not double:                              # ঠিক: CE সরাসরি logits-এ
        g = p.copy(); g[y] -= 1                 # ∂L/∂z = p − one-hot
        return -np.log(p[y]), g
    q = softmax(p)                              # ভুল: probability-কে আবার softmax
    gq = q.copy(); gq[y] -= 1                   # ∂L/∂p
    J = np.diag(p) - np.outer(p, p)             # softmax-এর Jacobian
    return -np.log(q[y]), J @ gq                # chain rule: ∂L/∂z

y = 0                                           # সঠিক শ্রেণি 0
for z in ([4.0, 0.0, 0.0], [0.0, 4.0, 0.0], [0.0, 0.0, 0.0]):
    z = np.array(z)
    l1, g1 = ce_and_grad(z, y); l2, g2 = ce_and_grad(z, y, double=True)
    print(f"logits {z} | ঠিক: loss {l1:.4f}, |grad| {np.linalg.norm(g1):.4f}"
          f" | softmax-এর পরে: loss {l2:.4f}, |grad| {np.linalg.norm(g2):.4f}")
best = -np.log(softmax(np.array([1.0, 0.0, 0.0]))[0])
print(f"softmax-এর পরে loss-এর নিচের সীমা (৩ শ্রেণি): {best:.4f}")

logits [4. 0. 0.] | ঠিক: loss 0.0360, |grad| 0.0433 | softmax-এর পরে: loss 0.5743, |grad| 0.0274
logits [0. 4. 0.] | ঠিক: loss 4.0360, |grad| 1.3769 | softmax-এর পরে: loss 1.5213, |grad| 0.0374
logits [0. 0. 0.] | ঠিক: loss 1.0986, |grad| 0.8165 | softmax-এর পরে: loss 1.0986, |grad| 0.2722

softmax-এর পরে loss-এর নিচের সীমা (৩ শ্রেণি): 0.5514

৩ · Optimizer আর scheduler — SGD-momentum, AdamW আর ডাকার ক্রম

torch.optim-এর optimizer-কে parameter-এর তালিকা দিয়ে তৈরি করতে হয়: torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9) বা torch.optim.AdamW(model.parameters(), lr=3e-3, weight_decay=1e-2). Momentum আগের ধাপগুলোর একটি চলমান যোগফল রাখে; Adam প্রতিটি parameter-এর জন্য gradient-এর গড় আর বর্গের গড় রাখে; AdamW তার সঙ্গে weight decay gradient-এ না মিশিয়ে আলাদাভাবে ওজন ছোট করে। এই তিনটির derivation আর তুলনা মেশিন লার্নিং কোর্সের পর্ব ১৪-এ; SGD আর mini-batch-এর ভিত্তি পর্ব ১৩-এ।

এই পর্বের জন্য একটি ব্যবহারিক কথাই জরুরি: optimizer-এর নিজের অবস্থা (state) আছে। AdamW-এর প্রতিটি parameter-এর পাশে exp_avg আর exp_avg_sq নামে সমান আকারের দুটি tensor আর একটি step গণনা থাকে, যা opt.state_dict()-এ ধরা পড়ে। তাই training থামিয়ে আবার শুরু করলে শুধু model-এর weight ফেরালে চলে না (অংশ ৮)। আর param_groups-এ থাকে learning rate আর weight decay; আলাদা layer-এ আলাদা learning rate দিতে চাইলে এখানেই দেওয়া হয়।

Learning-rate schedule training চলার সঙ্গে learning rate বদলায়। PyTorch-এ scheduler একটি আলাদা object, যা optimizer-এর lr বদলে দেয়। নিয়ম: scheduler.step() সবসময় optimizer.step()-এর পরে। PyTorch 1.1 থেকে এই ক্রম চালু; উল্টো ক্রমে ডাকলে PyTorch সতর্ক করে, যা আগের run-এর শেষ লাইনে দেখেছেন: UserWarning - Detected call of lr_scheduler.step() before optimizer.step(). উল্টো ক্রমে schedule-এর প্রথম মানটি বাদ পড়ে যায়। কোন scheduler প্রতি epoch-এ আর কোনটি প্রতি batch-এ ডাকতে হয়, আর warmup ও cosine, তা পর্ব ১৫ (Optimizer আর learning-rate schedule)-এর বিষয়।

৪ · Validation loop — model.eval() আর torch.no_grad() কেন দুটোই

Validation-এর উদ্দেশ্য মাপা, শেখা নয়। তাই সেখানে দুটি জিনিস বদলাতে হয়, আর দুটির জন্য দুটি আলাদা সুইচ:

দুটির প্রভাব আলাদা করে দেখতে বাজারঘরের best model (অংশ ৭) দিয়ে ২০০টি validation উদাহরণে চারটি অবস্থায় দুবার করে loss মাপা হলো (model-এ ০.২ হারের দুটি dropout layer আছে):

৫ · Metric ঠিকভাবে গড় করা — অসমান শেষ batch

CrossEntropyLoss-এর default reduction="mean", তাই প্রতিটি batch-এর loss সেই batch-এর উদাহরণগুলোর গড়। ২০০টি উদাহরণকে ৬৪-র batch-এ ভাগ করলে আকার হয় ৬৪, ৬৪, ৬৪ আর ৮. চারটি batch-এর গড়ের সরল গড় নিলে শেষের ৮টি উদাহরণ বাকি ১৯২টির সমান ওজন পায়। পুরো সেটের আসল গড় পেতে প্রতিটি batch-এর মানকে তার আকার n_b দিয়ে ওজন দিতে হয়:

সঠিক গড় = Σ_b n_b · m_b / Σ_b n_b

এখানে m_b হলো batch b-এর গড় loss বা accuracy. এটিই weighted mean; কোডে সহজ রূপ হলো total += loss.item() * len(yb), শেষে total / n. বাজারঘরের best model-এ সত্যিকারের run:

~/bazarghar-dl$ uv run python extras.py val
torch 2.15.0+cpu | numpy 2.5.4 | python 3.14.4
best.pt epoch: 4 | keys: ['epoch', 'model', 'optimizer', 'best_val', 'bad_epochs', 'torch_rng', 'loader_rng']
batch sizes: [64, 64, 64, 8] | batch loss: [0.5634, 0.8096, 0.4105, 0.3248]
naive mean loss 0.5271 | weighted 0.5837 | full set 0.5837
naive mean acc 0.8164 | weighted 0.8000
train grad=True  | val loss x2 [0.5925, 0.6086] | requires_grad True
train grad=False | val loss x2 [0.5706, 0.6234] | requires_grad False
eval  grad=True  | val loss x2 [0.5837, 0.5837] | requires_grad True
eval  grad=False | val loss x2 [0.5837, 0.5837] | requires_grad False

শেষের ৮টি উদাহরণের loss ছোট (০.৩২৪৮), আর সরল গড় তাকে এক-চতুর্থাংশ ওজন দিয়ে val loss ০.৫৮৩৭ থেকে ০.৫২৭১-এ নামিয়ে দিল, প্রায় ১০% আশাবাদী ভুল। Weighted গড় পুরো সেটে একবারে হিসাব করা মানের সঙ্গে হুবহু এক। নিচের ব্লকে একই কাজ দুটি ছোট function দিয়ে, আর দেখুন কখন দুটি পথ এক উত্তর দেয়।

import numpy as np

rng = np.random.default_rng(42)                 # ২০০টি val উদাহরণ, batch 64 → 64, 64, 64, 8
loss = rng.exponential(0.55, 200)               # প্রতিটি উদাহরণের loss
correct = rng.random(200) < 0.80                # প্রতিটি উদাহরণ ঠিক হলো কি না
loss[192:] *= 0.3; correct[192:] = True         # শেষ ছোট batch-টি "সহজ"

def batch_stats(bs):
    out = []                                    # প্রতি batch: (গড় loss, accuracy, আকার)
    for s in range(0, len(loss), bs):
        out.append((loss[s:s + bs].mean(), correct[s:s + bs].mean(), len(loss[s:s + bs])))
    return out

def naive(stats):                               # ভুল: প্রতিটি batch সমান ওজন
    return np.mean([l for l, a, n in stats]), np.mean([a for l, a, n in stats])

def weighted(stats):                            # ঠিক: batch-এর আকার দিয়ে ওজন
    N = sum(n for l, a, n in stats)
    return sum(l * n for l, a, n in stats) / N, sum(a * n for l, a, n in stats) / N

for bs in (64, 50):
    st = batch_stats(bs)
    print(f"batch {bs}: আকার {[n for *_, n in st]}")
    print("  naive    loss %.4f acc %.4f" % naive(st))
    print("  weighted loss %.4f acc %.4f" % weighted(st))
print(f"পুরো সেটের আসল মান: loss {loss.mean():.4f} acc {correct.mean():.4f}")

batch 64: আকার [64, 64, 64, 8]
  naive    loss 0.4372 acc 0.8516
  weighted loss 0.5156 acc 0.8100
batch 50: আকার [50, 50, 50, 50]
  naive    loss 0.5156 acc 0.8100
  weighted loss 0.5156 acc 0.8100
পুরো সেটের আসল মান: loss 0.5156 acc 0.8100

৬ · NumPy-তে পুরো loop — পাতাতেই চালিয়ে দেখুন

PyTorch-এর loop-এর প্রতিটি অংশের একটি NumPy প্রতিরূপ লিখলে বোঝা যায় কোন লাইন আসলে কী করে। নিচের ব্লকে তিন শ্রেণির ২ feature-এর ৩০০টি বিন্দু (১৫% label উল্টানো), ২৪০টি train আর ৬০টি validation; ২ → ৬৪ → ৩-এর একটি MLP; momentum-সহ SGD; ৩২-এর এলোমেলো mini-batch; প্রতি epoch-এ validation; ২০ epoch উন্নতি না হলে early stopping; আর সেরা weight-এর একটি কপি, যা একটি checkpoint-এর কাজ করে। Backward-এর সূত্র পর্ব ০৪-এর।

import numpy as np, matplotlib.pyplot as plt

rng = np.random.default_rng(42)                  # ৩ শ্রেণি, ২ feature, ১৫% label noise
y = rng.integers(0, 3, 300); X = rng.normal(0, 1.1, (300, 2)) + np.array([[0, 2], [2, -1], [-2, -1]])[y]
y = np.where(rng.random(300) < 0.15, rng.integers(0, 3, 300), y)
Xtr, ytr, Xva, yva = X[:240], y[:240], X[240:], y[240:]
P = {"W1": rng.normal(0, 0.5, (2, 64)), "b1": np.zeros(64), "W2": rng.normal(0, 0.3, (64, 3)), "b2": np.zeros(3)}
V = {k: np.zeros_like(v) for k, v in P.items()}  # momentum buffer (optimizer state)

def forward(X):
    H = np.maximum(X @ P["W1"] + P["b1"], 0); Z = H @ P["W2"] + P["b2"]
    Z = Z - Z.max(1, keepdims=True); p = np.exp(Z) / np.exp(Z).sum(1, keepdims=True)
    return H, p
def ce(p, y): return -np.log(p[np.arange(len(y)), y]).mean()

hist, best, bad = [], (np.inf, 0, None), 0
for epoch in range(1, 301):
    idx = rng.permutation(240); tot = 0.0
    for s in range(0, 240, 32):                  # শেষ batch ১৬টির
        b = idx[s:s + 32]; H, p = forward(Xtr[b])            # ১ forward
        tot += ce(p, ytr[b]) * len(b)                        # ২ loss (ওজনসহ যোগ)
        G = p.copy(); G[np.arange(len(b)), ytr[b]] -= 1; G /= len(b)   # ৩-৪ নতুন gradient
        dH = (G @ P["W2"].T) * (H > 0)
        g = {"W2": H.T @ G, "b2": G.sum(0), "W1": Xtr[b].T @ dH, "b1": dH.sum(0)}
        for k in P: V[k] = 0.9 * V[k] + g[k]; P[k] -= 0.05 * V[k]   # ৫ step
    va = ce(forward(Xva)[1], yva); hist.append((tot / 240, va))  # validation: শুধু forward
    if va < best[0]: best, bad = (va, epoch, {k: v.copy() for k, v in P.items()}), 0
    else: bad += 1
    if bad >= 20: break
print(f"থামল epoch {epoch}-এ | best epoch {best[1]}, val loss {best[0]:.4f}")
P = best[2]; acc = (forward(Xva)[1].argmax(1) == yva).mean()
print(f"best checkpoint-এ val accuracy {acc:.3f} | শেষ epoch-এ train loss {hist[-1][0]:.4f}")
h = np.array(hist); plt.plot(h[:, 0], label="train loss"); plt.plot(h[:, 1], label="val loss")
plt.axvline(best[1] - 1, ls="--", c="gray", label="best epoch"); plt.xlabel("epoch")
plt.ylabel("cross-entropy"); plt.legend(); plt.title("NumPy training loop with early stopping"); plt.show()

থামল epoch 33-এ | best epoch 13, val loss 0.4291
best checkpoint-এ val accuracy 0.833 | শেষ epoch-এ train loss 0.4681

৭ · PyTorch-এ পূর্ণ training — বাজারঘরের customer segment

এবার আসল PyTorch. বাজারঘর তাদের ক্রেতাদের তিনটি দলে ভাগ করতে চায়: মাঝেমধ্যে কেনেন (occasional), নিয়মিত (regular), আর ছাড় খোঁজেন (deal_seeker). প্রতিটি ক্রেতার ৫টি feature: মাসে অর্ডার, গড় ঝুড়ির দাম (টাকা), শেষ অর্ডারের পর কত দিন, ছাড়ের পণ্যের ভাগ, আর অ্যাপ থেকে কেনার ভাগ। ডেটা বানানো আর seeded: ৬০০ জন ক্রেতা, ১০% label উল্টানো, অর্থাৎ label noise (বাস্তবেও label-এ ভুল থাকে)। Seed দেওয়া torch.Generator দিয়ে ২০০ জন validation-এ, ৪০০ জন train-এ; standardization-এর গড় আর মানবিচ্যুতি শুধু train থেকে, যাতে validation-এর তথ্য train-এ ঢুকে data leakage না ঘটে (AI-এর ভিত্তি কোর্সের পর্ব ৫৬)। Project আগের পর্বগুলোর মতো uv দিয়ে:

~/bazarghar-dl$ uv init --vcs none --author-from none --name bazarghar-dl --no-readme --python 3.14
Initialized project `bazarghar-dl`
# pyproject.toml-এ PyTorch-এর CPU wheel index যোগ করা হলো ([[tool.uv.index]], explicit = true)
~/bazarghar-dl$ uv add torch==2.15.0 numpy
 …
 + numpy==2.5.4
 …
 + torch==2.15.0+cpu
 …

Script-এর প্রথম অর্ধেক: ডেটা, DataLoader, model, optimizer আর এক epoch চালানোর function. run_epoch একই function-এ train আর validation দুটোই করে: model.train(False) আর model.eval() একই কাজ, আর torch.set_grad_enabled(False) = no_grad. Model-এ ১২৮ unit-এর দুটি hidden layer আর ০.২ হারের dropout, মোট ১৭,৬৬৭টি parameter (গোনার নিয়ম পর্ব ০৯-এ)।

import argparse, numpy as np, torch, torch.nn as nn
from torch.utils.data import TensorDataset, DataLoader
from bazarghar_data import split

ap = argparse.ArgumentParser()
ap.add_argument("--resume"); ap.add_argument("--stop-after", type=int)
ap.add_argument("--skip", choices=["rng", "optimizer"])     # পরীক্ষা: কিছু বাদ দিয়ে resume
args = ap.parse_args()
torch.manual_seed(0)
Xtr, ytr, Xva, yva = split()
g = torch.Generator().manual_seed(0)                   # shuffle-এর নিজস্ব RNG
train_dl = DataLoader(TensorDataset(Xtr, ytr), batch_size=64, shuffle=True, generator=g)
val_dl = DataLoader(TensorDataset(Xva, yva), batch_size=64)
model = nn.Sequential(nn.Linear(5, 128), nn.ReLU(), nn.Dropout(0.2),
                      nn.Linear(128, 128), nn.ReLU(), nn.Dropout(0.2), nn.Linear(128, 3))
opt = torch.optim.AdamW(model.parameters(), lr=3e-3, weight_decay=1e-2)
loss_fn = nn.CrossEntropyLoss()                        # logits + class index

def run_epoch(dl, train):
    model.train(train)                                 # train(False) == eval()
    total, correct, n = 0.0, 0, 0
    with torch.set_grad_enabled(train):                # validation-এ no_grad
        for xb, yb in dl:
            logits = model(xb)                         # ১ forward
            loss = loss_fn(logits, yb)                 # ২ loss
            if train:
                opt.zero_grad()                        # ৩ পুরোনো gradient মোছা
                loss.backward()                        # ৪ backward
                opt.step()                             # ৫ parameter আপডেট
            total += loss.item() * len(yb)             # batch-এর আকার দিয়ে ওজন
            correct += (logits.argmax(1) == yb).sum().item(); n += len(yb)
    return total / n, correct / n

দ্বিতীয় অর্ধেক: checkpoint সেভ, resume আর epoch-এর লুপ। Early stopping-এর patience ৮: val loss টানা ৮ epoch আগের সেরার চেয়ে না কমলে থামা। প্রতি epoch-এ last.pt সেভ হয় (থামলে ফেরার জন্য), আর সেরা হলে best.pt (শেষে ব্যবহারের জন্য)।

def save(path, epoch):
    torch.save({"epoch": epoch, "model": model.state_dict(), "optimizer": opt.state_dict(),
                "best_val": best_val, "bad_epochs": bad, "torch_rng": torch.get_rng_state(),
                "loader_rng": g.get_state()}, path)

start, best_val, bad, patience = 1, float("inf"), 0, 8
if args.resume:
    ck = torch.load(args.resume)                       # weights_only=True (default)
    model.load_state_dict(ck["model"])
    if args.skip != "optimizer": opt.load_state_dict(ck["optimizer"])
    if args.skip != "rng": torch.set_rng_state(ck["torch_rng"]); g.set_state(ck["loader_rng"])
    start, best_val, bad = ck["epoch"] + 1, ck["best_val"], ck["bad_epochs"]
    print(f"resumed from epoch {ck['epoch']}")
for epoch in range(start, 101):
    tr_loss, tr_acc = run_epoch(train_dl, True)
    va_loss, va_acc = run_epoch(val_dl, False)
    mark = ""
    if va_loss < best_val:
        best_val, bad, mark = va_loss, 0, " *best"
        save("best.pt", epoch)
    else:
        bad += 1
    print(f"ep {epoch:3d} | train {tr_loss:.4f} {tr_acc:.3f} | val {va_loss:.4f} {va_acc:.3f}{mark}")
    save("last.pt", epoch)
    if bad >= patience:
        print(f"early stop: val loss {patience} epoch ধরে কমেনি; best epoch {epoch - patience}"); break
    if args.stop_after == epoch:
        print("(interrupted)"); break
torch.save(model.state_dict(), "final_weights.pt")

সত্যিকারের run (ডেস্কটপ, CPU, Python 3.14.4, PyTorch 2.15.0 CPU build, NumPy 2.5.4; লেখার সময়ের সংস্করণ, পরে বদলাতে পারে; পুরো run কয়েক সেকেন্ডের):

~/bazarghar-dl$ uv run python train.py
ep   1 | train 0.8820 0.698 | val 0.6440 0.765 *best
ep   2 | train 0.5751 0.760 | val 0.6244 0.785 *best
ep   3 | train 0.5379 0.787 | val 0.6282 0.800
ep   4 | train 0.5355 0.797 | val 0.5837 0.800 *best
ep   5 | train 0.5219 0.782 | val 0.6157 0.810
ep   6 | train 0.5131 0.795 | val 0.6073 0.805
ep   7 | train 0.4961 0.797 | val 0.6242 0.780
ep   8 | train 0.5064 0.792 | val 0.6245 0.800
ep   9 | train 0.4871 0.810 | val 0.6314 0.795
ep  10 | train 0.4949 0.815 | val 0.6552 0.785
ep  11 | train 0.4946 0.797 | val 0.6372 0.805
ep  12 | train 0.4955 0.805 | val 0.6489 0.785
early stop: val loss 8 epoch ধরে কমেনি; best epoch 4

তিনটি পর্যবেক্ষণ। এক: Val loss epoch ৪-এ সবচেয়ে কম (০.৫৮৩৭), তারপর ৮ epoch আর কমেনি, তাই epoch ১২-এ থামা, আর best.pt-এ epoch ৪-এর model. দুই: Accuracy আর loss একসঙ্গে চলে না: epoch ৫-এ val accuracy ০.৮১০, সবচেয়ে বেশি, অথচ val loss বেড়েছে। Loss probability-র আত্মবিশ্বাসও মাপে, accuracy শুধু সবচেয়ে বড় শ্রেণি। এখানে best বাছা হয়েছে val loss দিয়ে; ব্যবসার লক্ষ্য accuracy হলে সেটা দিয়েও বাছা যায়, কিন্তু তা আগে থেকে ঠিক করুন। তিন: Train loss আর val loss সরাসরি তুলনীয় নয়: train-এর সংখ্যা dropout চালু রেখে, epoch চলার সময় বদলাতে থাকা weight দিয়ে মাপা; epoch ১-এ তাই train loss (০.৮৮২০) val loss-এর (০.৬৪৪০) চেয়ে বেশি। আর এটি একটি seed-এর একটি run; ২০০ জনের val-এ accuracy-র ০.০১ পার্থক্য মানে মাত্র ২ জন ক্রেতা।

৮ · Checkpoint আর resume — থামা জায়গা থেকে হুবহু একই পথে

Checkpoint হলো একটি dictionary, যা torch.save দিয়ে ফাইলে যায়: model আর optimizer-এর state_dict, loop-এর হিসাব আর RNG state. হুবহু resume-এর জন্য কী কী লাগে, আর কোনটি বাদ দিলে কী হয়, নিচের stepper-এ; “বাদ দিলে” সারির সংখ্যাগুলো সত্যিকারের পরীক্ষা: epoch ৬-এ থামিয়ে last.pt থেকে আবার চালানো, কখনো একটি অংশ বাদ দিয়ে।

এখন আসল পরীক্ষা: একবার অবিরাম ১২ epoch (full.log), আর একবার epoch ৬-এ থামিয়ে নতুন process-এ --resume last.pt. তারপর compare.py নামের ছোট script দুই run-এর শেষ weight (final_weights.pt) torch.equal দিয়ে আর epoch ৭–১২-এর log লাইন মেলায়।

~/bazarghar-dl$ uv run python train.py > full.log
~/bazarghar-dl$ cp final_weights.pt full_weights.pt      # অবিরাম run-এর weight আলাদা নামে
~/bazarghar-dl$ uv run python train.py --stop-after 6
 …
ep   6 | train 0.5131 0.795 | val 0.6073 0.805
(interrupted)
~/bazarghar-dl$ uv run python train.py --resume last.pt | tee resumed.log
resumed from epoch 6
ep   7 | train 0.4961 0.797 | val 0.6242 0.780
ep   8 | train 0.5064 0.792 | val 0.6245 0.800
 …
ep  12 | train 0.4955 0.805 | val 0.6489 0.785
early stop: val loss 8 epoch ধরে কমেনি; best epoch 4
~/bazarghar-dl$ uv run python compare.py
tensors: 6 | সব হুবহু এক (torch.equal): True
epoch 7-12 log লাইন এক: True

# আবার epoch 6-এ থামিয়ে, এবার RNG state বাদ দিয়ে resume
~/bazarghar-dl$ uv run python train.py --resume last.pt --skip rng | tee resumed.log
resumed from epoch 6
ep   7 | train 0.4802 0.802 | val 0.6251 0.775
 …
~/bazarghar-dl$ uv run python compare.py
tensors: 6 | সব হুবহু এক (torch.equal): False
epoch 7-12 log লাইন এক: False

# আবার epoch 6-এ থামিয়ে, এবার optimizer state বাদ দিয়ে
~/bazarghar-dl$ uv run python train.py --resume last.pt --skip optimizer | tee resumed.log
resumed from epoch 6
ep   7 | train 0.5133 0.787 | val 0.6236 0.795
 …
~/bazarghar-dl$ uv run python compare.py
tensors: 6 | সব হুবহু এক (torch.equal): False
epoch 7-12 log লাইন এক: False

সব কিছু রাখলে মিল নিখুঁত, শুধু কাছাকাছি নয়। এই ধরনের reproducibility-র নিশ্চয়তা একই যন্ত্র, একই library version আর CPU-র জন্য। GPU-তে কিছু কাজ নিজে থেকেই অনির্ধারিত (non-deterministic), তাই সেখানে হুবহু মিলের জন্য torch.use_deterministic_algorithms(True)-এর মতো বাড়তি ব্যবস্থা লাগে, আর কিছু কাজ ধীর হয় (পর্ব ১২ আর পর্ব ১৯)। DataLoader-এ একাধিক worker থাকলে তাদের seed-ও ভাবতে হয় (পর্ব ১১)।

৯ · তিনটি পরিচিত ভুল — সত্যিকারের ফল

এই তিনটি ভুল কোনো error দেয় না; শুধু model খারাপ শেখে বা ভুল সংখ্যা দেখায়। একই বাজারঘর ডেটা, একই model আর AdamW দিয়ে ১৫ epoch করে (early stopping ছাড়া) প্রতিটি ভুলসহ আর ভুল ছাড়া train করে মাপা হলো। Script-এর মূল অংশ:

def fit(bug=None, epochs=15):
    model = make(); g = torch.Generator().manual_seed(0)
    dl = DataLoader(TensorDataset(Xtr, ytr), batch_size=64, shuffle=True, generator=g)
    opt = torch.optim.AdamW(model.parameters(), lr=3e-3, weight_decay=1e-2)
    for ep in range(epochs):
        model.train()
        for xb, yb in dl:
            out = model(xb)
            if bug == "softmax": out = torch.softmax(out, dim=1)   # ভুল: CE নিজেই log-softmax করে
            loss = loss_fn(out, yb)
            if bug != "no_zero_grad": opt.zero_grad()
            loss.backward(); opt.step()
    model.eval()
    with torch.no_grad():
        tr = loss_fn(model(Xtr), ytr).item()
        va_logits = model(Xva)
        va = loss_fn(va_logits, yva).item(); acc = (va_logits.argmax(1) == yva).float().mean().item()
    gnorm = torch.cat([p.grad.flatten() for p in model.parameters()]).norm().item()
    return model, tr, va, acc, gnorm
# … তারপর প্রতিটি ভুলের জন্য fit() ডেকে print; eval-এর পরীক্ষায় একই model-এ val loss তিনবার

~/bazarghar-dl$ uv run python mistakes.py
== ১) softmax-এর পরে CrossEntropyLoss (15 epoch, আসল logits দিয়ে loss মাপা)
None     train 0.4425 | val 0.6886 acc 0.790 | ভুল সূত্রে train loss 0.7604
softmax  train 1.0142 | val 1.3202 acc 0.785 | ভুল সূত্রে train loss 0.7309
softmax-এর পরে CE-র সর্বনিম্ন মান: 0.5514
== ২) zero_grad ভুলে যাওয়া
None         train 0.4425 | val 0.6886 acc 0.790 | শেষ grad norm 0.90
no_zero_grad train 0.8812 | val 0.9776 acc 0.710 | শেষ grad norm 52.58
== ৩) model.eval() ভুলে যাওয়া (একই model, val loss তিনবার)
train mode: [0.7181, 0.6821, 0.6816]
eval mode:  [0.6886, 0.6886, 0.6886]

চতুর্থ ভুলটি অংশ ৫-এ দেখেছেন (সরল গড়), আর পঞ্চমটি অংশ ৩-এ (scheduler আগে)। একটি ভালো অভ্যাস: নতুন loop লিখে প্রথমে একটি ছোট batch-এ বারবার train করুন; loss প্রায় শূন্যে না নামলে loop-এ ভুল আছে। এই কৌশল আর learning curve পড়া পর্ব ১৮ (Training ডিবাগ করা)-এর বিষয়।

১০ · AI-এর যুগে — AI-এর লেখা training loop যাচাই

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

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

• একটি ছোট batch-এ shape ছাপিয়ে দেখেছি: logits (N, C), label (N,) আর dtype int64
• প্রথমে একটি ছোট batch overfit করিয়ে দেখেছি loss প্রায় শূন্যে নামে কি না
• zero_grad backward-এর আগে, step backward-এর পরে, scheduler step-এর পরে আছে
• Validation-এ eval() আর no_grad() দুটিই আছে, আর val loss দুবার মাপলে এক আসে
• Metric batch-এর আকার দিয়ে ওজন করা; batch size বদলালে সংখ্যা বদলায় না
• Validation বা test-এর ডেটা থেকে কোনো পরিসংখ্যান (scaling, vocabulary) train-এ ঢোকেনি
• ফল কয়েকটি seed-এ দেখেছি, আর কোনো আসল গ্রাহকের ডেটা বা key AI-তে পেস্ট করিনি