Neural network-এর ধারণা — perceptron থেকে ছোট network, NumPy দিয়ে

এই পর্ব মডিউল ১২-এর শুরু, যেখানে আধুনিক AI-কে হাতে-কলমে আর সৎভাবে দেখব। ভিত আগেই তৈরি: পর্ব ৩৪-এ chain rule, gradient descent আর gradient checking; পর্ব ৩৮-এ cross-entropy; পর্ব ৫৯-এ sigmoid, softmax আর log loss; পর্ব ৬১-এ overfitting আর regularization; আর পর্ব ২-এ perceptron আর XOR-এর ইতিহাস। এখানে সেগুলো জুড়ে একটি ছোট neural network বানাব। চালানো যায় এমন চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python, NumPy 2.4, scikit-learn 1.8.0, matplotlib 3.10). শেষ তিনটি ব্লক একই namespace ভাগ করে, তাই পরের কোনো ব্লক আগে চালালে আগেরগুলো আপনা থেকে আগে চলে। শেষ ব্লকে scikit-learn প্রথমবার নামতে প্রায় ১০ সেকেন্ড লাগে।

১ · একটি কৃত্রিম neuron — weighted sum, bias আর activation

বাজারঘর (এই কোর্সের কাল্পনিক অনলাইন দোকান) প্রতিটি অর্ডারের জন্য জানতে চায়, ডেলিভারি দেরি হওয়ার ঝুঁকি কতটা। তিনটি তথ্য আছে, সবগুলো ০ থেকে ১-এর মাপে আনা: গুদাম থেকে দূরত্ব x₁, পার্সেলের ওজন x₂, আর আজ বৃষ্টি হচ্ছে কি না x₃ (০ বা ১)। একটি কৃত্রিম neuron এই তিনটি সংখ্যা থেকে একটি সংখ্যা বানায়, তিন ধাপে:

z = w₁x₁ + w₂x₂ + w₃x₃ + b = w·x + b · a = f(z)

এখানে w হলো প্রতিটি input-এর weight (কোন তথ্য কতটা গুরুত্বপূর্ণ, আর কোন দিকে টানে), b হলো bias (সব input শূন্য হলে স্কোর কত), z হলো weighted sum, আর f হলো activation function, যা z-কে চূড়ান্ত output a-তে বদলায়। f যদি sigmoid হয়, এই neuron আর পর্ব ৫৯-এর logistic regression একই জিনিস; নতুনত্ব আসে অনেক neuron স্তরে স্তরে জোড়ায়।

নিচের stepper একটি অর্ডারে একটি neuron-এর পুরো হিসাব দেখায়। ওজনগুলো এখানে হাতে বসানো (কাল্পনিক): w = (1.5, −0.5, 2.0), b = −1.0. চারটি ভিন্ন activation একই z থেকে কী দেয়, তাও পাশাপাশি।

২ · Perceptron — শেখার নিয়ম হাতে, AND শেখা আর XOR-এর ব্যর্থতা

McCulloch–Pitts নিউরনের weight মানুষকে বসাতে হতো। Frank Rosenblatt ১৯৫৮ সালে Psychological Review-এ perceptron প্রকাশ করেন, যার মূল নতুনত্ব একটি শেখার নিয়ম (পুরো গল্প পর্ব ২-এ)। Perceptron-এর activation হলো step function: s = w·x + b > ০ হলে output ১, নইলে ০. প্রতিটি উদাহরণে t (সঠিক উত্তর) আর out (perceptron-এর উত্তর) মেলানো হয়; ভুল হলে:

w ← w + η(t − out)·x · b ← b + η(t − out)

η (eta) হলো learning rate; এখানে η = ১. উত্তর ১ হওয়া উচিত ছিল কিন্তু ০ এসেছে (t − out = +১), তাহলে w-এ x যোগ হয়, ফলে পরের বার একই x-এ s বড় হয়। উল্টো ভুলে x বিয়োগ হয়। সব উদাহরণ একবার দেখা হলে এক epoch. পর্ব ২-এ এলোমেলো শুরু থেকে নিয়মটি চালানো হয়েছিল; এখানে সব ওজন শূন্য থেকে শুরু করব, যাতে প্রতিটি সংখ্যা কাগজে-কলমে মেলানো যায়। চারটি উদাহরণ এই ক্রমে: (0,0), (0,1), (1,0), (1,1); AND-এর t = (0, 0, 0, 1).

Perceptron-এর সিদ্ধান্তের সীমানা w·x + b = ০, দুই মাত্রায় একটি সরল রেখা। যে ডেটার দুই দল একটি রেখা (বেশি মাত্রায় একটি সমতল) দিয়ে আলাদা করা যায়, তাকে বলে linearly separable. Perceptron convergence theorem বলে, ডেটা linearly separable হলে নিয়মটি সীমিত সংখ্যক ভুলের পর থামবেই (পরিষ্কার প্রমাণের জন্য সাধারণত Novikoff-এর ১৯৬২ সালের কাজ উদ্ধৃত হয়)। AND তেমন ডেটা। XOR (ঠিক একটি input ১ হলে ১) নয়, আর তা চার লাইনে প্রমাণ করা যায়। ধরুন কোনো w₁, w₂, b XOR ঠিকভাবে করে। তাহলে:

• (0, 0) → ০: b ≤ ০
• (0, 1) → ১: w₂ + b > ০, আর (1, 0) → ১: w₁ + b > ০
• মাঝের দুটি যোগ করলে w₁ + w₂ + 2b > ০, অর্থাৎ w₁ + w₂ + b > −b ≥ ০
• কিন্তু (1, 1) → ০ চায় w₁ + w₂ + b ≤ ০. পরস্পরবিরোধী, তাই এমন কোনো ওজন নেই।

