Perceptron शुरुआत से: एक neuron क्या compute करता है

एक perceptron measurements लेता है, हर measurement को अपने control वाले एक number से multiply करता है, उन्हें जोड़ता है, एक और number जोड़ता है, और 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 पर ठहरना ज़रूरी है, क्योंकि यही वह picture है जो अगले उनतीस chapters तक काम करती रहती है, तब भी जब equations एक line में फिट होना बंद कर देती हैं। उन points का set जहाँ $s(\mathbf{x}) = 0$ — जहाँ perceptron बिल्कुल undecided है — plane में एक straight line है। एक तरफ score positive है और सब accept होता है; दूसरी तरफ negative है और सब reject होता है। perceptron के लिए learning का मतलब है उस line को हिलाना।

उस line के बारे में दो facts सीधे algebra से निकलते हैं, और दोनों आगे matter करेंगे:

• $\mathbf{w}$ उसके perpendicular है। weight vector boundary के along नहीं होता, वह उसके across point करता है, accepted side की ओर।
• $b$ उसे बिना घुमाए 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।

अगर answer yes है, कुछ न बदलें। अगर answer no है, nudge करें:

यही पूरा algorithm है, और इसे memorise करने के बजाय यह समझना ज़रूरी है कि यही सही nudge क्यों है। मान लें किसी part को accept होना चाहिए था ($y = +1$) और score negative निकला। $\mathbf{w}$ में $\mathbf{x}$ add करने से उसी part पर score बदलता है

जो positive number है। जिस part पर अभी गलती हुई थी, उसका score ऊपर जाता है, और उसे इसी direction में जाना था। यह rule कोई guessed heuristic नहीं है; यह सबसे छोटा change है जो सामने वाले case को provably improve करता है। बेशक यह किसी दूसरे case को तोड़ सकता है, इसलिए आप फिर से round लगाते हैं।

ध्यान दें क्या absent है। कहीं कोई derivative नहीं है। यह oversight नहीं है, और यही course का पहला सच में important idea है।

जिस चीज़ को आप differentiate करना चाहेंगे वह error है — misclassified parts की count। लेकिन वह count staircase है: line को nudge करते हुए यह 4 पर flat बैठी रहती है, फिर जैसे ही line किसी point को cross करती है, instantly 3 पर गिरती है। उसका derivative लगभग हर जगह zero है और steps पर undefined। Calculus के पास पकड़ने को कुछ नहीं। perceptron rule इसके around काम करता है, slope पूछता ही नहीं: यह सिर्फ पूछता है "right or wrong?", और ऐसी direction में move करता है जिसे geometrically justify कर सकता है।

यह genuine solution है, और dead end भी है। Chapter 2 में हमें ऐसा loss चाहिए होगा जो कहीं से आए, बस चुना न गया हो; Chapter 4 में ऐसा model जो बताए कि वह कितना sure है; और Chapter 5 में एक से ज़्यादा layer वाली चीज़ — और इनमें से कोई भी ऐसे rule से reachable नहीं है जो सिर्फ "wrong" जानता हो। usable slope वापस पाना ही अगले दो chapters को force करता है। लेकिन perceptron वह काम कर सकता है जो उसके successors में से कोई नहीं कर सकता: बिना calculus के सीखना।

Pure Python, NumPy नहीं। Lists और एक loop। NumPy अगले chapter में आएगा, जहाँ arithmetic उस loop में फिट होना बंद कर देता है जिसे आप पढ़ना चाहेंगे; उसे अभी introduce करना arithmetic को library के पीछे छिपा देगा, ठीक उस moment पर जब आप उसे देखना चाहते हैं।

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 के साथ — चार जो 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 गलत है। कुछ गलत है — सिवाय इसके कि कुछ भी गलत नहीं है, और इसका reason इस chapter की सबसे useful चीज़ है।

perceptron के पास guarantee है, जिसे Novikoff ने 1962 में prove किया था।¹ अगर data को किसी line से separate किया जा सकता है, तो algorithm stop होने से पहले अधिकतम

