Perceptron ابتدا سے: ایک Neuron کیا compute کرتا ہے

ایک perceptron measurements لیتا ہے، ہر ایک کو اپنے control میں موجود ایک number سے multiply کرتا ہے، انہیں جمع کرتا ہے، ایک اور number add کرتا ہے، اور sign دیکھتا ہے۔

ایک part کی measurements کو vector $\mathbf{x} = (x_1, x_2)$ کے طور پر لکھیں — width اور weight۔ perceptron ایک weight vector $\mathbf{w} = (w_1, w_2)$ اور ایک bias $b$ رکھتا ہے۔ اس کا score ہے

اور اس کا answer اس score کا sign ہے: اگر $s(\mathbf{x}) \geq 0$ ہو تو accept، ورنہ reject۔

یہی پورا model ہے۔ factory کے بارے میں perceptron جو کچھ بھی کبھی جانے گا وہ تین numbers میں رہتا ہے۔

Geometry پر رکنا فائدہ مند ہے، کیونکہ یہی وہ تصویر ہے جو اگلے انتیس chapters تک بھی کام کرتی رہتی ہے، حتیٰ کہ جب equations ایک line میں fit ہونا بند کر دیتی ہیں۔ points کا وہ set جہاں $s(\mathbf{x}) = 0$ — جہاں perceptron عین undecided ہے — plane میں ایک straight line ہے۔ ایک طرف score positive ہے اور ہر چیز accept ہوتی ہے؛ دوسری طرف negative ہے اور ہر چیز reject ہوتی ہے۔ perceptron کے لیے learning کا مطلب ہے اس line کو move کرنا۔

اس line کے بارے میں دو facts algebra سے براہِ راست نکلتے ہیں، اور دونوں بعد میں اہم ہوتے ہیں:

• $\mathbf{w}$ اس کے perpendicular ہے۔ weight vector boundary کے along نہیں پڑا ہوتا، وہ اس کے across، accepted side کی طرف point کرتا ہے۔
• $b$ اسے turn کیے بغیر slide کرتا ہے۔ bias کے بغیر line origin سے گزرنے پر مجبور ہوتی، جو millimetres اور grams ناپنے والی factory کے لیے ایک absurd constraint ہوتا — اس کا مطلب ہوتا کہ zero width اور zero weight والا part عین fence پر بیٹھا ہے۔

perceptron کچھ بھی جانے بغیر شروع کرتا ہے: $\mathbf{w} = (0, 0)$ اور $b = 0$۔ ہر score zero ہے، اس لیے یہ ہر چیز accept کرتا ہے۔

اب اسے ایک وقت میں ایک example دکھائیں۔ accepted parts کو $y = +1$ اور rejected ones کو $y = -1$ label کریں۔ ہر example کے لیے ایک سوال پوچھیں: کیا sign صحیح نکلا؟ اس سوال کو compact انداز میں لکھنے کا طریقہ یہ check کرنا ہے کہ آیا $y \cdot s(\mathbf{x})$ positive ہے — اگر label اور score sign میں agree کرتے ہیں تو ان کا product positive ہے، اور اگر disagree کرتے ہیں تو negative۔

اگر جواب yes ہے تو کچھ نہ بدلیں۔ اگر no ہے تو nudge کریں:

یہی پورا algorithm ہے، اور اسے memorize کرنے کے بجائے یہ سمجھنا مفید ہے کہ یہی صحیح nudge کیوں ہے۔ فرض کریں ایک part accept ہونا چاہیے تھا ($y = +1$) اور score negative نکلا۔ $\mathbf{w}$ میں $\mathbf{x}$ add کرنے سے اسی part پر score اتنا بدلتا ہے:

جو ایک positive number ہے۔ جس part پر ابھی غلطی ہوئی، اس کا score اوپر جاتا ہے، یعنی اسی direction میں جس direction کی اسے ضرورت تھی۔ یہ rule کوئی guessed heuristic نہیں؛ یہ وہ سب سے چھوٹی change ہے جو سامنے موجود case کو provably improve کرتی ہے۔ ظاہر ہے یہ کسی دوسرے case کو خراب کر سکتی ہے، اسی لیے آپ پھر round لگاتے ہیں۔

غور کریں کیا absent ہے۔ کہیں derivative نہیں۔ یہ oversight نہیں، اور یہی course کا پہلا واقعی اہم idea ہے۔