তাই XOR-এ perceptron নিয়ম কখনো থামে না; ওজনগুলো একটি চক্রে ঘোরে, যা নিচের কোডে সরাসরি দেখবেন। Marvin Minsky আর Seymour Papert-এর ১৯৬৯ সালের বই Perceptrons এই ধরনের সীমা কঠোর গণিতে দেখায়, মূলত এক স্তরের perceptron-এর জন্য। বইটি neural network গবেষণায় আগ্রহ কমার একটি কারণ হিসেবে প্রায়ই উল্লেখ করা হয়, তবে প্রভাব কতটা বড় ছিল, তা নিয়ে মত ভিন্ন (ভাবনার প্রশ্ন ১)।

৩ · Hidden layer দিয়ে XOR — হাতে বসানো network, আর linear স্তর কেন একটিতে মিশে যায়

একটি রেখা পারে না, দুটি রেখা পারে। XOR-কে ভেঙে লেখা যায়: “x₁ OR x₂, কিন্তু x₁ AND x₂ নয়”. OR আর AND দুটিই linearly separable, তাই প্রতিটির জন্য একটি করে neuron রাখি। এই দুটি neuron input আর output-এর মাঝে বসে; কেউ তাদের সঠিক মান বলে দেয় না, তাই এদের স্তরকে বলে hidden layer. হাতে বসানো ওজন (step activation):

• h₁ = step(x₁ + x₂ − 0.5): অন্তত একটি ১ হলে ১, অর্থাৎ OR
• h₂ = step(x₁ + x₂ − 1.5): দুটিই ১ হলে ১, অর্থাৎ AND
• output = step(h₁ − 2h₂ − 0.5): h₁ = ১ আর h₂ = ০ হলেই শুধু ১

যাচাই: (0,0) → h = (0,0) → step(−০.৫) = ০; (0,1) আর (1,0) → h = (1,0) → step(০.৫) = ১; (1,1) → h = (1,1) → step(১ − ২ − ০.৫) = ০. চারটিই ঠিক। মূল কথাটি জ্যামিতির: hidden layer ডেটাকে একটি নতুন জায়গায় নিয়ে যায়, যেখানে একটি রেখাই যথেষ্ট।

Activation বাদ দিলে কী হয় — দুটি linear স্তর একটিই

একটি প্রশ্ন স্বাভাবিক: স্তর বাড়ালেই কি ক্ষমতা বাড়ে? না, যদি স্তরগুলোর মাঝে কোনো non-linear activation না থাকে। দুটি linear স্তর মানে প্রথমে matrix A দিয়ে গুণ, তারপর B দিয়ে। পর্ব ১৭-এর matrix গুণ সহযোগী (associative): (xA)B = x(AB). তাই দুই স্তরের কাজ একটি matrix C = AB-র একটি স্তরই করতে পারে। Bias থাকলেও তাই: (xA + a)B + c = x(AB) + (aB + c), আবার একটি linear স্তর। একটি ছোট সংখ্যার উদাহরণ:

A = [[1, 2], [0, 1]], B = [[2, 0], [1, −1]] ⇒ AB = [[4, −2], [1, −1]]

x = (1, 1) হলে xA = (1, 3), তারপর (1, 3)B = (1·2 + 3·1, 1·0 + 3·(−1)) = (5, −3). আর সরাসরি x(AB) = (4 + 1, −2 − 1) = (5, −3). একই। মাঝে ReLU বসালে ঋণাত্মক মান কেটে যায়, আর এই সমতা ভাঙে; সেই ভাঙনই network-কে বাঁকা সীমানা আঁকার ক্ষমতা দেয়। নিচের ব্লক অংশ ২ আর ৩-এর তিনটি দাবি একসঙ্গে যাচাই করে।

import numpy as np

X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
step = lambda z: (z > 0).astype(int)                # s > 0 হলে 1, না হলে 0

def perceptron(y, epochs, show):
    w, b, errs = np.zeros(2), 0.0, []               # শুরু: সব ওজন শূন্য, η = 1
    for ep in range(1, epochs + 1):
        errs.append(0)
        for x, t in zip(X, y):
            out = int(w @ x + b > 0)
            if out != t:                            # ভুল হলেই শুধু বদল
                w, b = w + (t - out) * x, b + (t - out)
                errs[-1] += 1
                if show: print(f"  epoch {ep} x={x} t={t} out={out} -> w={w} b={b:+.0f}")
        if errs[-1] == 0: break
    return w, b, errs

for name, y, n_ep in [("AND", [0, 0, 0, 1], 10), ("XOR", [0, 1, 1, 0], 12)]:
    print(name)
    w, b, errs = perceptron(y, n_ep, show=(name == "AND"))
    print("  ভুল/epoch:", errs, "| w =", w, "b =", b, "| out =", step(X @ w + b), "t =", y)

W1, b1 = np.array([[1, 1], [1, 1]]), np.array([-0.5, -1.5])  # লুকানো স্তর: OR আর AND
W2, b2 = np.array([1, -2]), -0.5                              # OR হ্যাঁ কিন্তু AND না
H = step(X @ W1 + b1)
print("হাতে বসানো network: hidden =", H.tolist(), "-> XOR =", step(H @ W2 + b2))

A, B = np.array([[1, 2], [0, 1]]), np.array([[2, 0], [1, -1]])  # দুটি linear layer
x = np.array([[1, 1], [1, -3]])
print("A @ B =", (A @ B).tolist())
print("(x @ A) @ B =", (x @ A @ B).tolist(), "| x @ (A @ B) =", (x @ (A @ B)).tolist())
print("মাঝে ReLU দিলে:", (np.maximum(0, x @ A) @ B).tolist())

