Neuron আর perceptron — linear unit থেকে XOR-এর সমস্যা

এই পর্ব AI-এর ভিত্তি কোর্সের পর্ব ৬৮-এর ওপর দাঁড়ানো, যেখানে একটি neuron-এর forward হিসাব, শূন্য ওজন থেকে AND শেখা, XOR-এর চার লাইনের অসম্ভবতা আর হাতে বসানো hidden layer দেখানো হয়েছে। সেগুলো আর পুনরাবৃত্তি করব না। এখানে প্রশ্ন গভীর: perceptron কেন থামে, কতগুলো ভুলের পর থামে, না থামলে কী করবেন, আর logistic regression ও softmax-এর সঙ্গে তার আত্মীয়তা কোথায়। Sigmoid আর log loss-এর মূল কথা AI-এর ভিত্তি কোর্সের পর্ব ৫৯-এ, maximum margin মেশিন লার্নিং কোর্সের পর্ব ২৭-এ আর hinge loss পর্ব ২৮-এ। চালানো যায় এমন চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python, NumPy 2.4, scikit-learn 1.8.0); scikit-learn প্রথমবার নামতে প্রায় ১০ সেকেন্ড লাগে।

১ · Neuron-কে জ্যামিতির চোখে — w কেন সীমানার লম্ব

একটি artificial neuron হিসাব করে z = w·x + b, যেখানে w হলো weight-এর vector আর b হলো bias. Classification-এ সিদ্ধান্ত z-এর চিহ্নে: ধনাত্মক হলে এক শ্রেণি, ঋণাত্মক হলে অন্যটি। তাই z = ০ সেটটিই decision boundary; দুই feature-এ একটি সরল রেখা, d feature-এ একটি সমতল (hyperplane).

দুটি সুবিধাজনক রীতি পুরো পর্বে ব্যবহার করব। প্রথমত, label হবে y ∈ {−১, +১}, ০/১ নয়। তাহলে “ঠিক দিকে আছে” কথাটি একটি শর্তে লেখা যায়: y·z > ০. এই গুণফল m = y·z-কে বলে বিন্দুটির functional margin. দ্বিতীয়ত, x-এর শেষে একটি ১ জুড়ে x̃ = (x, 1) আর w̃ = (w, b) লিখলে z = w̃·x̃; bias তখন আর আলাদা কিছু নয়, শুধু আরেকটি weight. পরীক্ষায় এই “augmented” রূপটি প্রায়ই আসে।

দাবিটি ছোট একটি হিসাবে প্রমাণ হয়। নিচের stepper একটি নির্দিষ্ট রেখায় সেটি দেখায়, তারপর দূরত্বের সূত্র।

সব training বিন্দুর মধ্যে সবচেয়ে ছোট চিহ্নসহ দূরত্ব, min y_i(w·x_i + b)/‖w‖, হলো সেই রেখার geometric margin. এটি ধনাত্মক মানে সব বিন্দু ঠিক দিকে; তখন ডেটা linearly separable. সম্ভাব্য সব রেখার মধ্যে যার margin সবচেয়ে বড়, সেটিই SVM-এর রেখা (মেশিন লার্নিং কোর্সের পর্ব ২৭)।

২ · Perceptron নিয়ম ±১ রূপে — একটি update হাতে

±১ label আর augmented রূপে perceptron-এর পুরো নিয়ম এক লাইনের:

যদি y·(w̃·x̃) ≤ 0 হয়, তবে w̃ ← w̃ + y·x̃

AI-এর ভিত্তি কোর্সের পর্ব ৬৮-এর w ← w + η(t − out)x নিয়মের সঙ্গে এটি একই; সেখানে t − out হয় +১ বা −১, যা এখানে y. দুটি সূক্ষ্ম বিষয় পরীক্ষায় আসে। এক, “≤” চিহ্ন: ঠিক সীমানায় থাকা বিন্দুকেও (m = ০) ভুল ধরা হয়, নইলে শূন্য weight থেকে শুরু করলে কিছুই বদলাত না। দুই, শূন্য থেকে শুরু করলে learning rate η-এর মান সিদ্ধান্ত বদলায় না: প্রতিটি w̃ কেবল η দিয়ে গুণ হয়ে যায়, আর চিহ্ন একই থাকে।