جس چیز کو آپ differentiate کرنا چاہتے وہ error ہے — misclassified parts کی count۔ مگر وہ count staircase ہے: آپ line کو nudge کرتے رہتے ہیں تو یہ 4 پر flat رہتی ہے، پھر line جیسے ہی ایک point cross کرتی ہے اسی instant 3 پر drop ہو جاتی ہے۔ اس کا derivative تقریباً ہر جگہ zero ہے اور steps پر undefined۔ Calculus کے پاس پکڑنے کو کچھ نہیں۔ perceptron rule اس کے around کام کرتا ہے: وہ slope نہیں مانگتا؛ صرف «right or wrong?» پوچھتا ہے، اور ایسی direction میں move کرتا ہے جسے geometrically justify کر سکے۔

یہ ایک genuine solution ہے، اور ساتھ ہی dead end بھی۔ باب 2 میں ہمیں ایسی loss چاہیے ہو گی جو کہیں سے آتی ہو، صرف chosen نہ ہو؛ باب 4 میں ایسا model جو بتائے کہ وہ how sure ہے؛ اور باب 5 میں ایک سے زیادہ layer والی چیز — اور ان میں سے کوئی بھی اس rule سے reachable نہیں جو صرف «wrong» جانتا ہے۔ usable slope واپس لانا ہی اگلے دو chapters کو مجبور کرتا ہے۔ مگر perceptron کو وہ کام کرنے کا حق ملتا ہے جو اس کے successors میں سے کوئی نہیں کر سکتا: calculus کے بغیر learn کرنا۔

Pure Python، no NumPy۔ Lists اور ایک loop۔ NumPy اگلے chapter میں آتا ہے، جہاں arithmetic اس loop میں fit ہونا بند کر دیتی ہے جسے آپ پڑھنا چاہیں؛ اسے ابھی introduce کرنا arithmetic کو library کے پیچھے چھپا دے گا عین اس وقت جب آپ اسے دیکھنا چاہتے ہیں۔

def score(w, b, x):
    return w[0] * x[0] + w[1] * x[1] + b


def predict(w, b, x):
    return 1 if score(w, b, x) >= 0 else -1


def train(data, epochs=200):
    """Returns (w, b, epoch_it_converged) — or None for the epoch if it never did."""
    w, b = [0.0, 0.0], 0.0
    for epoch in range(epochs):
        mistakes = 0
        for x, y in data:
            if y * score(w, b, x) <= 0:          
                w[0] += y * x[0]                 
                w[1] += y * x[1]                 
                b += y                           
                mistakes += 1
        if mistakes == 0:
            return w, b, epoch + 1
    return w, b, None

highlighted چار lines ہی algorithm ہیں۔ باقی سب bookkeeping ہے۔

اور belt، جس سے آٹھ parts measure کیے گئے — چار جو ship ہوئے اور چار جو واپس آئے:

BELT = [
    ((18.0, 47.0), +1), ((19.5, 52.0), +1), ((20.2, 49.0), +1), ((21.0, 55.0), +1),
    ((24.0, 61.0), -1), ((25.5, 66.0), -1), ((23.0, 70.0), -1), ((26.0, 58.0), -1),
]

w, b, epoch = train(BELT, epochs=200)
print(epoch, w, b)

یہ آٹھ parts straight line سے separable ہیں — ہر accepted part 22 mm سے کم ہے اور ہر rejected one 23 mm یا اس سے زیادہ۔ 22 millimetres پر ایک vertical fence کام کر دیتی ہے۔ لہٰذا perceptron کو یہ find کر لینا چاہیے۔

اسے run کریں:

None [-142.1, -13.0] 54.0

دو سو epochs، 454 corrections، اور یہ converge نہیں ہوا۔ weights بڑے ہیں اور sign غلط ہے۔ کچھ غلط ہے — سوائے اس کے کہ کچھ بھی غلط نہیں، اور وجہ اس chapter کی سب سے useful چیز ہے۔

perceptron کے پاس guarantee ہے، جسے Novikoff نے 1962 میں prove کیا۔¹ اگر data کسی line سے بالکل بھی separate ہو سکتا ہے، تو algorithm زیادہ سے زیادہ اتنی

