Weight initialization আর normalization — Xavier, He, BatchNorm আর LayerNorm

পর্ব ০৩-এর NumPy MLP-এ আমরা weight-এর initialization করেছিলাম √(2/n_in) standard deviation দিয়ে, আর পর্ব ০৯-এ দেখেছি nn.Linear নিজে U(−1/√in, 1/√in) থেকে weight নেয়। কেন এই সংখ্যা, অন্য কোনোটি নয়? AI-এর ভিত্তি কোর্সের পর্ব ৬৮-এ এর সংক্ষিপ্ত উত্তর ছিল: স্তর পেরিয়ে signal যেন না হারায়। এই পর্বে সেই কথাটি মেপে, হিসাব করে, আর একটি সত্যিকারের ২০ স্তরের network শিখিয়ে দেখব। দ্বিতীয় অর্ধেকে আসবে normalization: শুরু ভালো হলেও training-এর মাঝে মাপ সরে যায়, তাই প্রতিটি স্তরে মাপ ঠিক রাখার একটি যন্ত্র। পাতার চারটি ব্লক NumPy-তে (প্রথম চালানোয় package আসতে কয়েক সেকেন্ড লাগে); PyTorch-এর অংশগুলো ডেস্কটপের সত্যিকারের run.

১ · Signal-এর পথ — গভীরতায় activation কেন হারায় বা ফাটে

একটি স্তর হিসাব করে z = Wx, তারপর activation h = f(z). ধরুন x-এর প্রতিটি মান স্বাধীন, গড় ০, variance Var(x); W-এর প্রতিটি মানও স্বাধীন, গড় ০, variance Var(W). z-এর একটি উপাদান হলো n টি গুণফলের যোগ, যেখানে n = fan_in, অর্থাৎ একটি neuron-এ কতগুলো input ঢোকে। স্বাধীন রাশির যোগে variance যোগ হয় (AI-এর ভিত্তি কোর্সের পর্ব ৩৭), তাই

Var(z) = n · Var(W) · Var(x)

অর্থাৎ প্রতিটি স্তর variance-কে g = n · Var(W) দিয়ে গুণ করে (activation-এর প্রভাব একটু পরে)। L টি স্তর পরে গুণক g^L. g = ০.৫ হলে ২০ স্তরে ০.৫^২০ ≈ ১০^−৬, আর g = ২ হলে প্রায় ১০^৬. এই ঘটনাকে বলে signal propagation-এর সমস্যা। Forward-এ activation হারালে backward-এ gradient-ও একই শিকল ধরে ফেরে, তাই gradient-ও হারায় (vanishing gradient) বা ফাটে; সেই দিকটি পর্ব ১৭ (Vanishing আর exploding gradient — residual connection আর gradient clipping)-এ মাপা হবে। এখানে শুধু forward.

নিচের ব্লক ২৫৬ চওড়া ২০টি স্তরে ৫১২টি এলোমেলো input পাঠায়, bias ছাড়া, আর প্রতিটি স্তরের পরে activation-এর standard deviation মাপে। চার রকম weight-এর std: স্থির ০.০১, Xavier √(1/n), He √(2/n), আর বড় 3/√n. দুটি activation: tanh আর ReLU.

import numpy as np
import matplotlib.pyplot as plt

n, depth = 256, 20                        # প্রতিটি স্তরে ২৫৬টি neuron
x0 = np.random.default_rng(42).standard_normal((512, n))   # ৫১২টি input
inits = {"small 0.01": lambda n: 0.01,
         "Xavier sqrt(1/n)": lambda n: np.sqrt(1 / n),
         "He sqrt(2/n)": lambda n: np.sqrt(2 / n),
         "large 3/sqrt(n)": lambda n: 3 / np.sqrt(n)}
acts = {"tanh": np.tanh, "relu": lambda z: np.maximum(z, 0)}

fig, axes = plt.subplots(1, 2, figsize=(9, 3.6))
for ax, (aname, f) in zip(axes, acts.items()):
    print(aname, "— activation-এর std: স্তর 1 | 5 | 10 | 20")
    for iname, s in inits.items():
        rng = np.random.default_rng(0)        # সব init-এ একই এলোমেলো ক্রম
        h, stds = x0, []
        for _ in range(depth):
            W = rng.normal(0, s(n), (n, n))
            h = f(h @ W)                      # bias 0, শুধু weight-এর প্রভাব
            stds.append(h.std())
        ax.semilogy(range(1, depth + 1), stds, marker="o", ms=3, label=iname)
        s1, s5, s10, s20 = (stds[i] for i in (0, 4, 9, 19))
        print(f"  {iname:17s} {s1:9.3g} {s5:9.3g} {s10:9.3g} {s20:9.3g}")
    ax.set(title=f"{aname}: activation std by depth", xlabel="layer",
           ylabel="std (log scale)")
axes[1].legend(fontsize=8)

tanh — activation-এর std: স্তর 1 | 5 | 10 | 20
  small 0.01            0.157  0.000102  1.09e-08  1.19e-16
  Xavier sqrt(1/n)      0.629     0.321     0.231     0.159
  He sqrt(2/n)          0.722     0.567     0.558     0.553
  large 3/sqrt(n)       0.863     0.837     0.838     0.837
relu — activation-এর std: স্তর 1 | 5 | 10 | 20
  small 0.01           0.0943  1.56e-05   3.9e-10  1.13e-19
  Xavier sqrt(1/n)      0.589     0.148    0.0355  0.000936
  He sqrt(2/n)          0.834      0.84      1.14     0.959
  large 3/sqrt(n)        1.77      36.1   2.1e+03  3.26e+06

২ · Xavier আর He — variance ধরে রাখার শর্ত থেকে সূত্র