AND
  epoch 1 x=[1 1] t=1 out=0 -> w=[1. 1.] b=+1
  epoch 2 x=[0 0] t=0 out=1 -> w=[1. 1.] b=+0
  epoch 2 x=[0 1] t=0 out=1 -> w=[1. 0.] b=-1
  epoch 2 x=[1 1] t=1 out=0 -> w=[2. 1.] b=+0
  epoch 3 x=[0 1] t=0 out=1 -> w=[2. 0.] b=-1
  epoch 3 x=[1 0] t=0 out=1 -> w=[1. 0.] b=-2
  epoch 3 x=[1 1] t=1 out=0 -> w=[2. 1.] b=-1
  epoch 4 x=[1 0] t=0 out=1 -> w=[1. 1.] b=-2
  epoch 4 x=[1 1] t=1 out=0 -> w=[2. 2.] b=-1
  epoch 5 x=[0 1] t=0 out=1 -> w=[2. 1.] b=-2
  ভুল/epoch: [1, 3, 3, 2, 1, 0] | w = [2. 1.] b = -2.0 | out = [0 0 0 1] t = [0, 0, 0, 1]
XOR
  ভুল/epoch: [2, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4] | w = [-1.  0.] b = 1.0 | out = [1 1 0 0] t = [0, 1, 1, 0]
হাতে বসানো network: hidden = [[0, 0], [1, 0], [1, 0], [1, 1]] -> XOR = [0 1 1 0]
A @ B = [[4, -2], [1, -1]]
(x @ A) @ B = [[5, -3], [1, 1]] | x @ (A @ B) = [[5, -3], [1, 1]]
মাঝে ReLU দিলে: [[5, -3], [2, 0]]

৪ · Activation function — step, sigmoid, tanh আর ReLU

XOR network হাতে বসানো গিয়েছিল। কিন্তু হাজার weight-এর network হাতে বসানো যায় না; weight শিখতে হবে gradient descent দিয়ে, আর তার জন্য activation-এর ঢাল (derivative) দরকার। Step function-এর ঢাল প্রায় সবখানে ০ আর z = ০-তে সংজ্ঞায়িত নয়, তাই gradient কোনো দিক দেখায় না। এ কারণেই বহুস্তরের network-এ ধারাবাহিক activation ব্যবহার হয়। নিচের ছবিতে চারটি activation (রঙিন রেখা) আর তাদের derivative (ড্যাশ দেওয়া রেখা), z = −৪ থেকে ৪:

Sigmoid-এর সর্বোচ্চ ঢাল ০.২৫. Backpropagation-এ (অংশ ৬) প্রতিটি স্তর পার হতে gradient এই ঢাল দিয়ে গুণ হয়। দশটি sigmoid স্তর পেরোলে সবচেয়ে ভালো অবস্থাতেও গুণনীয়ক ০.২৫^১০ ≈ ৯.৫ × ১০^−৭: শুরুর দিকের স্তরে gradient প্রায় নেই, তারা প্রায় শেখে না। একে বলে vanishing gradient (weight-ও এই গুণে ঢোকে, তাই আসল হিসাব আরও জটিল)। ReLU-এর ধনাত্মক দিকে ঢাল ১, তাই সমস্যা অনেকটা কমে। ReLU জনপ্রিয় করার কৃতিত্ব সাধারণত ২০১০–২০১১ সালের কয়েকটি গবেষণাকে দেওয়া হয় (Nair ও Hinton; Glorot, Bordes ও Bengio), যদিও একই ধরনের function আরও আগে ব্যবহৃত হয়েছিল।

৫ · একটি ২-স্তরের MLP — forward pass, প্রতিটি ধাপের shape, softmax আর cross-entropy

এবার শেখার উপযোগী একটি network. Input আর output-এর মাঝে একটি hidden layer থাকা সবচেয়ে সরল network-কে বলে MLP (multi-layer perceptron), যদিও এর neuron-গুলো আসলে perceptron নয়, ধারাবাহিক activation-এর neuron. আমাদের কাজ: বাজারঘরের দুটি scale করা feature (ধরুন অর্ডারের দূরত্ব আর অর্ডারের সময়) দেখে দুই দলের একটিতে ফেলা। ডেটা পুরো বানানো; দুই দলকে ইচ্ছা করে দুটি আধা-চাঁদের আকারে বানানো হয়েছে (machine learning-এ পরিচিত “two moons” খেলনা ডেটা), যাতে কোনো সরল রেখা তাদের আলাদা করতে না পারে। আসল দোকানের ডেটা এমন পরিষ্কার আকারে আসে না; এটি শুধু ধারণা দেখানোর খেলনা।

Forward pass মানে input থেকে output পর্যন্ত একবার হিসাব। n টি উদাহরণ একসঙ্গে একটি matrix-এ রাখলে (প্রতি সারিতে একটি), প্রতিটি ধাপ একটি matrix গুণ। h = ১৬টি hidden unit আর k = ২টি শ্রেণি ধরে:

Shape মেলানোর নিয়ম একটাই: (n, d) গুণ (d, h) = (n, h). b₁-এর shape (16,), যা পর্ব ১৫-এর broadcasting-এ প্রতিটি সারিতে যোগ হয়। Parameter গোনা যায় সরাসরি: W₁-এ ২ × ১৬ = ৩২, b₁-এ ১৬, W₂-এ ১৬ × ২ = ৩২, b₂-এ ২; মোট ৮২টি। শেষ স্তরের কাঁচা স্কোর Z₂-কে বলে logits. Softmax (পর্ব ৫৯-এর অংশ ৮) প্রতিটি সারিকে সম্ভাবনায় বদলায়:

p_j = e^z_j / ∑_m e^z_m · L = −(1/n) ∑_i ln p_{i, yi}

