NumPy-তে multilayer perceptron — forward pass আর activation function

AI-এর ভিত্তি কোর্সের পর্ব ৬৮-এ আপনি একটি neuron, perceptron, হাতে বসানো XOR network, চারটি activation আর এক hidden layer-এর MLP-এর forward pass দেখেছেন। এই পর্বের প্রশ্ন আরও এক ধাপ গভীরে: বাস্তব network-এ পুরো batch একসঙ্গে কীভাবে চলে, প্রতিটি tensor-এর shape কী, আজকের activation-গুলো কেন আলাদা, softmax কোথায় ভেঙে পড়ে, আর বাড়তি layer আসলে কী যোগ করে? Training আর gradient এই পর্বে নেই; সেটি পরের পর্ব ০৪ (Backpropagation হাতে-কলমে — chain rule থেকে পুরো gradient)-এর কাজ। চালানো যায় এমন চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python, NumPy, SciPy আর matplotlib); প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে।

১ · এক neuron থেকে পুরো batch — কেন সবকিছু matrix গুণ

একটি neuron-এর হিসাব z = w₁x₁ + … + w_dx_d + b, তারপর activation. Hidden layer-এ এমন h টি neuron পাশাপাশি; তাদের weight-গুলো কলাম হিসেবে সাজালে পাওয়া যায় matrix W, যার shape (d, h). একটি উদাহরণ x (দৈর্ঘ্য d)-এর জন্য পুরো layer: z = x @ W + b, দৈর্ঘ্য h. এবার B টি উদাহরণ সারি হিসেবে একটি matrix X (B, d)-এ রাখলে:

Z = XW + b,   (B × d)(d × h) → (B × h),   H = f(Z)

এখানে B হলো batch size, d হলো feature-এর সংখ্যা, h হলো layer-এর unit-এর সংখ্যা, আর f হলো activation function, যা ঘরে ঘরে আলাদাভাবে খাটে। b-এর shape (h,); NumPy একে (1, h) ধরে B সারিতে ছড়িয়ে দেয়, যা AI-এর ভিত্তি কোর্সের পর্ব ১৫-এর broadcasting. এক লাইনের এই রূপকে বলে vectorised হিসাব। এর তিনটি সুবিধা:

• গতি: Python-এর loop-এর বদলে একটি matrix গুণ, যা ভেতরে BLAS-এর মতো অপ্টিমাইজ করা library-তে বা GPU-তে চলে।
• একই ফল: সারিগুলো একে অন্যকে ছোঁয় না। সারি i-এর output শুধু X-এর সারি i-এর ওপর নির্ভর করে, তাই একটি একটি করে হিসাব করলেও ফল হুবহু এক (অংশ ৫-এর কোডে মিলিয়ে দেখবেন)।
• সব framework-এর ভাষা: PyTorch-এর মতো library-তে input-এর প্রথম মাত্রা প্রায় সবসময় batch; পর্ব ০৭ (PyTorch tensor — shape, dtype, device আর broadcasting)-এ একই ধারা দেখবেন।

একটি hidden layer থাকলে network-কে বলে MLP (multilayer perceptron); নামটি ঐতিহাসিক, কারণ এর neuron-গুলো perceptron-এর step function নয়, মসৃণ বা ভাঙা-রেখার activation ব্যবহার করে। Input থেকে output পর্যন্ত একবার হিসাবকে বলে forward pass. এই পর্বে network-এ দুটি hidden layer, কারণ দুটি থাকলেই স্তর থেকে স্তরে shape-এর ধারা আর গভীরতার প্রশ্ন দুটোই স্পষ্ট হয়।

২ · প্রতিটি tensor-এর shape — দুই hidden layer-এর network

বাজারঘরের কাজ: একটি অর্ডারের চারটি feature দেখে বলা, ডেলিভারি আগে হবে, সময়মতো হবে, না দেরিতে (তিনটি শ্রেণি)। Network: 4 → 16 → 8 → 3, অর্থাৎ d = ৪, প্রথম hidden layer-এ ১৬, দ্বিতীয়তে ৮, output-এ k = ৩ unit. নিচের ছবিতে প্রতিটি matrix আকার অনুযায়ী আঁকা: প্রতিটি ছোট ঘর একটি সংখ্যা।