Update কেন সাহায্য করে? ভুল বিন্দুর নতুন margin হয় y·(w̃ + yx̃)·x̃ = y·(w̃·x̃) + ‖x̃‖², কারণ y² = ১. অর্থাৎ প্রতিবার margin ঠিক ‖x̃‖² বাড়ে। কিন্তু এক বিন্দুকে ঠিক করতে গিয়ে অন্য বিন্দু নষ্ট হতে পারে, নিচে দেখুন।

৩ · Convergence theorem — Novikoff-এর (R/γ)² সীমা

Rosenblatt নিজে perceptron থামার একটি প্রমাণ দিয়েছিলেন; যে পরিষ্কার রূপটি আজ পাঠ্যবইয়ে চলে, তার জন্য সাধারণত Albert Novikoff-এর ১৯৬২ সালের একটি symposium-প্রবন্ধ উদ্ধৃত হয় (একই সময়ে H. D. Block-ও একটি প্রমাণ দেন বলে উল্লেখ পাওয়া যায়)। উপপাদ্যটি এরকম:

প্রমাণ তিন লাইনের, আর পরীক্ষায় প্রায়ই চাওয়া হয়। k-তম ভুলের পর weight w_k:

• u-এর দিকে অগ্রগতি: w_k·u = w_k−1·u + y(x̃·u) ≥ w_k−1·u + γ. শূন্য থেকে শুরু, তাই w_k·u ≥ kγ.
• দৈর্ঘ্যের বৃদ্ধি সীমিত: ‖w_k‖² = ‖w_k−1‖² + 2y(w_k−1·x̃) + ‖x̃‖². মাঝের পদ ≤ ০, কারণ ভুল হয়েছিল বলেই update. তাই ‖w_k‖² ≤ kR².
• জোড়া দেওয়া: Cauchy–Schwarz অসমতায় w_k·u ≤ ‖w_k‖. সুতরাং kγ ≤ √k·R, অর্থাৎ k ≤ (R/γ)².

লক্ষ করুন, সীমায় feature-এর সংখ্যা d বা বিন্দুর সংখ্যা N নেই; আছে শুধু ডেটার “আকার” R আর “ফাঁক” γ. আবার সীমাটি বলে না perceptron কোন রেখায় থামবে; মেশিন লার্নিং কোর্সের পর্ব ২৭-এ দেখা গেছে, ক্রম বদলালে থামার রেখা আর তার margin বদলায়।

এবার সংখ্যায় যাচাই। ডেটা: বাজারঘরের ৪০ জন কাল্পনিক গ্রাহক, seed দিয়ে বানানো। x₁ = মাসে অর্ডার (০–৮), x₂ = গড় বাস্কেট (হাজার টাকা, ০–৪), y = +১ যদি premium membership নেন। একটি লুকানো রেখার দুই পাশে একটু ফাঁক রেখে বিন্দু বাছা হয়েছে, তাই ডেটা আলাদা করা যায়। প্রথম তিনটি ব্লক এই module থেকে ডেটা নেয়।

# bazar_customers.py — বাজারঘরের কাল্পনিক গ্রাহক (seed দিয়ে বানানো)
import numpy as np

def make_customers(n=40, flip=0.0, seed=7):
    """x1 = মাসে অর্ডার, x2 = গড় বাস্কেট (হাজার টাকা); y = +1 premium নেন, -1 নেন না"""
    rng = np.random.default_rng(seed)
    X, y = [], []
    while len(y) < n:
        x = rng.uniform([0, 0], [8, 4])
        s = 0.5 * x[0] + 1.0 * x[1] - 4.0          # লুকানো আসল নিয়ম
        if abs(s) < 0.5 and flip == 0:            # পরিষ্কার ফাঁক রাখা
            continue
        X.append(x); y.append(1 if s > 0 else -1)
    X, y = np.round(np.array(X), 2), np.array(y)
    k = int(flip * n)                             # কিছু label উল্টে দেওয়া
    if k:
        idx = rng.choice(n, k, replace=False)
        y[idx] = -y[idx]
    return X, y

