Deep learning-এ regularization — dropout, weight decay আর early stopping

এই কোর্সের পর্ব ১০-এ training loop, AdamW আর patience-সহ early stopping লিখেছেন, আর পর্ব ০৯-এ দেখেছেন nn.Dropout train mode-এ টিকে থাকা মানকে 1/(1 − p) দিয়ে গুণ করে। Regularization-এর তত্ত্ব (L1/L2-এর জ্যামিতি, MAP, early stopping-কে implicit regularization হিসেবে দেখা) মেশিন লার্নিং কোর্সের পর্ব ১৭-এ আছে, আর bias–variance আর learning curve AI-এর ভিত্তি কোর্সের পর্ব ৬১-এ। এখানে প্রশ্ন একটাই: লাখ লাখ parameter-এর network-এ এই কৌশলগুলো আসলে কী করে, আর কতটা কাজে লাগে? পাতায় চালানো যায় এমন তিনটি NumPy ব্লক আছে (প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে); PyTorch-এর সব আউটপুট ডেস্কটপের সত্যিকারের run থেকে।

১ · Deep network কেন overfit করে, আবার কেন generalize করে

একটি MLP-এর parameter প্রায়ই train উদাহরণের সংখ্যার চেয়ে অনেক বেশি। অংশ ৭-এর network-এ ১৮ লাখের বেশি parameter, আর train-এ মাত্র ১০০০টি ছবি; ৩০ epoch-এর মধ্যে train accuracy ১.০০০ হয়ে যায়। Zhang ও সহকর্মীরা (ICLR ২০১৭) দেখিয়েছিলেন, বড় network এলোমেলো label-ও পুরোপুরি মুখস্থ করতে পারে। তবু বাস্তবে এরা নতুন ডেটায় ভালো করে, কারণ implicit regularization: ছোট weight থেকে শুরু, SGD-এর noise আর সীমিত ধাপ নিজেই সরল সমাধানের দিকে টানে। পর্ব ০৬-এ double descent-এ দেখেছেন, আকার বাড়ালে test ভুল সবসময় এক দিকে চলে না। তাই deep learning-এ regularization মানে পুরোনো bias–variance-এর সরল হিসাব নয়; এগুলো এমন হাতিয়ার, যার প্রভাব মেপে দেখতে হয়।

নিচের ছবিতে training-এর প্রতিটি স্তরে কোন regularizer কাজ করে, তা দেখানো হলো। এই পর্বে মূলত optimizer, model আর weight-এর গড়ের অংশ; ডেটা আর loss-এর অংশ পরের পর্বগুলোতে।

২ · NumPy-তে ইচ্ছা করে overfit — কোনো regularization নেই, weight decay আর dropout

সবচেয়ে পরিষ্কার পরীক্ষা: খুব কম ডেটায় খুব বড় network. নিচের ব্লকে sin(3x)-এর ১২টি noisy বিন্দু (noise-এর মানবিচ্যুতি ০.২৫, তাই সেরা সম্ভাব্য val MSE প্রায় ০.০৬), আর ১ → ২০০ (tanh) → ১-এর network, Adam দিয়ে ৩০০০ ধাপ। একই শুরুর weight থেকে তিনবার train: কিছু ছাড়া, weight decay λ = ০.৩ দিয়ে, আর dropout p = ০.৩ দিয়ে। Backward-এর সূত্র পর্ব ০৪-এর; Adam-এর derivation মেশিন লার্নিং কোর্সের পর্ব ১৪-এ।

import numpy as np, matplotlib.pyplot as plt

rng = np.random.default_rng(0); f = lambda x: np.sin(3 * x)      # ১২টি train, ২০০টি val বিন্দু
xtr = np.sort(rng.uniform(-1, 1, 12)); ytr = f(xtr) + rng.normal(0, 0.25, 12)
xva = np.linspace(-1, 1, 200); yva = f(xva) + rng.normal(0, 0.25, 200)
H = 200                                           # 1 → 200 hidden → 1

