Optimizer আর learning-rate schedule — SGD, AdamW, warmup আর cosine

মেশিন লার্নিং কোর্সের পর্ব ১৩-এ SGD, mini-batch আর schedule-এর তত্ত্ব, আর পর্ব ১৪-এ momentum, Adam (bias correction-সহ) আর AdamW derive করা আছে। এখানে সেগুলো আবার derive করব না। এই পর্বের প্রশ্ন ব্যবহারিক: গভীর network-এ এগুলো কীভাবে আচরণ করে, আর PyTorch-এ ঠিকভাবে কীভাবে বসাবেন। এই কোর্সের পর্ব ১০-এ training loop আর scheduler ডাকার ক্রম প্রথম দেখেছেন। পাতার তিনটি ব্লক NumPy-তে চলে (প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে); PyTorch-এর সব আউটপুট ডেস্কটপের সত্যিকারের run থেকে, CPU-তে, torch 2.15.0 আর Python 3.14.4 দিয়ে (লেখার সময়ে)।

১ · Learning rate — সবচেয়ে জরুরি hyperparameter

এক লাইনের recap: SGD-তে w ← w − η·g, যেখানে η (ইটা) learning rate আর g একটি mini-batch-এর gradient. Momentum আগের ধাপগুলোর চলমান যোগফল রাখে; Adam প্রতিটি parameter-এর ধাপকে তার gradient-এর বর্গের চলমান গড়ের বর্গমূল দিয়ে ভাগ করে; AdamW সঙ্গে weight decay আলাদাভাবে প্রয়োগ করে। সব optimizer-এই η একটি গুণক, যা প্রতিটি ধাপের মাপ ঠিক করে।

গভীর network-এ η-এর প্রভাব আরও তীব্র, তিনটি কারণে। প্রথম, loss-এর ভূদৃশ্য বিভিন্ন দিকে খুব আলাদা বাঁকা; সবচেয়ে খাড়া দিকের জন্য η বড় হলে loss লাফিয়ে বিস্ফোরিত হয়, আর তখন অনেক সময় NaN আসে। দ্বিতীয়, শুরুর দিকে weight এলোমেলো আর gradient বড়, শেষে ছোট আর কোলাহলপূর্ণ; একটি স্থির η দুই অবস্থার জন্য ঠিক হয় না। তৃতীয়, ধ্রুব η-তে mini-batch-এর noise শেষ পর্যন্ত থাকে, তাই loss সর্বনিম্ন বিন্দুর চারপাশে কাঁপে (মেশিন লার্নিং কোর্সের পর্ব ১৩-এর “মেঝে”)। অভিজ্ঞ অনুশীলনকারীদের মধ্যে একটি প্রচলিত কথা আছে: hyperparameter-এর মধ্যে যদি শুধু একটি tune করার সময় থাকে, learning rate করুন। এটি কোনো প্রমাণিত নিয়ম নয়, অভিজ্ঞতার কথা; তবে এই পর্বের run-গুলোও একই দিকে ইঙ্গিত দেয়।

২ · Schedule-এর পাঁচ আকার — সূত্র আর মান

ধরুন মোট T ধাপ, সর্বোচ্চ learning rate η_max, আর t হলো বর্তমান ধাপ (০ থেকে গোনা)। প্রচলিত পাঁচটি schedule:

• Constant: η_t = η_max. সরল, কিন্তু শেষে noise থেকে যায়।
• Step decay: প্রতি s ধাপে γ গুণ, η_t = η_max · γ^⌊t/s⌋. ⌊ ⌋ মানে নিচের পূর্ণসংখ্যা। ResNet-যুগের ছবি-classification-এ প্রচলিত ছিল (যেমন ৩০ epoch পরপর ১০ ভাগের ১)।
• Cosine: η_t = η_min + ½(η_max − η_min)(1 + cos(πt/T)). শুরুতে প্রায় সমতল, মাঝে দ্রুত নামে, শেষে আবার নরমভাবে η_min-এ থামে।
• Warmup + cosine: প্রথম W ধাপে রৈখিক ওঠা, η_t = η_max(t + 1)/W; তারপর বাকি T − W ধাপে cosine. Transformer আর বড় ভাষা model-এ এটি প্রায় মানক অভ্যাস।
• One-cycle: Leslie Smith-এর প্রস্তাব (২০১৮ সালের দিকে)। ছোট মান (η_max/২৫) থেকে প্রথম ৩০% ধাপে η_max-এ ওঠা, তারপর প্রায় শূন্যে নামা; momentum উল্টো দিকে চলে (০.৯৫ → ০.৮৫ → ০.৯৫)।

নিচের ব্লক পাঁচটি schedule একই ছবিতে আঁকে আর কয়েকটি ধাপে মান ছাপে। One-cycle-এর সূত্র PyTorch-এর OneCycleLR-এর default-এর মতো লেখা, যাতে অংশ ৫-এ মিলিয়ে দেখা যায়।

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

T, peak, warm = 1000, 0.1, 100            # মোট ধাপ, সর্বোচ্চ lr, warmup ধাপ
t = np.arange(T)