নিচের ব্লক perceptron-কে পাঁচটি আলাদা ক্রমে ভুল-শূন্য না হওয়া পর্যন্ত চালায় আর মোট ভুল গোনে। γ নেওয়া হয় maximum-margin (SVM) রেখা থেকে, augmented জগতে মেপে: উপপাদ্য যেকোনো আলাদা-করা u-এর জন্য খাটে, আর SVM-এর রেখা একটি ভালো u. ছবিতে perceptron-এর রেখা, SVM-এর রেখা আর বেগুনি তির হিসেবে w-এর দিক।

import numpy as np
import matplotlib.pyplot as plt
from sklearn.svm import SVC
from bazar_customers import make_customers
X, y = make_customers()                       # ৪০ জন গ্রাহক, আলাদা করা যায়
Xa = np.c_[X, np.ones(len(y))]                # x̃ = (x1, x2, 1): bias এখন একটি weight

def perceptron(order):
    w, mistakes = np.zeros(3), 0
    while True:                               # ভুল-শূন্য epoch না আসা পর্যন্ত
        changed = False
        for i in order:
            if y[i] * (w @ Xa[i]) <= 0:       # ভুল দিকে বা ঠিক সীমানায়
                w, mistakes, changed = w + y[i] * Xa[i], mistakes + 1, True
        if not changed:
            return w, mistakes
svm = SVC(kernel="linear", C=1e6).fit(X, y)   # maximum-margin রেখা
u = np.r_[svm.coef_[0], svm.intercept_[0]]
gamma = (y * (Xa @ u)).min() / np.linalg.norm(u)   # x̃-এর জগতে margin
R = np.linalg.norm(Xa, axis=1).max()
print(f"R = {R:.3f}, gamma = {gamma:.4f}, bound (R/gamma)^2 = {(R/gamma)**2:.0f}")
rng = np.random.default_rng(0)
for k in range(5):                            # ৫টি আলাদা ক্রম
    w, m = perceptron(rng.permutation(len(y)) if k else range(len(y)))
    print(f"order {k}: mistakes = {m:3d}, w = {np.round(w, 2)}")
w, _ = perceptron(range(len(y)))
gx = np.linspace(0, 8, 2)
plt.scatter(*X[y > 0].T, marker="^", c="tab:red", label="premium (+1)")
plt.scatter(*X[y < 0].T, c="tab:blue", label="no (-1)")
plt.plot(gx, -(w[0] * gx + w[2]) / w[1], "k", label="perceptron")
plt.plot(gx, -(u[0] * gx + u[2]) / u[1], "g--", label="max margin")
p = -w[2] * w[:2] / (w[:2] @ w[:2])           # রেখার ওপর একটি বিন্দু, সেখান থেকে w-এর তির
plt.arrow(*p, *(w[:2] / np.linalg.norm(w[:2])), width=0.03, color="purple")
plt.gca().set_aspect("equal"); plt.ylim(0, 5.4); plt.legend(fontsize=7, ncol=2, loc="upper left")
plt.xlabel("orders per month"); plt.ylabel("avg basket (thousand taka)")

R = 8.626, gamma = 0.1553, bound (R/gamma)^2 = 3087
order 0: mistakes = 105, w = [  3.48   7.49 -29.  ]
order 1: mistakes =  31, w = [  1.2    3.21 -11.  ]
order 2: mistakes =  61, w = [  2.82   4.81 -19.  ]
order 3: mistakes =  67, w = [  3.41   6.72 -23.  ]
order 4: mistakes =  35, w = [  2.08   2.45 -13.  ]

৪ · ডেটা আলাদা না হলে — চক্র, pocket আর গড়

বাস্তব ডেটায় কিছু label ভুল থাকে, কিছু গ্রাহক নিয়ম মানেন না। তখন কোনো রেখাই সব বিন্দু ঠিক ভাগ করে না, আর perceptron-এর উপপাদ্যের শর্ত ভাঙে। নিয়মটি তখন কখনো থামে না; weight একটি সীমিত এলাকায় ঘুরতে থাকে (এই “cycling” ফলটি Minsky–Papert-এর বইয়ে আর ১৯৭০-এর দিকে Block ও Levin-এর কাজে আলোচিত বলে জানা যায়)। শেষ epoch-এর weight তাই অনেকটা লটারি।