def predict(P, x, p=0.0, r=None, relu=False):    # p > 0 আর r দিলে dropout চালু (train mode)
    z = x[:, None] @ P[0] + P[1]; h = np.maximum(z, 0) if relu else np.tanh(z)
    m = (r.random(h.shape) >= p) / (1 - p) if p > 0 else 1.0   # inverted dropout mask
    return h, m, (h * m) @ P[2] + P[3]

def fit(wd=0.0, p=0.0, relu=False, steps=3000, lr=0.01):
    r = np.random.default_rng(1)
    P = [r.normal(0, 6, (1, H)), r.normal(0, 4, H), r.normal(0, H ** -0.5, (H, 1)), np.zeros(1)]
    M = [np.zeros_like(a) for a in P]; V = [np.zeros_like(a) for a in P]
    for t in range(1, steps + 1):
        h, m, out = predict(P, xtr, p, r, relu)
        g = 2 * (out - ytr[:, None]) / len(xtr)   # MSE-এর gradient
        dh = (g @ P[2].T) * m * ((h > 0) if relu else 1 - h ** 2)
        G = [xtr[None, :] @ dh, dh.sum(0), (h * m).T @ g, g.sum(0)]
        for i in range(4):
            if i in (0, 2): P[i] *= 1 - lr * wd     # weight decay: আগে সংকোচন (bias বাদ)
            M[i] = 0.9 * M[i] + 0.1 * G[i]; V[i] = 0.999 * V[i] + 0.001 * G[i] ** 2   # Adam
            P[i] -= lr * (M[i] / (1 - 0.9 ** t)) / (np.sqrt(V[i] / (1 - 0.999 ** t)) + 1e-8)
    return P

mse = lambda P, x, y: np.mean((predict(P, x)[2][:, 0] - y) ** 2)
runs = {"none": fit(), "weight decay 0.3": fit(wd=0.3), "dropout 0.3": fit(p=0.3)}
for name, P in runs.items():
    print(f"{name:16s} train {mse(P, xtr, ytr):.4f} | val {mse(P, xva, yva):.4f} | ||W2|| {np.linalg.norm(P[2]):.2f}")
plt.scatter(xtr, ytr, c="k", zorder=3, label="train points"); plt.plot(xva, f(xva), "k:", label="true sin(3x)")
for name, P in runs.items(): plt.plot(xva, predict(P, xva)[2][:, 0], label=name)
plt.ylim(-2, 2); plt.xlabel("x"); plt.ylabel("y"); plt.legend(fontsize=8); plt.title("12 points, 200 hidden units"); plt.show()

none             train 0.0070 | val 0.4324 | ||W2|| 1.92
weight decay 0.3 train 0.0226 | val 0.1001 | ||W2|| 1.58
dropout 0.3      train 0.0443 | val 0.0764 | ||W2|| 0.28

৩ · Weight decay — প্রতি ধাপে শূন্যের দিকে একটু টান

Weight decay-এর ধারণা সরল: প্রতিটি ধাপে প্রতিটি weight-কে একটু ছোট করুন, যাতে শুধু যে weight-গুলো loss কমাতে সত্যিই দরকার, সেগুলো বড় থাকে। Learning rate η (eta) আর decay-এর হার λ (lambda) হলে decoupled রূপ:

w ← w · (1 − η·λ)  (সংকোচন), তারপর  w ← w − η · ধাপ(g)

এখানে g হলো loss-এর gradient, আর “ধাপ” SGD-তে g নিজেই, Adam-এ m̂/(√v̂ + ε). আরেকটি পুরোনো রূপ হলো L2 regularization: loss-এ (λ/2)·‖w‖² যোগ করা, যাতে gradient হয় g + λw. সাধারণ SGD-তে দুটি হুবহু এক। Adam-এ এক নয়, কারণ λw অংশটিও Adam-এর √v̂ দিয়ে ভাগ হয়। Loshchilov আর Hutter (arXiv ২০১৭, ICLR ২০১৯) এই পার্থক্য দেখিয়ে AdamW প্রস্তাব করেন। নিচের stepper একটি weight-এ দুটি পথ পাশাপাশি দেখায়।