j হলো শ্রেণির নম্বর, আর loss হলো প্রতিটি উদাহরণের সঠিক শ্রেণিকে দেওয়া সম্ভাবনার −ln-এর গড়, অর্থাৎ পর্ব ৩৮-এর cross-entropy. উদাহরণ: logits (2, 1, 0) হলে softmax ≈ (০.৬৬৫, ০.২৪৫, ০.০৯০); সঠিক শ্রেণি প্রথমটি হলে loss = −ln ০.৬৬৫ ≈ ০.৪০৮. সব শ্রেণিকে সমান সম্ভাবনা দিলে loss = ln k (দুই শ্রেণিতে ০.৬৯৩১, দশে ২.৩০৩); শুরুর loss এর চেয়ে অনেক বেশি হলে শুরুর weight খুব বড়। আর e¹⁰⁰⁰ overflow করে, তাই প্রতিটি সারি থেকে তার সর্বোচ্চ মান বিয়োগ করে নিই; লব আর হর দুটিই e^−max দিয়ে গুণ হয় বলে ফল বদলায় না; এটি numerical stability-র একটি কৌশল।

৬ · Backpropagation — chain rule দিয়ে পেছনে হিসাব, হাতে এক ধাপ

Gradient descent-এর জন্য প্রতিটি weight-এর সাপেক্ষে loss-এর partial derivative লাগে। Network হলো ছোট ছোট function-এর একটি শিকল: x → z₁ → h → z₂ → p → L. পর্ব ৩৪-এর chain rule বলে, শিকলের derivative মানে প্রতিটি কড়ার ছোট derivative-এর গুণফল। Backpropagation এই গুণফল চতুরভাবে সাজায়: forward pass-এ প্রতিটি মধ্যবর্তী মান মনে রাখা হয়, তারপর loss থেকে শুরু করে পেছনে প্রতিটি স্তরে একবার করে গুণ। ফলে এক forward আর এক backward pass-এ সব weight-এর gradient পাওয়া যায়, প্রতিটি weight-এর জন্য আলাদা হিসাব ছাড়াই। এই হিসাবের নকশাকে বলে computational graph.

একটি ২-২-১ network (দুটি input, দুটি sigmoid hidden unit, একটি sigmoid output, binary cross-entropy loss) দিয়ে এক ধাপ হাতে করি। পরীক্ষায় হাতে কষতে দেওয়া হয় ঠিক এমন আকারই। Sigmoid output আর cross-entropy একসঙ্গে থাকলে ∂L/∂z₂ = p − y, যা পর্ব ৫৯-এর “আরও গভীরে” বাক্সে প্রমাণ করা আছে; আর sigmoid-এর ঢাল h(1 − h).

x = (1.0, 0.5), y = 1 · W₁ = [[0.5, −0.3], [0.2, 0.4]], b₁ = (0, 0) · W₂ = (0.7, −0.6), b₂ = 0 · η = 0.5

W₁-এর প্রতিটি সারি একটি input-এর, প্রতিটি কলাম একটি hidden unit-এর; z₁ = xW₁ + b₁.

একসঙ্গে n টি উদাহরণ — vectorised gradient

একটি একটি করে হিসাব শেখার জন্য ভালো, কাজের জন্য ধীর। অংশ ৫-এর softmax network-এ পুরো batch একবারে (Y হলো সঠিক শ্রেণির one-hot matrix, ⊙ উপাদান ধরে গুণ, 1[Z₁ > 0] হলো ReLU-এর ঢাল):

D₂ = (P − Y)/n · ∂W₂ = HᵀD₂ · ∂b₂ = ∑ D₂ (সারি ধরে)
D₁ = (D₂W₂ᵀ) ⊙ 1[Z₁ > 0] · ∂W₁ = XᵀD₁ · ∂b₁ = ∑ D₁

Softmax আর cross-entropy মিলেও output-এর gradient হুবহু “অনুমান বিয়োগ সত্য”, P − Y, sigmoid-এর মতোই। Shape দিয়ে যাচাই করুন: Hᵀ (16, n) গুণ D₂ (n, 2) = (16, 2), ঠিক W₂-এর shape; D₂W₂ᵀ = (n, 2)(2, 16) = (n, 16), ঠিক Z₁-এর shape. প্রতিটি gradient-এর shape তার parameter-এর shape-এর সমান হতেই হবে; কোড লেখার সময় এটিই সবচেয়ে দ্রুত পরীক্ষা।

৭ · নিজের হাতে NumPy MLP — weight initialization, gradient check, mini-batch আর learning rate

Training শুরুর আগে weight-এর একটি শুরুর মান লাগে। স্বাভাবিক প্রথম ভাবনা: সব শূন্য। কিন্তু তাতে একই স্তরের সব hidden unit হুবহু একই হিসাব করে, একই gradient পায়, আর চিরকাল একই থাকে; ১৬টি unit কার্যত একটি unit. এই সমতা ভাঙতে weight এলোমেলোভাবে শুরু করা হয় (symmetry breaking). ReLU আর আমাদের সূত্রে অবস্থা আরও খারাপ: W₂ শূন্য হলে D₁ শূন্য, আর W₁ শূন্য হলে H শূন্য, তাই কোনো weight-ই নড়ে না, শুধু b₂ শেখে। নিচের কোডে সেটি দেখবেন।

এলোমেলো কত বড়? খুব ছোট হলে স্তর পেরোতে পেরোতে সংকেত মিলিয়ে যায়, খুব বড় হলে বিস্ফোরিত হয় বা sigmoid/tanh দুই প্রান্তে আটকে যায়। একটি প্রচলিত নিয়ম: input-এর সংখ্যা d হলে weight-এর standard deviation প্রায় √(1/d) (Glorot ও Bengio, ২০১০-এর ধারণা থেকে) বা ReLU-এর জন্য √(2/d) (He ও সহকর্মীরা, ২০১৫), যাতে প্রতিটি স্তরের output-এর মাপ মোটামুটি একই থাকে। একে বলে weight initialization; নিয়মগুলো পুরো প্রমাণ নয়, কিছু অনুমানের ওপর দাঁড়ানো বাস্তব নির্দেশিকা।