def ramp(a, b, f):                        # f = 0-তে a, f = 1-এ b; মাঝে cosine বাঁক
    return b + (a - b) * 0.5 * (1 + np.cos(np.pi * np.clip(f, 0, 1)))

up = 0.3 * T - 1                          # one-cycle: 30% ধাপে ওঠা (PyTorch-এর default)
S = {
    "constant": np.full(T, peak),
    "step": peak * 0.1 ** (t // 400),     # প্রতি 400 ধাপে 10 ভাগের 1
    "cosine": ramp(peak, 0.0, t / T),
    "warmup+cosine": np.where(t < warm, peak * (t + 1) / warm,
                              ramp(peak, 0.0, (t - warm) / (T - warm))),
    "one-cycle": np.where(t <= up, ramp(peak / 25, peak, t / up),
                          ramp(peak, peak / 25 / 1e4, (t - up) / (T - 1 - up))),
}
pd.set_option("display.width", 70)
rows = [0, 50, 99, 100, 299, 550, 999]
print(pd.DataFrame({k: v[rows] for k, v in S.items()}, index=rows).round(4))

fig, ax = plt.subplots(figsize=(7, 3.4))
for k, v in S.items():
    ax.plot(t, v, label=k)
ax.set_xlabel("step"); ax.set_ylabel("learning rate")
ax.set_title("Five learning-rate schedules, peak 0.1, 1000 steps")
ax.legend(fontsize=8)
plt.show()

     constant   step  cosine  warmup+cosine  one-cycle
0         0.1  0.100  0.1000         0.0010     0.0040
50        0.1  0.100  0.0994         0.0510     0.0105
99        0.1  0.100  0.0976         0.1000     0.0277
100       0.1  0.100  0.0976         0.1000     0.0281
299       0.1  0.100  0.0795         0.0884     0.1000
550       0.1  0.010  0.0422         0.0500     0.0715
999       0.1  0.001  0.0000         0.0000     0.0000

পরীক্ষায় প্রায়ই আসে: নির্দিষ্ট ধাপে schedule-এর মান। একই warmup + cosine (T = ১০০০, W = ১০০, η_max = ০.১) পাঁচটি ধাপে হাতে বের করুন:

৩ · Warmup — Adam কেন শুরুতে হোঁচট খায়

Warmup-এর দুটি সাধারণ যুক্তি আছে। একটি সব optimizer-এর জন্য: শুরুতে weight এলোমেলো, gradient বড় আর দিক অনিশ্চিত, তাই পূর্ণ η-তে বড় লাফ network-কে খারাপ অঞ্চলে ঠেলে দিতে পারে। Goyal ও সহকর্মীরা (২০১৭) বিশাল batch-এ ImageNet train করতে কয়েক epoch-এর ধীর warmup ব্যবহার করেন, আর জানান তা ছাড়া শুরুর অস্থিরতা সামলানো কঠিন ছিল।

দ্বিতীয় যুক্তি Adam-এর নিজস্ব। Adam-এর ধাপ η · m̂/√v̂, যেখানে v̂ gradient-এর বর্গের চলমান গড় (bias correction-এর পরে)। প্রথম কয়েক ধাপে v̂ মাত্র এক-দুটি নমুনা থেকে হিসাব, তাই খুব অনিশ্চিত। প্রথম ধাপে m̂ = g আর √v̂ = |g|, তাই প্রতিটি parameter ঠিক ±η সরে, gradient যত ছোটই হোক। Liu ও সহকর্মীরা (RAdam, ২০১৯ সালের দিকে) যুক্তি দেন যে শুরুতে এই adaptive learning rate-এর variance বেশি, আর warmup সেটি নিয়ন্ত্রণ করে; এই ব্যাখ্যা নিয়ে আলোচনা চলছে, একমাত্র কারণ বলে ধরে নেওয়া ঠিক নয়। নিচে তিনটি parameter-এ প্রথম তিন ধাপ হাতে দেখুন (η = ০.০০১, β₁ = ০.৯, β₂ = ০.৯৯৯)।

Transformer-এর ক্ষেত্রে আরেকটি কারণ আছে। ২০১৭ সালের মূল Transformer প্রবন্ধে (Vaswani ও সহকর্মী) কয়েক হাজার ধাপের warmup, তারপর ধাপের বর্গমূলের বিপরীত অনুপাতে decay ব্যবহার হয়েছিল। পরে Xiong ও সহকর্মীরা (২০২০) দেখান, LayerNorm residual-এর পরে বসানো (post-LN) Transformer-এ শুরুতে শেষ layer-গুলোর gradient বড় থাকে, তাই warmup ছাড়া training অস্থির হয়; LayerNorm আগে বসালে (pre-LN) warmup-এর ওপর নির্ভরতা কমে। Normalization-এর বিস্তারিত পর্ব ১৪ (Weight initialization আর normalization)-এ, আর Transformer ব্লক পরের মডিউলগুলোতে।

৪ · LR range test — কয়েকশো ধাপে learning rate খোঁজা

সেরা η খুঁজতে পুরো training বারবার চালানো ব্যয়বহুল। Leslie Smith (“Cyclical Learning Rates for Training Neural Networks”, ২০১৫ সালে arXiv-এ, WACV ২০১৭) একটি সস্তা পথ জনপ্রিয় করেন, যা এখন LR range test নামে পরিচিত: খুব ছোট η থেকে শুরু করে প্রতি mini-batch-এ η একটু গুণ করে বাড়ান, আর loss লিখে রাখুন। ছোট η-তে loss প্রায় নড়ে না; একটি পরিসরে দ্রুত নামে; তারপর η খুব বড় হলে loss বিস্ফোরিত হয়। fastai library-র “lr_find” এই ধারণার একটি পরিচিত রূপ।

নিচের ব্লকে বাজারঘরের তিনটি customer segment (৪টি feature, ৬০০ জন গ্রাহক) আর ৪ → ৩২ → ৩-এর ছোট MLP. η ১০^−৪ থেকে ১০ পর্যন্ত ১০০ ধাপে জ্যামিতিক হারে বাড়ে; loss-এর চলমান গড় নেওয়া হয়, কারণ একক batch-এর loss খুব কোলাহলপূর্ণ।

import numpy as np, matplotlib.pyplot as plt

rng = np.random.default_rng(42)            # বাজারঘর: ৩টি customer segment, ৪টি feature
y = rng.integers(0, 3, 600)
X = rng.normal(0, 1, (600, 4)) + 1.5 * np.eye(3, 4)[y]
W1 = rng.normal(0, 0.5, (4, 32)); W2 = rng.normal(0, 0.25, (32, 3))

lrs = np.geomspace(1e-4, 10, 100)           # প্রতি batch-এ lr একটু বাড়ানো
losses, avg = [], 0.0
for i, lr in enumerate(lrs):
    b = rng.integers(0, 600, 32)
    H = np.maximum(X[b] @ W1, 0); Z = H @ W2
    Z -= Z.max(1, keepdims=True); P = np.exp(Z) / np.exp(Z).sum(1, keepdims=True)
    loss = -np.log(P[np.arange(32), y[b]] + 1e-12).mean()
    avg = 0.9 * avg + 0.1 * loss            # চলমান গড়, bias সংশোধনসহ
    losses.append(avg / (1 - 0.9 ** (i + 1)))
    if losses[-1] > 4 * min(losses):        # loss বিস্ফোরিত: থামুন
        break
    G = P.copy(); G[np.arange(32), y[b]] -= 1; G /= 32
    dH = (G @ W2.T) * (H > 0)
    W2 -= lr * H.T @ G; W1 -= lr * X[b].T @ dH

L = np.array(losses); n = len(L)
best = lrs[L.argmin()]
k = L.argmin(); g = np.gradient(L[:k + 1], np.log(lrs[:k + 1]))
steep = lrs[10 + g[10:].argmin()]            # প্রথম ১০ ধাপ বাদ (গড় তখনো অস্থির)
print(f"থামল lr {lrs[n - 1]:.3g}-এ ({n} ধাপ) | সবচেয়ে কম loss {L.min():.3f}, lr {best:.3g}-এ")
print(f"সবচেয়ে খাড়া নামা lr {steep:.3g} | best/10 = {best / 10:.3g}")
fig, ax = plt.subplots(figsize=(6.5, 3.2))
ax.plot(lrs[:n], L); ax.set_xscale("log")
ax.axvline(best, ls="--", c="gray"); ax.axvline(steep, ls=":", c="red")
ax.set_xlabel("learning rate (log scale)"); ax.set_ylabel("smoothed loss")
ax.set_title("LR range test: loss vs learning rate")
plt.show()

থামল lr 6.28-এ (96 ধাপ) | সবচেয়ে কম loss 0.568, lr 1.56-এ
সবচেয়ে খাড়া নামা lr 0.305 | best/10 = 0.156

একই পরীক্ষা PyTorch-এ MNIST-এর ২০,০০০টি ছবিতে (৭৮৪ → ২৫৬ → ১২৮ → ১০-এর MLP, প্রথম layer-এর পরে LayerNorm, batch ১২৮), দুই optimizer-এর জন্য। সত্যিকারের run:

~/bazarghar-dl$ uv run python rangetest.py
torch 2.15.0+cpu | numpy 2.5.4 | python 3.14.4
SGD-momentum  থামল lr 1.2 | সবচেয়ে কম loss 0.431 lr 0.24-এ | তার 1/10: 0.024
   lr 0.0001: smoothed loss 2.325
   lr 0.001: smoothed loss 2.260
   lr 0.01: smoothed loss 1.684
   lr 0.1: smoothed loss 0.479
   lr 1: smoothed loss 0.941
AdamW         থামল lr 0.31 | সবচেয়ে কম loss 0.470 lr 0.048-এ | তার 1/10: 0.0048
   lr 0.0001: smoothed loss 2.204
   lr 0.001: smoothed loss 1.300
   lr 0.01: smoothed loss 0.569
   lr 0.1: smoothed loss 0.520

দুই optimizer-এর উপযুক্ত পরিসর প্রায় ৪ থেকে ৫ গুণ আলাদা: SGD-momentum-এর বিস্ফোরণ ১.২-এ, AdamW-এর ০.৩১-এ। তাই “lr = 0.001” কোনো সর্বজনীন সংখ্যা নয়; প্রতিটি optimizer আর model-এর নিজের পরিসর আছে। ১/১০ নিয়মে অংশ ৮-এর তুলনায় SGD-momentum-এর জন্য ০.০২৫ আর AdamW-এর জন্য ০.০০৫ নেওয়া হয়েছে। সীমাবদ্ধতা মনে রাখুন: range test মাত্র কয়েকশো ধাপ দেখে, তাই এটি শুরুর পরিসর বলে, শেষের সেরা মান নয়; আর batch size বা model বদলালে আবার চালাতে হয়।

৫ · PyTorch-এ scheduler — ক্রম, প্রতি ধাপ না প্রতি epoch, আর plateau

torch.optim.lr_scheduler-এ প্রতিটি scheduler একটি optimizer নেয় আর তার param_groups-এর lr বদলায়। Warmup + cosine লেখার সবচেয়ে সরল পথ LambdaLR: একটি function দেয় η_max-এর কত ভগ্নাংশ। আরেকটি পথ SequentialLR দিয়ে LinearLR (warmup) আর CosineAnnealingLR জোড়া লাগানো।

def warmup_cosine(total, warm):
    def f(step):                      # LambdaLR-এর গুণক, peak lr-এর ভগ্নাংশ
        if step < warm:
            return (step + 1) / warm
        return 0.5 * (1 + math.cos(math.pi * (step - warm) / (total - warm)))
    return f

opt = torch.optim.AdamW(model.parameters(), lr=5e-3, weight_decay=0.01)
sch = torch.optim.lr_scheduler.LambdaLR(opt, warmup_cosine(TOTAL, WARM))
for xb, yb in batches:
    loss = F.cross_entropy(model(xb), yb)
    opt.zero_grad(); loss.backward(); opt.step()
    sch.step()                        # প্রতি ধাপে, optimizer.step()-এর পরে

পাতার NumPy সূত্র আর PyTorch-এর scheduler কি একই মান দেয়? একই সাতটি ধাপে (০, ৫০, ৯৯, ১০০, ২৯৯, ৫৫০, ৯৯৯) সত্যিকারের run:

~/bazarghar-dl$ uv run python extras.py sched
torch 2.15.0+cpu | numpy 2.5.4 | python 3.14.4
step           0.1000 0.1000 0.1000 0.1000 0.1000 0.0100 0.0010
cosine         0.1000 0.0994 0.0976 0.0976 0.0795 0.0422 0.0000
warmup+cosine  0.0010 0.0510 0.1000 0.1000 0.0884 0.0500 0.0000
one-cycle      0.0040 0.0105 0.0277 0.0281 0.1000 0.0715 0.0000
one-cycle momentum শুরুতে / শিখরে: 0.95 / 0.85

চারটি সারিই অংশ ২-এর টেবিলের সঙ্গে চার দশমিক ঘর পর্যন্ত মেলে। StepLR(step_size=400, gamma=0.1), CosineAnnealingLR(T_max=1000), আর OneCycleLR(max_lr=0.1, total_steps=1000)-এর default (শুরু max_lr/২৫, ৩০% ধাপে শিখর) ব্যবহার হয়েছে। শেষ লাইন দেখায় OneCycleLR momentum-ও বদলায়: learning rate শিখরে উঠলে momentum ০.৯৫ থেকে ০.৮৫-এ নামে।

পর্ব ১০-এ বলা নিয়মটি আবার: scheduler.step() optimizer.step()-এর পরে। উল্টো ক্রমে কী হয়, StepLR (প্রতি epoch-এ অর্ধেক, শুরু ০.১) দিয়ে সত্যিকারের run:

~/bazarghar-dl$ uv run python extras.py order
torch 2.15.0+cpu | numpy 2.5.4 | python 3.14.4
epoch 0: optimizer যে lr-এ চলল = 0.05
epoch 1: optimizer যে lr-এ চলল = 0.025
epoch 2: optimizer যে lr-এ চলল = 0.0125
warning: Detected call of `lr_scheduler.step()` before `optimizer.step()`. In PyTorch 1.1.0 and later, you should call them in  …

প্রথম epoch-এর optimizer ০.১-এ চলার কথা ছিল, কিন্তু scheduler আগে ডাকায় চলল ০.০৫-এ: schedule-এর প্রথম মান বাদ পড়ল, পুরো schedule এক ধাপ এগিয়ে গেল। এখানে ক্ষতি ছোট, কিন্তু warmup-এ প্রথম মানটিই সবচেয়ে ছোট আর সবচেয়ে জরুরি। PyTorch সতর্ক করে; warning উপেক্ষা করবেন না।

ReduceLROnPlateau অন্যরকম: সে ধাপ গোনে না, val loss দেখে। নির্দিষ্ট সংখ্যক epoch (patience) উন্নতি না হলে η-কে একটি গুণক দিয়ে কমায়। তাই step()-এ metric দিতে হয়: sch.step(val_loss). একটি বানানো val loss-এর ধারায় (factor ০.৫, patience ২, threshold ১০^−৩) সত্যিকারের run:

~/bazarghar-dl$ uv run python extras.py plateau
torch 2.15.0+cpu | numpy 2.5.4 | python 3.14.4
epoch 0: val loss 0.900 | bad epochs 0 | lr পরে 0.1000
epoch 1: val loss 0.700 | bad epochs 0 | lr পরে 0.1000
epoch 2: val loss 0.650 | bad epochs 0 | lr পরে 0.1000
epoch 3: val loss 0.660 | bad epochs 1 | lr পরে 0.1000
epoch 4: val loss 0.650 | bad epochs 2 | lr পরে 0.1000
epoch 5: val loss 0.651 | bad epochs 0 | lr পরে 0.0500
epoch 6: val loss 0.600 | bad epochs 0 | lr পরে 0.0500
epoch 7: val loss 0.610 | bad epochs 1 | lr পরে 0.0500
epoch 8: val loss 0.620 | bad epochs 2 | lr পরে 0.0500
epoch 9: val loss 0.630 | bad epochs 0 | lr পরে 0.0250

তিনটি সূক্ষ্ম বিষয় দেখুন। Epoch ৪-এ val loss আবার ০.৬৫০, সেরার সমান, কিন্তু উন্নতি গোনা হয়নি: threshold-এর আপেক্ষিক নিয়মে সেরার চেয়ে অন্তত ০.১% কম হতে হয়। Epoch ৫-এ খারাপ epoch তিনটি হলো, patience ২ পেরোল, তাই η অর্ধেক আর গোনা শূন্যে ফিরল (যে কারণে লাইনে ০ দেখাচ্ছে)। আর epoch ৬-এর ০.৬০০ নতুন সেরা হওয়ায় পরের কমানো আসে আবার তিন খারাপ epoch পরে। এই scheduler সুবিধাজনক যখন মোট training-এর দৈর্ঘ্য আগে জানা নেই; অসুবিধা, val noise-এ সিদ্ধান্ত ঝাঁকুনি খায়, আর cosine-এর মতো আগে থেকে জানা পথ থাকে না।

৬ · Adam + L2 বনাম AdamW, আর parameter group

মেশিন লার্নিং কোর্সের পর্ব ১৪-এ derive করা হয়েছে: SGD-তে L2 শাস্তি (loss-এ ½λ‖w‖²) আর weight decay (প্রতি ধাপে w ← (1 − ηλ)w) একই জিনিস, কিন্তু Adam-এ নয়। Adam + L2-তে λw gradient-এর ভেতরে ঢোকে, তারপর √v̂ দিয়ে ভাগ হয়। AdamW (Loshchilov আর Hutter, ২০১৭ সালে arXiv-এ, ICLR ২০১৯) decay-কে আলাদা করে: আগে w ← (1 − ηλ)w, তারপর সাধারণ Adam ধাপ। নিচের ব্লক পার্থক্যটি দুইভাবে দেখায়: এক ধাপের হিসাব, আর দুই ধরনের weight-এর ৩০০ ধাপ।

import numpy as np

def run(w, grads, lr=0.01, l2=0.0, wd=0.0, b1=0.9, b2=0.999, eps=1e-8):
    m = np.zeros_like(w); v = np.zeros_like(w)
    for t, g in enumerate(grads, start=1):
        g = g + l2 * w                       # Adam + L2: শাস্তি gradient-এর ভেতরে
        w = w * (1 - lr * wd)                # AdamW: ওজন আলাদাভাবে ছোট করা
        m = b1 * m + (1 - b1) * g; v = b2 * v + (1 - b2) * g * g
        mh = m / (1 - b1 ** t); vh = v / (1 - b2 ** t)
        w = w - lr * mh / (np.sqrt(vh) + eps)
    return w

# ১) এক ধাপ, হাতে মেলানোর মতো: w = 1, data gradient 0.5, lr 0.01, λ 0.1
one = [np.array([0.5])]
for name, kw in [("Adam", {}), ("Adam+L2", {"l2": 0.1}), ("AdamW", {"wd": 0.1})]:
    print(f"{name:8s} এক ধাপ পরে w = {run(np.array([1.0]), one, **kw)[0]:.4f}")

# ২) দুই ধরনের weight, প্রতিটির ২০০০টি কপি; gradient শুধু noise (গড় 0)
rng = np.random.default_rng(42)
scale = np.array([[10.0], [0.01]])            # সারি ০: বড় gradient, সারি ১: ছোট
G = [scale * rng.normal(0, 1, (2, 2000)) for _ in range(300)]
w0 = np.ones((2, 2000))
print("\n৩০০ ধাপ পরে গড় w   বড়-gradient   ছোট-gradient")
for name, kw in [("Adam", {}), ("Adam+L2", {"l2": 0.1}), ("AdamW", {"wd": 0.1})]:
    wf = run(w0, G, **kw).mean(axis=1)
    print(f"{name:8s}             {wf[0]:.3f}         {wf[1]:.3f}")
print(f"শুধু decay হলে (1 - 0.01*0.1)^300 = {(1 - 0.001) ** 300:.3f}")

Adam     এক ধাপ পরে w = 0.9900
Adam+L2  এক ধাপ পরে w = 0.9900
AdamW    এক ধাপ পরে w = 0.9890

৩০০ ধাপ পরে গড় w   বড়-gradient   ছোট-gradient
Adam                 0.996         1.003
Adam+L2              0.967         0.000
AdamW                0.737         0.743
শুধু decay হলে (1 - 0.01*0.1)^300 = 0.741

গভীর network-এ এর প্রভাব কেমন? একই MNIST MLP, warmup + cosine, lr ০.০০২, ৬ epoch, তিন seed; Adam-কে weight_decay=0.05 দিলে PyTorch তা gradient-এ যোগ করে (L2), আর AdamW আলাদা decay. সত্যিকারের run (CPU-তে প্রায় ২০ সেকেন্ড):

~/bazarghar-dl$ uv run python adam_l2.py
torch 2.15.0+cpu | numpy 2.5.4 | python 3.14.4
Adam (wd=0)                    test acc 97.30 ± 0.10% | weight norm 18.5
Adam + L2 (weight_decay=0.05)  test acc 92.42 ± 0.11% | weight norm 4.0
AdamW (weight_decay=0.05)      test acc 97.25 ± 0.06% | weight norm 17.9

একই সংখ্যা ০.০৫, কিন্তু অর্থ সম্পূর্ণ আলাদা। Adam + L2-তে weight-এর norm ১৮.৫ থেকে ৪.০-এ নেমে গেছে আর accuracy প্রায় ৫ শতাংশ-বিন্দু কমেছে: অনেক weight-এর gradient ছোট, তাই শাস্তি সেখানে প্রায় পুরো ধাপ দখল করেছে। AdamW-এ একই λ মৃদু: norm সামান্য কম, accuracy প্রায় একই। এই ছোট, ৬ epoch-এর কাজে decay-এর উপকার চোখে পড়েনি; regularization-এর লাভ মাপা হবে পর্ব ১৬ (Deep learning-এ regularization)-এ, ইচ্ছা করে overfit করা setup-এ। শিক্ষা: Adam আর AdamW-এর মধ্যে λ বদলানো যায় না, আর অন্য কারও AdamW-এর λ Adam-এ বসালে ফল ভেঙে যেতে পারে।

আরেকটি প্রচলিত অভ্যাস: bias আর normalization layer-এর weight (LayerNorm-এর γ) decay থেকে বাদ রাখা। যুক্তি: এগুলো সংখ্যায় খুব কম, overfitting-এ ভূমিকা সামান্য, আর norm-এর γ-কে শূন্যের দিকে টানলে layer-এর output-এর মাপই বদলে যায়। এর জন্য optimizer-কে parameter group-এর তালিকা দিতে হয়, প্রতিটির নিজের weight_decay:

decay, no_decay = [], []
for name, p in model.named_parameters():
    (decay if p.ndim >= 2 else no_decay).append(p)   # matrix-এ decay; bias আর norm-এর weight-এ নয়
opt = torch.optim.AdamW([{"params": decay, "weight_decay": 0.1},
                         {"params": no_decay, "weight_decay": 0.0}], lr=0.01)
for p in model.parameters(): p.grad = torch.zeros_like(p)        # gradient শূন্য: শুধু decay দেখা
opt.step()

সত্যিকারের run:

~/bazarghar-dl$ uv run python groups.py
torch 2.15.0+cpu | numpy 2.5.4 | python 3.14.4
0.weight   (256, 784)  decay
0.bias     (256,)      no decay
1.weight   (256,)      no decay
1.bias     (256,)      no decay
3.weight   (128, 256)  decay
3.bias     (128,)      no decay
5.weight   (10, 128)   decay
5.bias     (10,)       no decay
groups: [(3, 0.1), (5, 0.0)] | parameter: 234752 + 906
weight[0,0]: -0.00026739 -> -0.00026712 (অনুপাত 0.999000)
bias[0]:     -0.011718 -> -0.011718
LayerNorm.weight[0]: 1.000000 -> 1.000000

“ndim ≥ ২” নিয়মটি সরল কিন্তু কার্যকর: তিনটি Linear-এর weight matrix decay group-এ, আর তিনটি bias আর LayerNorm-এর দুটি vector অন্য group-এ। ২,৩৪,৭৫২টি parameter decay পায়, ৯০৬টি পায় না। Gradient শূন্য রেখে একটি ধাপ নিলে শুধু decay কাজ করে: weight ঠিক (১ − ০.০১ × ০.১) = ০.৯৯৯ গুণ হলো, bias আর LayerNorm-এর γ বদলায়নি। Embedding-এর মতো ২-মাত্রার কিন্তু “বিশেষ” parameter থাকলে নাম দিয়ে আলাদা করুন; এ নিয়ে সম্প্রদায়ে একমত নেই। Parameter group দিয়ে আলাদা layer-এ আলাদা learning rate-ও দেওয়া যায়, যা fine-tuning-এ কাজে লাগে; সেটি পর্ব ২৩ (Transfer learning)-এর বিষয়।

৭ · Gradient accumulation, effective batch আর learning rate

বড় batch memory-তে না ধরলে gradient accumulation: কয়েকটি ছোট micro-batch-এর backward চালিয়ে gradient জমতে দিন, তারপর একবার step(). তখন effective batch = micro-batch × জমানোর সংখ্যা (× GPU-র সংখ্যা)। একটি জরুরি খুঁটিনাটি: CrossEntropyLoss default-ভাবে batch-এর গড় দেয়, তাই k টি micro-batch-এর loss যোগ করলে k গুণ বড় gradient আসে। প্রতিটির loss k দিয়ে ভাগ করুন।

def grads(model, k, divide=True):            # k টি micro-batch-এ ভাগ করে backward
    model.zero_grad()
    for xm, ym in zip(xb.chunk(k), yb.chunk(k)):
        loss = nn.functional.cross_entropy(model(xm), ym)
        (loss / k if divide else loss).backward()
    return torch.cat([p.grad.flatten() for p in model.parameters()])

৬৪টি MNIST ছবি, একবারে বনাম ১৬-এর চারটি micro-batch-এ। সত্যিকারের run:

~/bazarghar-dl$ uv run python accum.py
torch 2.15.0+cpu | numpy 2.5.4 | python 3.14.4
১ x 64 বনাম ৪ x 16 (loss/4): সর্বোচ্চ পার্থক্য 1.49e-08, norm 1.4495 বনাম 1.4495
৪ x 16, ভাগ ছাড়া: norm 5.7980 (অনুপাত 4.000)
এক SGD ধাপের পরে parameter-এর সর্বোচ্চ পার্থক্য: 7.45e-09
BatchNorm থাকলে: সর্বোচ্চ পার্থক্য 3.94e-02, আপেক্ষিক 0.360

৪ দিয়ে ভাগ করলে দুই পথের gradient-এর পার্থক্য ১.৪৯ × ১০^−৮: float32-এ যোগের ক্রম আলাদা হওয়ার ছাপ মাত্র, গাণিতিকভাবে একই। ভাগ না করলে gradient ঠিক ৪ গুণ, যা SGD-তে learning rate ৪ গুণ করার সমান (Adam-এ অনুপাতের কারণে প্রভাব কম চোখে পড়ে, কিন্তু epsilon আর weight decay-এর ভারসাম্য বদলায়)। শেষ লাইনটি সতর্কবাণী: BatchNorm প্রতিটি micro-batch-এর নিজের গড় দিয়ে normalize করে, তাই ১৬-এর batch-এর পরিসংখ্যান ৬৪-এর মতো নয়, আর gradient-এ ৩৬% আপেক্ষিক পার্থক্য। LayerNorm প্রতিটি উদাহরণে আলাদা কাজ করে বলে এই সমস্যা নেই। শেষ micro-batch ছোট হলে ভাগ উদাহরণের সংখ্যা দিয়ে করাই নিখুঁত।

Batch বড় হলে learning rate কতটা বাড়াবেন? Goyal ও সহকর্মীরা (২০১৭) SGD-তে linear scaling rule জানান: batch k গুণ হলে η-ও k গুণ, সঙ্গে warmup; তাঁদের ImageNet-এর পরীক্ষায় একটি বড় সীমা পর্যন্ত (প্রায় ৮ হাজারের batch) নির্ভুলতা ধরে রাখা গিয়েছিল। এটি একটি অভিজ্ঞতালব্ধ নিয়ম, প্রমাণ নয়; খুব বড় batch-এ ভেঙে পড়ে। Adam-জাতীয় optimizer-এ অনেকে বর্গমূলের নিয়ম (batch k গুণ হলে η √k গুণ) ব্যবহার করেন; এ নিয়ে একমত নেই, তাই নতুন batch-এ range test আবার চালানোই নিরাপদ।

৮ · একই কাজে চার রকম training — SGD-momentum বনাম AdamW, schedule-সহ ও ছাড়া

এখন সব জোড়া লাগাই। একই MNIST MLP, ২০,০০০টি train ছবি, ১০,০০০ validation, ১০,০০০ test; ৮ epoch × ১৫৭ ধাপ = ১২৫৬ ধাপ; batch ১২৮. SGD-momentum (০.৯, weight decay ৫ × ১০^−৪) lr ০.০২৫, AdamW (weight decay ০.০১) lr ০.০০৫, দুটিই অংশ ৪-এর range test-এর ১/১০ নিয়মে। Schedule থাকলে ৬২ ধাপের warmup (৫%), তারপর cosine. প্রতিটি সেটআপ তিনটি seed-এ। সত্যিকারের run (CPU-তে পুরোটা প্রায় ৩০ সেকেন্ড):

~/bazarghar-dl$ uv run python compare.py
torch 2.15.0+cpu | numpy 2.5.4 | python 3.14.4
train 20000 | val 10000 | test 10000 | 8 epoch x 157 ধাপ = 1256 | warmup 62
SGD-momentum                  test acc 97.07 ± 0.19% | seed: 96.92, 97.00, 97.28
                              val loss/epoch: 0.197 0.134 0.131 0.114 0.108 0.119 0.106 0.103
SGD-momentum + warmup-cosine  test acc 97.15 ± 0.03% | seed: 97.17, 97.12, 97.15
                              val loss/epoch: 0.209 0.137 0.122 0.107 0.104 0.100 0.098 0.098
AdamW                         test acc 96.44 ± 0.46% | seed: 96.00, 96.92, 96.41
                              val loss/epoch: 0.192 0.139 0.138 0.135 0.128 0.131 0.149 0.140
AdamW + warmup-cosine         test acc 97.47 ± 0.08% | seed: 97.46, 97.40, 97.55
                              val loss/epoch: 0.185 0.129 0.125 0.108 0.105 0.097 0.095 0.095

সবচেয়ে বড় পার্থক্য optimizer-এ নয়, schedule-এ। ধ্রুব lr ০.০০৫-এ AdamW-এর val loss শেষ পাঁচ epoch-এ ০.১২৮ থেকে ০.১৪৯-এর মধ্যে কাঁপছে, test accuracy-র seed-ভেদে ছড়ানো ০.৪৬, তিন seed-এর মধ্যে প্রায় ১ শতাংশ-বিন্দুর ফারাক। একই lr-এ শিখর রেখে cosine দিয়ে নামালে val loss ০.০৯৫, accuracy ৯৭.৪৭ ± ০.০৮: শেষে ছোট ধাপ noise-এর মেঝে ভেঙেছে। SGD-momentum-এ lr তুলনামূলক ছোট (ধ্রুব রেখাও শেষে ০.১০৩), তাই schedule-এর লাভ কম, মূলত seed-ভেদ কমেছে (০.১৯ থেকে ০.০৩)। অর্থাৎ “AdamW SGD-এর চেয়ে ভালো” বা উল্টোটি এই run থেকে বলা যায় না: ধ্রুব lr-এ SGD এগিয়ে, schedule-সহ AdamW সামান্য এগিয়ে, আর পার্থক্য এক শতাংশ-বিন্দুরও কম।

৯ · নতুন optimizer — সতর্ক নোট, আর কোনটি কখন

প্রতি বছর নতুন optimizer প্রস্তাব হয়, প্রায়ই নির্দিষ্ট কিছু কাজে ভালো ফলের দাবিসহ। কয়েকটি নাম, যা আলোচনায় শুনবেন (সবগুলোর দাবি নির্দিষ্ট সেটআপের, সর্বজনীন নয়):

• Lion (Chen ও সহকর্মী, ২০২৩): program search দিয়ে খুঁজে পাওয়া; momentum-এর একটি মিশ্রণের শুধু চিহ্ন (sign) নিয়ে ধাপ দেয়, তাই v রাখতে হয় না, optimizer state অর্ধেক। সাধারণত AdamW-এর চেয়ে ছোট lr আর বড় weight decay চায়।
• Sophia (Liu ও সহকর্মী, ২০২৩): Hessian-এর diagonal-এর একটি সস্তা অনুমান দিয়ে ধাপ ভাগ করে, আর ধাপ clip করে; ভাষা model-এর pre-training-এর জন্য প্রস্তাবিত।
• Shampoo (Gupta ও সহকর্মী, ২০১৮): প্রতিটি weight matrix-এর জন্য ছোট preconditioner matrix রাখে, second-order পদ্ধতির কাছাকাছি (মেশিন লার্নিং কোর্সের পর্ব ১৫); হিসাব আর memory বেশি।
• Muon (২০২৪ সালের দিকে Keller Jordan ও সহকর্মীদের লেখা থেকে জনপ্রিয়): ২-মাত্রার weight matrix-এর momentum-কে Newton–Schulz পুনরাবৃত্তি দিয়ে প্রায় orthogonal করে; bias, embedding আর শেষ layer-এ সাধারণত AdamW-ই রাখা হয়।

এদের কয়েকটির পক্ষে ভালো ফলের রিপোর্ট আছে, কিন্তু স্বাধীন benchmark-এ (যেমন MLCommons-এর AlgoPerf উদ্যোগ) ফল কাজভেদে মিশ্র এসেছে বলে জানা যায়, আর ভালোভাবে tune করা AdamW এখনো শক্ত baseline. বাস্তব নিয়ম: নতুন optimizer চেষ্টার আগে AdamW-এর lr, warmup, schedule আর weight decay ঠিক করুন; তুলনা করুন একাধিক seed আর প্রতিটির নিজের tune করা lr-এ।

১০ · AI-এর যুগে — AI-এর দেওয়া optimizer সেটিং যাচাই

“AdamW আর cosine schedule দিয়ে training কোড দাও” বললে AI assistant দ্রুত কোড দেয়, কিন্তু এই পর্বের ভুলগুলো চুপচাপ: কোড চলে, শুধু ফল একটু খারাপ, বা seed-ভেদে অস্থির।

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

• প্রতিটি ধাপের lr লগ করে schedule-এর ছবি দেখেছি: warmup, শিখর আর শেষ মান প্রত্যাশামতো
• scheduler.step() optimizer.step()-এর পরে, আর সঠিক হারে (প্রতি ধাপ বা প্রতি epoch)
• AdamW ক্লাস ব্যবহার হয়েছে, আর param_groups ছাপিয়ে দেখেছি bias ও norm decay পায় না
• Accumulation-এ loss k দিয়ে ভাগ, আর এক batch বনাম micro-batch-এর gradient মিলিয়েছি
• নিজের model-এ LR range test চালিয়েছি, অন্য কারও lr কপি করিনি
• তুলনা কয়েকটি seed-এ, প্রতিটি সেটআপের নিজের lr-এ, আর কোনো ব্যক্তিগত ডেটা বা key AI-তে পেস্ট করিনি