फीड-फॉरवर्ड न्यूरल नेटवर्क्स समझिए: एक संपूर्ण ट्यूटोरियल

जब आप मशीन लर्निंग एल्गोरिद्म देखते हैं, तो फीड-फॉरवर्ड न्यूरल नेटवर्क (FFNN) जितने बुनियादी कॉन्सेप्ट बहुत कम होते हैं। यदि आपने कभी अपना पहला न्यूरल नेटवर्क बनाया है, तो बहुत संभव है कि वह फीड-फॉरवर्ड रहा हो। ये लगभग हर जगह दिखते हैं — सरल वर्गीकरण समस्याओं से लेकर गहरे आर्किटेक्चर की लेयर्स को शक्ति देने तक। 

सबसे पहले, मैं आपको दिखाता हूँ कि फीड-फॉरवर्ड न्यूरल नेटवर्क्स व्यापक परिप्रेक्ष्य में कहाँ फिट होते हैं:

इस ट्यूटोरियल में, मैं समझाऊँगा कि फीड-फॉरवर्ड न्यूरल नेटवर्क वास्तव में क्या है, यह कैसे विकसित हुआ, आज भी यह क्यों प्रासंगिक है, और वास्तविक दुनिया के उदाहरणों पर नज़र डालेंगे।

फीड-फॉरवर्ड न्यूरल नेटवर्क क्या है?

सहज रूप में, ऐसी नेटवर्क आर्किटेक्चर का सबसे अच्छा वर्णन है “डेटा केवल आगे की ओर बहता है, कोई लूप नहीं।”

मूल रूप से, FFNN डेटा को इस तरह प्रोसेस करता है कि वह एक दिशा में बहता है, इनपुट से आउटपुट तक। कोई लूप-बैक नहीं, कोई रिकर्शन नहीं, और कोई साइकिल नहीं (बैकप्रोपेगेशन को छोड़कर, जिस पर हम थोड़ी देर में आएंगे)। 

जब मैं इसे पहली बार सीख रहा था, तो जो मानसिक छवि मेरे लिए सबसे अधिक सहायक थी, वह थी फैक्ट्री का कन्वेयर बेल्ट। 

क्यों? 

क्योंकि प्रक्रिया का हर चरण (या नेटवर्क की हर लेयर) इनपुट पर कोई सरल ऑपरेशन करता है और फिर उसे अगले चरण को सौंप देता है।

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

1. इनपुट पहले लेयर (इनपुट लेयर) में जाते हैं।
2. वे वेट्स और बायस से ट्रांसफॉर्म होते हैं और एक एक्टिवेशन फ़ंक्शन से होकर गुजरते हैं।
3. यह प्रक्रिया एक या अधिक हिडन लेयर्स के माध्यम से जारी रहती है।
4. अंत में, आउटपुट लेयर एक प्रिडिक्शन बनाती है।

आपको ऐसी नेटवर्क आर्किटेक्चर कैसा दिखता है, यह दिखाने से पहले, मैं एक आम भ्रम दूर करना चाहता हूँ:

“फीड-फॉरवर्ड न्यूरल नेटवर्क्स और MLPs एक ही चीज़ हैं।”

इस भ्रम को दूर करने के लिए, हमें डीप लर्निंग के शुरुआती इतिहास पर नज़र डालनी होगी। 

डीप लर्निंग का प्रारंभिक इतिहास

परसेप्ट्रॉन: हम शुरुआत करते हैं परसेप्ट्रॉन से, जिसे 1950 के दशक में फ्रैंक रोसेनब्लैट ने विकसित किया। यह एक सिंगल-लेयर बाइनरी क्लासिफायर था, और भले ही यह सब कुछ हल नहीं कर सकता था (जैसे XOR समस्या), इसने न्यूरल नेटवर्क्स की नींव रखी।

सरल शब्दों में, परसेप्ट्रॉन ऐसे काम करता था:

1. इनपुट्स: हर इनपुट (जैसे x_1, x_2, आदि) के साथ एक संबद्ध वेट (w_1, w_2, आदि) होता है।
2. वेटेड सम: इनपुट्स को उनके वेट्स से गुणा कर जोड़ा जाता है, साथ में एक बायस टर्म: z = w1*x1 + w2*x2+ ... + b.
3. एक्टिवेशन: परिणाम को एक स्टेप फ़ंक्शन (एक्टिवेशन) से गुजारा जाता है। यदि मान थ्रेशहोल्ड से ऊपर है, तो परसेप्ट्रॉन 1 आउटपुट करता है; अन्यथा, 0।