দুটি সহজ সমাধান। Pocket algorithm (Stephen Gallant, ১৯৯০): চলতে চলতে প্রতিবার পুরো ডেটায় ভুল গুনে এখন পর্যন্ত সেরা weight “পকেটে” রাখা। Averaged perceptron: প্রতিটি ধাপের weight যোগ করে গড় নেওয়া; Yoav Freund আর Robert Schapire ১৯৯৯ সালে এর ভোটভিত্তিক রূপ বিশ্লেষণ করেন, আর Michael Collins ২০০২ সালে NLP-র tagging-এ এর একটি structured রূপ জনপ্রিয় করেন। নিচের ব্লকে ৬০ জন গ্রাহক, যার ১০% (৬ জনের) label উল্টে দেওয়া, ৪০ epoch.

import numpy as np
import matplotlib.pyplot as plt
from bazar_customers import make_customers

X, y = make_customers(n=60, flip=0.1, seed=3)   # ৬টি label উল্টানো: আলাদা করা যায় না
Xa = np.c_[X - X.mean(0), np.ones(len(y))]       # মাঝখানে আনা + bias-এর 1
errors = lambda w: int((y * (Xa @ w) <= 0).sum())

rng = np.random.default_rng(1)
w, avg = np.zeros(3), np.zeros(3)
pocket_w, pocket_err = w.copy(), errors(w)
history, best = [], []
for epoch in range(40):
    for i in rng.permutation(len(y)):
        if y[i] * (w @ Xa[i]) <= 0:
            w = w + y[i] * Xa[i]
            e = errors(w)                        # নতুন w পুরো ডেটায় কত ভুল
            if e < pocket_err:                   # ভালো হলে পকেটে রাখি
                pocket_w, pocket_err = w.copy(), e
        avg += w                                 # averaged perceptron-এর যোগফল
    history.append(errors(w)); best.append(pocket_err)

print("শেষ ১০ epoch-এ সাধারণ perceptron-এর ভুল:", history[-10:])
print("সাধারণ perceptron: সর্বনিম্ন", min(history), "সর্বোচ্চ", max(history),
      "| শেষ w-এর ভুল", history[-1])
print("averaged perceptron-এর ভুল:", errors(avg))
print("pocket-এর ভুল:", pocket_err, "of", len(y), "| w =", np.round(pocket_w, 2))
plt.plot(history, label="plain perceptron (end of epoch)")
plt.plot(best, label="pocket (best so far)", lw=2.5)
plt.xlabel("epoch"); plt.ylabel("training mistakes"); plt.legend()

শেষ ১০ epoch-এ সাধারণ perceptron-এর ভুল: [32, 18, 15, 12, 21, 15, 15, 35, 15, 16]
সাধারণ perceptron: সর্বনিম্ন 8 সর্বোচ্চ 35 | শেষ w-এর ভুল 16
averaged perceptron-এর ভুল: 11
pocket-এর ভুল: 6 of 60 | w = [1.47 2.96 0.  ]

৫ · Perceptron, hinge আর log loss — একই পরিবারের তিনটি loss

আসলে আমরা যা চাই, তা হলো কম ভুল: ০-১ loss, ভুলে ১, ঠিকে ০. কিন্তু এর ঢাল প্রায় সবখানে শূন্য, তাই gradient কোনো দিক দেখায় না। সমাধান একটি surrogate loss: margin m = y·z-এর একটি মসৃণ বা অন্তত ঢালু function. তিনটি পরিচিত বিকল্প:

• Perceptron loss max(0, −m): ভুল দিকে থাকলেই শাস্তি। একটি উদাহরণে এর ওপর SGD (η = ১) চালালে update হয় w̃ ← w̃ + yx̃, শুধু m ≤ ০ হলে: হুবহু perceptron নিয়ম।
• Hinge loss max(0, 1 − m): ঠিক দিকে থাকলেও margin ১-এর কম হলে শাস্তি। L2 শাস্তির সঙ্গে এটিই soft-margin SVM (মেশিন লার্নিং কোর্সের পর্ব ২৮)।
• Log loss log(1 + e^−m): কখনো পুরো শূন্য নয়; ঠিক দিকে দূরে গেলে খুব ছোট। এটিই logistic regression-এর loss, ±১ label-এ লেখা।