corrections کرتا ہے، پھر کوئی correction نہیں کرتا — جہاں $R$ data کا radius ہے، یعنی longest example vector کی length، اور $\gamma$ margin ہے: separating hyperplane سے closest point تک distance اس augmented space میں جہاں bias تیسرا coordinate ہے۔ اسی لیے data کو centre کرنا اسے بدل دیتا ہے جبکہ millimetres میں distance نہیں بدلتا۔

Guarantee unconditional ہے اور epochs، learning rates، یا luck کا ذکر نہیں کرتی۔ یہ time کا بھی ذکر نہیں کرتی، اور یہی omission اصل point ہے۔

ہمارے numbers ڈالیں۔ آٹھ parts سے directly measured، bias کو constant feature کے طور پر fold کر کے:

Theorem کبھی violate نہیں ہوا۔ raw version کو کافی دیر run کریں تو یہ converge ہو جاتا ہے — epoch 11,976 پر، 29,870 corrections کے بعد — اپنے 2,633,550 کے bound کے اندر آرام سے، اور یہی gap خود point ہے: theorem worst case کو bound کرتا ہے، typical one کو نہیں۔ اسے صرف اتنے epochs چاہیے تھے جو کسی کے بیٹھ کر دیکھنے سے ساٹھ گنا زیادہ تھے۔

دوسری row وہی آٹھ parts ہیں، وہی بیس lines کا code، بس تین lines add کی گئی ہیں تاکہ ہر measurement سے mean width اور mean weight subtract ہو جائے۔ بس یہی۔ پوری change یہی ہے۔ یہ points کے cloud کو move کر دیتی ہے تاکہ وہ (22, 57) پر floating کے بجائے origin کو straddle کرے، اور bound پر effect پندرہ ہزار کے factor کا ہے، کیونکہ دونوں terms ایک ساتھ improve ہوتے ہیں: $R$ 74 سے 13 پر آتا ہے کیونکہ points اب far-away origin سے measured نہیں ہیں، اور $\gamma$ 0.045 سے 0.989 تک بڑھتا ہے کیونکہ margin ایسے weight vector کے against measured ہے جسے data تک پہنچنے کے لیے اب huge bias carry نہیں کرنا پڑتا۔

mean_w = sum(x[0] for x, _ in BELT) / len(BELT)   # 22.15
mean_g = sum(x[1] for x, _ in BELT) / len(BELT)   # 57.25
CENTRED = [(((x[0] - mean_w), (x[1] - mean_g)), y) for x, y in BELT]

w, b, epoch = train(CENTRED, epochs=200)
print(epoch, w, b)

2 [-4.15, -10.25] 1.0

دو epochs میں converge ہو گیا، خود کو exactly ایک بار correct کر کے۔

یہاں ایک real lesson ہے اور وہ «اپنے inputs normalize کرنا یاد رکھیں» نہیں، اگرچہ آپ کو کرنا چاہیے۔ lesson یہ ہے کہ کسی algorithm کے finish ہونے کے بارے میں guarantee آپ کو یہ نہیں بتاتی کہ جب وہ finish کرے گا تو آپ وہاں موجود بھی ہوں گے یا نہیں، اور ان دونوں کے درمیان gap عموماً geometry ہوتی ہے۔ یہ اس pattern کی پہلی appearance ہے جس سے آپ باب 6 میں initialisation کے ساتھ، باب 10 میں learning-rate schedules کے ساتھ، اور باب 13 میں quantisation کے ساتھ دوبارہ ملیں گے: mathematics کہتی ہے کہ چیز possible ہے، اور engineering فیصلہ کرتی ہے کہ practical ہے یا نہیں۔ ایسا course جو آپ کو صرف theorem سکھاتا ہے، آپ کے ہاتھ میں ایک model دے دیتا ہے جو تین دن train ہوتا ہے اور الزام آپ پر لگاتا ہے۔

اب وہ failure جس نے neural networks کے پہلے era کو ختم کیا، اور یہ چار rows میں fit ہو جاتی ہے۔

factory کو بھول جائیں۔ دو inputs لیں جن میں سے ہر ایک یا 0 ہے یا 1، اور answer $+1$ مانگیں جب ان میں سے exactly ایک 1 ہو:

یہ XOR ہے — exclusive or۔ آگے پڑھنے سے پہلے، چاروں points paper پر draw کریں: unit square کے تین corners اور چوتھا۔ دو diagonal corners $(0,1)$ اور $(1,0)$ کو accept mark کریں، اور $(0,0)$ اور $(1,1)$ کو reject۔ اب ایک straight line draw کریں جس کے ایک side پر دونوں accepted points ہوں اور دوسرے side پر دونوں rejected points۔

آپ نہیں کر سکتے۔ بات یہ نہیں کہ یہ hard ہے، یا آپ کو cleverer algorithm چاہیے؛ بات یہ ہے کہ line موجود ہی نہیں۔ algebra کی تین lines دکھاتی ہیں کیوں۔ اگر perceptron چاروں کو right کر لیتا، تو چار rows کو order میں پڑھنے سے ملتا

درمیان والی دو inequalities add کریں: $w_1 + w_2 + 2b \geq 0$، تو $w_1 + w_2 \geq -2b$۔ آخری کہتی ہے $w_1 + w_2 < -b$۔ مل کر: $-2b \leq w_1 + w_2 < -b$، جس کے لیے $-2b < -b$ چاہیے، جس کے لیے $b > 0$ چاہیے۔ اور پہلی inequality کہتی ہے $b < 0$۔ ایسا کوئی $b$ نہیں، اس لیے ایسے weights بھی نہیں۔ کوئی perceptron، کسی بھی numbers کے ساتھ، XOR کو classify نہیں کرتا۔

پھر بھی اسے run کریں، کیونکہ algorithm کو fail ہوتے دیکھنا یہ سننے سے کہیں زیادہ قیمتی ہے کہ وہ fail ہو گا:

     100 epochs -> converged=None  w=[0.0, 0.0] b=0.0  correct=2/4
   1,000 epochs -> converged=None  w=[0.0, 0.0] b=0.0  correct=2/4
 100,000 epochs -> converged=None  w=[0.0, 0.0] b=0.0  correct=2/4

یہ diverge نہیں کرتا، اور نہ ہی کسی decent answer کے نزدیک thrash کرتا ہے۔ یہ cycle کرتا ہے: weight space میں ایک short loop چلتا ہے اور عین وہیں واپس آ جاتا ہے جہاں شروع ہوا تھا، ہمیشہ کے لیے، چار میں سے دو right کرتا ہوا — جو guessing سے بھی ملتا۔ ایک لاکھ epochs اور ایک سو indistinguishable ہیں، کیونکہ algorithm ایسی progress نہیں کر رہا جسے longer run finish کر سکے۔ اسے belt سے compare کریں، جو 200 epochs پر stuck دکھائی دیتی تھی مگر حقیقت میں real answer کی طرف grind کر رہی تھی۔ باہر سے پہلے چند seconds میں دونوں similar لگتے ہیں۔ theorem کے بغیر انہیں الگ پہچاننا impossible ہے — اور یہی theorem جاننے کی ایک اور دلیل ہے۔

1969 میں Marvin Minsky اور Seymour Papert نے Perceptrons شائع کی، ایک book-length mathematical study کہ یہ model exactly کیا represent کر سکتا ہے اور کیا نہیں۔² XOR اس کا سب سے quoted result ہے، اور quotation عموماً accusation کے طور پر استعمال ہوتی ہے: کہ book نے rivalry یا spite کی وجہ سے neural network research کو پندرہ سال کے لیے قتل کر دیا۔

Book میں mathematics correct ہے، اور XOR example سے زیادہ interesting ہے۔ Minsky اور Papert کی primary interest یہ نہیں تھی کہ single perceptron XOR کر سکتا ہے یا نہیں؛ وہ اس میں interested تھے کہ جب perceptrons کو limited receptive fields دیے جائیں — یعنی ہر unit input کا صرف ایک حصہ دیکھے — تو کیا ہوتا ہے، اور انہوں نے prove کیا کہ image کی بعض global properties، مثلاً کوئی figure connected ہے یا نہیں، اس طرح compute نہیں کی جا سکتیں خواہ آپ کتنی ہی units استعمال کریں۔ یہ locality کے بارے میں genuinely deep result ہے، اور popular story سے اس کا کوئی تعلق نہیں۔