লক্ষ্য সহজ: g = ১, যাতে প্রতিটি স্তরে variance যেমন ঢোকে তেমন বের হয়। Activation না থাকলে (বা শূন্যের কাছে প্রায় সরলরেখা tanh হলে) শর্ত n · Var(W) = ১, অর্থাৎ Var(W) = 1/fan_in; এটি LeCun-এর ১৯৯৮ সালের “Efficient BackProp”-এর পরামর্শের সঙ্গে মেলে। Glorot আর Bengio (AISTATS ২০১০) দেখলেন backward-এ gradient-এর জন্য একই শর্ত দাঁড়ায় fan_out দিয়ে (gradient ফেরে স্তরের output-এর দিক থেকে)। দুটি একসঙ্গে মানা যায় না যদি fan_in ≠ fan_out, তাই তাঁরা গড় নিলেন:

Xavier/Glorot: Var(W) = 2 / (fan_in + fan_out)

ReLU-এর ক্ষেত্রে একটি জিনিস বদলায়, যা He, Zhang, Ren আর Sun-এর ২০১৫ সালের প্রবন্ধ (“Delving Deep into Rectifiers”) হিসাব করে দেখায়। নিচের stepper সেই হিসাব ধাপে ধাপে করে।

এভাবে পাওয়া He/Kaiming init ReLU-পরিবারের network-এর প্রচলিত শুরু। দুটি নিয়মকে এক ছাঁচে লেখা যায়: Var(W) = gain² / fan, যেখানে gain activation-এর ওপর নির্ভর করে (linear-এ ১, ReLU-তে √২, tanh-এ PyTorch-এর মান ৫/৩) আর fan হয় fan_in (forward রক্ষা) বা fan_in ও fan_out-এর গড় (Xavier). Normal আর uniform দুই রূপই আছে; variance মিললে আচরণ প্রায় একই।

৩ · PyTorch-এর default init বনাম স্পষ্ট init

পর্ব ০৯-এ দেখেছিলাম nn.Linear weight আর bias দুটিই U(−1/√in, 1/√in) থেকে নেয়। এই সমবণ্টনের variance (1/√in)²/৩ = 1/(3·in). ReLU-এর হিসাবে g = n · 1/(3n) · ½ = 1/6, অর্থাৎ প্রতি স্তরে std প্রায় √(1/6) ≈ ০.৪১ গুণ হয়। তত্ত্ব বলে দশ স্তরেই প্রায় ১০^−৪. ডেস্কটপে মেপে দেখা যাক, সঙ্গে torch.nn.init-এর ফাংশনগুলোর std আর calculate_gain.

import math, torch
from torch import nn
torch.manual_seed(0)
n = 256
lin = nn.Linear(n, n)                              # PyTorch-এর default init
print("default weight std", round(lin.weight.std().item(), 4),
      "| তত্ত্ব 1/sqrt(3n) =", round(1 / math.sqrt(3 * n), 4))
w = torch.empty(n, n)
nn.init.kaiming_normal_(w, nonlinearity="relu")
print("kaiming_normal_ std", round(w.std().item(), 4),
      "| sqrt(2/n) =", round(math.sqrt(2 / n), 4))
nn.init.xavier_uniform_(w)
print("xavier_uniform_ std", round(w.std().item(), 4),
      "| sqrt(2/(n+n)) =", round(math.sqrt(2 / (2 * n)), 4))
for nl in ["linear", "tanh", "relu"]:
    print(f"calculate_gain('{nl}') =", round(nn.init.calculate_gain(nl), 4))

x0 = torch.randn(512, n)
for name in ["default", "he"]:
    torch.manual_seed(1); h, out = x0, []
    for i in range(20):
        lin = nn.Linear(n, n)
        if name == "he":
            nn.init.kaiming_normal_(lin.weight, nonlinearity="relu")
            nn.init.zeros_(lin.bias)
        with torch.no_grad():
            h = torch.relu(lin(h))
        if i + 1 in (1, 5, 10, 20):
            out.append(f"{i + 1}: {h.std().item():.3g}")
    print(f"{name:7s} ReLU activation std ->", " | ".join(out))

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

~/bazarghar-dl$ uv run python init_check.py
default weight std 0.036 | তত্ত্ব 1/sqrt(3n) = 0.0361
kaiming_normal_ std 0.0888 | sqrt(2/n) = 0.0884
xavier_uniform_ std 0.0626 | sqrt(2/(n+n)) = 0.0625
calculate_gain('linear') = 1
calculate_gain('tanh') = 1.6667
calculate_gain('relu') = 1.4142
default ReLU activation std -> 1: 0.339 | 5: 0.0226 | 10: 0.0228 | 20: 0.0233
he      ReLU activation std -> 1: 0.83 | 5: 0.789 | 10: 0.755 | 20: 0.671

প্রথম তিন লাইনে মাপা std সূত্রের সঙ্গে তৃতীয় দশমিক পর্যন্ত মেলে। শেষ দুই লাইন একটি সূক্ষ্ম কথা বলে। Default-এ std স্তর ১-এ ০.৩৪, স্তর ৫-এ ০.০২৩, তারপর আর কমে না, ০.০২৩-এর কাছে থেমে যায়। কারণ bias: প্রতিটি স্তর নিজের bias যোগ করে, যার std-ও প্রায় 1/√(3 · 256) ≈ ০.০৩৬; weight-এর পথে আসা signal মরে গেলেও bias-এর একটি স্থির “গুঞ্জন” থাকে। অর্থাৎ শেষ স্তরের activation-এ যা দেখা যায়, তার প্রায় সবটাই bias, input-এর তথ্য নয়। He init-এ (bias শূন্য) ২০ স্তরেও ০.৬৭. অংশ ৮-এ দেখব এই পার্থক্য training-এ কী করে।

৪ · সব weight সমান হলে — symmetry-র সমস্যা

