TensorFlow और PyTorch (भाग 3): पहला न्यूरल नेटवर्क

पहला न्यूरल नेटवर्क - Keras Sequential API v/s PyTorch nn.Module

नमस्कार मित्रों!

श्रृंखला के पिछले दो भागों में हमने TensorFlow और PyTorch के आंतरिक दर्शन को समझा और देखा कि कैसे Tensors और Gradients मिलकर डीप लर्निंग का गणितीय आधार तैयार करते हैं।

अब समय आ गया है सिद्धांतों से आगे बढ़कर प्रैक्टिकल निर्माण की ओर कदम बढ़ाने का - अपना पहला न्यूरल नेटवर्क (Artificial Neural Network) कोड में तैयार करना।

न्यूरल नेटवर्क अनिवार्य रूप से गणितीय न्यूरॉन्स की परस्पर जुड़ी हुई परतें (Interconnected Layers) हैं। जब हम कोई इनपुट देते हैं, तो वह वज़न (Weights) और बायस (Biases) से गुणा होकर, नॉन-लीनियर एक्टिवेशन फंक्शन से गुजरते हुए आउटपुट तक पहुँचता है।

आज AI Bodh पर हम एक व्यावहारिक वर्गीकरण समस्या (Binary Classification Task) के माध्यम से देखेंगे कि:

1. Google का Keras (TensorFlow) मॉडल निर्माण को किस तरह लेगो ब्लॉक्स की तरह सहज बनाता है।
2. Meta का PyTorch (nn.Module) ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के जरिए हर लेयर और फॉरवर्ड पास पर बारीक नियंत्रण कैसे देता है।
3. दोनों के ट्रेनिंग लूप (Training Loop) में आंतरिक रूप से क्या अंतर होता है।

 

1. समस्या और नेटवर्क आर्किटेक्चर (Problem Formulation)

मान लीजिए हम एक साधारण क्लासिफायर बना रहे हैं:

• इनपुट डायमेंशन: 10 फीचर्स (Features)
• हिडन लेयर (Hidden Layer): 32 न्यूरॉन्स, साथ में ReLU (Rectified Linear Unit) एक्टिवेशन (जो नेगेटिव मानों को शून्य कर केवल उपयोगी सिग्नल्स आगे भेजता है)।
• आउटपुट लेयर (Output Layer): 1 न्यूरॉन, साथ में Sigmoid एक्टिवेशन (जो आउटपुट को 0 और 1 के बीच संभाव्यता/Probability में बदलता है)।

2. TensorFlow (Keras): Sequential API और Declarative Approach

TensorFlow में मॉडल निर्माण की प्रक्रिया घोषणात्मक (Declarative) होती है। Keras की Sequential API आपको पहले से बने लेगो ब्लॉक्स की तरह लेयर्स को एक के ऊपर एक रखने की सुविधा देती है।

मॉडल परिभाषा एवं Compilation:

Python

import tensorflow as tf

from tensorflow.keras import layers, models

 

# 1. मॉडल का आर्किटेक्चर परिभाषित करना

model_tf = models.Sequential([

    # हिडन लेयर: 32 न्यूरॉन्स, 10 इनपुट फीचर्स

    layers.Dense(32, activation='relu', input_shape=(10,)),

   

    # आउटपुट लेयर: बाइनरी क्लासिफिकेशन हेतु 1 न्यूरॉन

    layers.Dense(1, activation='sigmoid')

])

 

# 2. मॉडल को कंपाइल करना (Loss, Optimizer, Metrics का निर्धारण)

model_tf.compile(

    optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),

    loss='binary_crossentropy',

    metrics=['accuracy']

)

 

# मॉडल की आंतरिक संरचना का संक्षिप्त विवरण देखना

model_tf.summary()

Keras में ट्रेनिंग (The High-Level fit() Abstraction):

Keras में ट्रेनिंग के लिए निम्न-स्तरीय लूप्स लिखने की आवश्यकता नहीं होती। fit() मेथड डेटा पाइपलाइन, बैकप्रोपैगेशन और वज़न अपडेट को आंतरिक रूप से प्रबंधित कर लेता है:

 

Python

# काल्पनिक डेटा जनरेशन

features = tf.random.normal([1000, 10])

labels = tf.random.uniform([1000, 1], minval=0, maxval=2, dtype=tf.int32)

 

# मॉडल ट्रेनिंग