ছবির নিয়ম একটাই: (B, a) @ (a, c) → (B, c); বাঁয়ের কলাম-সংখ্যা আর ডানের সারি-সংখ্যা (কমলা দাগ) সমান হতেই হবে, আর ফলে থাকে বাঁয়ের সারি আর ডানের কলাম। লক্ষ করুন, B কোনো weight-এর shape-এ নেই: একই weight ৬টি বা ৬০০০টি অর্ডারে চলে। নিচের stepper প্রতিটি ধাপে shape আর তার কারণ দেখায়।

গুণ-যোগের সংখ্যা আর memory

Parameter-এর পাশাপাশি খরচও গোনা যায়। (B, a) @ (a, c) গুণে প্রতিটি ফল-ঘরে a টি গুণ আর প্রায় a টি যোগ, তাই মোট প্রায় 2·B·a·c টি floating-point কাজ। পুরো network-এ forward pass ≈ 2·B·∑ n_inn_out; আমাদের network-এ B = ৬ হলে 2 × 6 × (64 + 128 + 24) = ২,৫৯২টি। Activation আর bias-এর খরচ এর তুলনায় ছোট। আরেকটি খরচ memory: training-এর সময় backward pass-এর জন্য Z1, H1, Z2, H2… সব রেখে দিতে হয়, যার মাপ B-এর সঙ্গে বাড়ে, আর weight-এর মাপ B-এর ওপর নির্ভর করে না। এই হিসাব পর্ব ০৪-এ আবার দরকার হবে, যখন backward-এর খরচ forward-এর সঙ্গে তুলনা করা হবে।

Parameter গোনার দুটি ব্যতিক্রম মনে রাখুন। প্রথম, normalization layer-এর ঠিক আগের linear layer-এ অনেক সময় bias রাখা হয় না (PyTorch-এ bias=False), কারণ normalization নিজেই একটি সরণ শেখে; তখন সেই layer-এ parameter শুধু n_in × n_out. দ্বিতীয়, কিছু model একই weight দুই জায়গায় ভাগ করে ব্যবহার করে (যেমন language model-এর input embedding আর output layer); তখন মোট parameter আলাদা আলাদা layer-এর যোগফলের চেয়ে কম। Model-এর “মাপ” পড়ার সময় তাই দেখে নিন কী গোনা হয়েছে।

৩ · Activation function গভীরে — sigmoid আর tanh-এর saturation

AI-এর ভিত্তি কোর্সের পর্ব ৬৮ দেখিয়েছে, activation না থাকলে দুটি linear layer মিলে একটি linear layer: X W₁ W₂ = X (W₁W₂). তাই non-linear f-ই গভীরতাকে অর্থ দেয়। কিন্তু কোন f? উত্তর আসে দুটি প্রশ্ন থেকে: f-এর মান কোন পরিসরে থাকে, আর f-এর derivative কোথায় কত বড়? দ্বিতীয়টি জরুরি, কারণ training-এ gradient প্রতিটি layer পেরোনোর সময় f′(z) দিয়ে গুণ হয় (পর্ব ০৪-এ এর পুরো হিসাব)।

Sigmoid: σ(z) = 1 / (1 + e^−z), মান ০ থেকে ১, derivative σ′(z) = σ(z)(1 − σ(z)). সর্বোচ্চ ঢাল z = ০-তে, মাত্র ০.২৫. z = ৩-এ ঢাল ০.০৪৫, z = ৬-এ ০.০০২৫. অর্থাৎ যে unit-এর weighted sum বড় হয়ে গেছে, সে প্রায় শেখা বন্ধ করে। আরেকটি সমস্যা: sigmoid-এর output সবসময় ধনাত্মক, তাই পরের layer-এর একটি unit-এর সব weight-এর gradient-এর চিহ্ন এক হয়, আর weight একসঙ্গে আঁকাবাঁকা পথে চলে।

tanh: tanh(z) = (e^z − e^−z) / (e^z + e^−z) = 2σ(2z) − 1, মান −১ থেকে ১, শূন্যকে কেন্দ্র করে। Derivative 1 − tanh²(z), সর্বোচ্চ ১. তাই hidden layer-এ tanh sigmoid-এর চেয়ে ভালো, কিন্তু saturation এখানে আরও দ্রুত: z = ৩-এ ঢাল ০.০০৯৯, sigmoid-এর চেয়েও কম। LSTM-এর মতো recurrent network-এ (পর্ব ২৯) tanh আর sigmoid এখনো gate-এর ভেতরে কাজ করে, কারণ সেখানে ০ থেকে ১ বা −১ থেকে ১-এর সীমাটাই দরকার।