“ছোট রাখাই যদি লক্ষ্য হয়, সব weight শূন্য দিলেই তো হয়?” না। একই স্তরের দুটি hidden unit-এর weight হুবহু এক হলে তারা একই input থেকে একই output দেয়, backward-এ একই gradient পায়, আর একই পরিমাণ বদলায়। পরের ধাপেও তারা এক। এভাবে চিরকাল: ১০০টি unit কার্যত একটি unit. এলোমেলো শুরু এই প্রতিসাম্য ভাঙে, যার নাম symmetry breaking. সব শূন্য হলে আরও খারাপ: tanh(0) = ০, তাই hidden output শূন্য, ফলে output-এর weight-এর gradient শূন্য, আর hidden-এর gradient-ও শূন্য (কারণ তা output-এর শূন্য weight দিয়ে গুণ হয়)। শুধু শেষ bias নড়ে।

নিচের ব্লক বাজারঘরের ২০০টি কাল্পনিক অর্ডারে (তিনটি standardized feature) একটি ৩ → ৪ (tanh) → ১ (sigmoid) network হাতে লেখা backprop-এ ২০০০ ধাপ শেখায় (পর্ব ০৪-এর ছাঁচ)। Label একটি XOR-ধাঁচের অ-রৈখিক নিয়ম, যা একটি unit দিয়ে শেখা যায় না। তিন রকম শুরু: সব শূন্য, সব ০.৫, আর এলোমেলো।

import numpy as np
np.set_printoptions(precision=3, suppress=True)
rng = np.random.default_rng(42)
X = rng.normal(size=(200, 3))     # বাজারঘর: দূরত্ব, পণ্য, বৃষ্টি (standardized)
y = ((X[:, 0] * X[:, 1] > 0) ^ (X[:, 2] > 1))[:, None] * 1.0

def train(W1, W2, steps=2000, lr=0.5):            # 3 → 4 (tanh) → 1 (sigmoid)
    b1, b2 = np.zeros(4), np.zeros(1)
    for _ in range(steps):
        H = np.tanh(X @ W1 + b1)
        p = 1 / (1 + np.exp(-(H @ W2 + b2)))
        d2 = (p - y) / len(X)                    # BCE-এর gradient, logit-এ
        dH = (d2 @ W2.T) * (1 - H ** 2)
        W2 -= lr * H.T @ d2; b2 -= lr * d2.sum(0)
        W1 -= lr * X.T @ dH; b1 -= lr * dH.sum(0)
    return W1, H, ((p > 0.5) == y).mean()

runs = {"zero 0": (np.zeros((3, 4)), np.zeros((4, 1))),
        "constant 0.5": (np.full((3, 4), 0.5), np.full((4, 1), 0.5)),
        "random N(0, 0.5²)": (rng.normal(0, 0.5, (3, 4)),
                              rng.normal(0, 0.5, (4, 1)))}
for name, (W1, W2) in runs.items():
    W1, H, acc = train(W1, W2)
    print(f"{name} | accuracy {acc:.3f}")
    print("  W1-এর ৪টি কলাম (প্রতিটি একটি hidden unit):\n", W1)
    print("  ৪টি unit-এর output-এ সবচেয়ে বড় পার্থক্য:",
          round(float(np.ptp(H, axis=1).max()), 6))

