Neural Network क्या है? Python और NumPy से Scratch से Neural Network बनाने की पूरी कहानी
आज के समय में Artificial Intelligence और Machine Learning की चर्चा लगभग हर जगह हो रही है। हम ऐसे AI tools इस्तेमाल कर रहे हैं जो तस्वीर पहचान सकते हैं, आवाज समझ सकते हैं, टेक्स्ट लिख सकते हैं और यहां तक कि हाथ से लिखे हुए नंबरों को भी पहचान सकते हैं। लेकिन क्या आपने कभी सोचा है कि आखिर एक Neural Network इन कामों को करता कैसे है?
Neural Network को समझने का सबसे अच्छा तरीका केवल किसी ready-made Machine Learning library का इस्तेमाल करना नहीं, बल्कि इसके पीछे की basic mathematics और logic को खुद समझना है। इसी approach में हम एक Neural Network को बिल्कुल शुरुआत से समझ सकते हैं—एक छोटे neuron से लेकर कई layers वाले network तक और फिर उसे वास्तव में data से सीखने के लिए train कर सकते हैं।
इस लेख में हम इसी पूरी प्रक्रिया को आसान हिंदी में समझेंगे। इसमें किसी complicated framework पर निर्भर होने के बजाय Python, NumPy और थोड़ी-सी mathematics की मदद से Neural Network के fundamental concepts को समझेंगे।
Neural Network आखिर होता क्या है?
सबसे आसान भाषा में कहें तो Neural Network एक mathematical model है, जो input data से patterns सीखने की कोशिश करता है।
मान लीजिए हमारे पास किसी image के pixels हैं और हमें पता लगाना है कि image में लिखा हुआ नंबर 5 है या 8। Computer के लिए image सिर्फ pixels की values होती हैं। Neural Network इन values के बीच मौजूद patterns को सीखता है और training के बाद नई image देखकर prediction करने की कोशिश करता है।
एक Neural Network कई छोटे computational units से मिलकर बना होता है, जिन्हें आमतौर पर neurons कहा जाता है।
हर neuron कुछ inputs लेता है, उन inputs को अलग-अलग importance देता है और फिर एक output तैयार करता है।
यही छोटी-सी प्रक्रिया आगे चलकर एक बड़े Neural Network का आधार बनती है।
सबसे पहले समझिए एक Neuron
मान लीजिए हमारे पास एक neuron है और उसके पास तीन inputs हैं:
Input 1
Input 2
Input 3
हर input के साथ एक weight जुड़ा हुआ है।
उदाहरण के लिए:
Input 1 का weight = 0.2
Input 2 का weight = 0.7
Input 3 का weight = -0.4
Neuron इन inputs को उनके weights के साथ multiply करता है और फिर सभी values को जोड़ता है।
इसके अलावा इसमें एक bias भी शामिल होता है।
इसका basic formula कुछ इस तरह होता है:
Output = (Input × Weight) का योग + Bias
अगर तीन inputs हैं, तो:
z = x₁w₁ + x₂w₂ + x₃w₃ + b
यही एक neuron की fundamental calculation है।
यह सुनने में बहुत साधारण लगता है, लेकिन Neural Networks की पूरी दुनिया इसी तरह की calculations को बड़े scale पर इस्तेमाल करती है।
Weight और Bias की जरूरत क्यों होती है?
यहां सबसे महत्वपूर्ण सवाल आता है कि आखिर weight और bias करते क्या हैं?
Weight किसी input की importance को represent करता है।
अगर किसी connection का weight बड़ा है, तो उस input का output पर ज्यादा प्रभाव पड़ सकता है। अगर weight छोटा है, तो उसका प्रभाव कम हो सकता है।
Negative weight भी हो सकता है। इसका मतलब है कि input output को विपरीत दिशा में प्रभावित कर रहा है।
दूसरी तरफ bias neuron को calculation में एक additional adjustment देता है।
इस तरह Neural Network के लिए weights और biases ऐसे parameters हैं जिन्हें training के दौरान बदला जाता है।
यही बदलाव Neural Network को सीखने की क्षमता देता है।
कई Neurons मिलकर बनाते हैं Layer
एक neuron काफी सीमित काम कर सकता है।
अगर हमें complex problem solve करनी है तो हमें कई neurons की जरूरत पड़ती है।
जब कई neurons एक साथ रखे जाते हैं, तो एक layer बनती है।
एक सामान्य Neural Network में तीन तरह की layers देखने को मिलती हैं:
Input Layer
Hidden Layer
Output Layer
Input Layer data को network में प्रवेश कराती है।
Hidden Layers input data को process करती हैं।
Output Layer अंतिम prediction देती है।
अगर network में केवल एक hidden layer हो तो वह छोटा network हो सकता है। लेकिन modern Deep Learning models में सैकड़ों या हजारों layers और बहुत बड़ी संख्या में parameters हो सकते हैं।
Neurons आपस में कैसे जुड़ते हैं?
एक layer के neurons आमतौर पर अगली layer के neurons से जुड़े हो सकते हैं।
मान लीजिए पहली layer में 3 neurons हैं और दूसरी layer में 4 neurons।
तो पहली layer का प्रत्येक neuron अगली layer के कई neurons को information दे सकता है।
इसका मतलब है कि network को बहुत सारी छोटी-छोटी calculations करनी पड़ती हैं।
अगर हम हर connection को manually calculate करें तो code बहुत लंबा और मुश्किल हो जाएगा।
यहीं पर Linear Algebra हमारी मदद करती है।
Dot Product ने calculation आसान कर दी
Neural Network में बार-बार होने वाली weighted sum calculations को matrices और vectors की मदद से compact रूप में लिखा जा सकता है।
Python में NumPy का इस्तेमाल करके हम matrix multiplication या dot product जैसी operations बहुत आसानी से कर सकते हैं।
उदाहरण के लिए conceptually:
z = X · W + b
इस एक calculation के पीछे वास्तव में कई neurons और उनके connections की calculations छिपी होती हैं।
यही वजह है कि Neural Networks में Linear Algebra इतनी महत्वपूर्ण है।
NumPy जैसी library numerical calculations को efficient तरीके से perform करने में मदद करती है।
लेकिन केवल Linear Calculation काफी नहीं है
अब तक हमारा network केवल weighted sums calculate कर रहा है।
यहां एक महत्वपूर्ण समस्या है।
अगर Neural Network में केवल linear calculations हों, तो चाहे हम कितनी भी layers जोड़ दें, पूरा network अंततः एक बड़े linear function की तरह behave कर सकता है।
इससे network की learning capability काफी सीमित हो जाती है।
हम चाहते हैं कि Neural Network complex और non-linear patterns को भी समझ सके।
इसके लिए हमें Activation Functions की जरूरत होती है।
ReLU क्या है?
सबसे popular activation functions में से एक है ReLU, जिसका पूरा नाम है:
Rectified Linear Unit
इसका basic formula है:
ReLU(x) = max(0, x)
मतलब अगर value negative है तो ReLU उसे 0 कर देता है।
अगर value positive है तो वही value आगे भेज दी जाती है।
उदाहरण:
ReLU(-5) = 0
ReLU(-1) = 0
ReLU(3) = 3
ReLU(10) = 10
यह छोटा-सा function Neural Network में non-linearity introduce करता है।
इसकी वजह से network ज्यादा complex relationships और patterns सीख सकता है।
Activation Function क्यों जरूरी है?
मान लीजिए network में कई layers हैं:
Input → Layer 1 → Layer 2 → Layer 3 → Output
अगर प्रत्येक layer केवल linear operation करे, तो mathematically कई linear transformations को combine करने पर भी एक linear transformation ही प्राप्त किया जा सकता है।
इसलिए hidden layers में activation function जोड़ना महत्वपूर्ण है।
ReLU जैसे activation function network को complex decision boundaries और non-linear relationships सीखने की क्षमता देते हैं।
यही concept Deep Learning architectures की foundation का एक महत्वपूर्ण हिस्सा है।
Output को Probability में बदलने के लिए Softmax
अब मान लीजिए हमारा Neural Network handwritten digit पहचान रहा है।
Output में 10 classes हैं:
0, 1, 2, 3, 4, 5, 6, 7, 8 और 9।
Network raw numerical values produce कर सकता है। लेकिन हमें यह जानना है कि network प्रत्येक class के बारे में कितना confident है।
यहां Softmax उपयोगी होता है।
Softmax raw scores को probability distribution में बदल देता है।
उदाहरण के लिए output कुछ ऐसा हो सकता है:
0 → 0.01
1 → 0.02
2 → 0.03
3 → 0.01
4 → 0.02
5 → 0.05
6 → 0.01
7 → 0.02
8 → 0.82
9 → 0.01
इस स्थिति में network का सबसे मजबूत prediction 8 होगा।
ध्यान देने वाली बात यह है कि probability का अर्थ यह नहीं है कि model निश्चित रूप से सही है। यह केवल model की learned prediction distribution को दर्शाती है।
Random Weights से Network सही Prediction क्यों नहीं करता?
जब Neural Network पहली बार बनाया जाता है तो उसके weights और biases आमतौर पर उचित learned values नहीं होते।
इसलिए शुरुआती prediction लगभग random हो सकती है।
यह बिल्कुल स्वाभाविक है।
एक नए student की तरह सोचिए जिसने अभी कोई किताब पढ़ी ही नहीं है। उससे किसी कठिन सवाल का सही जवाब मिलने की उम्मीद नहीं की जा सकती।
Neural Network को भी पहले data से सीखना पड़ता है।
और यहीं से training की असली प्रक्रिया शुरू होती है।
Training से पहले Loss Function समझिए
अगर network prediction कर रहा है तो हमें यह जानने का तरीका चाहिए कि prediction कितनी गलत है।
इसके लिए Loss Function का उपयोग किया जाता है।
Classification problems में Cross-Entropy Loss बहुत commonly इस्तेमाल किया जाता है।
इसका उद्देश्य prediction और actual answer के बीच difference को quantify करना है।
अगर model सही class को high probability देता है, तो loss कम हो सकता है।
अगर model गलत class को बहुत ज्यादा probability देता है, तो loss ज्यादा हो सकता है।
सरल शब्दों में:
Loss हमें बताता है कि network अभी कितना गलत है।
अब हमें पता चल गया कि network कितना गलत है, लेकिन अगला सवाल है—गलती को ठीक कैसे करें?
Backpropagation: Neural Network का सीखने वाला हिस्सा
यहीं पर आता है Backpropagation।
Backpropagation Neural Network के training process का एक महत्वपूर्ण algorithmic concept है।
इसे आसान उदाहरण से समझते हैं।
कल्पना कीजिए कि कई chefs मिलकर एक dish बना रहे हैं।
हर chef किसी एक ingredient की मात्रा तय करता है।
Dish का स्वाद खराब हो गया।
अब हमें पता लगाना है कि किस chef के ingredient की मात्रा कितनी बदलनी चाहिए।
ठीक इसी तरह Neural Network में अलग-अलग weights output को प्रभावित करते हैं।
Loss Function हमें बताता है कि final prediction कितनी गलत है।
Backpropagation network में पीछे की ओर जाकर यह calculate करने में मदद करता है कि अलग-अलग parameters में बदलाव loss को किस दिशा में प्रभावित करेगा।
Derivatives की भूमिका
Backpropagation में derivatives महत्वपूर्ण भूमिका निभाते हैं।
Derivative हमें यह समझने में मदद करता है कि किसी variable में छोटा बदलाव output या loss को किस तरह प्रभावित करेगा।
Neural Network में हम gradients calculate करते हैं।
Gradient essentially parameters के संबंध में loss की sensitivity बताता है।
सरल रूप में:
Gradient = Loss किस दिशा में और कितना बदल रहा है
अगर हमें पता है कि किसी weight को बढ़ाने से loss बढ़ रहा है, तो हम उसे कम करने की दिशा में adjustment कर सकते हैं।
अगर किसी weight को बढ़ाने से loss कम हो रहा है, तो model उस दिशा में आगे बढ़ सकता है।
इसी feedback mechanism की वजह से Neural Network धीरे-धीरे बेहतर prediction करना सीखता है।
Forward Pass और Backward Pass
Training process को एक simple cycle में समझा जा सकता है:
Forward Pass → Loss Calculation → Backward Pass → Parameter Update
पहले input network में जाता है।
फिर network forward direction में calculation करता है।
Output मिलता है।
इसके बाद actual answer के साथ prediction की तुलना करके loss calculate किया जाता है।
फिर backward pass में gradients calculate किए जाते हैं।
अंत में weights और biases को update किया जाता है।
इसके बाद वही process फिर से दोहराया जाता है।
यानी:
Predict → Measure Error → Calculate Gradients → Update → Repeat
बहुत सारे iterations के बाद network data के patterns को बेहतर तरीके से सीखने लगता है।
Learning Rate क्या होता है?
Weights को update करते समय हमें यह तय करना होता है कि कितना बड़ा बदलाव करना है।
इसे नियंत्रित करने के लिए Learning Rate इस्तेमाल किया जाता है।
अगर learning rate बहुत छोटा है, तो network बहुत धीरे सीख सकता है।
अगर learning rate बहुत बड़ा है, तो network solution के आसपास लगातार उछल सकता है और stable तरीके से converge नहीं कर सकता।
इसे पहाड़ से नीचे उतरने के उदाहरण से समझ सकते हैं।
अगर आप बहुत छोटे कदम लेते हैं, तो नीचे पहुंचने में बहुत समय लगेगा।
अगर आप बहुत बड़े कदम लेते हैं, तो संभव है कि आप सही जगह से आगे निकल जाएं।
इसलिए learning rate का उचित चयन training के लिए महत्वपूर्ण है।
Optimizer क्या करता है?
Training में parameters को update करने के लिए optimization algorithms का उपयोग किया जाता है।
एक basic approach है:
Stochastic Gradient Descent यानी SGD
SGD gradient की दिशा का इस्तेमाल करके weights को update करता है।
Conceptually update कुछ इस प्रकार होता है:
New Weight = Old Weight − Learning Rate × Gradient
यह formula छोटा है, लेकिन Neural Network training की foundation में इसका बहुत बड़ा योगदान है।
Modern Deep Learning में SGD के अलावा कई दूसरे optimizers भी इस्तेमाल किए जाते हैं, जैसे Adam और अन्य adaptive optimization techniques।
लेकिन Neural Network को scratch से समझने के लिए basic SGD एक अच्छा starting point है।
Neural Network में Bugs भी आते हैं
जब कोई व्यक्ति Neural Network को scratch से implement करता है, तो केवल mathematics ही चुनौती नहीं होती।
Coding bugs भी काफी परेशान कर सकते हैं।
एक छोटी-सी गलत variable reference, गलत shape, गलत gradient या incorrect update rule पूरा model खराब कर सकता है।
कभी-कभी network train ही नहीं करता।
कभी loss कम होने के बजाय बढ़ने लगता है।
कभी predictions पूरी तरह random रहती हैं।
और कभी output देखने में इतना अजीब लगता है कि समझ ही नहीं आता समस्या mathematics में है या code में।
इसलिए Neural Network development में debugging भी learning process का महत्वपूर्ण हिस्सा है।
Training Data और Test Data
अब मान लीजिए हमारा Neural Network digits पहचानना सीख रहा है।
हमें data को training और testing के लिए अलग-अलग रखना चाहिए।
Training Data का उपयोग model को सीखाने के लिए किया जाता है।
Test Data का उपयोग यह देखने के लिए किया जाता है कि model unseen examples पर कैसा perform करता है।
अगर model training data पर बहुत अच्छा perform करता है लेकिन नए data पर खराब performance देता है, तो यह overfitting का संकेत हो सकता है।
इसलिए केवल training accuracy देखना पर्याप्त नहीं है।
Test performance भी महत्वपूर्ण है।
MNIST Dataset: Neural Network की Classic परीक्षा
Neural Networks सीखने के लिए सबसे प्रसिद्ध datasets में से एक है MNIST।
इसमें handwritten digits की images होती हैं।
प्रत्येक image 28 × 28 pixels की होती है।
हर image को 0 से 9 तक किसी digit की class दी जाती है।
इसका मतलब एक Neural Network को यह सीखना होता है कि pixels के pattern देखकर कौन-सा digit दिखाई दे रहा है।
उदाहरण के लिए अगर image में handwritten 8 है, तो model का उद्देश्य output classes में 8 को सबसे ज्यादा probability देना है।
यह problem शुरुआती Neural Network projects के लिए काफी उपयोगी है क्योंकि इसका concept सरल है लेकिन इसमें वास्तविक machine learning की पूरी training pipeline दिखाई देती है।
Image Neural Network तक कैसे पहुंचती है?
28 × 28 image में कुल:
784 pixels
होते हैं।
एक simple fully connected network के लिए इन pixels को एक vector में flatten किया जा सकता है।
इस तरह image:
28 × 28
से बदलकर:
784 × 1
जैसे input representation में आ सकती है।
फिर यह data network की input layer में जाता है।
Network अलग-अलग weights के माध्यम से pixels के patterns को process करता है।
Training के दौरान model सीखता है कि किस तरह के pixel arrangements किस digit से जुड़े हुए हैं।
Neural Network की Accuracy कैसे बढ़ती है?
पहली बार training करने पर accuracy बहुत कम हो सकती है।
यह normal है।
Accuracy improve करने के लिए कई चीजों का प्रभाव पड़ सकता है:
Weight initialization
Learning rate
Network architecture
Batch size
Number of training epochs
Activation functions
Optimizer
Data preprocessing
इन parameters को carefully tune करने से performance बेहतर हो सकती है।
Mini-batch training भी useful होती है।
इसमें पूरा dataset एक साथ process करने के बजाय data के छोटे batches पर model को update किया जाता है।
इससे training computationally manageable हो सकती है और optimization process अधिक practical बनता है।
97% के आसपास Accuracy का क्या मतलब है?
अगर किसी digit classification model की test accuracy लगभग 97% है, तो इसका अर्थ है कि test examples के बड़े हिस्से को model सही classify कर रहा है।
लेकिन accuracy को हमेशा context के साथ समझना चाहिए।
केवल accuracy देखकर यह नहीं कहा जा सकता कि model हर तरह की handwritten image पर समान रूप से अच्छा काम करेगा।
Real-world data में handwriting styles, image quality, noise और preprocessing अलग हो सकते हैं।
फिर भी MNIST जैसी benchmark problem पर high accuracy यह दिखाती है कि हमारा basic Neural Network meaningful patterns सीखने में सक्षम है।
जब Model गलत होता है तो क्या होता है?
Neural Network की सबसे interesting चीजों में से एक यह है कि कभी-कभी उसकी गलतियां इंसान को भी समझ आती हैं।
कुछ handwritten digits इतने अस्पष्ट होते हैं कि इंसान को भी उन्हें पहचानने में समय लग सकता है।
कभी 3 और 8 जैसी shapes confusing हो सकती हैं।
कभी 4 और 9 के बीच similarity हो सकती है।
ऐसे examples को model गलत classify कर सकता है।
इससे हमें यह भी समझ आता है कि Machine Learning model केवल "जादू" नहीं करता।
वह data में मौजूद patterns के आधार पर prediction करता है।
Fashion-MNIST: क्या Neural Network में Fashion Sense है?
Digits पहचानने के बाद अगला interesting challenge है Fashion-MNIST।
इस dataset में भी 10 classes होती हैं और images का basic format MNIST जैसा होता है।
लेकिन यहां handwritten numbers की जगह clothing items होते हैं।
उदाहरण के तौर पर dataset में अलग-अलग प्रकार के:
Shirts
Pants
Shoes
Bags
Boots
जैसे categories शामिल होती हैं।
अब problem थोड़ी ज्यादा challenging हो जाती है।
क्योंकि clothing images में visual differences कई बार subtle होते हैं।
Fashion-MNIST पर Performance क्यों बदल सकती है?
Digit recognition में shapes काफी distinctive हो सकती हैं।
लेकिन clothing categories में कुछ classes एक-दूसरे से visually similar हो सकती हैं।
उदाहरण के लिए shirt और similar upper-body clothing को distinguish करना आसान नहीं हो सकता।
इसी वजह से वही simple Neural Network architecture जो digits पर शानदार performance देता है, Fashion-MNIST पर comparatively कम accuracy दे सकता है।
यह एक महत्वपूर्ण lesson है:
Model की performance केवल model पर निर्भर नहीं करती, बल्कि data और problem की complexity पर भी निर्भर करती है।
87% Accuracy भी क्यों अच्छी हो सकती है?
अगर एक simple fully connected Neural Network Fashion-MNIST पर लगभग 87% accuracy देता है, तो यह खराब परिणाम नहीं है।
इसका मतलब है कि model ने dataset में useful visual patterns सीखे हैं।
लेकिन अगर हमें इससे भी बेहतर performance चाहिए तो architecture को अधिक sophisticated बनाया जा सकता है।
उदाहरण के लिए image problems के लिए Convolutional Neural Networks यानी CNNs अधिक suitable हो सकते हैं।
CNN images में local spatial patterns को efficiently सीख सकते हैं।
इसलिए Fashion-MNIST जैसी image classification problem से हमें यह समझ आता है कि architecture का चुनाव भी महत्वपूर्ण है।
Scratch से Neural Network बनाने का असली फायदा
आज आप कुछ lines of code में high-level Machine Learning libraries का इस्तेमाल करके Neural Network बना सकते हैं।
लेकिन scratch से implementation करने का फायदा यह है कि आपको अंदर की process समझ आती है।
आप समझ पाते हैं:
Neuron क्या करता है
Weight कैसे काम करता है
Bias क्यों होता है
Matrix multiplication क्यों उपयोगी है
Activation function क्यों चाहिए
Loss क्या बताता है
Gradient क्या है
Backpropagation कैसे काम करता है
Learning rate क्या करता है
Optimizer क्यों इस्तेमाल होता है
Training loop कैसे चलता है
एक बार ये fundamentals समझ आ जाएं तो PyTorch, TensorFlow या अन्य frameworks को समझना भी आसान हो सकता है।
पूरा Neural Network एक बार फिर समझिए
अगर पूरे concept को बहुत सरल तरीके से summarize करें तो Neural Network की training कुछ ऐसी होती है:
Step 1: Input
Model को data दिया जाता है।
Step 2: Weighted Calculation
Inputs को weights के साथ combine किया जाता है और bias जोड़ा जाता है।
Step 3: Activation
ReLU जैसे activation functions non-linearity introduce करते हैं।
Step 4: Output
Final layer prediction के लिए scores देती है।
Step 5: Softmax
Classification में scores को probability distribution में बदला जा सकता है।
Step 6: Loss
Prediction और वास्तविक answer के बीच error calculate किया जाता है।
Step 7: Backpropagation
Gradients calculate किए जाते हैं ताकि पता चले parameters को किस दिशा में बदलना चाहिए।
Step 8: Update
Optimizer weights और biases को update करता है।
Step 9: Repeat
यह पूरी प्रक्रिया बार-बार दोहराई जाती है।
Training के साथ model धीरे-धीरे अपने parameters को adjust करता है और predictions बेहतर होती जाती हैं।
Neural Network से आगे की दुनिया
एक basic fully connected Neural Network Machine Learning की शुरुआत समझने के लिए बेहतरीन है, लेकिन AI की दुनिया इससे काफी बड़ी है।
Images के लिए CNNs उपयोगी हो सकते हैं।
Sequence और language problems के लिए अलग architectures विकसित किए गए हैं।
आज Transformers ने Natural Language Processing, computer vision और multimodal AI में बहुत बड़ा प्रभाव डाला है।
Large Language Models भी Neural Network technology की advanced forms पर आधारित हैं।
इसलिए एक single neuron से शुरू होने वाली journey आगे चलकर ChatGPT जैसे sophisticated AI systems तक पहुंच सकती है।
क्या Neural Network सीखना मुश्किल है?
शुरुआत में Neural Networks complicated लग सकते हैं।
Weights, biases, matrices, derivatives, gradients और backpropagation जैसे शब्द डराने वाले लगते हैं।
लेकिन अगर इन्हें छोटे हिस्सों में divide किया जाए तो concept काफी manageable हो जाता है।
सबसे पहले neuron समझिए।
फिर layer।
फिर matrix multiplication।
उसके बाद activation function।
फिर loss।
फिर gradient और backpropagation।
अंत में training loop।
इस क्रम में सीखने पर Neural Network किसी रहस्यमय technology की तरह नहीं लगेगा, बल्कि mathematical operations की एक organized chain जैसा दिखाई देगा।
निष्कर्ष
Neural Network की असली खूबसूरती इसकी complexity में नहीं, बल्कि इस बात में है कि बहुत सारी simple mathematical operations मिलकर एक ऐसा system बना सकती हैं जो data से patterns सीख सके।
एक neuron weighted inputs और bias से शुरू होता है।
कई neurons layers बनाते हैं।
Linear algebra इन calculations को efficient बनाती है।
ReLU network में non-linearity लाता है।
Softmax classification probabilities बनाने में मदद करता है।
Loss Function बताता है कि prediction कितनी गलत है।
Backpropagation gradients के जरिए parameters को सुधारने का रास्ता देता है।
Learning rate update की गति नियंत्रित करता है।
Optimizer training को practical बनाता है।
और फिर यही process हजारों या लाखों बार दोहराई जाती है।
MNIST जैसे dataset पर यही basic ideas handwritten digits पहचानना सीख सकते हैं, जबकि Fashion-MNIST पर model कपड़ों और accessories जैसी categories को classify करने की कोशिश कर सकता है।
सबसे महत्वपूर्ण बात यह है कि Neural Network को समझने के लिए शुरुआत किसी बड़े और complicated AI model से करने की जरूरत नहीं है। एक neuron से शुरुआत करके धीरे-धीरे layers, activation functions, loss और backpropagation तक पहुंचना कहीं ज्यादा प्रभावी तरीका है।
यही approach Machine Learning को केवल इस्तेमाल करने से आगे ले जाकर उसे समझने में मदद करती है।
और जब आपको यह समझ आ जाता है कि एक Neural Network अंदर से किस तरह calculations करता है और अपनी गलतियों से parameters को बदलकर सीखता है, तब Artificial Intelligence की बहुत-सी advanced technologies को समझने की नींव भी तैयार हो जाती है।
0 टिप्पणियाँ