দশটি sigmoid layer পেরোলে সবচেয়ে ভালো অবস্থাতেও গুণনীয়ক ০.২৫^১০ ≈ ৯.৫ × ১০^−৭, যাকে বলে vanishing gradient. এর প্রতিকার (ভালো initialization, normalization, residual connection) পর্ব ১৪ আর পর্ব ১৭-এর বিষয়; এখানে শুধু মনে রাখুন, activation-এর ঢালই সমস্যার মূল।

৪ · ReLU পরিবার আর মসৃণ বিকল্প — Leaky ReLU, GELU আর SiLU

ReLU = max(0, z). ধনাত্মক দিকে ঢাল ঠিক ১, তাই যত স্তরই হোক, সক্রিয় পথে gradient ছোট হয় না; হিসাবও সবচেয়ে সস্তা, একটি তুলনা মাত্র। z = ০-তে derivative সংজ্ঞায়িত নয়; library-গুলো সাধারণত সেখানে ০ ধরে নেয়, আর বাস্তবে z ঠিক ০ হওয়া বিরল। ২০১০ সালের আশেপাশে Nair ও Hinton, আর ২০১১ সালে Glorot, Bordes ও Bengio-র কাজের পর ReLU জনপ্রিয় হয়, আর ২০১২ সালের AlexNet ReLU ব্যবহার করে দ্রুত training-এর কথা জানায়।

ReLU-র দুর্বলতা হলো dying ReLU: যদি কোনো unit-এর z সব input-এ ঋণাত্মক হয় (ধরুন একটি বড় learning-rate ধাপ bias-কে অনেক নিচে নামিয়ে দিল), তাহলে তার output সবসময় ০, ঢালও ০, আর gradient কখনো তাকে ফিরিয়ে আনে না। সে network-এ থেকেও কোনো কাজ করে না।

• Leaky ReLU (Maas, Hannun ও Ng, ২০১৩): z < ০ হলে αz, যেখানে α ছোট (PyTorch-এর nn.LeakyReLU-এ ডিফল্ট 0.01). ঋণাত্মক দিকেও সামান্য ঢাল থাকে, তাই কোনো unit পুরোপুরি মরে না। α-কে শেখার parameter বানালে তাকে বলে PReLU (He ও সহকর্মী, ২০১৫)।
• GELU (Hendrycks ও Gimpel, ২০১৬): GELU(z) = z·Φ(z), যেখানে Φ হলো standard normal distribution-এর CDF (AI-এর ভিত্তি কোর্সের পর্ব ৩৬)। ভাবনাটি: input-কে “কতটা রাখব” তা ঠিক হয় z কত বড় তার সম্ভাবনা দিয়ে; বড় ধনাত্মক z প্রায় পুরোটা যায়, বড় ঋণাত্মক z প্রায় ০. BERT আর GPT-2-সহ অনেক Transformer-এ এটি ব্যবহার হয়েছে। দ্রুত হিসাবের জন্য একটি tanh-ভিত্তিক আসন্ন রূপও চলে: 0.5z(1 + tanh(√(2/π)(z + 0.044715z³))); PyTorch-এ nn.GELU(approximate="tanh").
• SiLU / Swish: SiLU(z) = z·σ(z). Elfwing ও সহকর্মীরা ২০১৭ সালে একে SiLU নামে ব্যবহার করেন, আর একই বছর Ramachandran, Zoph ও Le স্বয়ংক্রিয় অনুসন্ধানে z·σ(βz) খুঁজে পেয়ে Swish নাম দেন; β = ১ হলে দুটি এক। আজকের অনেক বড় language model-এর feed-forward অংশে SiLU-র gate-যুক্ত রূপ (SwiGLU) দেখা যায়, যা পর্ব ৩৫ (Transformer block)-এ আসবে।

এখানে φ হলো standard normal-এর ঘনত্ব, e^−z²/2/√(2π)। GELU আর SiLU monotonic নয়: ঋণাত্মক দিকে একটু নিচে নেমে আবার ০-এর দিকে ফেরে, আর তাদের ঢাল কিছু জায়গায় ১-এর চেয়েও বেশি (GELU-তে সর্বোচ্চ প্রায় ১.১৩, z = √2-এ)। নিচের ব্লক ছয়টির derivative সূত্র central difference দিয়ে যাচাই করে, আর ছবিতে saturation-এর এলাকা ধূসর রঙে দেখায়।