मूलतः, परसेप्ट्रॉन एक लीनियर क्लासिफायर है, यानी यह केवल सीधी रेखा (या हाइपरप्लेन) जैसी निर्णय सीमाएँ बना सकता है। एक ओर, परसेप्ट्रॉन के गुण थे—बहुत सरल और सुरुचिपूर्ण (क्योंकि यह जीवविज्ञान से प्रेरित था) और कम्प्यूटेशनली सस्ता। दूसरी ओर, यह गैर-रेखीय रूप से पृथक समस्याएँ, जैसे XOR समस्या, हल नहीं कर सकता था। 

मल्टी-लेयर परसेप्ट्रॉन (MLPs): कुछ दशकों आगे बढ़ें तो 1980 के दशक में शोधकर्ताओं ने समझा कि यदि आप कई परसेप्ट्रॉन्स को स्टैक करें और नॉन-लीनियर एक्टिवेशन फ़ंक्शंस जोड़ें, तो आप अधिक जटिल समस्याएँ हल कर सकते हैं। इस संरचना को कहा गया मल्टी-लेयर परसेप्ट्रॉन।

यह ऐसे काम करता था: 

1. इनपुट लेयर: डेटासेट से कच्चे फीचर्स लेती थी।
2. हिडन लेयर्स: एक या अधिक परसेप्ट्रॉन्स की लेयर्स जो ट्रांसफॉर्मेशन लागू करती हैं। हर न्यूरॉन z = w*x + b करता है और फिर इसे नॉन-लीनियर एक्टिवेशन फ़ंक्शन जैसे सिग्मॉइड, टैनएच आदि से गुजारता है। 
3. आउटपुट लेयर: अंतिम लेयर अंतिम प्रिडिक्शन देती है (जैसे, क्लास प्रॉबेबिलिटी, रिग्रेशन वैल्यूज़)।

इन नॉन-लीनियर एक्टिवेशंस का जोड़ना निर्णायक था। इनके बिना, कई लेयर्स को स्टैक करना एक ही लीनियर ट्रांसफॉर्मेशन में सिमट जाता। इनके साथ, MLPs बहुत जटिल, नॉन-लीनियर फ़ंक्शंस को भी प्रदर्शित कर सकते थे।

इससे न्यूरल नेटवर्क थ्योरी के सबसे प्रसिद्ध परिणामों में से एक आया: यूनिवर्सल एप्रॉक्सिमेशन थ्योरम। 

यह प्रमेय बताता है कि केवल एक हिडन लेयर वाला न्यूरल नेटवर्क भी — बशर्ते उसमें नॉन-लीनियर एक्टिवेशन फ़ंक्शन और पर्याप्त न्यूरॉन्स हों — किसी भी बाउंडेड डोमेन पर किसी भी सतत फ़ंक्शन का सन्निकटन कर सकता है। 

डीप लर्निंग युग: 2010 के दशक में पहुँचते हुए, हम डीप लर्निंग युग में प्रवेश करते हैं। GPUs और बिग डेटा के साथ, FFNNs और गहरे व अधिक शक्तिशाली आर्किटेक्चर में विकसित हुए, जिन्होंने CNNs, RNNs और Transformers की बुनियाद रखी — और आज हम मूलतः यहीं हैं।

तो, अब मूल भ्रम पर लौटते हुए, हम जानते हैं:

• फीड-फॉरवर्ड न्यूरल नेटवर्क (FFNN): किसी भी न्यूरल नेटवर्क की सामान्य श्रेणी जिसमें डेटा एक दिशा में बहता है (इनपुट → हिडन → आउटपुट), कोई लूप नहीं।
• मल्टी-लेयर परसेप्ट्रॉन (MLP): FFN का एक विशिष्ट प्रकार जिसमें कम-से-कम एक हिडन लेयर होती है (वेट्स, बायस और एक्टिवेशन वाले न्यूरॉन्स)।