PyTorch-এ torch.optim.AdamW(params, lr, weight_decay=λ) ঠিক অংশ ২-এর NumPy কোডের মতো আগে p.mul_(1 − lr·λ) করে। দুটি ব্যবহারিক কথা। প্রথম, bias আর normalization layer-এর weight-এ সাধারণত decay দেওয়া হয় না; তাই parameter দুই দলে ভাগ করা হয় (অংশ ৭-এর কোডে p.ndim > 1 দিয়ে)। দ্বিতীয়, η·λ-ই আসল সংকোচন, তাই learning rate বদলালে decay-এর শক্তিও বদলায়। λ-এর আকার, parameter group আর schedule-এর সঙ্গে সম্পর্ক পর্ব ১৫ (Optimizer আর learning-rate schedule)-এ সত্যিকারের run দিয়ে দেখবেন।

৪ · Dropout গভীরে — train আর eval-এ কী ঘটে, আর কোথায় বসাবেন

PyTorch-এর inverted dropout-এ train mode-এ প্রতিটি মান p সম্ভাবনায় শূন্য হয়, আর টিকে থাকা মান 1/(1 − p) দিয়ে গুণ হয়। ফলে প্রত্যাশিত মান (expected value) বদলায় না: E[h̃] = (1 − p) · h/(1 − p) = h. Eval mode-এ কিছুই বন্ধ হয় না, কিছুই গুণ হয় না। নিচে ছয়টি unit-এর একটি layer, p = ০.৫.

কোথায় বসাবেন? MLP-তে সাধারণ জায়গা hidden layer-এর activation-এর পরে: Linear → ReLU → Dropout. শেষ layer-এর (logits-এর) পরে কখনো নয়, কারণ তাতে loss-এর input-ই এলোমেলো হয়। হার সাধারণত বড় fully-connected layer-এ ০.২–০.৫, input-এ থাকলে আরও কম। CNN-এর convolution layer-এ সাধারণ dropout কম কাজে দেয়, কারণ পাশের pixel প্রায় একই তথ্য বহন করে; সেখানে পুরো channel বাদ দেওয়া nn.Dropout2d বা পরের দিকের fully-connected অংশে dropout বেশি দেখা যায় (CNN পর্ব ২০–২৬-এ)। Transformer-এ attention-এর weight-এ আর residual যোগের আগে ছোট হারে dropout থাকে; খুব বড় ডেটায় pretraining-এ অনেকে dropout শূন্য রাখেন বলে রিপোর্ট আছে। BatchNorm-এর সঙ্গে dropout মেশালে train আর eval-এর পরিসংখ্যানে অমিল হতে পারে; ক্রম আর ঝুঁকি পর্ব ১৪ (Weight initialization আর normalization)-এ।

৫ · MC dropout — অনিশ্চয়তার এক ঝলক

Inference-এর সময় যদি dropout ইচ্ছা করে চালু রাখি আর একই input-এ অনেকবার forward করি? প্রতিবার আলাদা “ছোট network” আলাদা উত্তর দেবে; উত্তরগুলোর ছড়ানো ভাব (spread) একটি অনিশ্চয়তার আভাস। Gal আর Ghahramani (ICML ২০১৬) এই MC dropout-কে একটি approximate Bayesian পদ্ধতি হিসেবে ব্যাখ্যা করেন (variational inference-এর ধারণা মেশিন লার্নিং কোর্সের পর্ব ৪৮-এ)। প্রত্যাশা: train ডেটা যেখানে নেই, সেখানে spread বাড়বে, অর্থাৎ epistemic uncertainty. নিচের ব্লক আগের ব্লকের dropout network (tanh) আর একই ভাবে train করা একটি ReLU network-এ ৩০০টি mask চালায়; train বিন্দু শুধু −১ থেকে ১-এর মধ্যে। আগের ব্লক একবার চালানো থাকলে এটি সেটির ফল ব্যবহার করে।