import numpy as np
from scipy.special import erf
import matplotlib.pyplot as plt
np.set_printoptions(precision=3, suppress=True)

sig = lambda z: 1 / (1 + np.exp(-z))
Phi = lambda z: 0.5 * (1 + erf(z / np.sqrt(2)))      # standard normal CDF
phi = lambda z: np.exp(-z**2 / 2) / np.sqrt(2 * np.pi)
al = 0.1                                             # Leaky slope (PyTorch default 0.01)
acts = {   # name: (f, f')
    "sigmoid": (sig, lambda z: sig(z) * (1 - sig(z))),
    "tanh":    (np.tanh, lambda z: 1 - np.tanh(z)**2),
    "ReLU":    (lambda z: np.maximum(0, z), lambda z: (z > 0) * 1.0),
    "Leaky":   (lambda z: np.where(z > 0, z, al * z), lambda z: np.where(z > 0, 1.0, al)),
    "GELU":    (lambda z: z * Phi(z), lambda z: Phi(z) + z * phi(z)),
    "SiLU":    (lambda z: z * sig(z), lambda z: sig(z) * (1 + z * (1 - sig(z)))),
}
zs = np.array([-6.0, -3.0, -1.0, -0.5, 0.5, 1.0, 3.0, 6.0])   # skip the kink at 0
print("z      ", zs)
for name, (f, df) in acts.items():
    num = (f(zs + 1e-5) - f(zs - 1e-5)) / 2e-5        # central difference
    print(f"{name:<7}", df(zs), f"check {np.max(np.abs(num - df(zs))):.0e}")

z = np.linspace(-6, 6, 601)
fig, ax = plt.subplots(1, 2, figsize=(10, 3.6))
for name, (f, df) in acts.items():
    ax[0].plot(z, f(z), label=name); ax[1].plot(z, df(z), label=name)
for a in ax:                                         # sigmoid/tanh saturate here
    a.axvspan(-6, -3, color="grey", alpha=0.15); a.axvspan(3, 6, color="grey", alpha=0.15)
ax[0].set(title="f(z)", xlabel="z", ylim=(-1.2, 3)); ax[1].set(title="f'(z), grey: |z| > 3", xlabel="z")
ax[1].legend(fontsize=8); fig.subplots_adjust(wspace=0.25); plt.show()

z       [-6.  -3.  -1.  -0.5  0.5  1.   3.   6. ]
sigmoid [0.002 0.045 0.197 0.235 0.235 0.197 0.045 0.002] check 6e-12
tanh    [0.    0.01  0.42  0.786 0.786 0.42  0.01  0.   ] check 1e-11
ReLU    [0. 0. 0. 0. 1. 1. 1. 1.] check 4e-11
Leaky   [0.1 0.1 0.1 0.1 1.  1.  1.  1. ] check 4e-11
GELU    [-0.    -0.012 -0.083  0.133  0.867  1.083  1.012  1.   ] check 2e-11
SiLU    [-0.012 -0.088  0.072  0.26   0.74   0.928  1.088  1.012] check 4e-11

৫ · বাজারঘর ডেটায় পুরো forward pass — shape, parameter আর প্রথম loss

এবার অংশ ২-এর network সত্যিই চালানো যাক। ডেটা কাল্পনিক, seed দেওয়া: ৬টি অর্ডার, চারটি feature (দূরত্ব ১ থেকে ২৫ কিলোমিটার, দাম ২০০ থেকে ৫,০০০ টাকা, আগের অর্ডার ০ থেকে ২৯, রাতের অর্ডার কি না)। Label-ও এলোমেলো, কারণ এখানে শেখা নয়, শুধু forward pass দেখা উদ্দেশ্য। Weight শুরু হয় He initialization দিয়ে, অর্থাৎ standard deviation √(2/n_in)-এর normal distribution থেকে; ReLU-র জন্য এই মাপ কেন, তা পর্ব ১৪ (Weight initialization আর normalization)-এর বিষয়।

import numpy as np
np.set_printoptions(precision=3, suppress=True)
rng = np.random.default_rng(42)
B, d, h1, h2, k = 6, 4, 16, 8, 3     # batch, features, hidden 1, hidden 2, classes
# বাজারঘর orders: distance km, order value Tk, past orders, night order (0/1)
raw = np.column_stack([rng.uniform(1, 25, B), rng.uniform(200, 5000, B),
                       rng.integers(0, 30, B), rng.integers(0, 2, B)]).astype(float)
