CodeUtility
कोडिंग को डेवलपर्स के लिए आसान बनाना।!
Python में AI की अवधारणाएँ

Python में न्यूरॉन और एक्टिवेशन फ़ंक्शन

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

आसान शब्दों में अवधारणा

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

शुद्ध Python में एक कृत्रिम न्यूरॉन बनाएँ: इनपुट का भारित योग और बायस, जिसे sigmoid या ReLU से गुज़ारा जाता है।

मुख्य बातें

  • वेट बताते हैं कि हर इनपुट कितना ज़रूरी है; बायस नतीजे को ऊपर या नीचे खिसकाता है।
  • एक्टिवेशन के बिना, कई न्यूरॉन जोड़ने पर भी सिर्फ़ एक रैखिक (सीधी रेखा वाला) मॉडल बनता है।
  • sigmoid 0 और 1 के बीच मान देता है, इसलिए यह प्रायिकता के लिए सही है।
  • ReLU तेज़ है और आधुनिक नेटवर्क की हिडन लेयर में आम तौर पर यही चुना जाता है।

इसका उपयोग कब करें?

  • समझें कि न्यूरल नेटवर्क और AI लाइब्रेरी के अंदर क्या होता है।
  • संबंधित चुनौतियों में खुद लागू करने से पहले विचार को समझें।
  • मशीन लर्निंग कोर्स, इंटरव्यू और प्रोजेक्ट की तैयारी करें।

इसे काम करते देखें

इनपुट, वेट और बायस बदलने के लिए स्लाइडर खिसकाएँ। देखें कि भारित योग z, sigmoid और ReLU वक्रों पर कैसे चलता है।

उदाहरण कोड

कोड चलाएँ →
main.py
import math

# A neuron multiplies each input by a weight, adds them up and adds a bias.
def dot(a, b):
    return sum(x * y for x, y in zip(a, b))

def sigmoid(z):
    return 1 / (1 + math.exp(-z))   # squashes any number into (0, 1)

def relu(z):
    return max(0.0, z)              # keeps positives, turns negatives into 0

inputs = [0.5, -1.0, 2.0]
weights = [0.8, 0.2, -0.5]
bias = 0.1

z = dot(inputs, weights) + bias      # weighted sum
print("weighted sum z =", round(z, 3))
print("sigmoid(z) =", round(sigmoid(z), 3))
print("relu(z) =", relu(z))

# The activation decides how strongly the neuron "fires".
for value in [-2, 0, 2]:
    print(f"z={value:>2}  sigmoid={sigmoid(value):.3f}  relu={relu(value)}")

अपेक्षित आउटपुट

weighted sum z = -0.7
sigmoid(z) = 0.332
relu(z) = 0.0
z=-2  sigmoid=0.119  relu=0.0
z= 0  sigmoid=0.500  relu=0.0
z= 2  sigmoid=0.881  relu=2

यह कैसे काम करता है

dot() भारित योग z निकालता है। sigmoid, z को 0 और 1 के बीच दबा देता है, जबकि ReLU धनात्मक मान रखता है और ऋणात्मक मानों को 0 कर देता है। लूप दिखाता है कि हर एक्टिवेशन ऋणात्मक, शून्य और धनात्मक इनपुट पर कैसी प्रतिक्रिया देता है।

मान बदलें और Python इंस्टॉल किए बिना CodeUtility ऑनलाइन Python कंपाइलर में प्रोग्राम चलाएँ।

अभ्यास के कार्य

बड़े dataset पर जाने से पहले input बदलें और edge cases की जाँच करें।

  1. इनपुट या वेट बदलें और रन करने से पहले आउटपुट का अनुमान लगाएँ।
  2. हर गणना चरण को देखने के लिए बीच के मान प्रिंट करें।
  3. नीचे दी गई चुनौतियाँ हल करके विचार को खुद लागू करें।
Python IDE में चलाएँ →

चैलेंज से अभ्यास करें

इस पाठ में सीखी बात से एक असली समस्या हल करें। हर चैलेंज ब्राउज़र में चलता है, तुरंत टेस्ट और AI रिव्यू के साथ।

सभी चैलेंज