শেষ সারিটি গুরুত্বপূর্ণ। প্রতিটি loss-এর gradient হলো −(টান)·y·x̃; perceptron-এ টান ১ শুধু m ≤ ০ হলে, hinge-এ ১ শুধু m < ১ হলে, আর log loss-এ টান σ(−m), যা কখনো শূন্য নয়। তাই logistic regression সব বিন্দুর কথা শোনে, ভুলগুলোর কথা বেশি জোরে। Perceptron loss-এর একটি অদ্ভুত দিকও আছে: w̃ = ০-তে সব m = ০, loss শূন্য, অর্থাৎ “কিছু না শেখা”-ই এর সর্বনিম্ন বিন্দু। Perceptron কাজ করে কারণ নিয়মটি m = ০-কেও ভুল ধরে update করে; একটি loss হিসেবে এটি একা দাঁড়ায় না। Hinge-এর “১” ঠিক এই ফাঁকটি বন্ধ করে।

৬ · Sigmoid neuron মানেই logistic regression — gradient descent নিজে লেখা

Neuron-এর activation যদি sigmoid σ(z) = 1/(1 + e^−z) হয় আর loss হয় log loss, তাহলে neuron আর logistic regression একই জিনিস। ০/১ label t আর p = σ(z) ধরলে, chain rule-এ (AI-এর ভিত্তি কোর্সের পর্ব ৩৪) ঢালটি দাঁড়ায় খুব সরল রূপে:

∂L/∂w̃ = (p − t)·x̃, গড় নিলে ∇L = X̃ᵀ(p − t)/N

Perceptron-এর update (t − out)·x̃-এর সঙ্গে মিলিয়ে দেখুন: আকার একই, পার্থক্য শুধু out-এর জায়গায় p. Perceptron শক্ত ০/১ উত্তর দেয় আর শুধু ভুলে নড়ে; sigmoid neuron নরম সম্ভাবনা দেয় আর প্রতিটি বিন্দুতে তার ভুলের মাপ অনুযায়ী নড়ে। এই ধারাবাহিকতাই পরের পর্বগুলোতে বহুস্তরের network-এ chain rule চালানো সম্ভব করে। নিচের ব্লক আগের ব্লকের একই ডেটায় gradient descent নিজে লেখে, scikit-learn-এর সঙ্গে মেলায়, আর pocket-এর রেখার সঙ্গে তিনটি loss পাশাপাশি দেখায়।

import numpy as np
from sklearn.linear_model import LogisticRegression
from bazar_customers import make_customers

X, y = make_customers(n=60, flip=0.1, seed=3)   # আগের ব্লকের একই ডেটা
Xc = X - X.mean(0)
Xa = np.c_[Xc, np.ones(len(y))]
t = (y + 1) // 2                                 # label 0/1, sigmoid-এর জন্য
sigmoid = lambda z: 1 / (1 + np.exp(-z))

w, eta = np.zeros(3), 0.5
for step in range(2001):
    p = sigmoid(Xa @ w)                          # সব গ্রাহকের সম্ভাবনা
    if step in (0, 10, 100, 500, 2000):
        loss = -np.mean(t * np.log(p) + (1 - t) * np.log(1 - p))
        print(f"step {step:4d}: log loss {loss:.4f}, w = {np.round(w, 3)}")
    w -= eta * Xa.T @ (p - t) / len(t)           # gradient: (p − t)·x-এর গড়

sk = LogisticRegression(C=1e10).fit(Xc, y)       # প্রায় শাস্তিহীন, তুলনার জন্য
print("scikit-learn:", np.round(np.r_[sk.coef_[0], sk.intercept_], 3))
pocket = np.array([1.47, 2.96, 0.0])             # আগের ব্লকের pocket-এর w
for name, v in [("sigmoid neuron", w), ("pocket perceptron", pocket)]:
    m = y * (Xa @ v)                             # প্রতিটি বিন্দুর margin y·z
    print(f"{name:17s} ভুল {int((m <= 0).sum())}/60 | মোট loss:"
          f" perceptron {np.maximum(0, -m).mean():.3f},"
          f" hinge {np.maximum(0, 1 - m).mean():.3f},"
          f" log {np.logaddexp(0, -m).mean():.3f}")

