दिमाग और AIमध्यमपाठ 2995 मिनट का पाठ

स्पाइकिंग न्यूरॉन्स बनाम आर्टिफ़िशियल न्यूरॉन्स

असली न्यूरॉन्स समय के साथ छोटे-छोटे इलेक्ट्रिकल स्पाइक्स (झटकों) में बात करते हैं। ज़्यादातर AI मॉडल्स के न्यूरॉन्स सीधे-सादे नंबर्स पास करते हैं। एक साधारण स्पाइकिंग न्यूरॉन बनाएं और दोनों का फ़र्क देखें।

✦ ट्यूटर से पूछें 🧪 लैब · 25 min 📝 पाठ का टेस्ट

स्पीड

पाठ वीडियो में

60 सेकंड में

स्पाइकिंग न्यूरॉन्स बनाम आर्टिफ़िशियल न्यूरॉन्स

असली न्यूरॉन्स समय के साथ छोटे-छोटे इलेक्ट्रिकल स्पाइक्स (झटकों) में बात करते हैं। ज़्यादातर AI मॉडल्स के न्यूरॉन्स सीधे-सादे नंबर्स पास करते हैं। एक साधारण स्पाइकिंग न्यूरॉन…

1/3

आसान शब्दों में

कल्पना कीजिए कि नीचे एक छोटे छेद वाली एक बाल्टी है। लोग उसमें पानी डालते हैं। पानी धीरे-धीरे बाहर रिसता रहता है। अगर वे काफ़ी तेज़ी से पानी डालें, तो बाल्टी ऊपर तक भर जाती है और छलक कर गिर जाती है, फिर से खाली हो जाती है। एक असली न्यूरॉन कुछ-कुछ उस बाल्टी की तरह काम करता है: यह इनपुट इकट्ठा करता है, कुछ रिसने देता है, और भर जाने पर एक स्पाइक के साथ "छलक" पड़ता है। एक AI न्यूरॉन कैलकुलेटर की तरह ज़्यादा होता है: नंबर्स अंदर जाते हैं, और हर बार एक नंबर बाहर निकलता है।

आर्टिफ़िशियल न्यूरॉन

ज़्यादातर AI मॉडल्स में एक आर्टिफ़िशियल न्यूरॉन कुछ इनपुट नंबर्स लेता है, हर एक को एक वेट (weight) से गुणा करता है, उन्हें जोड़ता है, और कुल योग को एक साधारण फ़ंक्शन से गुज़ारता है, जैसे "अगर पॉज़िटिव है तो रख लो, नहीं तो शून्य कर दो"। आउटपुट एक नंबर होता है। पूरा नेटवर्क हर न्यूरॉन के लिए, हर इनपुट के लिए, यह सब एक साथ करता है।

Python: one artificial neuronpython

import numpy as np

x = np.array([0.5, 0.2, 0.9])      # inputs
w = np.array([0.8, -0.4, 0.3])     # weights (learned in training)
b = 0.1                            # bias
total = x @ w + b
output = max(0.0, total)           # "ReLU": keep positive values
print("total =", round(total, 3), "-> output =", round(output, 3))

स्पाइकिंग न्यूरॉन

एक असली न्यूरॉन की बाहरी परत, यानी सेल मेम्ब्रेन पर एक वोल्टेज होता है। इनपुट्स इस वोल्टेज को ऊपर या नीचे धकेलते हैं। बिना इनपुट के यह वापस अपने रेस्टिंग लेवल (आराम की स्थिति) पर आ जाता है। जब यह एक थ्रेशोल्ड (सीमा) को पार करता है, तो न्यूरॉन एक छोटा इलेक्ट्रिकल पल्स छोड़ता है जिसे स्पाइक कहते हैं, और वोल्टेज रीसेट हो जाता है। जानकारी इस बात में होती है कि स्पाइक कब आते हैं और कितनी बार आते हैं।

एक लोकप्रिय और सरल मॉडल है लीकी इंटीग्रेट-एंड-फ़ायर (LIF) न्यूरॉन:

इंटीग्रेट: समय के साथ इनपुट को जोड़ते जाना, जैसे बाल्टी में पानी भरना।
लीकी: वोल्टेज धीरे-धीरे वापस रेस्टिंग लेवल पर आ जाता है, जैसे बाल्टी का छेद।
फ़ायर: जब वोल्टेज थ्रेशोल्ड तक पहुँच जाए, तो एक स्पाइक रिकॉर्ड करें और रीसेट कर दें।

नोट

LIF न्यूरॉन असली न्यूरॉन का एक बहुत ही सरलीकृत रूप है, लेकिन यह समय के साथ स्पाइक्स के मुख्य विचार को अच्छी तरह दिखाता है। पाठ 3 में मक्खी के पूरे दिमाग वाले मॉडल में इसी तरह के सरल स्पाइकिंग न्यूरॉन्स का इस्तेमाल किया गया था।

आमने-सामने तुलना

	आर्टिफ़िशियल न्यूरॉन (ज़्यादातर AI)	स्पाइकिंग न्यूरॉन (दिमाग, LIF मॉडल)
आउटपुट	हर बार एक नंबर	खास पलों में स्पाइक्स, अक्सर कुछ भी नहीं
समय (Time)	आमतौर पर समय की कोई इनबिल्ट समझ नहीं	समय के साथ वोल्टेज बदलता है; टाइमिंग मायने रखती है
गतिविधि (Activity)	हर इनपुट के लिए हर न्यूरॉन गणना करता है	ज़्यादातर न्यूरॉन्स ज़्यादातर समय शांत रहते हैं
सीखना (Learning)	वेट्स को बैकप्रोपैगेशन से ट्रेन किया जाता है	दिमाग सिनेप्सेस को कई तरीकों से बदलता है, जिन पर अभी भी अध्ययन जारी है
हार्डवेयर	GPUs पर बहुत अच्छा चलता है	इवेंट-ड्रिवन न्यूरोमॉर्फिक चिप्स के लिए उपयुक्त (पाठ 7)

एक अहम व्यवहार: फ़ायरिंग थ्रेशोल्ड

किसी LIF न्यूरॉन को एक छोटा, स्थिर इनपुट दें तो उसका वोल्टेज बढ़ता है, फिर थ्रेशोल्ड से नीचे ही थम जाता है। यह कभी फ़ायर नहीं करता। उसे एक बड़ा इनपुट दें और वह बार-बार फ़ायर करता है। इनपुट जितना बड़ा होगा, वह उतनी ही तेज़ी से फ़ायर करेगा। इस तरह एक स्थिर इनपुट की ताक़त एक फ़ायरिंग रेट बन जाती है। आप इसे लैब में खुद देखेंगे।

असली उदाहरण

प्रेशर कुकर के बारे में सोचें। आँच से प्रेशर बनता है; थोड़ी भाप रिसती रहती है। धीमी आँच पर सीटी कभी नहीं बजती। तेज़ आँच पर सीटी बजती है, प्रेशर घटता है, फिर बनता है, और फिर सीटी बजती है। आँच और तेज़ कर दें तो सीटियाँ और जल्दी-जल्दी बजेंगी। यही है आपकी रसोई में मौजूद एक लीकी इंटीग्रेट-एंड-फ़ायर न्यूरॉन।

सोचिए। एक आर्टिफ़िशियल न्यूरॉन हर इनपुट के लिए एक आउटपुट देता है। एक स्पाइकिंग न्यूरॉन अक्सर कुछ भी नहीं देता। "ज़्यादातर समय कुछ न देना" ऊर्जा बचाने के लिए एक बड़ा फ़ायदा क्यों हो सकता है? पाठ 6 में इसका जवाब है।

और देखें और पढ़ें

लैब

Numpy में एक काम करने वाला लीकी इंटीग्रेट-एंड-फ़ायर न्यूरॉन, इसका फ़ायरिंग थ्रेशोल्ड व्यवहार, और सबसे छोटा स्थिर इनपुट जिससे यह स्पाइक करता है।