history = model_tf.fit(

    features,

    labels,

    epochs=10,

    batch_size=32,

    verbose=1

• विशेषता: Keras उन परिदृश्यों के लिए आदर्श है जहाँ मानक आर्किटेक्चर (Standard Architectures) का तेजी से प्रोटोटाइपिंग और परीक्षण करना हो।

 

3. PyTorch: nn.Module और ऑब्जेक्ट-ओरिएंटेड Imperative Approach

PyTorch में न्यूरल नेटवर्क का निर्माण एक इंजीनियर की तरह पुर्जे जोड़ने जैसा है। यहाँ हम torch.nn.Module बेस क्लास को इनहेरिट करते हैं:

1. __init__ मेथड में हम नेटवर्क के घटकों (Layers) को इनिशियलाइज़ करते हैं।
2. forward मेथड में हम स्पष्ट रूप से कोड करते हैं कि डेटा इन लेयर्स से होकर कैसे आगे बढ़ेगा।

मॉडल परिभाषा (Subclassing nn.Module):

Python

import torch

import torch.nn as nn

import torch.optim as optim

 

class SimpleClassifier(nn.Module):

    def __init__(self, input_dim=10, hidden_dim=32, output_dim=1):

        super(SimpleClassifier, self).__init__()

        # लेयर्स का इनिशियलाइज़ेशन

        self.fc1 = nn.Linear(input_dim, hidden_dim)

        self.relu = nn.ReLU()

        self.fc2 = nn.Linear(hidden_dim, output_dim)

        self.sigmoid = nn.Sigmoid()

 

    def forward(self, x):

        # डेटा का अग्रगामी प्रवाह (Forward Pass)

        x = self.fc1(x)

        x = self.relu(x)

        x = self.fc2(x)

        x = self.sigmoid(x)

        return x

 

# मॉडल का इंस्टेंस बनाना

model_torch = SimpleClassifier()

print(model_torch)

PyTorch में ट्रेनिंग (The Explicit 5-Step Loop):

PyTorch में कोई डिफ़ॉल्ट fit() फंक्शन नहीं होता। डेवलपर को ट्रेनिंग लूप के प्रत्येक चक्र (Epoch) को स्पष्ट रूप से लिखना होता है। यह प्रक्रिया सीखने और कस्टम शोध के लिए अत्यधिक पारदर्शी है:

 

Python

# लॉस फंक्शन और ऑप्टिमाइज़र तय करना

criterion = nn.BCELoss()

optimizer = optim.Adam(model_torch.parameters(), lr=0.001)

 

# काल्पनिक डेटा जनरेशन

dummy_x = torch.randn(1000, 10)

dummy_y = torch.randint(0, 2, (1000, 1)).float()

 

# 5-चरणीय ट्रेनिंग लूप

epochs = 10

batch_size = 32

 

for epoch in range(epochs):

    # डेटा को मिनी-बैचेस में प्रोसेस करना

    permutation = torch.randperm(dummy_x.size()[0])

    epoch_loss = 0.0

   

    for i in range(0, dummy_x.size()[0], batch_size):

        indices = permutation[i:i + batch_size]

        batch_x, batch_y = dummy_x[indices], dummy_y[indices]

       

        # चरण 1: पुराने संचित ग्रेडिएंट्स को शून्य करना

        optimizer.zero_grad()

       

        # चरण 2: फॉरवर्ड पास (मॉडल से अनुमान प्राप्त करना)

        predictions = model_torch(batch_x)

       

        # चरण 3: हानि (Loss) की गणना करना

        loss = criterion(predictions, batch_y)

       

        # चरण 4: बैकवर्ड पास (ग्रेडिएंट्स का रिवर्स-मोड कैलकुलेशन)

        loss.backward()

       

        # चरण 5: ऑप्टिमाइज़र द्वारा वज़न (Weights) को अपडेट करना

        optimizer.step()

       

        epoch_loss += loss.item()

       

    print(f"Epoch [{epoch+1}/{epochs}], Loss: {epoch_loss / (1000/batch_size):.4f}")

 

4. आर्किटेक्चरल तुलना: अमूर्तता (Abstraction) v/s नियंत्रण

कसौटी	TensorFlow (Keras Sequential)	PyTorch (nn.Module)
प्रोग्रामिंग प्रतिमान	घोषणात्मक (Declarative) - कॉन्फ़िगरेशन जैसा	आज्ञावाचक (Imperative) - विशुद्ध ऑब्जेक्ट-ओरिएंटेड Python
अमूर्तता का स्तर (Abstraction)	उच्च (High) - compile() और fit() में जटिलता छुपी रहती है	निम्न/मध्यम - हर चरण डेवलपर द्वारा स्पष्ट कोड किया जाता है
कस्टम आर्किटेक्चर (GANs/RL)	Functional API या Subclassing की आवश्यकता होती है	स्वाभाविक - forward() मेथड में सामान्य Python if/else या लूप्स संभव
ट्रेनिंग लूप का नियंत्रण	कॉलबैक्स (Callbacks) के माध्यम से नियंत्रित	कोड के प्रत्येक चरण पर पूर्ण और सीधा नियंत्रण

निष्कर्ष (Takeaway)

• TensorFlow (Keras) एक आधुनिक कार के ऑटोमैटिक गियरबॉक्स की तरह है। आपको बस एक्सेलरेटर दबाना है (model.fit()), और गियर अपने आप बदलते रहते हैं। यह तेज़, सुरक्षित और उत्पादक है।
• PyTorch (nn.Module) एक रेस कार के मैन्युअल गियरबॉक्स की तरह है। क्लच, ब्रेक और गियर की टाइमिंग आपके हाथ में है। यह शुरुआत में थोड़ा श्रमसाध्य लग सकता है, लेकिन यह आपको वाहन (मॉडल) के व्यवहार पर 100% कमांड देता है।

न्यूरल नेटवर्क का ढांचा खड़ा करना केवल आधी यात्रा है; इस नेटवर्क को कुशलतापूर्वक डेटा खिलाना बाकी आधी यात्रा है।

श्रृंखला के भाग 4 में हम डेटा इंजीनियरिंग के सबसे महत्वपूर्ण विषय को कवर करेंगे: "डेटा हैंडलिंग और परफॉर्मेंस - tf.data बनाम PyTorch DataLoader" - जहाँ हम जानेंगे कि मॉडल को भूखा रखे बिना GPU को डेटा की निरंतर सप्लाई कैसे सुनिश्चित की जाती है।

सीखते रहिए, प्रयोग करते रहिए और AI के इस सफर में जुड़े रहिए!

–०–

– डॉ. चंद्रेश कुमार छतलानी