zero 0 | accuracy 0.530
  W1-এর ৪টি কলাম (প্রতিটি একটি hidden unit):
 [[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
  ৪টি unit-এর output-এ সবচেয়ে বড় পার্থক্য: 0.0
constant 0.5 | accuracy 0.590
  W1-এর ৪টি কলাম (প্রতিটি একটি hidden unit):
 [[1.377 1.377 1.377 1.377]
 [1.816 1.816 1.816 1.816]
 [0.231 0.231 0.231 0.231]]
  ৪টি unit-এর output-এ সবচেয়ে বড় পার্থক্য: 0.0
random N(0, 0.5²) | accuracy 0.965
  W1-এর ৪টি কলাম (প্রতিটি একটি hidden unit):
 [[-1.483 -1.439  1.819 -1.583]
 [-1.6    1.448  1.631  1.36 ]
 [-1.144 -0.971 -1.074  0.942]]
  ৪টি unit-এর output-এ সবচেয়ে বড় পার্থক্য: 1.999998

৫ · BatchNorm — প্রতিটি feature-কে batch ধরে normalize করা

Init শুধু শুরুটা ঠিক করে; training-এ weight বদলালে প্রতিটি স্তরের input-এর মাপও সরে যায়। Ioffe আর Szegedy (ICML ২০১৫) প্রস্তাব করলেন Batch Normalization: একটি স্তরের প্রতিটি feature (কলাম) j-এর জন্য, B আকারের batch-এ

μ_j = গড়(x_·j), σ²_j = গড়((x_·j − μ_j)²), x̂ = (x − μ_j) / √(σ²_j + ε), y = γ_j x̂ + β_j

এখানে ε (PyTorch-এ 1e-5) শূন্য দিয়ে ভাগ ঠেকায়; γ (scale, শুরুতে ১) আর β (shift, শুরুতে ০) শেখা parameter, যাতে network দরকার হলে normalize-এর আগের মাপে ফিরে যেতে পারে। Training-এর variance-এ ভাগ হয় B দিয়ে (biased). এর সঙ্গে চলে দুটি running statistics: running_mean আর running_var, যা প্রতি batch-এ হালনাগাদ হয়, momentum m (PyTorch-এ ০.১) দিয়ে:

running = (1 − m) · running + m · batch-এর মান

PyTorch running_var-এ batch-এর unbiased variance (B − ১ দিয়ে ভাগ) জমায়। Eval-এ batch-এর পরিসংখ্যান নয়, এই জমানো মান দিয়ে normalize হয়, যাতে একটি নমুনার উত্তর batch-এর অন্যদের ওপর নির্ভর না করে। নিচের stepper একটি feature-এর চারটি সংখ্যায় পুরো হিসাব করে।

এবার একই হিসাব NumPy-তে, দুটি feature (পণ্যের সংখ্যা আর শত টাকায় দাম) নিয়ে, তারপর একই উৎসের ৬০টি batch দিয়ে running statistics কীভাবে আসল মানের দিকে এগোয় তা দেখা। আসল উৎসের গড় [৫, ২৫] আর variance [৪, ১০০]।

import numpy as np
np.set_printoptions(precision=4, suppress=True)
# batch-এ ৪টি অর্ডার, feature ২টি: পণ্যের সংখ্যা আর দাম (শত টাকায়)
X = np.array([[2., 10.], [4., 30.], [6., 20.], [8., 40.]])
gamma, beta, eps = np.array([2., 1.]), np.array([0.5, 0.]), 1e-5

mu, var = X.mean(axis=0), X.var(axis=0)    # প্রতিটি feature-এর কলাম ধরে, ÷N
x_hat = (X - mu) / np.sqrt(var + eps)
Y = gamma * x_hat + beta
print("mean", mu, "| var (÷N)", var)
print("x̂ =\n", x_hat)
print("y = γ·x̂ + β =\n", Y)
print("y-এর কলাম-গড়", Y.mean(0), "| কলাম-std", Y.std(0))

# running statistics: momentum 0.1, শুরু mean 0, var 1 (PyTorch-এর মতো)
rm, rv, m = np.zeros(2), np.ones(2), 0.1
rm = (1 - m) * rm + m * mu
rv = (1 - m) * rv + m * X.var(axis=0, ddof=1)     # running-এ ÷(N−1)
print("১টি step পরে running_mean", rm, "| running_var", rv)

rng = np.random.default_rng(0)
for step in range(2, 61):                        # একই উৎসের নতুন batch
    B = rng.normal([5, 25], [2, 10], size=(32, 2))
    rm = (1 - m) * rm + m * B.mean(0)
    rv = (1 - m) * rv + m * B.var(0, ddof=1)
    if step in (10, 30, 60):
        print(f"step {step}: running_mean {rm} | running_var {rv}")
one = np.array([[5., 25.]])                      # eval: মাত্র একটি অর্ডার
print("eval-এ একটি অর্ডার:", gamma * (one - rm) / np.sqrt(rv + eps) + beta)

mean [ 5. 25.] | var (÷N) [  5. 125.]
x̂ =
 [[-1.3416 -1.3416]
 [-0.4472  0.4472]
 [ 0.4472 -0.4472]
 [ 1.3416  1.3416]]
y = γ·x̂ + β =
 [[-2.1833 -1.3416]
 [-0.3944  0.4472]
 [ 1.3944 -0.4472]
 [ 3.1833  1.3416]]
y-এর কলাম-গড় [0.5 0. ] | কলাম-std [2. 1.]
১টি step পরে running_mean [0.5 2.5] | running_var [ 1.5667 17.5667]
step 10: running_mean [ 3.1817 16.6135] | running_var [ 3.1273 67.505 ]
step 30: running_mean [ 4.9093 23.2224] | running_var [ 4.2297 90.1461]
step 60: running_mean [ 4.9155 25.0446] | running_var [ 3.6444 98.0532]
eval-এ একটি অর্ডার: [[ 0.5886 -0.0045]]

BatchNorm কেন কাজ করে? মূল প্রবন্ধ বলেছিল এটি internal covariate shift কমায়: training-এ আগের স্তর বদলালে পরের স্তরের input-এর বণ্টন সরে যায়, BatchNorm তা স্থির রাখে। পরে Santurkar ও সহকর্মীদের (NeurIPS ২০১৮) পরীক্ষায় দেখা যায় ইচ্ছে করে বণ্টন সরিয়ে দিলেও BatchNorm-এর সুবিধা থাকে; তাঁদের ব্যাখ্যা, এটি loss-এর তলকে মসৃণ করে, ফলে বড় learning rate চলে। কোন ব্যাখ্যা পুরো সত্য, তা নিয়ে আলোচনা এখনো চলছে; ব্যবহারিক ফল নিয়ে বিতর্ক কম: দ্রুত, বড় learning rate-এ, init-এর প্রতি কম সংবেদনশীল training. Linear-এর ঠিক পরে BatchNorm বসালে Linear-এর bias অর্থহীন (গড় বিয়োগে মুছে যায়), তাই অনেকে bias=False দেন।

৬ · Train বনাম eval — running statistics আর ছোট batch-এর ফাঁদ

BatchNorm-ই PyTorch-এর সেই layer, যার আচরণ train() আর eval() (eval mode)-এ সবচেয়ে বেশি বদলায় (পর্ব ০৯-এ Dropout দেখেছিলাম, পর্ব ১০-এ লুপের নিয়ম)। ডেস্কটপে stepper-এর চারটি অর্ডারই nn.BatchNorm1d-কে দেওয়া হলো, γ = [২, ১], β = [০.৫, ০] বসিয়ে।

import torch
from torch import nn
torch.set_printoptions(precision=4, sci_mode=False)

X = torch.tensor([[2., 10.], [4., 30.], [6., 20.], [8., 40.]])
bn = nn.BatchNorm1d(2)                       # momentum 0.1, eps 1e-5
with torch.no_grad():
    bn.weight.copy_(torch.tensor([2., 1.]))  # γ
    bn.bias.copy_(torch.tensor([0.5, 0.]))   # β
print(bn)
print("buffers:", [n for n, _ in bn.named_buffers()])
print("শুরুতে running_mean", bn.running_mean, "running_var", bn.running_var)

bn.train()
y_train = bn(X)
print("train-mode output:\n", y_train.detach())
print("১ step পরে running_mean", bn.running_mean,
      "running_var", bn.running_var, "| num_batches_tracked",
      bn.num_batches_tracked.item())

bn.eval()
with torch.no_grad():
    print("eval-mode output (একই X):\n", bn(X))

bn.train()
try:
    bn(X[:1])                                # batch-এ মাত্র একটি নমুনা
except ValueError as e:
    print("ValueError:", e)

a = torch.tensor([[5., 25.]])
with torch.no_grad():
    o1 = bn(torch.cat([a, X[:1]]))[0]
    o2 = bn(torch.cat([a, X[3:]]))[0]
print("একই অর্ডার, দুটি আলাদা batch-এ (train):", o1, o2)
ln = nn.LayerNorm(2)
print("LayerNorm একটি নমুনায়:", ln(a).detach())

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

~/bazarghar-dl$ uv run python bn_modes.py
BatchNorm1d(2, eps=1e-05, momentum=0.1, affine=True, bias=True, track_running_stats=True)
buffers: ['running_mean', 'running_var', 'num_batches_tracked']
শুরুতে running_mean tensor([0., 0.]) running_var tensor([1., 1.])
train-mode output:
 tensor([[-2.1833, -1.3416],
        [-0.3944,  0.4472],
        [ 1.3944, -0.4472],
        [ 3.1833,  1.3416]])
১ step পরে running_mean tensor([0.5000, 2.5000]) running_var tensor([ 1.5667, 17.5667]) | num_batches_tracked 1
eval-mode output (একই X):
 tensor([[ 2.8968,  1.7894],
        [ 6.0925,  6.5613],
        [ 9.2883,  4.1754],
        [12.4840,  8.9472]])
ValueError: Expected more than 1 value per channel when training, got input size torch.Size([1, 2])
একই অর্ডার, দুটি আলাদা batch-এ (train): tensor([2.5000, 1.0000]) tensor([-1.5000, -1.0000])
LayerNorm একটি নমুনায়: tensor([[-1.,  1.]])

পাঁচটি জিনিস মিলিয়ে দেখুন। এক: BatchNorm-এর তিনটি buffer: running_mean, running_var আর num_batches_tracked; এগুলো state_dict-এ যায়, শেখানো হয় না। দুই: train-mode output হুবহু পাতার NumPy-র y, আর এক step পরে running_mean [০.৫, ২.৫], running_var [১.৫৬৬৭, ১৭.৫৬৬৭], ঠিক stepper-এর হিসাব; দ্বিতীয় feature-এ ০.৯ + ০.১ × (৫০০/৩) = ১৭.৫৬৬৭, অর্থাৎ unbiased variance. তিন: একই X-এ eval-mode output পুরো আলাদা (২.৯ থেকে ১২.৫), কারণ মাত্র এক step-এর running stats এখনো শুরুর (০, ১)-এর কাছে। চার: training-এ একটি নমুনার batch-এ variance হিসাব অর্থহীন, তাই PyTorch থামিয়ে দেয়। পাঁচ: train mode-এ একই অর্ডার [৫, ২৫] এক batch-এ পায় [২.৫, ১.০], আরেক batch-এ [−১.৫, −১.০]: output নির্ভর করে পাশে কে আছে তার ওপর। LayerNorm একটি নমুনাতেই চলে।

এখন বড় ফাঁদটি একটি আসল model-এ। ২০ স্তরের MLP (প্রতিটি Linear-এর পরে BatchNorm) Fashion-MNIST-এ দুই epoch শেখানো হলো, তারপর ১০,০০০টি test ছবিতে accuracy মাপা হলো পাঁচভাবে: ঠিক নিয়মে eval mode-এ, আর model.eval() ভুলে train mode-এ বিভিন্ন batch-এ। প্রতিবার একই state_dict থেকে শুরু, কারণ train mode-এ forward running stats বদলে দেয়।

bn1 = model[1]
print("প্রথম BatchNorm: running_mean[:4]", bn1.running_mean[:4].numpy().round(3))
print("                 running_var[:4] ", bn1.running_var[:4].numpy().round(3))
print("num_batches_tracked", bn1.num_batches_tracked.item(), "(= 2 epoch × 469 batch)")

state = {k: v.clone() for k, v in model.state_dict().items()}
def acc(mode, bs, order=None):
    model.load_state_dict(state)               # প্রতিবার একই শুরু
    model.train(mode == "train")               # False মানে eval()
    idx = order if order is not None else torch.arange(len(Xte))
    hit = 0
    with torch.no_grad():
        for b in idx.split(bs):
            hit += (model(Xte[b]).argmax(1) == yte[b]).sum().item()
    return hit / len(Xte)

by_class = torch.argsort(yte, stable=True)     # একই শ্রেণির ছবি পরপর
print(f"eval mode, batch 256          : {acc('eval', 256):.4f}")
print(f"eval mode, batch 1            : {acc('eval', 1):.4f}")
print(f"train mode ভুলে, batch 256     : {acc('train', 256):.4f}")
print(f"train mode ভুলে, batch 8       : {acc('train', 8):.4f}")
print(f"train mode ভুলে, শ্রেণি ধরে সাজানো: {acc('train', 256, by_class):.4f}")

সত্যিকারের run (ডেস্কটপ, CPU, PyTorch 2.15.0, torchvision 0.29.2; Fashion-MNIST, Zalando Research, MIT লাইসেন্স):

~/bazarghar-dl$ uv run python bn_trap.py
প্রথম BatchNorm: running_mean[:4] [-1.192 -4.481  0.081 -1.784]
                 running_var[:4]  [52.41  31.801  9.8   22.389]
num_batches_tracked 938 (= 2 epoch × 469 batch)
eval mode, batch 256          : 0.8330
eval mode, batch 1            : 0.8330
train mode ভুলে, batch 256     : 0.8363
train mode ভুলে, batch 8       : 0.5656
train mode ভুলে, শ্রেণি ধরে সাজানো: 0.1465

দুই epoch training-এর পরে প্রথম BatchNorm-এর running_var ৯.৮ থেকে ৫২: প্রথম Linear-এর output-এর মাপ শুরুর তুলনায় (default init-এ হিসাব করলে প্রায় ১/৩) অনেক বড় হয়েছে, কিন্তু BatchNorm তা সামলে নেওয়ায় পরের স্তর মাপ-ঠিক input পায়। ৯৩৮ = ২ × ৪৬৯ batch, প্রতিটি training step-এ একবার করে হালনাগাদ। Eval mode-এ batch ২৫৬ আর batch ১ হুবহু একই accuracy (০.৮৩৩০): output batch-নিরপেক্ষ। model.eval() ভুলে গেলে বড় এলোমেলো batch-এ ক্ষতি চোখে পড়ে না (০.৮৩৬৩), আর ঠিক এ কারণেই বাগটি বিপজ্জনক: পরীক্ষায় লুকিয়ে থাকে। Batch ৮-এ accuracy নামে ০.৫৬৫৬-এ। আর test ছবি শ্রেণি ধরে সাজানো থাকলে (প্রতিটি batch-এ প্রায় একই শ্রেণি) ০.১৪৬৫, প্রায় আন্দাজের সমান: batch-এর গড় নিজেই শ্রেণির তথ্য মুছে দেয়। বাস্তবে ডেটাবেস থেকে তারিখ বা বিভাগ ধরে সাজিয়ে আসা batch-এ ঠিক এটি ঘটতে পারে।

৭ · LayerNorm, RMSNorm আর GroupNorm — কোন axis ধরে normalize

BatchNorm-এর দুর্বলতা তার batch-নির্ভরতা: ছোট batch, sequence-এর আলাদা দৈর্ঘ্য, আর একটি একটি token ধরে text তৈরিতে batch-এর পরিসংখ্যান অর্থহীন বা অনুপলব্ধ। Ba, Kiros আর Hinton (২০১৬) প্রস্তাব করলেন Layer Normalization: একই হিসাব, কিন্তু প্রতিটি নমুনার ভেতরে, তার সব feature জুড়ে। কোনো running stats নেই, train আর eval-এ একই আচরণ। Zhang আর Sennrich (NeurIPS ২০১৯) দেখালেন গড় বিয়োগটুকু বাদ দিলেও প্রায়ই চলে: RMSNorm শুধু root mean square দিয়ে ভাগ করে, y = γ · x / √(গড়(x²) + ε), যা একটু সস্তা। Wu আর He (ECCV ২০১৮)-এর GroupNorm ছবির channel-গুলোকে কয়েকটি দলে ভাগ করে প্রতিটি নমুনার প্রতিটি দলের ভেতরে normalize করে; ছোট batch-এর ছবির কাজে এটি BatchNorm-এর বিকল্প। ছবিটি তিনটির পার্থক্য দেখায়।

এবার NumPy-তে, এমন তিনটি vector দিয়ে যা পার্থক্যগুলো স্পষ্ট করে: দ্বিতীয়টি প্রথমটির ১০ গুণ, তৃতীয়টি প্রথমটির সঙ্গে ১০০ যোগ। শেষে তৃতীয় সারি বদলে দেখা হবে প্রথম সারির ফল কোন পদ্ধতিতে বদলায়।

import numpy as np
np.set_printoptions(precision=3, suppress=True)
X = np.array([[1., 2., 3., 4.],          # একটি token বা অর্ডারের ৪টি feature
              [10., 20., 30., 40.],      # প্রথম সারি × 10
              [101., 102., 103., 104.]]) # প্রথম সারি + 100

def layer_norm(x, eps=1e-5):             # প্রতিটি সারির ভেতরে, শেষ axis
    mu = x.mean(-1, keepdims=True)
    return (x - mu) / np.sqrt(x.var(-1, keepdims=True) + eps)

def rms_norm(x, eps=1e-6):               # গড় বিয়োগ নেই, শুধু RMS দিয়ে ভাগ
    return x / np.sqrt((x ** 2).mean(-1, keepdims=True) + eps)

def batch_norm(x, eps=1e-5):             # প্রতিটি কলাম, batch-এর axis 0
    return (x - x.mean(0)) / np.sqrt(x.var(0) + eps)

print("LayerNorm:\n", layer_norm(X))
print("RMSNorm:\n", rms_norm(X))
print("BatchNorm (এই তিন সারি একটি batch):\n", batch_norm(X))

X2 = X.copy(); X2[2] = [0., 0., 0., 50.]          # শুধু তৃতীয় সারি বদলাল
print("প্রথম সারি, তৃতীয়টি বদলের পরে:")
print("  LayerNorm", layer_norm(X2)[0], "| BatchNorm", batch_norm(X2)[0])

LayerNorm:
 [[-1.342 -0.447  0.447  1.342]
 [-1.342 -0.447  0.447  1.342]
 [-1.342 -0.447  0.447  1.342]]
RMSNorm:
 [[0.365 0.73  1.095 1.461]
 [0.365 0.73  1.095 1.461]
 [0.985 0.995 1.005 1.015]]
BatchNorm (এই তিন সারি একটি batch):
 [[-0.804 -0.904 -1.002 -1.096]
 [-0.605 -0.49  -0.363 -0.226]
 [ 1.41   1.394  1.365  1.322]]
প্রথম সারি, তৃতীয়টি বদলের পরে:
  LayerNorm [-1.342 -0.447  0.447  1.342] | BatchNorm [-0.593 -0.593 -0.593 -1.384]

কোথায় বসাবেন. MLP আর CNN-এ প্রচলিত ক্রম Linear/Conv → BatchNorm → ReLU (মূল প্রবন্ধের মতো); কেউ কেউ ReLU-এর পরে বসান, দুই পক্ষেই পরীক্ষার ফল আছে, সর্বজনীন উত্তর নেই। Transformer-এ প্রশ্নটি pre-norm বনাম post-norm: ২০১৭ সালের মূল Transformer residual যোগের পরে LayerNorm বসাত (post-norm), আর পরে Xiong ও সহকর্মীদের (২০২০) বিশ্লেষণসহ অনেক কাজে দেখা যায় residual শাখার ভেতরে, sublayer-এর আগে বসালে (pre-norm) গভীর model warmup ছাড়াও স্থিরভাবে শেখে। রিপোর্ট অনুযায়ী Llama-র মতো অনেক নতুন ভাষা model pre-norm RMSNorm ব্যবহার করে। বিস্তারিত পর্ব ৩৫ (Transformer block — residual, LayerNorm আর feed-forward)-এ।

৮ · একই গভীর MLP-এ মাপা — default, He, BatchNorm আর LayerNorm

এবার সব একসঙ্গে। Fashion-MNIST (২৮ × ২৮ ধূসর পোশাকের ছবি, ১০টি শ্রেণি; ৬০,০০০ train, ১০,০০০ test). Model: ২০টি Linear স্তর, প্রতিটি ২৫৬ চওড়া, মাঝে ReLU; SGD (learning rate ০.০২, momentum ০.৯), batch ১২৮, ৬ epoch. শুধু একটি জিনিস বদলায়: (ক) default init, (খ) He init আর শূন্য bias, (গ) default init + প্রতিটি Linear-এর পরে BatchNorm, (ঘ) default init + প্রতিটি Linear-এর পরে LayerNorm. প্রতিটি epoch-এর পরে train loss আর test accuracy, আর কোন epoch-এ প্রথম ৮৫% test accuracy.

import os, sys, time, torch
from torch import nn
from torchvision import datasets

torch.set_num_threads(4)
DEPTH, WIDTH, EPOCHS, TARGET = 20, 256, 6, 0.85

def load(train):
    ds = datasets.FashionMNIST("data", train=train, download=True)
    x = ds.data.float().div(255).view(len(ds), -1)
    return (x - 0.2860) / 0.3530, ds.targets      # train-এর গড়/std

Xtr, ytr = load(True); Xte, yte = load(False)

def make(kind):
    layers, d = [], 784
    for _ in range(DEPTH - 1):
        lin = nn.Linear(d, WIDTH)
        if kind in ("he", "lnhe"):
            nn.init.kaiming_normal_(lin.weight, nonlinearity="relu")
            nn.init.zeros_(lin.bias)
        norm = {"bn": nn.BatchNorm1d(WIDTH), "ln": nn.LayerNorm(WIDTH),
                "lnhe": nn.LayerNorm(WIDTH)}.get(kind)
        layers += [lin] + ([norm] if norm else []) + [nn.ReLU()]
        d = WIDTH
    return nn.Sequential(*layers, nn.Linear(d, 10))

def run(kind, seed=0):
    torch.manual_seed(seed)
    model = make(kind)
    opt = torch.optim.SGD(model.parameters(), lr=float(os.environ.get("LR", "0.02")), momentum=0.9)
    lossf, hit, t0, out = nn.CrossEntropyLoss(), None, time.time(), []
    for ep in range(1, EPOCHS + 1):
        model.train(); tot = 0.0
        for idx in torch.randperm(len(Xtr)).split(128):
            loss = lossf(model(Xtr[idx]), ytr[idx])
            opt.zero_grad(); loss.backward(); opt.step()
            tot += loss.item() * len(idx)
        model.eval()
        with torch.no_grad():
            acc = (model(Xte).argmax(1) == yte).float().mean().item()
        if hit is None and acc >= TARGET: hit = ep
        out.append(f"{tot / len(Xtr):.3f}/{acc:.3f}")
    print(f"{kind:8s} seed {seed}", " ".join(out), f"| {TARGET:.0%}: epoch {hit}",
          f"| {time.time() - t0:.0f} s")

if __name__ == "__main__":
    print("torch", torch.__version__, "| depth", DEPTH, "| width", WIDTH)
    print("প্রতি epoch: train loss/test accuracy")
    for kind in sys.argv[1:] or ["default", "he", "bn", "ln"]:
        run(kind, int(os.environ.get("SEED", "0")))

সত্যিকারের run (ডেস্কটপ, CPU-তে, ৪টি thread; PyTorch 2.15.0, torchvision 0.29.2). প্রতিটি ঘরে “train loss/test accuracy”:

~/bazarghar-dl$ uv run python deep_mlp.py
torch 2.15.0+cpu | depth 20 | width 256
প্রতি epoch: train loss/test accuracy
default  seed 0 2.303/0.100 2.303/0.100 2.303/0.100 2.303/0.100 2.303/0.100 2.303/0.100 | 85%: epoch None | 22 s
he       seed 0 0.783/0.779 0.467/0.831 0.401/0.844 0.359/0.866 0.336/0.857 0.317/0.871 | 85%: epoch 4 | 25 s
bn       seed 0 0.711/0.798 0.480/0.833 0.408/0.842 0.374/0.858 0.351/0.863 0.330/0.863 | 85%: epoch 4 | 30 s
ln       seed 0 2.326/0.100 2.312/0.100 2.308/0.100 2.306/0.100 2.305/0.100 2.304/0.100 | 85%: epoch None | 33 s
~/bazarghar-dl$ SEED=1 uv run python deep_mlp.py
…
default  seed 1 2.303/0.100 2.303/0.100 2.303/0.100 2.303/0.100 2.303/0.100 2.303/0.100 | 85%: epoch None | 18 s
he       seed 1 0.727/0.804 0.464/0.834 0.394/0.854 0.352/0.860 0.328/0.861 0.308/0.863 | 85%: epoch 3 | 18 s
bn       seed 1 0.703/0.795 0.477/0.839 0.414/0.858 0.373/0.845 0.353/0.868 0.328/0.859 | 85%: epoch 3 | 25 s
ln       seed 1 1.900/0.197 1.853/0.197 2.251/0.108 2.302/0.100 2.306/0.100 2.305/0.100 | 85%: epoch None | 33 s
~/bazarghar-dl$ SEED=2 uv run python deep_mlp.py
…
default  seed 2 2.303/0.100 2.303/0.100 2.303/0.100 2.303/0.100 2.303/0.100 2.303/0.100 | 85%: epoch None | 19 s
he       seed 2 0.797/0.807 0.458/0.844 0.395/0.860 0.357/0.860 0.327/0.872 0.310/0.869 | 85%: epoch 3 | 20 s
bn       seed 2 0.698/0.813 0.476/0.852 0.413/0.850 0.381/0.862 0.352/0.859 0.334/0.864 | 85%: epoch 2 | 20 s
ln       seed 2 2.328/0.100 2.310/0.100 2.307/0.100 2.305/0.100 2.304/0.100 2.304/0.100 | 85%: epoch None | 30 s
~/bazarghar-dl$ uv run python deep_mlp.py lnhe
…
lnhe     seed 0 0.751/0.782 0.493/0.832 0.421/0.844 0.379/0.864 0.352/0.861 0.334/0.872 | 85%: epoch 4 | 25 s
~/bazarghar-dl$ LR=0.005 uv run python deep_mlp.py ln
…
ln       seed 0 0.714/0.806 0.473/0.852 0.405/0.848 0.367/0.863 0.348/0.851 0.348/0.873 | 85%: epoch 2 | 24 s
~/bazarghar-dl$ uv run python ln_probe.py   # training-এর আগে
default  শেষ hidden std 0.022 | নমুনা-ভেদে std 0.0000 | দুই ছবির cosine 1.0000
he       শেষ hidden std 1.089 | নমুনা-ভেদে std 0.4215 | দুই ছবির cosine 0.9340
ln       শেষ hidden std 0.570 | নমুনা-ভেদে std 0.1866 | দুই ছবির cosine 0.9293
ln+he    শেষ hidden std 0.592 | নমুনা-ভেদে std 0.1466 | দুই ছবির cosine 0.9536

পড়ার নিয়ম: ১০টি শ্রেণিতে আন্দাজে উত্তর দিলে loss −ln(১/১০) = ২.৩০৩ আর accuracy ০.১০০. তিনটি seed-এর সারাংশ:

Default init: loss ছয় epoch ধরে ২.৩০৩-এ স্থির, accuracy ঠিক ০.১০০, তিনটি seed-এই। অংশ ৩-এর মাপের সঙ্গে মেলে: শেষ স্তরে প্রায় শুধু bias-এর গুঞ্জন পৌঁছায়, তাই model সব ছবিকে একই রকম দেখে, আর gradient-ও একই শিকল ধরে মিলিয়ে যায়। He init আর BatchNorm দুটিই প্রথম epoch-এই ৭৮–৮১% আর ২ থেকে ৪ epoch-এ ৮৫%. BatchNorm init ঠিক না করেও কাজ করেছে, কারণ প্রতিটি স্তরে মাপ নতুন করে বসায়; বিনিময়ে প্রতি epoch-এ সময় একটু বেশি। এই ছোট পরীক্ষায় দুটির মধ্যে স্পষ্ট বিজয়ী নেই; seed বদলালে ক্রম বদলায়।

LayerNorm-এর ফলটি সবচেয়ে শিক্ষণীয়। Default init + LayerNorm, lr ০.০২-এ তিনটি seed-এই আটকে গেছে (seed ১-এ প্রথমে ০.১৯৭ পর্যন্ত উঠে আবার ০.১০০-এ নেমেছে)। অথচ শুরুর অবস্থা খারাপ ছিল না: আলাদা একটি পরীক্ষায় (ln_probe.py, একই model, training-এর আগে) শেষ hidden স্তরে বিভিন্ন ছবির মধ্যে পার্থক্যের std ০.১৮৭, যেখানে default-এ ০.০০০০. একই model lr ০.০০৫-এ দুই epoch-এ ৮৫% ছোঁয়, আর He init দিলে lr ০.০২-তেও চলে। অর্থাৎ এখানে LayerNorm signal বাঁচিয়েছে, কিন্তু এই learning rate-এ শেখা অস্থির হয়েছে। কেন ঠিক এই সংমিশ্রণে, তা এই কয়েকটি run থেকে নিশ্চিত বলা যায় না; বাস্তব শিক্ষা হলো normalization যাদু নয়: init, learning rate আর স্থাপত্য একসঙ্গে কাজ করে, আর সাধারণ MLP-এ LayerNorm-এর চেয়ে Transformer-এর residual পথের সঙ্গে LayerNorm-এর জুটিই বেশি প্রচলিত। Learning rate কীভাবে বাছবেন তা পর্ব ১৫ (Optimizer আর learning-rate schedule — SGD, AdamW, warmup আর cosine)-এ, আর “loss ২.৩০৩-এ আটকে” ধরনের লক্ষণ পড়া পর্ব ১৮ (Training ডিবাগ করা — এক batch overfit, learning curve আর সাধারণ ভুল)-এ। সব সংখ্যা একটি মেশিনে একটি করে run; সাধারণ benchmark নয়।

৯ · AI-এর যুগে — AI-এর লেখা init আর normalization যাচাই

AI assistant-কে “deep MLP লিখে দাও” বললে সাধারণত চলে এমন কোড আসে, কিন্তু এই পর্বের ভুলগুলো ঠিক সেই ধরনের, যা error দেয় না। পুরোনো টিউটোরিয়াল থেকে শেখা AI কখনো nn.init.xavier_uniform (শেষে _ ছাড়া, অনেক আগে deprecated) লেখে, ReLU network-এ Xavier দেয়, BatchNorm-এর আগের Linear-এ bias রাখে, বা validation-এ model.eval() ভুলে যায়। “BatchNorm internal covariate shift দূর করে” কথাটি প্রায়ই প্রমাণিত সত্য হিসেবে লেখে, যদিও অংশ ৫-এ দেখেছেন বিষয়টি বিতর্কিত।

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

• একটি random batch-এ স্তর ধরে activation-এর std ছেপেছি; গভীরতায় তা হারায়ও না, ফাটেও না
• Activation অনুযায়ী init মিলিয়েছি (ReLU-তে He, tanh-এ Xavier), আর ফাংশনের নামের শেষে _ আছে
• Training-এর শুরুর loss −ln(1/C)-এর কাছে কি না দেখেছি (১০ শ্রেণিতে প্রায় ২.৩০৩)
• Validation আর prediction-এ eval() আর no_grad() আছে; একই নমুনা দুটি batch-এ দিয়ে একই output পেয়েছি
• BatchNorm-এর batch আকার যথেষ্ট বড়; না হলে GroupNorm বা LayerNorm ভেবেছি
• “কোনটি ভালো” দাবি অন্তত কয়েকটি seed আর learning rate-এ মেপেছি; কোনো আসল গ্রাহকের ডেটা AI-তে পেস্ট করিনি