~25 min

समस्या

यह आपके ब्राउज़र में चलता है।

स्टार्टर कोड चलाएं। यह एक स्थिर इनपुट I (मिलीवोल्ट में) के साथ एक न्यूरॉन के वोल्टेज को सिमुलेट करता है, लेकिन "fire" वाला हिस्सा गायब है, इसलिए यह कभी स्पाइक नहीं करता।
simulate_lif में, फ़ायर का नियम जोड़ें: जब V >= V_TH हो, तो spikes में समय रिकॉर्ड करें और V को V_RESET पर रीसेट कर दें।
इसे 10, 20 और 40 के इनपुट्स के लिए चलाएं। ध्यान दें कि 200 ms में हर एक कितने स्पाइक्स देता है।
सबसे छोटा स्थिर इनपुट (लगभग 0.5 तक) खोजें जिससे कम से कम एक स्पाइक मिले, और इसे rheobase में स्टोर करें। आप लूप का इस्तेमाल करके खोज सकते हैं।
एक वाक्य लिखकर बताएं कि इनपुट 10 कोई स्पाइक क्यों नहीं देता।

प्रैक्टिस लैब

कोड में बदलाव करें और इसे रन करें। Python आपके ब्राउज़र में चलता है — हमारे सर्वर पर कुछ नहीं भेजा जाता।

रन करने के लिए Ctrl + Enter दबाएं

import numpy as np
import matplotlib.pyplot as plt

# Leaky integrate-and-fire neuron. Textbook-style values, for learning only.
TAU = 20.0       # ms, how fast the voltage leaks back to rest
V_REST = -70.0   # mV
V_TH = -55.0     # mV, firing threshold
V_RESET = -70.0  # mV, voltage right after a spike
DT = 0.1         # ms, time step

def simulate_lif(I, T=200.0):
    """Steady input I (mV). Returns (spike_times, voltages)."""
    V, spikes, trace = V_REST, [], []
    for k in range(int(T / DT)):
        V += DT / TAU * (-(V - V_REST) + I)   # leak + integrate
        # TODO: fire! if V has reached V_TH: record the time k*DT, reset V
        trace.append(V)
    return spikes, np.array(trace)

for I in (10, 20, 40):
    spikes, trace = simulate_lif(I)
    print(f"input {I:>2} mV -> {len(spikes)} spikes in 200 ms")
    plt.plot(np.arange(len(trace)) * DT, trace, label=f"I = {I}")
plt.axhline(V_TH, linestyle="--", color="gray")
plt.xlabel("time (ms)"); plt.ylabel("voltage (mV)"); plt.legend(); plt.show()

rheobase = None   # TODO: smallest steady input that gives at least one spike
print("Smallest input that spikes:", rheobase)

आउटपुट

कोई आउटपुट नहीं। वैल्यूज़ देखने के लिए print(...) जोड़ें।

आपका काम तब पूरा होगा जब

फ़ायर नियम स्पाइक का समय रिकॉर्ड करता है और वोल्टेज को रीसेट करता है
इनपुट 10 कोई स्पाइक नहीं देता; 20 कुछ स्पाइक्स देता है; 40 बहुत ज़्यादा स्पाइक्स देता है
rheobase उस मान के करीब मिलता है जहाँ रेस्टिंग वोल्टेज और इनपुट मिलकर थ्रेशोल्ड तक पहुँच जाते हैं
वाक्य समझाता है कि लीक थ्रेशोल्ड से नीचे छोटे इनपुट्स को संतुलित कर देता है

कठिन सवाल

उत्तर देखने से पहले ख़ुद जवाब देने की कोशिश करें। अगर आप इनके जवाब दे सकते हैं, तो आप पाठ समझ गए हैं।

Q1इस मॉडल में स्पाइक देने वाला सबसे छोटा इनपुट 15 के करीब क्यों है? नंबर्स का इस्तेमाल करके बताएं।दिखाएं