दूसरे शब्दों में, सभी MLPs, FFNNs हैं, लेकिन सभी FFNNs, MLPs नहीं हैं। यह याद रखने के लिए बहुत महत्वपूर्ण बिंदु है। एक और आम भ्रम एक सिंगल-लेयर परसेप्ट्रॉन (यानी केवल इनपुट से आउटपुट) के बारे में है।

सिंगल-लेयर परसेप्ट्रॉन एक FFNN है, पर MLP नहीं! केवल तब जब हम हिडन लेयर्स जोड़ते हैं, यह MLP बनता है।

यह भेद इसलिए महत्वपूर्ण है क्योंकि MLPs यूनिवर्सल फ़ंक्शन एप्रॉक्सिमेशन में सक्षम हैं (पर्याप्त हिडन यूनिट्स और नॉन-लीनियर एक्टिवेशन के साथ), जबकि सरल सिंगल-लेयर परसेप्ट्रॉन जो प्रदर्शित कर सकता है उसमें सीमित है।

फीड-फॉरवर्ड न्यूरल नेटवर्क की आर्किटेक्चर

पिछले खंड से, हमने FFNN के बारे में बहुत कुछ सीखा, लेकिन सरल शब्दों में इन्हें सरल ट्रांसफॉर्मेशंस के स्टैक के रूप में समझा जा सकता है। FFNN बनाने वाले कई घटक होते हैं, तो आइए इन्हें विस्तार से देखें, विशेषकर MLP संरचना को। 

एक MLP में तीन प्रकार की लेयर्स होती हैं; इनपुट, हिडन और आउटपुट लेयर, जिनका हमने पहले संक्षेप में उल्लेख किया था। 

ऊपर दिए डायग्राम पर नज़र डालें जब हम इन लेयर्स का विस्तार से अन्वेषण करें। 

इनपुट लेयर

यही नेटवर्क का प्रवेश बिंदु है। यहाँ प्रत्येक न्यूरॉन डेटासेट के एक फीचर का प्रतिनिधित्व करता है। महत्वपूर्ण बात यह है कि इनपुट लेयर स्वयं कोई गणना नहीं करती — यह केवल कच्ची संख्याओं को आगे पास करती है। हमारे उदाहरण में, चूँकि इनपुट लेयर में केवल दो न्यूरॉन्स हैं, इसका मतलब है कि हमारे डेटासेट में दो फीचर्स हैं (या हम अपने डेटासेट से केवल दो फीचर्स मान रहे हैं)। 

हिडन लेयर्स

यहीं वास्तविक गणना होती है। हमारे पास दो हिडन लेयर्स हैं, प्रत्येक में चार न्यूरॉन्स। हिडन लेयर का प्रत्येक न्यूरॉन ये तीन काम करता है:

1. वेटेड सम: हर इनपुट को एक वेट से गुणा किया जाता है और फिर सबको जोड़ा जाता है। 
2. बायस: एक स्थिर बायस जोड़ा जाता है ताकि फ़ंक्शन को शिफ्ट करने में लचीलापन मिले।
3. एक्टिवेशन फ़ंक्शन: ReLU, tanh, या sigmoid जैसी नॉन-लीनियर स्क्वैशिंग फ़ंक्शन लगाई जाती है। यही कदम नेटवर्क को जटिल, नॉन-लीनियर पैटर्न सीखने में सक्षम बनाता है।

आउटपुट लेयर

आउटपुट लेयर अंतिम प्रिडिक्शन बनाती है, और इसका डिज़ाइन उस समस्या पर निर्भर करता है जिसे हम हल कर रहे हैं:

• रिग्रेशन समस्याएँ, जैसे घर की कीमतों का अनुमान। इस स्थिति में, आउटपुट लेयर में बिना एक्टिवेशन (लीनियर) वाला एक न्यूरॉन होगा। लीनियर क्यों? क्योंकि हम मानों को स्क्वैश नहीं करना चाहते — घर की कीमतें कोई भी वास्तविक संख्या हो सकती हैं।
• बाइनरी क्लासिफिकेशन समस्याएँ (हाँ/ना), जैसे ईमेल स्पैम है या नहीं। यहाँ, आउटपुट लेयर में सिग्मॉइड एक्टिवेशन वाला एक न्यूरॉन होगा। सिग्मॉइड क्यों? क्योंकि हम चाहते हैं कि नेटवर्क 0 और 1 के बीच मान दे (क्योंकि हम प्रॉबेबिलिटीज प्रिडिक्ट कर रहे हैं)। 
• मल्टी-क्लास क्लासिफिकेशन (3 या अधिक क्लास) — जैसे किसी इमेज को अलग-अलग जानवरों के रूप में वर्गीकृत करना। आउटपुट लेयर में प्रति क्लास एक न्यूरॉन होगा, और सॉफ्टमैक्स एक्टिवेशन होगा। सॉफ्टमैक्स क्यों? क्योंकि यह रॉ स्कोर्स को ऐसी प्रॉबेबिलिटीज में बदल देता है जिनका योग 1 होता है (जैसे, 70% बिल्ली, 20% कुत्ता, 10% घोड़ा)।

आपके संदर्भ के लिए, यहाँ एक डायग्राम है जो FFNN और सामान्य रूप से डीप लर्निंग में उपयोग होने वाले नौ आम एक्टिवेशन फ़ंक्शंस के आकार दिखाता है। 

आगे बढ़ने से पहले, यह भी नोट करना ज़रूरी है कि एक लेयर का हर न्यूरॉन अगली लेयर के हर न्यूरॉन से जुड़ता है (इसीलिए इसे फुली-कनेक्टेड कहा जाता है)। 

हमारे उदाहरण पर फिर लौटते हुए, हमारे पास है:

Params = (2·4+4)+(4·4+4)+(4·1+1)=12+20+5=37

हर ब्रैकेट लगातार लेयर्स के बीच पैरामीटर्स की संख्या दिखाता है, जहाँ पिछली और मौजूदा लेयर के न्यूरॉन्स की संख्या को गुणा किया जाता है और फिर बायस की संख्या (अर्थात मौजूदा लेयर के न्यूरॉन्स की संख्या) जोड़ी जाती है। अभ्यास के लिए अन्य न्यूरल नेटवर्क उदाहरणों पर भी यह गणना करने की कोशिश करें!

फीडफॉरवर्ड न्यूरल नेटवर्क का प्रशिक्षण

डीप लर्निंग में, प्रशिक्षण दो चरणों में बाँटा जाता है: फॉरवर्ड पास/प्रोपेगेशन और बैकप्रोपेगेशन। सरल शब्दों में, फॉरवर्ड प्रोपेगेशन हमें प्रिडिक्शन देता है, जबकि बैकप्रोपेगेशन वह तरीका है जिससे हम गलतियों से सीखते हैं। 

फॉरवर्ड प्रोपेगेशन 

अब तक हमने जो भी कवर किया है वह फॉरवर्ड प्रोपेगेशन के अंतर्गत आता है। संक्षेप में, जब डेटा MLP से होकर गुजरता है, तो हर लेयर वही दो चरण करती है, जिन्हें गणितीय रूप में इन समीकरणों से लिखा जा सकता है:

यहाँ z वह आउटपुट है जो पिछली लेयर के आउटपुट को मौजूदा लेयर के वेट्स से गुणा कर और बायस जोड़कर मिलता है, जिसे लीनियर स्टेप भी कहा जाता है। 

स्वाभाविक रूप से, यदि पिछली लेयर इनपुट लेयर है, तो यह x होगा, al-1 के बजाय। अगला चरण है एक्टिवेशन स्टेप। इसे अधिक गणितीय रूप से कठोर बनाने के लिए, हम वेट्स और बायस को इस प्रकार लिख सकते हैं:

बैकप्रोपेगेशन

जब हमें आउटपुट मिल गया, तो हम अपने नेटवर्क को कैसे बताएँ कि यह सही था या नहीं? या बेहतर यह कि नेटवर्क को हमारे दिए कार्य में कैसे बेहतर बनायें। यहीं बैकप्रोपेगेशन आता है। इसे नेटवर्क के लिए फीडबैक सिस्टम की तरह समझ सकते हैं, जो मॉडल को बताता है कि वह कितने अंतर से गलत था और खुद को कैसे समायोजित करे। इसे हम ऐसे तोड़ सकते हैं:

1. प्रिडिक्शन की तुलना: मॉडल ने क्या प्रिडिक्ट किया (ŷ) और वास्तविक उत्तर (y) क्या था, देखें।
2. त्रुटि की गणना: हम लॉस फ़ंक्शन से मापते हैं कि प्रिडिक्शन कितना गलत था, जैसे MSE।
3. बैकप्रोपेगेट (चेइन रूल द्वारा): सभी बायस और वेट्स के सापेक्ष ग्रेडिएंट निकाले जाते हैं: ∂L/∂w,∂L/∂b ।
4. ग्रेडिएंट डीसेंट अपडेट: लॉस घटाने के लिए पैरामीटर्स को नीचे दिए नियम से अपडेट किया जाता है:

यहाँ η लर्निंग रेट है, एक पैरामीटर जो यह निर्धारित करता है कि हर अपडेट पर पैरामीटर्स कितना बदलें। 

इस प्रक्रिया के कई राउंड्स में, नेटवर्क धीरे-धीरे सीखता है और कार्य में बेहतर होता जाता है।

चीज़ों को और स्पष्ट करने के लिए, एक बहुत छोटा उदाहरण साथ में देखते हैं। मान लीजिए हमारे पास है:

• इनपुट: x = 2
• लक्षित आउटपुट: y=4
• प्रिडिक्शन: ŷ = 3

अब चरणों से गुजरते हैं। 

1. प्रिडिक्शन की तुलना: ŷ =3, y = 4
2. त्रुटि: इस उदाहरण के लिए, हम MSE इस्तेमाल करेंगे: L=(y−y^​)2=(4−3)2=1
3. बैकप्रोपेगेट: नेटवर्क डेरिवेटिव्स का उपयोग करके यह पता लगाता है कि प्रत्येक वेट और बायस ने इस त्रुटि में कितना योगदान दिया और फिर हर पैरामीटर को ग्रेडिएंट डीसेंट अपडेट स्टेप से अपडेट किया जाता है। 

PyTorch में फीड फॉरवर्ड न्यूरल नेटवर्क कोड करना

हमने FFNN (विशेषकर MLP) बनाने के लिए आवश्यक गणित कवर कर लिया है। आगे बढ़ने के लिए, हम इसे PyTorch में कोड करेंगे। 

मल्टीलियर परसेप्ट्रॉन

# Imports we will be needing
import torch
import torch.nn as nn
import torch.optim as optim

X,y = dataset # Here will be our dataset 

# We have created a MLP here using nn.Sequential()
model = nn.Sequential(
    nn.Linear(2, 4),  # input layer → hidden layer (2 → 4)
    nn.ReLU(),        # relu activation function
    nn.Linear(4, 4), # hidden layer 1 → hidden layer 2 (4 → 4)
    nn.ReLU(), 
    nn.Linear(4, 1)   # hidden layer 2 → output (4 → 1)
)


criterion = nn.MSELoss()         # regression loss, i.e our loss function
optimizer = optim.SGD(model.parameters(), lr=0.1) # Optimizer using the Stochastic Gradient Descent

# Training Loop
EPOCHS = 200 # Number of epochs we will be training for
for epoch in range(EPOCHS):
    # Forward pass
    outputs = model(X)
    loss = criterion(outputs, y)

    # Backward pass
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()संचालित द्वारा

इस बिंदु पर, आप PyTorch कोड को पहले समझे गणितीय चरणों से मैप कर पाने चाहिए। हालाँकि, आपके मन में Epochs को लेकर एक प्रश्न हो सकता है।

एक epoch पूरे प्रशिक्षण डेटासेट का न्यूरल नेटवर्क से एक संपूर्ण पास होता है। उदाहरण के लिए, मान लीजिए हमारे पास 1,000 प्रशिक्षण डेटा पॉइंट्स हैं और बैच साइज = 100, तो जब नेटवर्क सभी 1,000 इमेज देख लेता है (यानी 10 बैच), वह 1 epoch होता है। ट्रेनिंग आमतौर पर कई epochs लेती है ताकि मॉडल अपने वेट्स को बेहतर करता रहे।

कन्वोल्यूशनल न्यूरल नेटवर्क

मैं अन्य FFNNs का भी संक्षेप में उल्लेख करना चाहता हूँ, जिनमें से एक बहुत प्रसिद्ध है कन्वोल्यूशनल न्यूरल नेटवर्क (CNN)। 