দ্বিতীয় জরুরি কাজ gradient check: পর্ব ৩৪-এর central difference, (L(θ + ε) − L(θ − ε))/2ε, দিয়ে প্রতিটি parameter-এর gradient সংখ্যায় মেপে হাতে লেখা backprop-এর সঙ্গে মেলানো। এটি ধীর (প্রতিটি parameter-এর জন্য দুটি forward pass), তাই শুধু কোড যাচাইয়ে, ছোট ডেটায়, একবার। নিচের ব্লক খেলনা ডেটা বানায় (৩০০টি বিন্দু: ২৪০টি train, ৬০টি validation), MLP-এর function লেখে আর ৮২টি parameter-এর প্রতিটিতে gradient check চালায়।

import numpy as np

rng = np.random.default_rng(42)
n = 300                                               # বাজারঘরের খেলনা ডেটা, পুরো বানানো
t, y = rng.uniform(0, np.pi, n), rng.integers(0, 2, n)
X = np.column_stack([np.cos(t) + y - 0.5, np.sin(t) * (1 - 2 * y) + 0.5 * y - 0.25])
X = X + rng.normal(0, 0.15, (n, 2))
Xtr, ytr, Xva, yva = X[:240], y[:240], X[240:], y[240:]

def init(d, h, k):                                    # ছোট random ওজন, scale √(2/d)
    return {"W1": rng.normal(0, np.sqrt(2 / d), (d, h)), "b1": np.zeros(h),
            "W2": rng.normal(0, np.sqrt(1 / h), (h, k)), "b2": np.zeros(k)}

def forward(P, X):                                    # X (n,d) -> H (n,h) -> p (n,k)
    Z1 = X @ P["W1"] + P["b1"]; H = np.maximum(0, Z1)
    Z2 = H @ P["W2"] + P["b2"]
    E = np.exp(Z2 - Z2.max(axis=1, keepdims=True))   # stable softmax
    return Z1, H, E / E.sum(axis=1, keepdims=True)

def loss_grads(P, X, y):
    Z1, H, Pr = forward(P, X); n = len(y)
    D2 = Pr.copy(); D2[np.arange(n), y] -= 1; D2 /= n  # ∂L/∂Z2 = (p − onehot)/n
    D1 = (D2 @ P["W2"].T) * (Z1 > 0)                 # chain rule; ReLU-এর ঢাল 0 বা 1
    G = {"W1": X.T @ D1, "b1": D1.sum(0), "W2": H.T @ D2, "b2": D2.sum(0)}
    return -np.log(Pr[np.arange(n), y]).mean(), G

P = init(2, 16, 2)
L0, G = loss_grads(P, Xtr, ytr); worst, eps = 0.0, 1e-6
for k in P:                                           # gradient check: central difference
    for i in np.ndindex(P[k].shape):
        old = P[k][i]; P[k][i] = old + eps; lp = loss_grads(P, Xtr, ytr)[0]
        P[k][i] = old - eps; lm = loss_grads(P, Xtr, ytr)[0]; P[k][i] = old
        worst = max(worst, abs((lp - lm) / (2 * eps) - G[k][i]))
print("shape:", {k: v.shape for k, v in P.items()}, "| parameter:", sum(v.size for v in P.values()))
print(f"শুরুর loss {L0:.4f} (ln 2 = 0.6931) | gradient check: সবচেয়ে বড় পার্থক্য {worst:.1e}")

shape: {'W1': (2, 16), 'b1': (16,), 'W2': (16, 2), 'b2': (2,)} | parameter: 82
শুরুর loss 1.1328 (ln 2 = 0.6931) | gradient check: সবচেয়ে বড় পার্থক্য 2.8e-10

Training loop — epoch, mini-batch আর learning rate

প্রতিটি ধাপে পুরো ডেটার gradient না নিয়ে ছোট একটি দলের (mini-batch, এখানে ৩২টি) gradient নিলে অনেক বেশি ধাপ নেওয়া যায়, আর gradient-এর সামান্য এলোমেলোতা অনেক সময় সাহায্যও করে; একে stochastic gradient descent (SGD) বলে। প্রতিটি epoch-এ ডেটার ক্রম নতুন করে এলোমেলো করা হয়। Learning rate η = ০.২: খুব বড় হলে loss লাফাতে বা বিস্ফোরিত হতে পারে, খুব ছোট হলে training অনেক ধীর (পর্ব ৩৪)। নিচের ব্লক ২০০ epoch train করে, প্রতিটি epoch-এর শেষে train loss আর validation accuracy রাখে, শূন্য দিয়ে শুরুর পরীক্ষাটি চালায়, আর তিনটি ছবি আঁকে।

import numpy as np
import matplotlib.pyplot as plt

def train(P, X, y, Xv, yv, epochs, lr=0.2, bs=32):
    hist = []
    for ep in range(epochs):
        idx = rng.permutation(len(y))                 # প্রতি epoch-এ নতুন এলোমেলো ক্রম
        for s in range(0, len(y), bs):
            b = idx[s:s + bs]
            G = loss_grads(P, X[b], y[b])[1]          # একটি mini-batch-এর gradient
            for k in P: P[k] -= lr * G[k]             # SGD-এর এক ধাপ
        acc = (forward(P, Xv)[2].argmax(1) == yv).mean()
        hist.append((loss_grads(P, X, y)[0], acc))
    return np.array(hist)

rng = np.random.default_rng(0); P = init(2, 16, 2)
hist = train(P, Xtr, ytr, Xva, yva, epochs=200)
for e in (1, 10, 50, 200):
    print(f"epoch {e:3d}: train loss {hist[e-1, 0]:.3f} | validation accuracy {hist[e-1, 1]:.3f}")