step    0: log loss 0.6931, w = [0. 0. 0.]
step   10: log loss 0.4691, w = [0.532 0.687 0.269]
step  100: log loss 0.4399, w = [0.72  1.331 0.584]
step  500: log loss 0.4399, w = [0.724 1.342 0.59 ]
step 2000: log loss 0.4399, w = [0.724 1.342 0.59 ]
scikit-learn: [0.724 1.342 0.59 ]
sigmoid neuron    ভুল 12/60 | মোট loss: perceptron 0.184, hinge 0.497, log 0.440
pocket perceptron ভুল 6/60 | মোট loss: perceptron 0.420, hinge 0.646, log 0.578

৭ · অনেক শ্রেণি — multi-class perceptron আর softmax neuron

বাজারঘর গ্রাহকদের তিন দলে ভাগ করতে চায়: বাজেট, নিয়মিত আর প্রিমিয়াম। এটি multiclass classification. মেশিন লার্নিং কোর্সের পর্ব ২৫-এ one-vs-rest দেখেছেন, যেখানে তিনটি আলাদা binary model. এখানে একটি model-ই সব শ্রেণি দেখে:

• Multi-class perceptron: প্রতিটি শ্রেণি c-এর জন্য একটি weight সারি W_c; অনুমান ŷ = argmax_c W_c·x̃. ভুল হলে W_y ← W_y + x̃ (ঠিক শ্রেণিকে কাছে টানা) আর W_ŷ ← W_ŷ − x̃ (ভুল করে বাছা শ্রেণিকে দূরে ঠেলা)। এর পেছনে একটি সুন্দর কৌশল আছে (পাঠ্যবইয়ে প্রায়ই Kesler-এর construction নামে): K শ্রেণির সমস্যাকে একটি বড় binary perceptron-এ লেখা যায়, তাই আলাদা করা যায় এমন ডেটায় একই ধরনের ভুলের সীমা খাটে।
• Softmax neuron: প্রতিটি শ্রেণির score z_c = W_c·x̃, তারপর softmax দিয়ে সম্ভাবনা p_c = e^z_c/∑_j e^z_j, আর loss cross-entropy. Gradient আবার একই আকারের: (P − Y)ᵀ-এর সঙ্গে x̃, যেখানে Y হলো one-hot label. দুই শ্রেণিতে softmax হুবহু sigmoid. P − Y-এর পুরো derivation পর্ব ০৪ (Backpropagation হাতে-কলমে)-এ আসবে।

দুটির সম্পর্ক binary ক্ষেত্রের মতোই: multi-class perceptron শুধু সবচেয়ে বড় score দেখে আর ভুলে নড়ে; softmax সব score থেকে নরম সম্ভাবনা বানায়, প্রতিটি উদাহরণে নড়ে। নিচের ব্লকে দুটিকে তিন দলের ৯০ জন গ্রাহকে চালানো হয়েছে, আর শেষে একই softmax trainer (K = ২) XOR-এর চারটি বিন্দুতে, প্রথমে শুধু x₁, x₂ দিয়ে, তারপর x₁x₂ যোগ করে। শেষ লাইনের ফলের ব্যাখ্যা অংশ ৮-এ।

import numpy as np

rng = np.random.default_rng(5)                   # বাজারঘরের ৩ ধরনের গ্রাহক
centers = np.array([[1.5, 0.8], [4.0, 1.5], [6.0, 3.2]])   # বাজেট, নিয়মিত, প্রিমিয়াম
X = np.vstack([c + rng.normal(0, 0.6, (30, 2)) for c in centers])
y = np.repeat(np.arange(3), 30)
Xa = np.c_[X - X.mean(0), np.ones(len(y))]

W = np.zeros((3, 3))                             # প্রতি শ্রেণির জন্য একটি weight সারি
for epoch in range(20):
    for i in rng.permutation(len(y)):
        guess = np.argmax(W @ Xa[i])
        if guess != y[i]:                        # ভুল: ঠিক শ্রেণি কাছে, ভুলটি দূরে
            W[y[i]] += Xa[i]; W[guess] -= Xa[i]
print("multi-class perceptron: ভুল", int((np.argmax(Xa @ W.T, 1) != y).sum()), "of 90")