हालाँकि CNN के अंत में भी एक MLP होता है, शुरुआत में इसमें Convolutional Layers और Pooling Layers नामक विशेष लेयर्स होती हैं। पहले Convolutional Layers की बात करें, ये ज़रूरी हैं क्योंकि ये एक बार में इनपुट के छोटे-छोटे स्थानीय क्षेत्रों को फ़िल्टर (या कर्नेल) का उपयोग करके देखती हैं।

यह इमेज क्लासिफिकेशन में इसलिए बहुत उपयोगी है क्योंकि:

• डेंस लेयर्स हर पिक्सेल को अलग मानतीं, स्पैशियल स्ट्रक्चर को नज़रअंदाज़ करतीं।
• दूसरी ओर, कन्वोल्यूशनल लेयर्स छोटे पैचों में किनारों, टेक्सचर और आकारों का पता लगा सकती हैं — फिर गहराई में जाते-जाते इन्हें अधिक जटिल पैटर्न में संयोजित कर सकती हैं।

कन्वोल्यूशनल लेयर्स के साथ, CNNs पूलिंग लेयर्स का भी उपयोग करते हैं।

ध्यान देने की बात है कि पूलिंग लेयर्स पैरामीटर्स नहीं सीखतीं, बल्कि फीचर मैप्स को डाउनसैंपल करती हैं ताकि वे छोटे और अधिक प्रबंधनीय हो जाएँ।

• सबसे आम है मैक्स पूलिंग, जो हर छोटे क्षेत्र (जैसे 2×2 विंडो) से अधिकतम मान लेती है।
• पूलिंग नेटवर्क को अधिक कुशल बनाती है और ट्रांसलेशन इनवेरिएंस भी देती है (नेटवर्क इस बात की अधिक परवाह करता है कि कोई फीचर मौजूद है या नहीं, न कि वह ठीक कहाँ है)।

हम PyTorch का उपयोग करके एक CNN इस तरह कोड कर सकते हैं:

class SimpleCNN(nn.Module): # Define our model as a class
    def __init__(self):
        super().__init__()
        self.conv = nn.Conv2d(1, 8, 3)     # 1→8 channels, 3x3 kernel
        self.pool = nn.MaxPool2d(2, 2)
        self.fc   = nn.Linear(8*13*13, 10) # flatten → 10 classes

    def forward(self, x): # Forward propagation function 
        x = self.pool(torch.relu(self.conv(x)))
        x = x.view(x.size(0), -1)          # flatten
        return self.fc(x)संचालित द्वारा

ऊपर दिए कोड में, हमने एक बहुत सरल CNN बनाया है, जिसमें एक कन्वोल्यूशन लेयर, एक पूलिंग लेयर और एक लीनियर लेयर शामिल है। 

फीड-फॉरवर्ड न्यूरल नेटवर्क्स के अन्य उदाहरण

हमने FFNNs के दो बहुत प्रसिद्ध और महत्वपूर्ण उदाहरण कवर किए, लेकिन और भी कई उदाहरण हैं जो अपने-अपने क्षेत्रों में क्रांतिकारी रहे हैं, जैसे:

1. Transformers: प्रत्येक ब्लॉक में एक MLP/FFN भाग होता है (सेल्फ-अटेंशन के बाद, "फीड-फॉरवर्ड लेयर" विमाओं को बढ़ाती और फिर घटाती है)।
2. विज़न Transformers (ViTs): इमेज पैच पर ट्रांसफॉर्मर ब्लॉक्स (अंदर FFNNs के साथ) लागू करते हैं।
3. ऑटोएन्कोडर्स (बेसिक): एन्कोडर + डिकोडर दोनों FFNNs से बने होते हैं।
4. रिकमेंडर सिस्टम्स (MLP-आधारित): जैसे Wide & Deep मॉडल्स रैंकिंग और प्रिडिक्शंस के लिए।

अंतिम विचार

उम्मीद है कि अब आप समझ गए होंगे कि AI के क्षेत्र में FFNNs कितने महत्वपूर्ण हैं। इनके बिना, डीप लर्निंग का आधुनिक परिदृश्य अस्तित्व में नहीं होता।

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