nets = {"tanh": (runs["dropout 0.3"], False), "relu": (fit(p=0.3, relu=True), True)}
xs = np.linspace(-3, 3, 121); out = abs(xs) > 1      # train ডেটা শুধু -1 থেকে 1-এর মধ্যে
for name, (P, relu) in nets.items():
    r = np.random.default_rng(7)                      # ৩০০টি এলোমেলো dropout mask
    S = np.stack([predict(P, xs, 0.3, r, relu)[2][:, 0] for _ in range(300)])
    sd = S.std(0); ev = predict(P, xs, relu=relu)[2][:, 0]
    print(f"{name}: x=0-তে {S.mean(0)[60]:.3f} ± {sd[60]:.3f} (eval {ev[60]:.3f}) | x=3-এ {S.mean(0)[120]:.3f} ± {sd[120]:.3f}")
    print(f"      গড় spread: ডেটার ভেতরে {sd[~out].mean():.3f}, বাইরে {sd[out].mean():.3f}")
    plt.plot(xs, S.mean(0), label=f"{name} MC mean"); plt.fill_between(xs, S.mean(0) - 2 * sd, S.mean(0) + 2 * sd, alpha=0.25)
plt.scatter(xtr, ytr, c="k", zorder=3, label="train points"); plt.axvspan(-1, 1, color="gray", alpha=0.1)
plt.ylim(-6, 4); plt.xlabel("x"); plt.legend(fontsize=8); plt.title("MC dropout: mean ± 2 sd (300 masks)"); plt.show()

tanh: x=0-তে -0.115 ± 0.162 (eval -0.109) | x=3-এ 0.009 ± 0.183
      গড় spread: ডেটার ভেতরে 0.164, বাইরে 0.179
relu: x=0-তে -0.126 ± 0.123 (eval -0.124) | x=3-এ -1.178 ± 3.114
      গড় spread: ডেটার ভেতরে 0.221, বাইরে 1.458

৬ · Early stopping আর weight-এর গড় — EMA আর SWA

Early stopping আর patience-এর কোড পর্ব ১০-এ লিখেছেন। এখানে দুটি নতুন কথা। প্রথম, কোন metric দেখে থামবেন তা গুরুত্বপূর্ণ: অংশ ৭-এর run-এ val loss epoch ৩-এ সবচেয়ে কম, কিন্তু val accuracy সবচেয়ে বেশি epoch ২৪-এ। দ্বিতীয়, শেষের weight না নিয়ে weight-এর গড় নেওয়া যায়।

Learning rate স্থির থাকলে SGD-এর weight সমাধানের চারপাশে লাফাতে থাকে, কারণ প্রতিটি mini-batch-এর gradient-এ noise আছে। সেই লাফানো weight-এর exponential moving average (EMA) রাখা যায়: w̄ ← β·w̄ + (১ − β)·w, যেখানে β (beta) ০.৯৯ বা ০.৯৯৯-এর মতো। EMA training-এ কোনো প্রভাব ফেলে না; gradient শুধু আসল weight-এ যায়, EMA পাশে আলাদা কপি। ধারণাটি পুরোনো: Polyak আর Juditsky (১৯৯২)-এর iterate averaging. Stochastic Weight Averaging (SWA; Izmailov ও সহকর্মী, UAI ২০১৮) training-এর শেষ দিকে কয়েকটি epoch-এর weight-এর সমান গড় নেয়, প্রায়ই একটি বড় বা চক্রাকার learning rate-এর সঙ্গে। নিচে বাজারঘরের ডেলিভারি সময়ের একটি সরল linear model-এ ৪টির ছোট batch দিয়ে noisy SGD.

import numpy as np, matplotlib.pyplot as plt

rng = np.random.default_rng(42)             # বাজারঘর: দূরত্ব (কিমি, স্কেল করা) → ডেলিভারির সময় (মিনিট)
x = rng.uniform(-1, 1, 400); y = 30 + 8 * x + rng.normal(0, 6, 400)
xtr, ytr, xva, yva = x[:300], y[:300], x[300:], y[300:]
A = np.c_[np.ones(300), xtr]; w_best = np.linalg.lstsq(A, ytr, rcond=None)[0]   # train-এর নিখুঁত সমাধান

w = np.zeros(2); ema = w.copy(); beta = 0.98; raw_hist, ema_hist = [], []
for step in range(1, 1501):
    b = rng.integers(0, 300, 4)               # ৪টির ছোট batch: gradient-এ অনেক noise
    err = w[0] + w[1] * xtr[b] - ytr[b]
    w = w - 0.1 * np.array([err.mean(), (err * xtr[b]).mean()])
    ema = beta * ema + (1 - beta) * w        # weight-এর EMA, gradient-এ কোনো প্রভাব নেই
    raw_hist.append(w.copy()); ema_hist.append(ema.copy())