X = (raw - raw.mean(axis=0)) / raw.std(axis=0)       # standardise each column
y = rng.integers(0, k, B)        # 0 = early, 1 = on time, 2 = late (invented labels)

def layer(n_in, n_out):                              # He init, zero bias
    return rng.normal(0, np.sqrt(2 / n_in), (n_in, n_out)), np.zeros(n_out)
W1, b1 = layer(d, h1); W2, b2 = layer(h1, h2); W3, b3 = layer(h2, k)
relu = lambda Z: np.maximum(0, Z)
def softmax(Z):
    E = np.exp(Z - Z.max(axis=1, keepdims=True))
    return E / E.sum(axis=1, keepdims=True)

Z1 = X @ W1 + b1;  H1 = relu(Z1)                      # (B,d)@(d,h1) + (h1,)
Z2 = H1 @ W2 + b2; H2 = relu(Z2)
Z3 = H2 @ W3 + b3; P = softmax(Z3)
for n, T in [("X", X), ("W1", W1), ("b1", b1), ("H1", H1), ("W2", W2), ("b2", b2),
             ("H2", H2), ("W3", W3), ("b3", b3), ("Z3", Z3), ("P", P)]:
    print(f"{n:<3}{str(T.shape):<8}", end="\n" if n in ("b1", "b2", "b3", "P") else "")
params = sum(T.size for T in (W1, b1, W2, b2, W3, b3))
print("parameters:", params, "=", (d+1)*h1, "+", (h1+1)*h2, "+", (h2+1)*k)
print("P:\n", P, "\nrow sums:", P.sum(axis=1))
loss = -np.log(P[np.arange(B), y]).mean()
print(f"loss {loss:.3f}  vs ln 3 = {np.log(3):.3f}   zero share in H1: {np.mean(H1 == 0):.2f}")
x0 = X[0]                                            # one order alone, vector form
p0 = softmax((relu(relu(x0 @ W1 + b1) @ W2 + b2) @ W3 + b3)[None, :])
print("row 0 alone == batch row 0:", np.allclose(p0[0], P[0]))

X  (6, 4)  W1 (4, 16) b1 (16,)
H1 (6, 16) W2 (16, 8) b2 (8,)
H2 (6, 8)  W3 (8, 3)  b3 (3,)
Z3 (6, 3)  P  (6, 3)
parameters: 243 = 80 + 136 + 27
P:
 [[0.215 0.554 0.231]
 [0.291 0.37  0.339]
 [0.361 0.383 0.257]
 [0.087 0.698 0.214]
 [0.294 0.359 0.347]
 [0.323 0.386 0.291]]
row sums: [1. 1. 1. 1. 1. 1.]
loss 1.064  vs ln 3 = 1.099   zero share in H1: 0.50
row 0 alone == batch row 0: True

৬ · Softmax-কে নিরাপদ রাখা — max বিয়োগ আর log-sum-exp

Softmax p_j = e^z_j / ∑_m e^z_m, যেখানে z হলো একটি সারির logits আর j শ্রেণির নম্বর। সূত্রটি সহজ, কিন্তু কম্পিউটারের দশমিক সংখ্যার (float) সীমা আছে। float64-এ সবচেয়ে বড় মান প্রায় 1.8 × 10³⁰⁸, তাই e^z ভেঙে পড়ে z ≈ ৭০৯.৮-এর পরে: ফল হয় inf, যাকে বলে overflow. উল্টো দিকে z ≈ −৭৪৫-এর নিচে e^z হয়ে যায় ঠিক ০, যাকে বলে underflow. তখন inf/inf বা 0/0 দুটোই nan.

সমাধান একটি সরল সমতা। যেকোনো ধ্রুবক c-এর জন্য

e^z_j / ∑ e^z_m = e^{z_j − c} / ∑ e^{z_m − c}

কারণ লব আর হর দুটিই e^−c দিয়ে গুণ হয়েছে। c = max_m z_m নিলে সবচেয়ে বড় ঘাত হয় ঠিক ০, তাই e^০ = ১, overflow অসম্ভব; আর হরে অন্তত একটি ১ থাকে, তাই হর কখনো ০ নয়। Log নিলে একই কৌশল থেকে আসে log-sum-exp: LSE(z) = log ∑ e^z_m = c + log ∑ e^{z_m − c}, আর log-softmax = z − LSE(z). নিচের stepper একটি সারি হাতে হিসাব করে।

