Back Propagation :Backward Pass (Gradient Descent)

Backward Pass (Gradient Descent)

(बैकवर्ड पास और ग्रेडिएंट डिसेंट)

---

🔶 1. Backward Pass क्या है?

Backward Pass (या Backpropagation) एक ऐसी प्रक्रिया है जिसमें neural network द्वारा की गई गलती (loss) को input की दिशा में “वापस” propagate किया जाता है — ताकि यह पता लगाया जा सके कि network की किस weight ने कितनी गलती की।

यह gradient information तब use होती है weights को सही दिशा में adjust करने के लिए ताकि अगली बार prediction बेहतर हो सके।

---

🎯 उद्देश्य:

“Neural network की prediction में हुई गलती को mathematically trace करके यह पता लगाना कि model के कौन-कौन से weights इस गलती के ज़िम्मेदार हैं, और उन्हें कैसे सुधारना है।”

---

🔄 2. Process Overview: Forward → Loss → Backward → Update

पूरा Training Loop:

Input → Forward Pass → Output → Loss Calculation → 
Backward Pass → Gradient Calculation → 
Optimizer Step → Weight Update

---

🧮 3. गणितीय दृष्टिकोण: Chain Rule से Gradient निकालना

मान लीजिए:

• y=f(x)
• L=Loss(y,y^)

तो:

​

जहाँ:

• w: model parameter (weight)
• z=w⋅x+b
• y=f(z) (activation function)

यहाँ हम chain rule का उपयोग कर एक neuron से अगले neuron तक derivative propagate करते हैं — यही कहलाता है backpropagation.

---

📘 4. Gradient Descent: Training की Core Algorithm

Weight Update Rule:

जहाँ:

• η: learning rate (सीखने की रफ़्तार)
• ∂L/∂w: loss का gradient उस weight के respect में
• यह बताता है weight को किस दिशा और मात्रा में adjust करना है

---

⚠️ यदि Learning Rate बहुत बड़ी हो:

• Model overshoot कर जाता है
• Training unstable हो जाती है

⚠️ यदि बहुत छोटी हो:

• Model बहुत धीरे सीखता है
• Local minima में अटक सकता है

---

🔧 5. PyTorch Implementation Example:

import torch
import torch.nn as nn
import torch.optim as optim

# Model
model = nn.Sequential(
    nn.Linear(2, 3),
    nn.ReLU(),
    nn.Linear(3, 1),
    nn.Sigmoid()
)

# Data
x = torch.tensor([[1.0, 2.0]])
y = torch.tensor([[0.0]])

# Loss and Optimizer
criterion = nn.BCELoss()
optimizer = optim.SGD(model.parameters(), lr=0.1)

# ----------- Training Step ------------
# Step 1: Forward Pass
y_pred = model(x)

# Step 2: Loss Calculation
loss = criterion(y_pred, y)

# Step 3: Backward Pass
optimizer.zero_grad()     # Clear old gradients
loss.backward()           # Backpropagate
optimizer.step()          # Update weights

---

🧠 6. Visual Explanation:

Training Flowchart:

          Prediction
              ↑
          Forward Pass
              ↓
        Loss Calculation
              ↓
        Backward Pass
              ↓
    Gradient w.r.t. Weights
              ↓
       Optimizer Step
              ↓
        Weights Updated

---

🔍 7. Roles of Key PyTorch Methods:

Method	Purpose
loss.backward()	Gradient calculate करता है loss से सभी weights तक
optimizer.step()	Calculated gradients को use करके weights update करता है
optimizer.zero_grad()	पुराने gradients को clear करता है

---

💡 उदाहरण: Gradient कैसे काम करता है?

मान लीजिए model ने y^=0.8 predict किया और true label था y=1, तो loss होगा: L=(y−y^)2=(1−0.8)2=0.04

इसका gradient: dL/ dy =2(y^−y)=2(0.8−1)=−0.4

यह negative gradient बताता है कि prediction कम था, weight को बढ़ाने की ज़रूरत है।

---

📝 अभ्यास प्रश्न (Practice Questions):

1. Backward Pass क्या करता है neural network में?
2. Gradient Descent का update rule लिखिए
3. PyTorch में loss.backward() किसका काम करता है?
4. Chain Rule क्यों ज़रूरी है backpropagation में?
5. Learning Rate अधिक होने से क्या खतरा होता है?

---

🎯 Objectives Recap:

• Backward Pass = Loss से gradient निकालने की प्रक्रिया
• Gradient Descent = Weights update करने की तकनीक
• Chain Rule = Gradient को propagate करने का आधार
• PyTorch ने इस पूरे process को automate किया है