corrections करता है — जहाँ $R$ data का radius है, सबसे लंबे 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 से सीधे मापकर, bias को constant feature के रूप में fold करके:

theorem कभी violate नहीं हुआ। raw version को काफी देर चलाएँ और यह converge करता है — epoch 11,976 पर, 29,870 corrections के बाद — अपने 2,633,550 के bound के आराम से अंदर, और वह gap खुद point है: theorem worst case bound करता है, typical one नहीं। इसे बस उन epochs से साठ गुना ज़्यादा चाहिए थे जितने कोई बैठकर देखेगा।

दूसरी row वही आठ parts हैं, वही बीस lines का code, बस हर measurement से mean width और mean weight subtract करने के लिए तीन lines जोड़ी गई हैं। बस इतना। पूरा change यही है। यह points के cloud को move करता है ताकि वह (22, 57) पर float करने के बजाय origin को straddle करे, और bound पर असर पंद्रह हजार के factor का है, क्योंकि दोनों terms एक साथ improve होते हैं: $R$ 74 से 13 पर गिरता है क्योंकि points अब दूर के origin से measured नहीं हैं, और $\gamma$ 0.045 से 0.989 पर उठता है क्योंकि margin ऐसे weight vector के against measure होता है जिसे 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 हुआ, और इसने खुद को ठीक एक बार किया।

यहाँ असली lesson है और वह "अपने inputs normalise करना याद रखें" नहीं है, हालांकि आपको करना चाहिए। lesson यह है कि किसी algorithm के finish होने की guarantee आपको इस बारे में कुछ नहीं बताती कि उसके finish होने पर आप वहाँ होंगे या नहीं, और दोनों के बीच का gap आम तौर पर geometry होता है। यह उस pattern की पहली appearance है जिसे आप Chapter 6 में initialisation के साथ, Chapter 10 में learning-rate schedules के साथ, और Chapter 13 में quantisation के साथ फिर मिलेंगे: mathematics कहता है कि चीज़ possible है, और engineering तय करती है कि यह practical है या नहीं। जो course आपको सिर्फ theorem सिखाता है, वह आपको ऐसा model थमा देता है जो तीन days train करता है और blame आप पर डालता है।

अब वह failure जिसने neural networks के पहले era को खत्म किया, और यह चार rows में फिट हो जाता है।

factory को भूल जाएँ। दो inputs लें जो हर एक 0 या 1 हो सकते हैं, और answer को $+1$ होने को कहें जब उनमें से ठीक एक 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।

आप नहीं कर सकते। बात यह नहीं कि यह कठिन है, या आपको cleverer algorithm चाहिए; बात यह है कि line exists ही नहीं करती। तीन lines का algebra बताता है क्यों। अगर perceptron ने चारों को सही किया, तो चार rows को क्रम से पढ़ने पर मिलता है

बीच की दो inequalities add करें: $w_1 + w_2 + 2b \geq 0$, इसलिए $w_1 + w_2 \geq -2b$। आखिरी one कहता है $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 होते देखना सिर्फ यह सुनने से ज़्यादा valuable है कि वह 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 चलता है और जहाँ से शुरू हुआ था वहीं लौट आता है, हमेशा के लिए, चार में से दो सही करता हुआ — जो guessing से भी मिल जाता। एक hundred thousand epochs और एक hundred indistinguishable हैं, क्योंकि algorithm ऐसी progress नहीं कर रहा जिसे longer run finish कर सके। इसकी तुलना belt से करें, जो 200 epochs पर stuck दिखता था और असल में real answer की ओर grind कर रहा था। बाहर से पहले कुछ seconds तक दोनों similar दिखते हैं। theorem के बिना उन्हें अलग बताना impossible है — और यह theorem जानने के पक्ष में एक और argument है।