এবার একই হিসাব তিনটি সারিতে: একটি সাধারণ, একটি খুব বড় (১০০০-এর ঘরে) আর একটি খুব ঋণাত্মক। সরল (naive) পথে কী ভাঙে, তা লুকানো নয়, সরাসরি মান দেখে ধরা হয়েছে; np.errstate(all="ignore") শুধু ডেস্কটপের RuntimeWarning চুপ রাখে। ব্রাউজারের Python-এ (WebAssembly) এমনিতেও floating-point সতর্কবার্তা আসে না, তাই সেখানে nan বা inf নীরবে জন্মায়; মান যাচাই করাই একমাত্র ভরসা।

import numpy as np
from scipy.special import logsumexp, softmax as sp_softmax
np.set_printoptions(precision=4, suppress=True)
Z = np.array([[3.2, 1.3, 0.2],                       # ordinary logits
              [1000.0, 999.0, 998.0],                # very large
              [-1000.0, -1001.0, -1002.0]])          # very negative
with np.errstate(all="ignore"):                      # no warnings, just look
    E = np.exp(Z)                                    # naive: exponentiate directly
    naive = E / E.sum(axis=1, keepdims=True)
    naive_lse = np.log(E.sum(axis=1))
print("exp(Z):\n", E)
print("naive softmax:\n", naive, "\nNaN count:", np.isnan(naive).sum())

m = Z.max(axis=1, keepdims=True)                     # stable: subtract row max
S = np.exp(Z - m)
stable = S / S.sum(axis=1, keepdims=True)
lse = (m + np.log(S.sum(axis=1, keepdims=True))).ravel()
print("stable softmax:\n", stable)
print("naive lse :", naive_lse)
print("stable lse:", lse)
print("scipy lse :", logsumexp(Z, axis=1), " softmax same:", np.allclose(stable, sp_softmax(Z, axis=1)))

z = np.array([0.0, -800.0])                          # log of a tiny probability
with np.errstate(under="ignore", divide="ignore"):
    p = np.exp(z) / np.exp(z).sum()
    print("p:", p, " log p naive:", np.log(p), " log-softmax z - lse:", z - logsumexp(z))
f32 = np.finfo(np.float32).max
with np.errstate(over="ignore"):
    print(f"float32 max {f32:.3e}, ln = {np.log(f32):.2f};  exp(88), exp(89):", np.exp(np.float32([88, 89])))

exp(Z):
 [[24.5325  3.6693  1.2214]
 [    inf     inf     inf]
 [ 0.      0.      0.    ]]
naive softmax:
 [[0.8338 0.1247 0.0415]
 [   nan    nan    nan]
 [   nan    nan    nan]]
NaN count: 6
stable softmax:
 [[0.8338 0.1247 0.0415]
 [0.6652 0.2447 0.09  ]
 [0.6652 0.2447 0.09  ]]
naive lse : [3.3818    inf   -inf]
stable lse: [   3.3818 1000.4076 -999.5924]
scipy lse : [   3.3818 1000.4076 -999.5924]  softmax same: True
p: [1. 0.]  log p naive: [  0. -inf]  log-softmax z - lse: [   0. -800.]
float32 max 3.403e+38, ln = 88.72;  exp(88), exp(89): [1.6516e+38        inf]

Temperature — softmax-এর ধার বাড়ানো-কমানো

Softmax-এর আগে logits-কে একটি ধনাত্মক সংখ্যা T দিয়ে ভাগ করলে, অর্থাৎ softmax(z/T), সম্ভাবনার “ধার” বদলায়। T-কে বলে temperature. Stepper-এর z = (৩.২, ১.৩, ০.২)-এ T = ১ দেয় (০.৮৩৩৮, ০.১২৪৭, ০.০৪১৫); T = ২ দিলে বণ্টন চ্যাপ্টা হয়, (০.৬২১২, ০.২৪০২, ০.১৩৮৬); T = ০.৫ দিলে তীক্ষ্ণ, (০.৯৭৫৮, ০.০২১৮, ০.০০২৪)। T → ০ হলে সবচেয়ে বড় logit-টি প্রায় সব সম্ভাবনা পায় (argmax), T → ∞ হলে সব শ্রেণি সমান। Language model-এ পরের token বাছার সময় এই T-ই “সৃজনশীলতা” নিয়ন্ত্রণের হাতল, যা AI-এর ভিত্তি কোর্সের পর্ব ৭০-এ decoding-এর অংশে এসেছে। লক্ষ করুন, ছোট T logits-এর পার্থক্যকে বড় করে, তাই overflow-এর ঝুঁকিও বাড়ে; max বিয়োগ তখন আরও জরুরি। Knowledge distillation-এও (একটি বড় model-এর সম্ভাবনা দিয়ে ছোট model শেখানো) বড় T ব্যবহার করে “নরম” সম্ভাবনা নেওয়া হয়, যা পরে কোর্সে আসবে।