def softmax_fit(F, labels, K, steps=3000, eta=0.5):
    V, Y = np.zeros((F.shape[1], K)), np.eye(K)[labels]
    for _ in range(steps):
        Z = F @ V
        P = np.exp(Z - Z.max(1, keepdims=True)); P /= P.sum(1, keepdims=True)
        V -= eta * F.T @ (P - Y) / len(F)        # cross-entropy-র gradient: P − Y
    return P
P = softmax_fit(Xa, y, 3)
j = P.max(1).argmin()                            # সবচেয়ে দ্বিধার গ্রাহক
print("softmax neuron: ভুল", int((P.argmax(1) != y).sum()), "of 90 | গ্রাহক", j,
      X[j].round(2), "আসল", y[j], "সম্ভাবনা", P[j].round(3))

S = np.array([[-1, -1], [-1, 1], [1, -1], [1, 1]])  # XOR, ±1 রূপে
t = np.array([0, 1, 1, 0])
for name, F in [("x1, x2", np.c_[S, np.ones(4)]),
                ("x1, x2, x1*x2", np.c_[S, S[:, 0] * S[:, 1], np.ones(4)])]:
    p = softmax_fit(F, t, 2)[:, 1]
    print(f"features [{name}]: P(XOR=1) = {np.round(p, 3)}")

multi-class perceptron: ভুল 1 of 90
softmax neuron: ভুল 1 of 90 | গ্রাহক 47 [2.9  1.38] আসল 1 সম্ভাবনা [0.435 0.565 0.   ]
features [x1, x2]: P(XOR=1) = [0.5 0.5 0.5 0.5]
features [x1, x2, x1*x2]: P(XOR=1) = [0. 1. 1. 0.]

৮ · XOR, Minsky–Papert আর দুটি পথ — feature map বনাম hidden layer

AI-এর ভিত্তি কোর্সের পর্ব ৬৮-এ ০/১ রূপে চারটি অসমতা যোগ করে XOR-এর অসম্ভবতা দেখানো হয়েছে। ±১ রূপে একই সত্যটি আরও গভীর একটি কারণে দাঁড়ায়, যা উপরের ০.৫-এরও ব্যাখ্যা:

XOR কতটা ব্যতিক্রম? Thomas Cover ১৯৬৫ সালে গুনে দেখান, d-মাত্রায় “সাধারণ অবস্থানের” N বিন্দুর ২^N রকম label-এর মধ্যে কতগুলো একটি সমতলে আলাদা করা যায় (Cover-এর theorem). Bias-সহ দুই input মানে d = ৩, আর চারটি কোণে সূত্র দেয় ১৬-এর মধ্যে ১৪; বাকি দুটি ঠিক XOR আর তার উল্টো। আমাদের একটি scratch হিসাবে (scipy-র linprog দিয়ে প্রতিটি label-সমষ্টির জন্য আলাদা-করা রেখা খুঁজে) ঠিক এই ১৪ এসেছে, আর তিন input-এর ২৫৬টি Boolean function-এর মধ্যে ১০৪টি। ফলটির শিক্ষা: বিন্দু বাড়লে linear model-এর পক্ষে আলাদা করা সম্ভব এমন label-এর ভাগ দ্রুত কমে, আর মাত্রা বাড়ালে বাড়ে। Feature map ঠিক এই কাজটি করে।

Minsky আর Papert আসলে কী দেখান। তাঁদের ১৯৬৯ সালের বই Perceptrons শুধু XOR নয়; তাঁরা perceptron-এর input-এ বসা “স্থানীয়” feature-গুলোর “order” (একটি feature কতগুলো pixel একসঙ্গে দেখে) নিয়ে প্রমাণ দেন। যেমন n টি input-এর parity (একের সংখ্যা জোড় না বিজোড়; দুই input-এ এটিই XOR) বুঝতে অন্তত একটি feature-কে সব n টি input একসঙ্গে দেখতে হয়, আর ছবির “সংযুক্ত কি না” ধরনের বৈশিষ্ট্যও সীমিত order-এ ধরা যায় না। অর্থাৎ সমস্যা ছিল feature-এ: ঠিক feature দিলে এক স্তরই যথেষ্ট, কিন্তু সেই feature কে দেবে? বইটির ঐতিহাসিক প্রভাব নিয়ে মতভেদ আছে; সেই বিতর্ক AI-এর ভিত্তি কোর্সের পর্ব ২ আর পর্ব ৬৮-এ।