R, E = np.array(raw_hist[500:]), np.array(ema_hist[500:])   # প্রথম ৫০০ ধাপ বাদ
val = lambda w: np.mean((w[0] + w[1] * xva - yva) ** 2)
print("train-এর নিখুঁত সমাধান:", np.round(w_best, 3))
print(f"শেষ ১০০০ ধাপে নিখুঁত সমাধান থেকে গড় দূরত্ব: raw {np.linalg.norm(R - w_best, axis=1).mean():.3f}"
      f" | EMA {np.linalg.norm(E - w_best, axis=1).mean():.3f}")
print(f"শেষ ধাপে val MSE: raw {val(w):.3f} | EMA {val(ema):.3f} | নিখুঁত {val(w_best):.3f}")
print(f"শেষ ১০০০ ধাপে val MSE-এর গড়: raw {np.mean([val(v) for v in R]):.3f} | EMA {np.mean([val(v) for v in E]):.3f}")
plt.plot(np.array(raw_hist)[:, 1], lw=0.6, label="raw slope w1")
plt.plot(np.array(ema_hist)[:, 1], lw=2, label=f"EMA (beta={beta})")
plt.axhline(w_best[1], c="k", ls=":", label="least-squares slope"); plt.xlabel("step"); plt.ylabel("w1")
plt.legend(); plt.title("Noisy SGD weights vs their EMA"); plt.show()

train-এর নিখুঁত সমাধান: [29.633  9.049]
শেষ ১০০০ ধাপে নিখুঁত সমাধান থেকে গড় দূরত্ব: raw 0.851 | EMA 0.368
শেষ ধাপে val MSE: raw 40.334 | EMA 38.490 | নিখুঁত 38.227
শেষ ১০০০ ধাপে val MSE-এর গড়: raw 38.875 | EMA 38.326

PyTorch-এ এর জন্য torch.optim.swa_utils: AveragedModel(model, multi_avg_fn=get_ema_multi_avg_fn(0.999)) দিয়ে EMA, শুধু AveragedModel(model) দিয়ে সমান গড় (SWA), সঙ্গে SWALR scheduler. প্রতি ধাপে opt.step()-এর পরে ema.update_parameters(model). Model-এ BatchNorm থাকলে গড় weight-এর জন্য running statistics নতুন করে মাপতে হয়: torch.optim.swa_utils.update_bn(loader, swa_model).

৭ · PyTorch-এ সত্যিকারের তুলনা — ১০০০টি Fashion-MNIST ছবি, বড় MLP

এবার আসল network. Fashion-MNIST (Xiao, Rasul আর Vollgraf, ২০১৭; Zalando Research, MIT licence) হলো ১০ শ্রেণির পোশাকের ২৮ × ২৮ ধূসর ছবি; torchvision দিয়ে নামানো। ইচ্ছা করে overfit করার জন্য train-এ মাত্র ১০০০টি ছবি, validation-এ train অংশের আরও ৫০০০টি, আর শেষ মাপের জন্য আলাদা ১০,০০০টি test ছবি। Model: ৭৮৪ → ১০২৪ → ১০২৪ → ১০, মোট ১৮,৬৩,৬৯০টি parameter; AdamW, lr ০.০০১, ৩২-এর batch, ৬০ epoch. প্রতিটি run-এ একবারে একটিই জিনিস বদলানো হয়েছে। Script-এর মূল অংশ:

def make_mlp(p):
    return nn.Sequential(
        nn.Linear(784, 1024), nn.ReLU(), nn.Dropout(p),
        nn.Linear(1024, 1024), nn.ReLU(), nn.Dropout(p),
        nn.Linear(1024, 10))

model = make_mlp(args.p)
decay = [p for n_, p in model.named_parameters() if p.ndim > 1]      # bias-এ decay নয়
no_decay = [p for n_, p in model.named_parameters() if p.ndim == 1]
opt = torch.optim.AdamW([{"params": decay, "weight_decay": args.wd},
                         {"params": no_decay, "weight_decay": 0.0}], lr=1e-3)