৭ · গভীরতা কী যোগ করে — ReLU network ভাঁজ করে, টুকরো গোনা

ReLU network-এর output input-এর একটি piecewise linear function: input-এর জগৎ কয়েকটি এলাকায় ভাগ হয়, আর প্রতিটি এলাকার ভেতরে network একটি সাধারণ linear function. কারণ প্রতিটি এলাকায় কোন unit চালু আর কোনটি বন্ধ, তা স্থির; চালু unit identity, বন্ধ unit ০, তাই পুরো network সেখানে কয়েকটি matrix-এর গুণফল মাত্র। এই এলাকাগুলোকে বলে linear region. যত বেশি region, তত আঁকাবাঁকা আকার network আঁকতে পারে।

এখান থেকে একটি সীমা খাতায় বের করা যায়। ১-D input-এ এক hidden layer-এর প্রতিটি unit ReLU(wx + b) একটি ভাঁজ দেয়, x = −b/w-তে; n টি unit সর্বোচ্চ n টি ভাঁজ, অর্থাৎ n + 1 টি টুকরো. গভীর network-এ ধরুন আগের layer পর্যন্ত R টি টুকরো আছে। পরের layer-এর প্রতিটি unit-এর z প্রতিটি টুকরোর ভেতরে linear, তাই প্রতিটি টুকরোয় সর্বোচ্চ একবার শূন্য পার হয়: একটি unit সর্বোচ্চ R টি নতুন ভাঁজ যোগ করে, n টি unit সর্বোচ্চ nR টি। নতুন মোট ≤ R + nR = R(n + 1). তাই n₁, n₂, … প্রস্থের layer-গুলোর জন্য সর্বোচ্চ টুকরো ≤ ∏(n_l + 1): গভীরতায় গুণফল, প্রস্থে শুধু যোগফল। Montúfar, Pascanu, Cho ও Bengio (২০১৪) বহু-মাত্রার input-এর জন্য এই ধরনের সীমা নিয়ে কাজ করেন। কিন্তু সর্বোচ্চ সম্ভব আর এলোমেলো weight-এ বাস্তবে যা ঘটে, এক কথা নয়। নিচের ব্লক সেটি সংখ্যা দিয়ে মাপে: ৬০,০০১টি ঘন বিন্দুতে প্রতিটি unit-এর চালু/বন্ধ ধারা কতবার বদলায়, তা গুনে।

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(-3, 3, 60001)[:, None]           # dense 1-D grid, one column

def count(pats):                                  # regions = on/off pattern changes + 1
    P = np.hstack(pats)
    return 1 + np.any(P[1:] != P[:-1], axis=1).sum()
def net(widths, seed):
    rng = np.random.default_rng(seed)
    h, n_in, pats = x, 1, []
    for w in widths:
        W = rng.normal(0, np.sqrt(2 / n_in), (n_in, w))   # He init
        z = h @ W + rng.normal(0, 0.5, w)
        pats.append(z > 0)
        h, n_in = np.maximum(0, z), w
    return (h @ rng.normal(0, np.sqrt(1 / n_in), n_in)), count(pats)

print("net   units    bound  regions: mean (min-max), 10 seeds")
for ws in ([8], [24], [8] * 3, [96], [24] * 4):
    r = [net(ws, s)[1] for s in range(10)]
    bound = np.prod([w + 1 for w in ws])
    print(f"{len(ws)}x{ws[0]:<3} {sum(ws):>5} {bound:>8}  {np.mean(r):6.1f} ({min(r)}-{max(r)})")

u, pats = x.ravel(), []                           # hand-set folds: 3 layers x 2 units
for c in (0.0, 1.5, 0.75):
    pats.append((u > c)[:, None])                  # one on/off switch per fold
    u = np.maximum(0, u - c) + np.maximum(0, c - u)   # |u - c| from two ReLUs