1969 में Marvin Minsky और Seymour Papert ने Perceptrons publish की, एक book-length mathematical study कि यह model exactly क्या represent कर सकता है और क्या नहीं।² XOR इसका सबसे ज़्यादा quoted result है, और quotation आम तौर पर accusation की तरह deploy होती है: कि book ने rivalry या spite के कारण neural network research को पंद्रह साल के लिए मार दिया।

book में mathematics correct है, और XOR example से ज़्यादा interesting है। Minsky और Papert primarily इस बात में interested नहीं थे कि single perceptron XOR कर सकता है या नहीं; वे यह समझना चाहते थे कि क्या होता है जब perceptrons को limited receptive fields दिए जाते हैं — हर unit input का सिर्फ हिस्सा देखता है — और उन्होंने prove किया कि image की कुछ global properties, जैसे कोई figure connected है या नहीं, इस तरह compute नहीं की जा सकतीं, चाहे आप कितने भी units use करें। यह locality के बारे में genuinely deep result है, और popular story से इसका कोई लेना-देना नहीं।

popular story history पर भी wrong है। Minsky और Papert explicitly multi-layer perceptrons discuss करते हैं और कहते हैं कि उनकी power का सवाल open है — उन्हें suspicion था कि theory को extend करना "sterile" होगा, जो prediction है, proof नहीं, और वह wrong था। 1969 में missing चीज़ layers stack करने का idea नहीं था; missing था stack को train करने का तरीका। perceptron rule यह नहीं कर सकता: उसे जानना होता है कि हर unit कितना wrong है, और middle में buried unit के लिए compare करने को कोई label नहीं होता। यह gap तब तक open रहा जब तक 1986 में backpropagation popularised नहीं हुआ,³ और इसे close करना ही Chapter 5 करता है।

तो honest summary यह है। book ने real model की real limitation prove की। seventies में field की funding collapse के कई causes थे, जिनमें से एक यह था कि early sixties में perceptrons के लिए किए गए promises extravagant थे। और technical obstacle solvable था, लेकिन tool अभी किसी के पास नहीं था।

perceptron अड़सठ साल पुराना है और आपने अभी एक लिखा है। यह precise होना worth है कि इसके कौन-से parts अब भी उस machine में हैं जिसे आप इस course के अंत तक finish करेंगे, क्योंकि answer है: आपके अनुमान से ज़्यादा।

perceptron एक साथ दो चीज़ों पर stuck हुआ, और वे असल में एक ही चीज़ निकलती हैं।

यह XOR represent नहीं कर सकता, क्योंकि एक line पर्याप्त नहीं है। इसे fix करने का मतलब है layers stack करना — first layer जो space को bend करती है, second जो bent space में line draw करती है। वही Chapter 5 है।

लेकिन आप perceptron rule से stack train नहीं कर सकते, क्योंकि वह सिर्फ "wrong" जानता है, और network के middle में unit के पास wrong होने के लिए अपना कोई label नहीं है। stack train करने के लिए आपको हर weight के लिए जानना होगा कि कितना wrong, और किस direction में — आपको slope चाहिए। और perceptron का error function, staircase, slope रखता ही नहीं।

इसलिए stack से पहले usable derivative वाला loss function होना चाहिए। ऐसा भी नहीं जो इसलिए चुना गया हो क्योंकि उसे differentiate करना convenient है: ऐसा जो कहीं से आए, data के बारे में कुछ true कहे, और जिसका gradient उस meaning से निकले, न कि tidy दिखने के लिए reverse-engineer किया गया हो।

वही Chapter 2 है, और यह एक ऐसे सवाल से शुरू होता है जिसका answer perceptron को कभी देना नहीं पड़ा: "क्या यह part अच्छा है?" नहीं, बल्कि "अगर यही 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, जो same update को different emphasis के साथ derive करता है; और linear algebra के लिए Deisenroth, Faisal और Ong के Mathematics for Machine Learning के chapters 2 और 3, अगर ऊपर वाले box ने आपको जितना दिया उससे ज़्यादा चाहिए।