Popular story history پر بھی wrong ہے۔ Minsky اور Papert explicitly multi-layer perceptrons discuss کرتے ہیں اور کہتے ہیں کہ ان کی power کا سوال open ہے — انہیں شک تھا کہ theory کو extend کرنا “sterile” ہو گا، جو prediction ہے، proof نہیں، اور وہ wrong نکلی۔ 1969 میں missing چیز layers کو stack کرنے کا idea نہیں تھا؛ missing چیز stack کو train کرنے کا طریقہ تھا۔ perceptron rule یہ نہیں کر سکتا: اسے جاننا ہوتا ہے کہ ہر unit کتنی wrong ہے، اور middle میں دفن unit کے لیے compare کرنے کو کوئی label نہیں ہوتا۔ یہ gap 1986 میں backpropagation کے popularise ہونے تک open رہا،³ اور اسے close کرنا Chapter 5 کا کام ہے۔

تو honest summary یہ ہے۔ Book نے real model کی real limitation prove کی۔ ستر کی دہائی میں field کی funding collapse کے کئی causes تھے، جن میں سے ایک یہ تھا کہ early sixties میں perceptrons کے لیے کیے گئے promises extravagant تھے۔ اور technical obstacle solvable تھا، مگر کسی کے پاس tool ابھی نہیں تھا۔

perceptron اڑسٹھ سال پرانا ہے اور آپ نے ابھی ایک لکھا ہے۔ یہ precise ہونا مفید ہے کہ اس کے کون سے parts ابھی بھی اس machine میں موجود ہیں جس کے ساتھ آپ یہ course finish کریں گے، کیونکہ answer ہے: آپ کے اندازے سے زیادہ۔

perceptron ایک ساتھ دو چیزوں پر stuck ہوا، اور آخر میں وہ دونوں ایک ہی چیز نکلتی ہیں۔

یہ XOR کو represent نہیں کر سکتا، کیونکہ ایک line کافی نہیں۔ اسے fix کرنے کا مطلب layers stack کرنا ہے — پہلی layer space کو bend کرتی ہے، دوسری bent space میں line draw کرتی ہے۔ یہ Chapter 5 ہے۔

مگر آپ perceptron rule سے stack train نہیں کر سکتے، کیونکہ یہ صرف «wrong» جانتا ہے، اور network کے middle میں موجود unit کے پاس اپنی کوئی label نہیں ہوتی جس کے بارے میں وہ wrong ہو۔ stack train کرنے کے لیے آپ کو ہر weight کے لیے جاننا ہوتا ہے کہ how wrong، اور کس direction میں — آپ کو slope چاہیے۔ اور perceptron کی error function، staircase، کے پاس slope نہیں۔

لہٰذا stack سے پہلے ایسی loss function ہونی چاہیے جس کا usable derivative ہو۔ وہ بھی ایسی نہیں جو صرف اس لیے choose کی گئی ہو کہ اسے differentiate کرنا convenient ہے: ایسی جو کہیں سے آتی ہو، data کے بارے میں کچھ true کہتی ہو، اور جس کا gradient اسی meaning سے نکلتا ہو، tidy دکھنے کے لیے reverse-engineered نہ ہو۔

یہ Chapter 2 ہے، اور یہ ایک ایسا سوال پوچھ کر شروع ہوتا ہے جس کا answer perceptron کو کبھی نہیں دینا پڑا: «کیا یہ part good ہے؟» نہیں، بلکہ «اگر یہ truth ہے تو یہ readings کتنی likely ہیں؟»

اس chapter کے ساتھ یہ بھی پڑھنے کے قابل ہیں: Rosenblatt کا original paper، The Perceptron: A Probabilistic Model for Information Storage and Organization in the Brain (Psychological Review 65(6), 1958)، جو اپنی reputation سے زیادہ readable ہے؛ McCulloch اور Pitts، A Logical Calculus of the Ideas Immanent in Nervous Activity (Bulletin of Mathematical Biophysics 5, 1943)، وہ paper جس نے پہلی بار neuron کو weighted sum پر threshold کے طور پر model کیا؛ Hal Daumé III کے A Course in Machine Learning کا perceptron section، جو اسی update کو different emphasis کے ساتھ derive کرتا ہے؛ اور linear algebra کے لیے Deisenroth، Faisal اور Ong کی Mathematics for Machine Learning کے chapters 2 اور 3، اگر اوپر کے box نے آپ کو اس سے زیادہ چاہنے پر چھوڑ دیا جو اس نے دیا۔