Z = {k: np.zeros_like(v) for k, v in P.items()}       # সব ওজন শূন্য দিয়ে শুরু
hz = train(Z, Xtr, ytr, Xva, yva, epochs=50)
print("শূন্য থেকে শুরু: accuracy", hz[-1, 1].round(3), "| W1 এখনো সব শূন্য?", bool(np.all(Z["W1"] == 0)))

g1, g2 = np.meshgrid(np.linspace(-2, 2.5, 150), np.linspace(-1.6, 1.8, 150))
prob = forward(P, np.column_stack([g1.ravel(), g2.ravel()]))[2][:, 1].reshape(g1.shape)
fig, ax = plt.subplots(1, 3, figsize=(11, 3.3), layout="constrained")
ax[0].plot(hist[:, 0]); ax[0].set(title="Training loss", xlabel="epoch", ylabel="cross-entropy")
ax[1].plot(hist[:, 1], color="#16a34a")
ax[1].set(title="Validation accuracy", xlabel="epoch", ylim=(0.4, 1.02))
ax[2].contourf(g1, g2, prob, levels=[0, 0.5, 1], colors=["#bfdbfe", "#fde68a"])
ax[2].scatter(Xtr[:, 0], Xtr[:, 1], c=ytr, cmap="coolwarm", s=10)
ax[2].set(title="Decision boundary, 16 ReLU units", xlabel="x1", ylabel="x2")
plt.show()

epoch   1: train loss 0.391 | validation accuracy 0.700
epoch  10: train loss 0.209 | validation accuracy 0.867
epoch  50: train loss 0.070 | validation accuracy 0.983
epoch 200: train loss 0.021 | validation accuracy 1.000
শূন্য থেকে শুরু: accuracy 0.55 | W1 এখনো সব শূন্য? True

৮ · হাতে লেখা অঙ্ক, MLPClassifier আর PyTorch — একই ধারণা, তিনটি হাতিয়ার

খেলনা ডেটা থেকে একটি সত্যিকারের, যদিও ছোট, ডেটাসেটে যাই। scikit-learn-এর সঙ্গে আসা load_digits-এ ১৭৯৭টি হাতে লেখা অঙ্কের (০–৯) ৮ × ৮ pixel-এর ছবি; প্রতিটি pixel ০ থেকে ১৬. scikit-learn-এর নথি অনুযায়ী এটি UCI-এর হাতে লেখা অঙ্কের একটি ডেটাসেট থেকে নেওয়া। প্রতিটি ছবিকে ৬৪টি সংখ্যার একটি সারি ধরলে (পর্ব ১৮: ছবি মানেই array) একই MLP কাজ করে, শুধু shape বদলায়: ৬৪ → ৩২ ReLU → ১০ softmax. বাজারঘরের হাতে লেখা অর্ডার-ফর্মের মোবাইল নম্বর পড়ার কাজ এই ধরনের, যদিও আসল ছবি অনেক বড় আর অগোছালো। একই ব্লকে scikit-learn-এর MLPClassifier, যার ভেতরে একই ধরনের network আর Adam নামের একটি উন্নত optimizer; সঙ্গে ConvergenceWarning আছে কি না গুনে দেখা।

import warnings
import numpy as np
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.exceptions import ConvergenceWarning

d = load_digits()                                     # ৮×৮ pixel-এর হাতে লেখা অঙ্ক
Xa, Xb, ya, yb = train_test_split(d.data / 16, d.target, test_size=0.25,
                                  random_state=42, stratify=d.target)
print("train", Xa.shape, "| test", Xb.shape, "| pixel-এর মান 0 থেকে 1")

rng = np.random.default_rng(42)
P = init(64, 32, 10)                                  # 64 -> 32 ReLU -> 10 softmax
hist = train(P, Xa, ya, Xb, yb, epochs=30, lr=0.3)
print("নিজের MLP:", sum(v.size for v in P.values()), "parameter | train loss",
      hist[-1, 0].round(3), "| test accuracy", hist[-1, 1].round(3))
pred = forward(P, Xb)[2].argmax(1)
wrong = np.bincount(yb[pred != yb], minlength=10)
print("কোন অঙ্ক কতবার ভুল:", wrong.tolist())

with warnings.catch_warnings(record=True) as caught:
    warnings.simplefilter("always")
    clf = MLPClassifier(hidden_layer_sizes=(32,), max_iter=1000, random_state=42).fit(Xa, ya)
n_conv = sum(issubclass(w.category, ConvergenceWarning) for w in caught)
print("MLPClassifier: test accuracy", round(clf.score(Xb, yb), 3), "| iteration", clf.n_iter_,
      "| ConvergenceWarning", n_conv)

train (1347, 64) | test (450, 64) | pixel-এর মান 0 থেকে 1
নিজের MLP: 2410 parameter | train loss 0.026 | test accuracy 0.964
কোন অঙ্ক কতবার ভুল: [2, 3, 1, 1, 0, 2, 1, 2, 2, 2]
MLPClassifier: test accuracy 0.976 | iteration 398 | ConvergenceWarning 0

ConvergenceWarning — থামার আগে থামানো

max_iter কম হলে MLPClassifier শেষ না করেই থামে আর একটি ConvergenceWarning দেয়। এই warning উপেক্ষা করা AI-এর লেখা কোডে খুব সাধারণ। ডেস্কটপে তিন রকম সেটিংয়ে একই ডেটা (সত্যিকারের run, Python 3.14.4, scikit-learn 1.9.1, লেখার সময়ে সর্বশেষ স্থিতিশীল; পাতার ব্রাউজারে 1.8.0):

