अब हम PyTorch में Model Training, फिर उसे Save और Load करने की पूरी प्रक्रिया विस्तार से सीखते हैं —
जो किसी भी Deep Learning project का core हिस्सा है।
🔷 1. 🔁 Model Training in PyTorch
🧱 Training Steps Overview:
- Model बनाना (
nn.Module) - Loss function चुनना (
nn.CrossEntropyLoss, etc.) - Optimizer सेट करना (
torch.optim) - Forward pass करना
- Loss calculate करना
- Backward pass (
loss.backward()) - Optimizer step (
optimizer.step())
🧪 Full Example (Classifier):
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
# Sample data
X = torch.tensor([[0.,0.],[0.,1.],[1.,0.],[1.,1.]])
y = torch.tensor([[0.],[1.],[1.],[0.]])
dataset = TensorDataset(X, y)
dataloader = DataLoader(dataset, batch_size=2, shuffle=True)
# Step 1: Model
class XORNet(nn.Module):
def __init__(self):
super(XORNet, self).__init__()
self.fc1 = nn.Linear(2, 4)
self.fc2 = nn.Linear(4, 1)
def forward(self, x):
x = torch.relu(self.fc1(x))
return torch.sigmoid(self.fc2(x))
model = XORNet()
# Step 2: Loss and Optimizer
criterion = nn.BCELoss()
optimizer = optim.Adam(model.parameters(), lr=0.1)
# Step 3: Training loop
for epoch in range(500):
for xb, yb in dataloader:
y_pred = model(xb)
loss = criterion(y_pred, yb)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if epoch % 100 == 0:
print(f"Epoch {epoch}, Loss: {loss.item():.4f}")
🔷 2. 💾 Saving a PyTorch Model
PyTorch में 2 तरीके हैं model save करने के:
✅ Option 1: State Dict Only (Recommended)
torch.save(model.state_dict(), "xor_model.pth")
यह केवल model के weights save करता है, architecture नहीं।
✅ Option 2: Complete Model (Not Recommended)
torch.save(model, "xor_model_full.pth")
यह पूरा model + structure save करता है, पर version compatibility issues आ सकते हैं।
🔷 3. 📂 Loading a Model
🔁 Load from State Dict (Best Practice):
model = XORNet() # पहले architecture बनाओ
model.load_state_dict(torch.load("xor_model.pth"))
model.eval() # evaluation mode में डालना ज़रूरी
🔍
.eval()inference के समय BatchNorm / Dropout को deactivate करता है।
🧠 Bonus: GPU Compatibility (Saving/Loading)
✅ Save on GPU, Load on CPU:
# Save (from GPU)
torch.save(model.state_dict(), "model_gpu.pth")
# Load on CPU
device = torch.device("cpu")
model.load_state_dict(torch.load("model_gpu.pth", map_location=device))
🧪 Example: Inference After Loading
model.eval()
with torch.no_grad():
test = torch.tensor([[1., 1.]])
output = model(test)
print("Predicted:", output.item())
📦 Advanced Tip: Save Optimizer State Too
torch.save({
'model_state': model.state_dict(),
'optimizer_state': optimizer.state_dict(),
}, "checkpoint.pth")
Load Later:
checkpoint = torch.load("checkpoint.pth")
model.load_state_dict(checkpoint['model_state'])
optimizer.load_state_dict(checkpoint['optimizer_state'])
🧠 Evaluation Tips
- हमेशा
model.eval()use करें inference के लिए torch.no_grad()में prediction करें (memory efficiency के लिए)- Large models के लिए model checkpoints का उपयोग करें
📝 Practice Questions:
- PyTorch में model train करने के मुख्य steps क्या हैं?
- State dict और full model saving में क्या अंतर है?
- Optimizer state क्यों save करना चाहिए?
.eval()और.train()modes में क्या फर्क है?- Inference में
torch.no_grad()का उपयोग क्यों करें?
🧠 Summary Table
| Task | Method |
|---|---|
| 🔧 Train | Forward → Loss → Backward → Optimizer |
| 💾 Save Weights | torch.save(model.state_dict(), path) |
| 📂 Load Weights | model.load_state_dict(torch.load(path)) |
| 📌 Inference | model.eval() + with torch.no_grad() |
| 🔁 Save with Optimizer | Use checkpoint = {'model': ..., 'opt': ...} |
