A simple Multi-Layer Perceptron (MLP) in PyTorch to learn the XOR function

XOR (Exclusive OR) एक प्रसिद्ध लॉजिकल फंक्शन है, जिसे मशीन लर्निंग में अक्सर यह जाँचना के लिए उपयोग किया जाता है कि कोई मॉडल non-linear समस्याएँ हल कर सकता है या नहीं। यह एक सरल लेकिन शक्तिशाली उदाहरण है, जो दर्शाता है कि केवल एक linear मॉडल पर्याप्त नहीं होता।

इस अध्याय में, हम PyTorch का उपयोग करते हुए एक Multi-Layer Perceptron (MLP) बनाएँगे, जो XOR function को सिख सके। हम हर चरण को विस्तारपूर्वक समझेंगे — डेटा तैयार करना, मॉडल बनाना, ट्रेनिंग करना और prediction करना।


XOR Function क्या है?

XOR एक binary logic function है जो true return करता है जब दो inputs में से केवल एक true होता है।

इनपुट x1इनपुट x2आउटपुट (x1 ⊕ x2)
000
011
101
110

❗ XOR एक non-linearly separable function है, जिसका अर्थ है कि आप एक simple straight line से इन inputs को classify नहीं कर सकते।

इसलिए हमें चाहिए — एक non-linear model जैसे कि MLP।


🧠 Multi-Layer Perceptron (MLP) का परिचय

MLP एक feedforward neural network है जिसमें तीन प्रमुख layers होती हैं:

  1. Input Layer – जो raw inputs को लेती है।
  2. Hidden Layer(s) – जो inputs को process करके features सीखती है।
  3. Output Layer – जो final prediction देती है।

MLP में hidden layers और non-linear activation functions की वजह से यह linear models से ज़्यादा शक्तिशाली होता है।


📐 MLP Architecture for XOR (चित्रात्मक रूप)

    Input:     x1   x2
│ │
▼ ▼
[ Hidden Layer ]
[ 4 Neurons + ReLU ]

[ Output Layer ]
[ 1 Neuron + Sigmoid ]

यह architecture हमें XOR function को सिखाने में मदद करेगा।


🛠️ PyTorch में Step-by-Step Implementation

🧾 Step 1: Dataset तैयार करना

import torch

# इनपुट और आउटपुट डेटा (XOR टेबल)
X = torch.tensor([[0,0], [0,1], [1,0], [1,1]], dtype=torch.float32)
Y = torch.tensor([[0], [1], [1], [0]], dtype=torch.float32)

🧾 Step 2: Model Class बनाना

import torch.nn as nn

class XOR_MLP(nn.Module):
def __init__(self):
super(XOR_MLP, self).__init__()
self.hidden = nn.Linear(2, 4) # 2 इनपुट → 4 hidden neurons
self.relu = nn.ReLU() # Non-linearity
self.output = nn.Linear(4, 1) # Hidden → Output
self.sigmoid = nn.Sigmoid() # 0-1 के बीच output squeeze

def forward(self, x):
x = self.hidden(x)
x = self.relu(x)
x = self.output(x)
x = self.sigmoid(x)
return x

🧾 Step 3: Model Initialization और Optimizer Setup

model = XOR_MLP()

# Loss Function और Optimizer
criterion = nn.BCELoss() # Binary Cross Entropy Loss
optimizer = torch.optim.Adam(model.parameters(), lr=0.1)

🧾 Step 4: Model Training Loop

for epoch in range(1000):
optimizer.zero_grad() # Gradients reset करो
outputs = model(X) # Forward pass
loss = criterion(outputs, Y) # Loss compute
loss.backward() # Backpropagation
optimizer.step() # Weights update

if epoch % 100 == 0:
print(f"Epoch {epoch}, Loss: {loss.item():.4f}")

🧾 Step 5: Prediction और Evaluation

with torch.no_grad():
predicted = model(X)
predicted_classes = (predicted > 0.5).float()
print("\nPrediction:")
for i in range(len(X)):
print(f"Input: {X[i].tolist()} => Predicted: {predicted_classes[i].item():.0f}")

📊 Output (उदाहरण)

Epoch 0, Loss: 0.6931
...
Epoch 900, Loss: 0.0012

Prediction:
Input: [0.0, 0.0] => Predicted: 0
Input: [0.0, 1.0] => Predicted: 1
Input: [1.0, 0.0] => Predicted: 1
Input: [1.0, 1.0] => Predicted: 0

📌 निष्कर्ष (Conclusion)

  • XOR function को सीखने के लिए एक simple linear model काम नहीं करता।
  • Hidden layer और non-linear activation function (जैसे ReLU) की मदद से MLP इस complex pattern को सिख सकता है।
  • यह example बताता है कि कैसे deep learning non-linear समस्याओं को हल करने में सक्षम होती है।

✅ अभ्यास प्रश्न (Exercises)

  1. XOR function को सिखाने के लिए hidden layer में neurons की संख्या कम या ज़्यादा करने पर क्या प्रभाव पड़ता है? एक्सपेरिमेंट करके बताइए।
  2. Sigmoid की जगह Tanh activation function का प्रयोग कीजिए। क्या परिणामों में कोई अंतर आया?
  3. अगर हम hidden layer को हटा दें तो क्या model XOR function सीख पाएगा? क्यों?

🎯 ऑब्जेक्टिव प्रश्न (MCQs)

  1. XOR function कैसा function है?
    • (a) Linearly separable
    • (b) Non-linearly separable ✅
    • (c) Linear
    • (d) Constant
  2. MLP में कौन सा activation function non-linearity लाता है?
    • (a) Linear
    • (b) ReLU ✅
    • (c) Softmax
    • (d) None
  3. PyTorch में binary classification के लिए कौन-सा loss function प्रयोग होता है?
    • (a) MSELoss
    • (b) CrossEntropyLoss
    • (c) BCELoss ✅
    • (d) NLLLoss