~/bazarghar-ai$ python mlp_warning.py
~/bazarghar-ai/.venv/Lib/site-packages/sklearn/neural_network/_multilayer_perceptron.py:785: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (20) reached and the optimization hasn't converged yet.
  warnings.warn(
{'max_iter': 20} -> iteration 20 | test accuracy 0.88
{'max_iter': 1000} -> iteration 398 | test accuracy 0.976
{'early_stopping': True, 'max_iter': 1000} -> iteration 44 | test accuracy 0.896

২০ iteration-এ থামানো model-এর accuracy ০.৮৮, আর warning স্পষ্ট বলছে শেষ হয়নি। max_iter=1000 দিলে নিজে থেকে ৩৯৮-এ থামে। early_stopping=True train ডেটার ১০% আলাদা রেখে সেখানে score আর না বাড়লে থামে: এখানে ৪৪-এ থেমে ০.৮৯৬, কম; default ধৈর্য (n_iter_no_change=10) আর ছোট validation ভাগে এই ডেটায় আগেভাগে থেমে গেছে। কোন সেটিং ভালো, তা মেপে ঠিক করতে হয়; এটি একটি ডেটায় একটি run, সাধারণ নিয়ম নয়।

Overfitting আর তার ওষুধ — dropout আর weight decay

২৪১০ parameter আর ১৩৪৭টি train ছবি: parameter উদাহরণের চেয়ে বেশি। বড় network সহজেই train ডেটা মুখস্থ করতে পারে (পর্ব ৬১-এর overfitting); train loss কমছে অথচ validation loss বাড়ছে, তাহলে মুখস্থ শুরু। তিনটি প্রচলিত প্রতিকার:

• Weight decay: loss-এ (λ/2)‖W‖² যোগ, অর্থাৎ পর্ব ৬১-এর L2 regularization; gradient-এ শুধু λW যোগ হয়। scikit-learn-এ এটি alpha. (Adam-এর মতো optimizer-এ weight decay আর L2 penalty হুবহু এক নয়; পরের Deep Learning কোর্সের বিষয়।)
• Dropout: training-এর প্রতি ধাপে hidden unit-এর একটি অংশ এলোমেলোভাবে শূন্য করা, যাতে network কোনো একটি unit-এর ওপর নির্ভর না করে; test-এর সময় সব unit চালু। পরিচিত উৎস Hinton ও সহকর্মীদের ২০১২ আর Srivastava ও সহকর্মীদের ২০১৪ সালের কাজ। MLPClassifier-এ dropout নেই; PyTorch-এ nn.Dropout.
• Early stopping: validation-এর score আর না বাড়লে থামা, ওপরের run-এ যা দেখলেন।

রোগ না থাকলে ওষুধ ক্ষতিও করে: অনুশীলন ২-এ দেখবেন, overfitting-হীন খেলনা ডেটায় বড় λ accuracy কমায়।

PyTorch-এ একই network — autograd দিয়ে মিলিয়ে দেখা

বাস্তব কাজে কেউ হাতে backprop লেখেন না; PyTorch-এর মতো framework প্রতিটি হিসাব একটি computational graph-এ লিখে রাখে আর loss.backward() ডাকলে chain rule নিজে চালায় (automatic differentiation, PyTorch-এ যার নাম autograd). PyTorch ব্রাউজারের Python-এ চলে না, তাই ডেস্কটপে CPU-র জন্য তৈরি PyTorch install করে একই খেলনা ডেটায় দুটি জিনিস চালানো হলো: আমাদের NumPy network-এর একই শুরুর weight PyTorch-এ বসিয়ে gradient তুলনা, তারপর PyTorch-এর ভাষায় একই training loop. mlp_numpy.py হলো ওপরের প্রথম shared ব্লকের ডেটা আর function (gradient check বাদে)। Tensor হলো PyTorch-এর array, NumPy-র ndarray-এর মতো, সঙ্গে gradient রাখার ব্যবস্থা।

import numpy as np, torch
from torch import nn
from mlp_numpy import Xtr, ytr, Xva, yva, init, loss_grads   # একই ডেটা আর NumPy MLP

torch.manual_seed(0)
print("torch", torch.__version__, "| numpy", np.__version__)
model = nn.Sequential(nn.Linear(2, 16), nn.ReLU(), nn.Linear(16, 2)).double()
loss_fn = nn.CrossEntropyLoss()                    # softmax + cross-entropy একসঙ্গে

# ১) autograd বনাম হাতে লেখা backprop: একই শুরুর ওজনে gradient মেলে কি?
P = init(2, 16, 2)
with torch.no_grad():
    model[0].weight.copy_(torch.tensor(P["W1"].T)); model[0].bias.copy_(torch.tensor(P["b1"]))
    model[2].weight.copy_(torch.tensor(P["W2"].T)); model[2].bias.copy_(torch.tensor(P["b2"]))
X, y = torch.tensor(Xtr, dtype=torch.float64), torch.tensor(ytr)
loss = loss_fn(model(X), y)
loss.backward()                                    # autograd: পুরো backprop এক লাইনে
L_np, G = loss_grads(P, Xtr, ytr)
print(f"loss: torch {loss.item():.6f} | numpy {L_np:.6f}")
print("W1-এর gradient-এ সর্বোচ্চ পার্থক্য:", f"{np.abs(model[0].weight.grad.numpy().T - G['W1']).max():.1e}")

# ২) একই training loop, PyTorch-এর ভাষায়
opt = torch.optim.SGD(model.parameters(), lr=0.2)
g = torch.Generator().manual_seed(0)
for epoch in range(200):
    for idx in torch.randperm(len(y), generator=g).split(32):
        opt.zero_grad()
        loss_fn(model(X[idx]), y[idx]).backward()
        opt.step()
with torch.no_grad():
    acc = (model(torch.tensor(Xva)).argmax(1).numpy() == yva).mean()
    print(f"200 epoch পরে train loss {loss_fn(model(X), y).item():.3f} | validation accuracy {acc:.3f}")

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

~/bazarghar-ai$ python mlp_torch.py
torch 2.15.0+cpu | numpy 2.5.4
loss: torch 1.132768 | numpy 1.132768
W1-এর gradient-এ সর্বোচ্চ পার্থক্য: 5.6e-17
200 epoch পরে train loss 0.021 | validation accuracy 1.000

একই শুরুর weight-এ দুই loss ছয় দশমিক পর্যন্ত এক (১.১৩২৭৬৮, ওপরের gradient check ব্লকের শুরুর loss-এর সঙ্গেও মেলে), আর autograd-এর gradient আমাদের হাতে লেখা gradient থেকে সর্বোচ্চ 5.6 × 10⁻¹⁷ দূরে, float64-এর গোল করার মাপ। অর্থাৎ loss.backward() ঠিক সেই হিসাবই করে, যা আমরা অংশ ৬-এ হাতে করেছি। দুটি খুঁটিনাটি: nn.Linear weight-কে (output, input) shape-এ রাখে, তাই .T; আর CrossEntropyLoss নিজেই softmax লাগায়, তাই সরাসরি logits নেয়। Model-এর শেষে আরেকটি softmax বসালে কোড চলবে কিন্তু শেখা খারাপ হবে, একটি পরিচিত ভুল।

৯ · বড় ছবি — universal approximation, deep learning-এর ফিরে আসা, আর এই কোর্স যা শেখায় না

একটি hidden layer যথেষ্ট চওড়া হলে কতটা পারে? ১৯৮৯ সালে George Cybenko (sigmoid-এর জন্য) আর একই সময়ে Kurt Hornik, Maxwell Stinchcombe ও Halbert White দেখান, একটি hidden layer-এর network যথেষ্ট unit পেলে একটি সীমিত এলাকায় যেকোনো ধারাবাহিক function-কে যত কাছে চাই তত কাছে আনতে পারে। একে বলে universal approximation theorem. কথাটি শুনতে বিশাল, কিন্তু সীমাগুলো জরুরি: উপপাদ্য বলে এমন weight আছে, তা খুঁজে পাওয়া যাবে কি না বলে না; কতগুলো unit লাগবে, তা অনেক সময় অবাস্তব রকম বেশি হতে পারে; আর train ডেটায় মিললেই নতুন ডেটায় ভালো হবে, এমন কোনো নিশ্চয়তা নেই। বাস্তবে গভীর (অনেক স্তরের) network অনেক কাজে কম parameter-এ ভালো করে বলে দেখা যায়; কেন, তা নিয়ে তাত্ত্বিক গবেষণা এখনো চলছে।

Neural network-এর ধারণা পুরোনো, তাহলে ২০১০-এর দশকে হঠাৎ এত সাফল্য কেন? সাধারণ ব্যাখ্যা (পর্ব ৪-এ বিস্তারিত): বড় লেবেলসহ ডেটা (যেমন ImageNet), GPU-তে দ্রুত matrix গুণ, আর ReLU, dropout, ভালো initialization-এর মতো কৌশল। প্রতীক হিসেবে প্রায়ই বলা হয় ২০১২ সালের ImageNet প্রতিযোগিতা, যেখানে Alex Krizhevsky, Ilya Sutskever আর Geoffrey Hinton-এর AlexNet নামের একটি convolutional network আগের পদ্ধতিগুলোর চেয়ে স্পষ্টভাবে কম ভুল করে। তবে কোন কারণের ভূমিকা কত বড়, আর আগের কাজের কৃতিত্ব কতটা, তা নিয়ে মতভেদ আছে; একটি ঘটনাকে “শুরু” বলা সবসময়ই সরলীকরণ।

এই কোর্সের লক্ষ্য ভিত, তাই অনেক কিছু ইচ্ছা করে বাদ। ছবির জন্য CNN (convolutional network, যা কাছাকাছি pixel-এর গঠন কাজে লাগায়), ক্রম বা সময়ের ডেটার জন্য RNN আর LSTM, আর আজকের language model-এর transformer স্থাপত্য পরের Deep Learning কোর্সের বিষয়। Attention-এর মূল ধারণাটুকু, তিনটি token-এর ছোট NumPy হিসাবসহ, আসবে পর্ব ৭০ (LLM কীভাবে কাজ করে — token, পরের শব্দের অনুমান আর সীমা)-এ। Momentum, Adam, batch normalization আর GPU-তে training-ও পরের কোর্সে; তবে forward, loss, backward আর হালনাগাদের এই চক্রই সবগুলোর নিচে।

১০ · AI-এর যুগে — AI assistant-এর লেখা neural network কোড যাচাই

AI assistant কয়েক সেকেন্ডে চলনসই neural network কোড দেয়। সমস্যা হলো, এখানে অনেক ভুল কোড ভাঙে না, শুধু খারাপ শেখে: loss কমে, একটি accuracy ছাপা হয়, আর ভুলটি চোখের আড়ালে থাকে।

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

• প্রতিটি gradient-এর shape তার parameter-এর shape-এর সমান, আর gradient check-এর পার্থক্য খুব ছোট
• শুরুর loss ln k-এর কাছাকাছি; weight শূন্য নয়, scale যুক্তিসঙ্গত
• Softmax stable; PyTorch-এ CrossEntropyLoss-এর আগে কোনো softmax নেই
• ভাগ আগে; validation দিয়ে বাছাই, test একবার; সরল baseline-এর সঙ্গে তুলনা আছে
• সব warning পড়েছি (ConvergenceWarning সহ); loss আর validation curve দেখেছি
• Library-র parameter নিজের সংস্করণের docs-এ মিলিয়েছি; ব্যাখ্যায় “বোঝে” বা “ভাবে” লিখিনি; আসল গ্রাহকের ডেটা পেস্ট করিনি