ema = AveragedModel(model, multi_avg_fn=get_ema_multi_avg_fn(args.ema)) if args.ema else None
for epoch in range(1, args.epochs + 1):
    model.train()
    for b in torch.randperm(1000, generator=gen).split(32):
        loss = F.cross_entropy(model(Xtr[b]), ytr[b])
        opt.zero_grad(); loss.backward(); opt.step()
        if ema: ema.update_parameters(model)
    trl, tra, _ = evaluate(model, Xtr, ytr); val, vaa, _ = evaluate(model, Xva, yva)   # eval() + no_grad
    ...
    if args.patience:                                    # early stopping
        if val < best[0]: best, bad = (val, epoch, copy.deepcopy(model.state_dict())), 0
        else: bad += 1
        if bad >= args.patience:
            model.load_state_dict(best[2]); break

খেয়াল করুন: dropout প্রতিটি hidden ReLU-এর পরে, শেষ Linear-এর পরে নয়। Ensemble মানে seed ০, ১ আর ২-এর তিনটি “কিছু ছাড়া” model-এর softmax probability-র গড়। সত্যিকারের run (ডেস্কটপ, CPU):

~/bazarghar-dl$ uv run python reg.py --tag none
[none] torch 2.15.0+cpu | python 3.14.4 | CPU-তে 21 s
~/bazarghar-dl$ uv run python reg.py --patience 10 --tag es
[es] থামল epoch 13-এ, best epoch 3 ফেরানো হলো
~/bazarghar-dl$ uv run python reg.py --wd 0.5 --tag wd05      # একইভাবে wd2, drop05 (--p 0.5),
~/bazarghar-dl$ uv run python reg.py --ema 0.999 --tag ema    # none_s1, none_s2 (--seed 1, 2)
 …
~/bazarghar-dl$ uv run python summary.py
config           train acc/loss │ val acc/loss │ test acc/loss
none (60 ep)     1.000  0.000 │ 0.815  1.485 │ 0.813  1.526
early stop       0.883  0.325 │ 0.792  0.591 │ 0.787  0.606
weight decay 0.5 1.000  0.001 │ 0.810  0.953 │ 0.811  0.973
weight decay 2.0 0.965  0.154 │ 0.784  0.816 │ 0.777  0.818
dropout 0.5      0.993  0.036 │ 0.814  1.025 │ 0.810  1.066
EMA 0.999        0.999  0.007 │ 0.814  0.798 │ 0.810  0.824
ensemble of 3    1.000  0.000 │ 0.814  1.250 │ 0.812  1.293
dropout model, train mode-এ val acc দুবার: [0.789, 0.791] | eval mode-এ: 0.8136

প্রতিটি run CPU-তে ১৪–২৫ সেকেন্ড (একটি স্থানীয় run). টেবিলটি সৎভাবে পড়লে শিক্ষাটি একটু অপ্রত্যাশিত: accuracy-তে প্রায় কোনো পার্থক্য নেই; সব config-এর test accuracy ০.৭৭৭ থেকে ০.৮১৩. বড় পার্থক্য loss-এ। কিছু ছাড়া model-এর val loss ১.৪৮৫, অথচ epoch ৩-এ তা ছিল ০.৫৯১: model ভুল উত্তরগুলোতেও প্রায় ১০০% নিশ্চিত হয়ে গেছে, অর্থাৎ calibration নষ্ট (মেশিন লার্নিং কোর্সের পর্ব ২৬)। Dropout, weight decay ০.৫ আর ensemble loss কমায়, EMA সবচেয়ে বেশি (০.৭৯৮)। Weight decay ২.০ বেশি জোরালো: train accuracy ০.৯৬৫-এ আটকে, test accuracy সবচেয়ে কম। Early stopping val loss দেখে epoch ৩-এর weight ফেরাল, তাই loss-এ ভালো কিন্তু accuracy-তে খারাপ। ১০০০টি ছবিতে আসল সীমা ডেটার পরিমাণ; সেখানে সবচেয়ে কার্যকর regularizer প্রায়ই আরও ডেটা বা data augmentation.