print("hand-set fold net: 6 units, regions =", count(pats))

fig, ax = plt.subplots(1, 3, figsize=(11, 3))
for a, (t, y) in zip(ax, [("random 1x24", net([24], 0)[0]),
                          ("random 4x24", net([24] * 4, 0)[0]), ("hand-set 3x2 folds", u)]):
    a.plot(x.ravel(), y, lw=1.2); a.set(title=t, xlabel="x")
fig.subplots_adjust(wspace=0.3); plt.show()

net   units    bound  regions: mean (min-max), 10 seeds
1x8       8        9     8.4 (7-9)
1x24     24       25    23.3 (21-25)
3x8      24      729    20.0 (17-24)
1x96     96       97    88.8 (86-93)
4x24     96   390625    83.8 (64-113)
hand-set fold net: 6 units, regions = 8

সংক্ষেপে: গভীরতা সম্ভাবনা বাড়ায়, অর্থাৎ কম parameter-এ অনেক বেশি টুকরো আঁকা যায়, আর সেই টুকরো পুনরাবৃত্ত, গঠনযুক্ত (একটি ভাঁজ আগের সব ভাঁজের ওপর পড়ে)। এটিই “স্তরে স্তরে feature জোড়া”-র জ্যামিতিক রূপ: প্রথম layer সরল সীমারেখা আঁকে, পরের layer সেই ভাঁজ-করা জগতে আবার সরল কাট দেয়, যা মূল input-এ জটিল আকার নেয়। কিন্তু training সেই সম্ভাবনা সত্যিই কাজে লাগাবে কি না, প্রস্থ বনাম গভীরতার তাত্ত্বিক ফল, আর করাতের দাঁতের মতো function-এ গভীর network-এর সুবিধা কতটা, তা পর্ব ০৬ (Network কী শিখতে পারে — universal approximation, গভীরতা আর প্রস্থ)-এর বিষয়।

৮ · AI-এর যুগে — AI-এর লেখা forward pass আর activation কোড যাচাই

AI assistant-কে “NumPy-তে একটি MLP লিখে দাও” বললে সাধারণত চলার মতো কোড আসে। বিপদ হলো, ভুলগুলো প্রায়ই error দেয় না, শুধু ভুল সংখ্যা দেয়। এই বিষয়ে যে ভুলগুলো বারবার দেখা যায়: weight-এর (in, out) আর (out, in) রীতি মিশিয়ে ফেলা; softmax-এ max বিয়োগ না করা বা axis ভুল দেওয়া; সম্ভাবনার ওপর np.log নিয়ে loss বানানো, যেখানে log-softmax দরকার ছিল; PyTorch-এর loss-এ logits-এর বদলে softmax-এর ফল পাঠানো; output layer-এও ReLU বসানো; আর GELU-কে tanh-আসন্ন রূপে লিখে তাকেই “exact” বলা। এ ছাড়া AI মাঝে মাঝে activation-এর ইতিহাস বা প্রবন্ধের নাম আত্মবিশ্বাসের সঙ্গে ভুল বলে, তাই উদ্ধৃতি মূল উৎসে মিলিয়ে নিন।

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

• B = ২ বা ৩-এর একটি ছোট batch চালিয়ে প্রতিটি tensor-এর .shape ছাপিয়েছি, আর খাতার হিসাবের সঙ্গে মিলিয়েছি
• Parameter-এর সংখ্যা (n_in + 1) × n_out-এর যোগফলের সঙ্গে মেলে
• Softmax-এর প্রতিটি সারির যোগফল ১, আর logits-এ ১০০০ যোগ করলেও ফল বদলায় না, nan আসে না
• শুরুর loss ln k-এর কাছাকাছি (k = শ্রেণির সংখ্যা)
• একটি উদাহরণ আলাদা চালিয়ে batch-এর সেই সারির সঙ্গে মিলিয়েছি
• Activation-এর derivative central difference দিয়ে যাচাই করেছি, আর library-র নিজের ডকুমেন্টেশনে (আমার version-এর) ডিফল্ট মান, যেমন Leaky ReLU-র ঢাল বা GELU-র approximate, মিলিয়েছি
• নিজের ডেটা বা কোনো গোপন key AI-কে দিইনি; উদাহরণে কাল্পনিক ডেটা ব্যবহার করেছি