দুটি পথ। প্রথম পথ: মানুষ feature বানায়, বা kernel দিয়ে অসীম মাত্রার feature-এ অন্তর্নিহিতভাবে যায় (মেশিন লার্নিং কোর্সের পর্ব ২৯)। দ্বিতীয় পথ: একটি hidden layer feature map-টি নিজেই ডেটা থেকে শেখে; XOR-এর জন্য কয়েকটি ReLU unit-ই x₁x₂-এর কাজ করতে পারে। Deep learning দ্বিতীয় পথ, আর পর্ব ০৩ (NumPy-তে multilayer perceptron) সেটি vectorised রূপে লিখবে; পর্ব ০৬ (Network কী শিখতে পারে) দেখাবে এই পথের তাত্ত্বিক ক্ষমতা আর সীমা।

৯ · জীবন্ত নিউরনের সঙ্গে তুলনা — মিল কোথায়, সীমা কোথায়

“Neuron” নামটি জীববিজ্ঞান থেকে ধার করা। McCulloch আর Pitts (১৯৪৩)-এর যুক্তির একক আর Rosenblatt-এর perceptron দুটিই মস্তিষ্ক থেকে অনুপ্রাণিত। তুলনাটি কোথায় খাটে আর কোথায় খাটে না, সংক্ষেপে:

সবচেয়ে চমকপ্রদ পার্থক্যটি XOR-এর সঙ্গেই জড়িত। ২০২০ সালে Science-এ Albert Gidon ও সহকর্মীরা মানুষের cortex-এর কিছু নিউরনের dendrite-এ এক ধরনের বৈদ্যুতিক সংকেত বর্ণনা করেন, যা মাঝারি input-এ সবচেয়ে জোরালো আর বেশি input-এ দুর্বল হয়; লেখকদের মতে এর ফলে একটি নিউরনের অংশ XOR-ধরনের হিসাব করতে পারে। ২০২১ সালে Neuron পত্রিকায় Beniaguev, Segev আর London একটি বিস্তারিত নিউরন-model-এর আচরণ নকল করতে কয়েক স্তরের একটি deep network দরকার বলে রিপোর্ট করেন। দুটিই সক্রিয় গবেষণা, শেষ কথা নয়। কিন্তু শিক্ষাটি পরিষ্কার: “একটি কৃত্রিম neuron = একটি জীবন্ত নিউরন” ধরে নেওয়া ভুল; একটি জীবন্ত নিউরন সম্ভবত অনেক বেশি কিছু করে। তাই এই কোর্সে neuron মানে একটি গাণিতিক unit, মস্তিষ্কের দাবি নয়।

১০ · AI-এর যুগে — AI-এর লেখা perceptron আর neuron কোড যাচাই

“একটি perceptron লিখে দাও” বললে AI সাধারণত চলার মতো কোড দেয়। ভুল থাকে ছোট জায়গায়, যা আউটপুট দেখে ধরা কঠিন:

AI-এর লেখা neuron বা perceptron কোড হাতে পেলে — যাচাইয়ের চেকলিস্ট

• চার-পাঁচটি বিন্দুর খেলনা ডেটায় প্রথম দুটি update হাতে হিসাব করে কোডের সঙ্গে মিলিয়েছি
• Label-এর রূপ (০/১ না ±১) আর update-এর সূত্র একে অপরের সঙ্গে মেলে
• প্রতিটি array-র shape ছাপিয়ে দেখেছি: X (N×d), w (d), bias কোথায়
• প্রতি epoch-এর ভুল বা loss আঁকা হয়েছে; একটি ভাগ্যবান run নয়, কয়েকটি seed আর ক্রমে চালানো
• একটি সরল baseline-এর (scikit-learn-এর LogisticRegression) সঙ্গে মিলিয়েছি, আর ভুল গোনা হয়েছে আলাদা validation অংশে
• ইতিহাস বা উপপাদ্যের যেকোনো উদ্ধৃতি মূল উৎসে খুঁজে দেখেছি; গোপন বা ব্যক্তিগত ডেটা AI-তে পেস্ট করিনি