শেষে একটি দক্ষতা, যা সব learning curve-এ লাগে: train আর val-এর ফারাক পড়া। নিচের stepper একই “কিছু ছাড়া” run-এর কয়েকটি epoch দেখায় (সব সংখ্যা সত্যিকারের run-এর hist_none.json থেকে)।

৮ · আরও regularizer, ensemble আর কোনটি কখন

Ensemble. কয়েকটি আলাদা seed-এর model-এর probability-র গড় (ensemble) প্রায় সবসময় একটি model-এর চেয়ে স্থির; Lakshminarayanan ও সহকর্মীরা (NeurIPS ২০১৭) এই “deep ensemble”-কে অনিশ্চয়তা মাপার একটি শক্ত baseline হিসেবে দেখান। খরচ: train আর inference দুটিই ততগুণ। Bagging আর voting-এর মূল ধারণা মেশিন লার্নিং কোর্সের পর্ব ৩৩-এ। আমাদের run-এ তিনটি model-এর ensemble val loss ১.৪৮৫ থেকে ১.২৫০-এ আনল, accuracy প্রায় একই; তিনটিই একই ভাবে মুখস্থ করলে গড়ও বেশি সাহায্য করে না।

আরও কয়েকটি, সংক্ষেপে: label smoothing target-কে একটু নরম করে (যেমন ০.৯ আর বাকিটা অন্য শ্রেণিতে ভাগ), তাই অতি-নিশ্চিত হওয়া কঠিন; বিস্তারিত পর্ব ১৩ (Deep learning-এর loss)-এ। Mixup (Zhang ও সহকর্মী, ICLR ২০১৮) দুটি ছবি আর তাদের label-এর ওজনযুক্ত মিশ্রণ বানায়; CutMix (Yun ও সহকর্মী, ICCV ২০১৯) একটি ছবির টুকরো আরেকটিতে বসায়; দুটিই পর্ব ২৪ (Data augmentation)-এ। Stochastic depth (Huang ও সহকর্মী, ECCV ২০১৬) train-এ residual block-এর পুরো শাখা এলোমেলোভাবে বাদ দেয়; একে DropPath-ও বলা হয়, আর গভীর residual network ও Vision Transformer-এ দেখা যায় (residual connection পর্ব ১৭-এ)।

৯ · AI-এর যুগে — regularization নিয়ে AI-এর পরামর্শ যাচাই

“আমার model overfit করছে, কী করব?” জিজ্ঞেস করলে AI assistant প্রায় সবসময় একই তালিকা দেয়: dropout ০.৫, weight decay, early stopping. তালিকাটি ভুল নয়, কিন্তু অংশ ৭-এ দেখলেন, ফল ডেটা আর metric-এর ওপর নির্ভর করে। AI প্রায়ই model.eval() ভুলে যায়, logits-এর পরে dropout বসায়, Adam-এ weight_decay-কে AdamW-এর সমান ধরে, BatchNorm আর bias-এ decay দেয়, MC dropout-এর spread-কে “calibrated confidence” বলে, আর একটি seed-এর একটি run দেখে উপসংহার টানে। তাই পরামর্শের সঙ্গে পরীক্ষার পরিকল্পনাও চান।

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

• আগে regularization ছাড়া baseline চালিয়ে train/val curve দেখেছি; overfitting সত্যিই আছে
• Dropout শুধু hidden activation-এর পরে, logits-এর পরে নয়; validation-এ eval() আর no_grad() আছে
• Optimizer AdamW, আর bias ও normalization-এর weight decay শূন্য; lr বদলালে decay-এর প্রভাবও বদলায় তা মাথায় রেখেছি
• Early stopping কোন metric দেখে, তা কাজের লক্ষ্য দেখে ঠিক করেছি, আর best checkpoint ফেরানো হয়
• প্রতিবার একটি বদল, কয়েকটি seed, validation-এ তুলনা; test set শুধু শেষে একবার
• MC dropout বা ensemble-এর spread-কে নিখুঁত probability বলিনি; প্রয়োজনে calibration মেপেছি
• AI-এর দেওয়া API (swa_utils, Dropout2d) নিজের version-এর docs-এ মিলিয়েছি; কোনো ব্যক্তিগত ডেটা বা key পেস্ট করিনি