एक स्थिर इनपुट I के साथ, वोल्टेज वहाँ ठहरता है जहाँ लीक इनपुट को बेअसर कर देता है: V_REST + I पर। न्यूरॉन तभी फ़ायर कर सकता है जब वह लेवल थ्रेशोल्ड तक पहुँचे, यानी -70 + I >= -55, जिससे मिलता है I >= 15। 15 से ज़रा सा ऊपर होने पर वहाँ पहुँचने में काफ़ी समय लगता है, इसलिए 200 ms के रन में स्पाइक देने वाला सबसे छोटा इनपुट 15 से ज़रा सा ऊपर होता है।

Q2असली न्यूरॉन्स एक स्पाइक के तुरंत बाद दोबारा फ़ायर नहीं कर सकते। आप मॉडल में इस "रिफ्रैक्टरी पीरियड" को कैसे जोड़ेंगे, और इससे क्या बदलेगा?दिखाएं

एक काउंटर रखें: हर स्पाइक के बाद, V को V_RESET पर बनाए रखें और दोबारा इंटीग्रेट करने से पहले कुछ मिलीसेकंड तक इनपुट को नज़रअंदाज़ करें। इससे फ़ायरिंग रेट की एक ऊपरी सीमा तय हो जाती है: बहुत बड़ा इनपुट भी न्यूरॉन को हर रिफ्रैक्टरी पीरियड और थ्रेशोल्ड तक पहुँचने में लगे समय से ज़्यादा तेज़ी से फ़ायर नहीं करवा सकता। इसके बिना, LIF मॉडल बहुत बड़े इनपुट्स के लिए अवास्तविक रूप से तेज़ फ़ायर कर सकता है।

जारी रखने के लिए कृपया साइन इन करें।

अक्सर पूछे जाने वाले सवाल

क्या आर्टिफ़िशियल न्यूरॉन्स की नक़ल असली न्यूरॉन्स से की गई थी?

वे कई दशक पहले असली न्यूरॉन्स से प्रेरित हुए थे, लेकिन वे बहुत ज़्यादा सरल हैं। आधुनिक AI मॉडल्स बायोलॉजी के मुकाबले गणित और कंप्यूटर हार्डवेयर से कहीं ज़्यादा प्रभावित हैं।

क्या स्पाइकिंग नेटवर्क्स सामान्य AI नेटवर्क्स की तरह सीख सकते हैं?

शोधकर्ता स्पाइकिंग नेटवर्क्स को कई तरीकों से ट्रेन करते हैं, जिनमें सामान्य नेटवर्क्स के तरीकों के अनुकूलित रूप भी शामिल हैं। यह एक सक्रिय रिसर्च क्षेत्र है, और स्पाइकिंग नेटवर्क्स को ट्रेन करना आज आमतौर पर ज़्यादा मुश्किल है।

क्या असली न्यूरॉन्स सचमुच LIF मॉडल की तरह ही काम करते हैं?

यह मुख्य विचार को पकड़ता है, लेकिन असली न्यूरॉन्स कहीं अधिक जटिल होते हैं। उनमें इनपुट प्रोसेस करने वाली शाखाएं होती हैं, कई तरह के आयन चैनल्स होते हैं, और कई प्रकार के सिनेप्सेस होते हैं। वैज्ञानिक अपने सवाल के हिसाब से सरल या विस्तृत मॉडल चुनते हैं।

लैब में नंबर्स की यूनिट्स (इकाइयां) क्या हैं?

वोल्टेज मिलीवोल्ट में है और समय मिलीसेकंड में, जिनके मान आम टेक्स्टबुक रेंज में हैं। गणित को सरल रखने के लिए इनपुट सीधे मिलीवोल्ट में लिखा गया है। यह सिखाने के लिए बनाया गया मॉडल है, किसी असली न्यूरॉन का माप नहीं।

पाठ का टेस्ट

5 सवाल। पास होने और इस पाठ को पूरा करने के लिए 3 सही होने चाहिए (60%)।

टेस्ट देने और अपनी प्रोग्रेस सेव करने के लिए साइन इन करें