Using GPUs and TPUs in Deep Learning

July 12, 2025 by Anand Singh

अब जब आप PyTorch और Keras दोनों में model बना और train कर रहे हैं, तो performance boost के लिए GPU/TPU का इस्तेमाल करना ज़रूरी हो जाता है — खासकर बड़े datasets या deep models के लिए।

🔷 1. 🔥 Why Use GPUs?

CPU vs GPU	GPU Advantage
Sequential	Parallel computing
Few cores	Thousands of cores
Slower matrix ops	Faster tensor operations
General-purpose	Special for ML/DL, CUDA-optimized

🔶 PyTorch में GPU का उपयोग कैसे करें?

✅ Step 1: Check GPU Availability

import torch

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("Using device:", device)

✅ Step 2: Model और Data को GPU पर भेजना

model = MyNet().to(device)  # Model को GPU पर भेजें
X = X.to(device)
y = y.to(device)

✅ Training Code में बदलाव:

for epoch in range(1000):
    y_pred = model(X)
    loss = criterion(y_pred, y)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

बस यह ध्यान रखें कि model और data दोनों एक ही device पर होने चाहिए।

🔷 2. GPU से Prediction (Inference)

model.eval()
with torch.no_grad():
    test = torch.tensor([[1., 0.]]).to(device)
    output = model(test)
    print("Prediction:", output.item())

🔷 3. Keras (TensorFlow) में GPU का उपयोग

TensorFlow अपने आप GPU को detect करता है और उपयोग करता है (अगर उपलब्ध हो)। बस ensure करें कि:

TensorFlow-GPU version install हो
NVIDIA Drivers + CUDA Toolkit सही से install हो

✅ Check GPU:

import tensorflow as tf
print("Num GPUs Available:", len(tf.config.list_physical_devices('GPU')))

✅ Tensor और Model GPU पर चलेंगे अपने आप:

model.fit(X, y, epochs=10)  # If GPU available, TensorFlow will use it

✅ Manually GPU select करना:

with tf.device('/GPU:0'):
    model = tf.keras.Sequential([...])
    model.compile(...)
    model.fit(...)

🔷 4. Google Colab में GPU/TPU Use

✅ GPU Enable करें:

Runtime → Change runtime type → Hardware accelerator → GPU or TPU

✅ Check GPU/TPU:

import tensorflow as tf
print(tf.config.list_physical_devices('GPU'))   # For GPU
print(tf.config.list_logical_devices('TPU'))    # For TPU

🔷 5. TPUs क्या होते हैं?

Aspect	Detail
TPU	Tensor Processing Unit (Google द्वारा बनाया गया)
Speed	GPU से भी तेज़ है कुछ tasks में
Best for	Very large models, production-level serving
Use	Mainly in Google Colab, Cloud TPUs, TensorFlow

📝 Practice Questions:

PyTorch में GPU support कैसे check करते हैं?
Model को GPU पर भेजने के लिए कौनसा syntax है?
TensorFlow GPU vs TPU में क्या अंतर है?
Google Colab में GPU enable कैसे करते हैं?
क्या CPU से GPU training में फर्क आता है?

🧠 Summary Table

Task	PyTorch	Keras (TF)
GPU Check	`torch.cuda.is_available()`	`tf.config.list_physical_devices()`
Send to GPU	`x.to(device)`	Automatic
Model to GPU	`model.to(device)`	Automatic
Use Colab GPU	Runtime > Change > GPU	Same
TPU Support	❌ (Limited)	✅ (Good)

Model Training, Saving, and Loading in Keras

July 12, 2025 by Anand Singh

अब हम Keras (जो TensorFlow का high-level API है) में Deep Learning Model को Train, Save, और Load करना सीखेंगे — step-by-step और practical examples के साथ।

🔷 1. ✅ Model Training in Keras (Step-by-Step)

📌 Step 1: Import Libraries

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

📌 Step 2: Define Model

model = Sequential([
    Dense(8, activation='relu', input_shape=(2,)),
    Dense(1, activation='sigmoid')
])

📌 Step 3: Compile Model

model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy']
)

📌 Step 4: Prepare Data

import numpy as np

X = np.array([[0,0], [0,1], [1,0], [1,1]])
y = np.array([0, 1, 1, 0])

📌 Step 5: Train Model

model.fit(X, y, epochs=100, batch_size=2, verbose=1)

🔷 2. 💾 Saving a Keras Model

✅ Option 1: Save Full Model (Best Practice)

model.save("my_model.h5")  # Saves architecture + weights + optimizer state

OR in newer format:

model.save("my_model.keras")  # New native format

✅ Option 2: Save Only Weights

model.save_weights("model_weights.h5")

🔷 3. 📂 Loading a Saved Model

✅ Load Full Model:

from tensorflow.keras.models import load_model

model = load_model("my_model.h5")

This will return the model ready to use — no need to recompile or redefine.

✅ Load Only Weights:

First define the model architecture same as before:

model = Sequential([
    Dense(8, activation='relu', input_shape=(2,)),
    Dense(1, activation='sigmoid')
])

Then load the weights:

model.load_weights("model_weights.h5")

🔷 4. 🔁 Save and Load during Training (Checkpointing)

✅ Use ModelCheckpoint Callback

from tensorflow.keras.callbacks import ModelCheckpoint

checkpoint = ModelCheckpoint("best_model.h5", save_best_only=True, monitor="loss")

model.fit(X, y, epochs=50, callbacks=[checkpoint])

🔷 5. 🧪 Inference (Prediction)

pred = model.predict(np.array([[1, 0]]))
print("Prediction:", pred[0][0])

🧠 Use .predict() method for classification, regression, or output generation.

🔧 Extra: Exporting to TF Lite (Mobile/Edge)

converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()

with open('model.tflite', 'wb') as f:
    f.write(tflite_model)

📝 Practice Questions:

Keras में model train करने के steps क्या हैं?
.h5 और .keras में क्या अंतर है?
model.save() और model.save_weights() में क्या फर्क है?
Training के दौरान best model कैसे save करते हैं?
Model load करने के बाद inference कैसे करते हैं?

🧠 Summary Table

Task	Keras Method
Train Model	`model.fit()`
Save Full Model	`model.save("model.h5")`
Save Only Weights	`model.save_weights()`
Load Full Model	`load_model("model.h5")`
Load Weights Only	`model.load_weights()`
Predict / Inference	`model.predict(x)`
Save Best during Training	`ModelCheckpoint(callback)`

Model Training, Saving, and Loading in PyTorch

July 12, 2025 by Anand Singh

अब हम 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': ...}`

Introduction of PyTorch – Complete Beginner Guide with Examples

August 8, 2026July 12, 2025 by Anand Singh

Introduction of PyTorch

अगर आप Machine Learning, Deep Learning, Computer Vision, Natural Language Processing या Artificial Intelligence सीखना शुरू कर रहे हैं, तो आपने PyTorch का नाम जरूर सुना होगा।

PyTorch एक powerful framework है जिसकी help से हम tensors पर mathematical operations कर सकते हैं, neural networks बना सकते हैं, models को train कर सकते हैं और CPU या GPU पर computations perform कर सकते हैं। Official PyTorch documentation इसे CPU और GPU दोनों के लिए optimized tensor library के रूप में describe करती है।

Simple language में कहें तो:

PyTorch Python की help से Deep Learning models बनाने और train करने का एक framework है।

Suppose हमें images देखकर यह पता करना है कि image में cat है या dog। इसके लिए हमें image data load करना होगा, उसे numbers में convert करना होगा, neural network बनाना होगा, model को examples दिखाकर train करना होगा और फिर new image पर prediction करनी होगी।

PyTorch इन सभी steps को handle करने के लिए useful tools provide करता है।

इस chapter में हम PyTorch को बिल्कुल basic level से समझेंगे। हमारा focus केवल code याद करने पर नहीं होगा। हम यह भी समझेंगे कि Tensor क्या है, GPU क्यों use होता है, gradient क्या करता है, model कैसे learn करता है और training loop के अंदर वास्तव में क्या होता है।

What is PyTorch?

PyTorch एक Python-based open-source framework है जिसका main use tensor computation और deep neural networks बनाने में होता है। इसके important components में tensor library, automatic differentiation system, neural-network modules, optimizers और data-loading utilities शामिल हैं।

PyTorch में Deep Learning model बनाने का basic flow इस तरह समझ सकते हैं:

Data → Tensor → Model → Prediction → Loss → Gradient → Weight Update → Better Prediction

यही पूरा Deep Learning का basic cycle है।

मान लीजिए हमारे पास students का data है:

Study Hours	Attendance	Result
2	55%	Fail
4	65%	Pass
6	80%	Pass
8	90%	Pass

हम चाहते हैं कि computer पुराने data को देखकर new student के result का prediction करे।

PyTorch की help से हम इस data को tensors में convert करेंगे, model बनाएंगे, prediction करेंगे, prediction की error calculate करेंगे और model के parameters update करेंगे।

बार-बार यही process होने पर model धीरे-धीरे data से pattern learn करता है।

Why Do We Need PyTorch?

Theoretically neural network को केवल Python और mathematics की help से भी बनाया जा सकता है।

Suppose हमारे पास एक simple neuron है: y=wx+b

यहां x input है, w weight है, b bias है और y output है।

एक छोटे model के लिए calculations manually लिखना possible है। लेकिन modern neural networks में लाखों या कभी-कभी बहुत बड़ी संख्या में parameters हो सकते हैं। ऐसे models में matrices, gradients, optimization, batching और hardware acceleration manually manage करना practical नहीं होता।

PyTorch इस complexity को आसान बनाता है।

उदाहरण के लिए matrix multiplication:

import torch

A = torch.tensor([[1, 2],
                  [3, 4]])

B = torch.tensor([[5, 6],
                  [7, 8]])

C = torch.matmul(A, B)

print(C)

PyTorch required tensor operation perform कर देता है और यही type की operations neural networks के अंदर बहुत बड़ी scale पर होती हैं।

Main Features of PyTorch

PyTorch का core tensor computation पर आधारित है और इसके साथ torch.autograd, torch.nn, torch.optim, Dataset और DataLoader जैसे components मिलते हैं। torch.autograd gradient calculation automate करता है, torch.nn.Module neural-network models का base class है और torch.optim model parameters update करने वाले optimizers provide करता है।

Beginner के लिए PyTorch को इन major parts में समझना सबसे useful है:

PyTorch Component	Main Work
`torch.Tensor`	Data को numerical form में store करना
`torch.autograd`	Gradients automatically calculate करना
`torch.nn`	Neural network layers और models बनाना
`torch.optim`	Model weights update करना
`Dataset`	Individual data samples manage करना
`DataLoader`	Data को batches में model तक पहुंचाना
`torch.save()`	Model/tensors save करना
`torch.load()`	Saved information load करना

Official documentation के अनुसार DataLoader dataset पर Python iterable provide करता है और batching, loading order तथा single या multi-process data loading जैसी capabilities support करता है।

Installing PyTorch

सबसे पहले Python system में installed होना चाहिए।

Basic pip environment में PyTorch install करने के लिए commonly यह command use की जाती है:

pip install torch torchvision torchaudio

लेकिन GPU/CUDA support hardware और environment के अनुसार अलग हो सकता है, इसलिए GPU-based installation के लिए official PyTorch installation selector के अनुसार command choose करना better है।

Installation check करने के लिए:

import torch

print(torch.__version__)

अगर version print हो जाता है, तो PyTorch successfully import हो रहा है।

Your First PyTorch Program

सबसे simple program:

import torch

x = torch.tensor([10, 20, 30, 40])

print(x)

Output लगभग इस प्रकार होगा:

tensor([10, 20, 30, 40])

यहां:

import torch

PyTorch library import करता है।

और:

torch.tensor(...)

Python values को PyTorch Tensor में convert करता है।

अब सबसे important question आता है:

Tensor आखिर है क्या?

What is a Tensor in PyTorch?

Tensor PyTorch का सबसे basic और important concept है।

Easy language में:

Tensor numbers को organized form में store करने वाला multidimensional data structure है।

अगर आपने Mathematics में scalar, vector और matrix पढ़ा है तो Tensor को समझना बहुत आसान है।

Dimension	Example	सामान्य नाम
0D	`5`	Scalar
1D	`[1,2,3]`	Vector
2D	`[[1,2],[3,4]]`	Matrix
3D+	Multiple matrices	Higher-dimensional Tensor

उदाहरण:

import torch

a = torch.tensor(5)

b = torch.tensor([1, 2, 3])

c = torch.tensor([
    [1, 2],
    [3, 4]
])

print(a)
print(b)
print(c)

Why Are Tensors Important?

Computer directly image को वैसे नहीं देखता जैसे human देखता है।

Suppose एक RGB image की size है:

224 × 224

हर pixel में Red, Green और Blue information होती है।

Deep Learning में ऐसी image को numerical tensor के रूप में represent किया जा सकता है, जैसे:

3 × 224 × 224

जहां 3 RGB channels को show कर सकता है।

इसी तरह text, audio और tabular data को भी suitable numerical representation में convert करके tensors के माध्यम से process किया जा सकता है।

इसलिए Deep Learning का बड़ा हिस्सा अंत में tensor operations पर आ जाता है।

Creating Tensors

PyTorch में tensors कई तरीकों से create किए जा सकते हैं।

Tensor from values

import torch

x = torch.tensor([1, 2, 3, 4])

print(x)

Tensor filled with zeros

x = torch.zeros(3, 3)

print(x)

Output:

tensor([[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]])

Tensor filled with ones

x = torch.ones(2, 3)

print(x)

Random Tensor

x = torch.rand(2, 3)

print(x)

Random tensors Deep Learning में बहुत useful हैं। उदाहरण के लिए neural network parameters को शुरुआत में random values से initialize किया जा सकता है।

Tensor Shape

Tensor का shape हमें बताता है कि tensor में कितनी dimensions हैं और हर dimension की size क्या है।

import torch

x = torch.tensor([
    [1, 2, 3],
    [4, 5, 6]
])

print(x.shape)

Output:

torch.Size([2, 3])

इसका मतलब tensor में:

2 Rows
3 Columns

हैं।

Deep Learning में shape समझना बहुत important है क्योंकि बहुत common errors tensor shape mismatch के कारण आते हैं।

Tensor Data Type

Tensor के अंदर अलग-अलग types का data हो सकता है।

import torch

x = torch.tensor([1.5, 2.5, 3.5])

print(x.dtype)

Possible output:

torch.float32

Machine Learning models में floating-point tensors बहुत commonly use होते हैं।

हम manually datatype भी define कर सकते हैं:

x = torch.tensor([1, 2, 3], dtype=torch.float32)

print(x)

Basic Tensor Operations

PyTorch में tensor पर normal mathematical operations आसानी से perform किए जा सकते हैं।

import torch

a = torch.tensor([10, 20, 30])
b = torch.tensor([1, 2, 3])

print(a + b)
print(a - b)
print(a * b)
print(a / b)

यहां * element-wise multiplication करता है।

Matrix multiplication के लिए:

A = torch.tensor([[1., 2.],
                  [3., 4.]])

B = torch.tensor([[5., 6.],
                  [7., 8.]])

C = torch.matmul(A, B)

print(C)

Neural networks के अंदर इसी type की matrix operations बार-बार होती हैं।

CPU and GPU in PyTorch

Deep Learning models में बहुत large mathematical calculations होती हैं। GPU many numerical operations को parallel तरीके से execute करने में useful हो सकता है, और PyTorch tensors GPU hardware पर computation के लिए move किए जा सकते हैं. PyTorch का tensor system GPU acceleration support करता है।

Available CUDA GPU check करने के लिए commonly:

import torch

print(torch.cuda.is_available())

हम device select कर सकते हैं:

device = torch.device(
    "cuda" if torch.cuda.is_available() else "cpu"
)

print(device)

Tensor को selected device पर भेज सकते हैं:

x = torch.tensor([1., 2., 3.])

x = x.to(device)

print(x)

अगर CUDA GPU available है तो tensor GPU पर जा सकता है, otherwise CPU पर रहेगा।

Model को भी similarly device पर भेजा जाता है:

model = model.to(device)

Important point यह है कि operation में use होने वाले model और tensors compatible device पर होने चाहिए।

What is Autograd?

अब PyTorch का एक बहुत important concept आता है:

`torch.autograd`

Neural network को train करने के लिए हमें यह जानना होता है कि model की error को कम करने के लिए weights को किस direction में change करना चाहिए।

इसके लिए gradients calculate किए जाते हैं।

PyTorch में torch.autograd automatic differentiation engine है जो computational graph से gradients calculate कर सकता है। Official PyTorch tutorial के अनुसार backpropagation के दौरान gradients के आधार पर model parameters adjust किए जाते हैं।

Simple example:

import torch

x = torch.tensor(2.0, requires_grad=True)

y = x ** 2

y.backward()

print(x.grad)

यहां:

y = x²

तो derivative:

dy/dx = 2x

और x = 2 पर gradient:

मिलेगा।

PyTorch ने यह derivative manually लिखवाए बिना calculate कर दिया।

यही feature बड़े neural networks को train करने में extremely useful है।

What Does `requires_grad=True` Mean?

जब हम लिखते हैं:

x = torch.tensor(2.0, requires_grad=True)

तो हम PyTorch को बताते हैं कि इस tensor पर होने वाले operations का gradient track करना है।

Official documentation के अनुसार requires_grad_() autograd को tensor operations record करना शुरू करने के लिए use किया जा सकता है।

Deep Learning में model weights के gradients needed होते हैं ताकि optimizer उन्हें update कर सके।

What is a Neural Network?

Neural Network एक mathematical model है जो input data से patterns learn करने की कोशिश करता है।

Simple neuron को ऐसे imagine करें:

Input
  ↓
Weight
  ↓
Weighted Calculation
  ↓
Bias
  ↓
Activation
  ↓
Output

Basic equation: y=wx+b

जहां:

x = Input
w = Weight
b = Bias
y = Output

जब multiple neurons और layers combine होते हैं, neural network बनता है।

`torch.nn` in PyTorch

PyTorch में neural networks बनाने के लिए torch.nn package दिया गया है। torch.nn.Module सभी neural-network modules का base class है और custom models generally इसी से subclass किए जाते हैं।

Example:

import torch
import torch.nn as nn

class SimpleModel(nn.Module):

    def __init__(self):
        super().__init__()

        self.layer = nn.Linear(2, 1)

    def forward(self, x):
        return self.layer(x)

Model create करें:

model = SimpleModel()

print(model)

Understanding `nn.Linear`

Suppose:

nn.Linear(2, 1)

इसका meaning है:

2 Input Features
       ↓
Linear Layer
       ↓
1 Output

अगर हमारे student example में inputs हैं:

Study Hours
Attendance

तो 2 input features होंगे।

Output:

Predicted Score

एक value हो सकती है।

Linear layer internally weights और bias use करती है।

What is the Forward Method?

हर PyTorch model में commonly:

def forward(self, x):

define किया जाता है।

यह बताता है कि input model के अंदर किस path से जाएगा।

Example:

def forward(self, x):

    x = self.layer1(x)

    x = self.relu(x)

    x = self.layer2(x)

    return x

Flow:

Input
 ↓
Layer 1
 ↓
ReLU
 ↓
Layer 2
 ↓
Output

इस process को forward pass कहा जाता है।

Dataset and DataLoader

Real Deep Learning project में data बहुत बड़ा हो सकता है।

मान लीजिए हमारे पास:

100,000 images

हैं।

सभी images को एक साथ memory में load करना हमेशा practical नहीं होता।

PyTorch इस problem को handle करने के लिए Dataset और DataLoader abstractions provide करता है। Official tutorial के अनुसार Dataset individual samples access/processing करता है, जबकि DataLoader samples को collect करके batches में training loop तक पहुंचाता है।

Simple concept:

Complete Dataset
      ↓
DataLoader
      ↓
Batch 1
Batch 2
Batch 3
...
      ↓
Model

Example:

from torch.utils.data import TensorDataset, DataLoader
import torch

X = torch.tensor([
    [1., 2.],
    [2., 3.],
    [3., 4.],
    [4., 5.]
])

y = torch.tensor([
    [1.],
    [2.],
    [3.],
    [4.]
])

dataset = TensorDataset(X, y)

loader = DataLoader(
    dataset,
    batch_size=2,
    shuffle=True
)

अब training के समय:

for inputs, targets in loader:

    print(inputs)
    print(targets)

Data batches में मिलेगा।

What is Batch Size?

Suppose dataset में:

1000 samples

हैं।

अगर:

batch_size = 100

तो roughly 10 batches बनेंगे।

एक batch:

100 samples

model को एक साथ देगा।

Batching training को manageable बनाती है और hardware resources effectively use करने में help कर सकती है।

What is Loss Function?

Model पहली बार correct prediction नहीं करता।

Suppose:

Actual Value = 10
Prediction   = 6

तो prediction गलत है।

लेकिन computer को कैसे पता चलेगा कि prediction कितना गलत है?

यह काम Loss Function करती है।

Loss एक numerical value देती है जो model prediction और target के difference को represent करती है।

Regression में example:

criterion = nn.MSELoss()

Classification में problem के अनुसार दूसरे loss functions use किए जाते हैं।

Concept:

Prediction
    +
Actual Target
    ↓
Loss Function
    ↓
Error

Training का main objective generally इसी loss को reduce करना होता है।

What is an Optimizer?

Gradient calculate हो जाने के बाद model weights automatically खुद नहीं बदलते।

Weights update करने के लिए optimizer use किया जाता है।

PyTorch का torch.optim package optimizers provide करता है जो model parameters का state रखकर उन्हें calculated optimization rule के अनुसार update करते हैं।

Example:

optimizer = torch.optim.Adam(
    model.parameters(),
    lr=0.001
)

यहां:

Adam = Optimizer
lr = Learning Rate

Learning rate decide करती है कि एक update में parameters कितने change होंगे।

Complete Training Process in PyTorch

अब PyTorch का सबसे important concept समझते हैं।

Training loop generally इस flow को follow करता है:

Data
 ↓
Model
 ↓
Prediction
 ↓
Loss
 ↓
Backward Pass
 ↓
Gradient
 ↓
Optimizer
 ↓
Weight Update
 ↓
Next Batch

Official PyTorch training tutorial भी Dataset/DataLoader, loss function, optimizer और training loop को model training के मुख्य building blocks के रूप में explain करता है।

Basic code:

for epoch in range(100):

    for inputs, targets in loader:

        optimizer.zero_grad()

        predictions = model(inputs)

        loss = criterion(predictions, targets)

        loss.backward()

        optimizer.step()

अब इसे line-by-line समझते हैं।

Step 1: `optimizer.zero_grad()`

optimizer.zero_grad()

Previous gradient values clear करता है ताकि current training step के gradients clean तरीके से calculate किए जा सकें।

Step 2: Forward Pass

predictions = model(inputs)

Input model में जाता है और prediction मिलता है।

Example:

Input = 5 hours study
Model Prediction = 70 Marks

Step 3: Calculate Loss

loss = criterion(predictions, targets)

Prediction को actual value से compare किया जाता है।

Example:

Prediction = 70
Actual     = 80

Loss function difference को numerical form में represent करती है।

Step 4: Backward Pass

loss.backward()

यह gradients calculate करता है।

Conceptually model पूछ रहा है:

कौन-से weights prediction की error के लिए responsible हैं और उन्हें किस direction में change करना चाहिए?

Autograd इस gradient calculation को automatically handle करता है।

Step 5: Update Weights

optimizer.step()

Optimizer calculated gradients के basis पर model parameters update करता है।

फिर अगला batch आता है और यही process repeat होता है।

What is an Epoch?

Suppose training dataset में:

10,000 images

हैं।

जब model सभी 10,000 training images को एक बार process कर लेता है, इसे generally:

1 Epoch

कहा जाता है।

अगर:

epochs = 20

तो model complete training dataset को 20 passes तक process करेगा।

लेकिन ज्यादा epochs का मतलब हमेशा better model नहीं होता। कुछ point के बाद model training data पर overfit भी कर सकता है।

Simple Complete PyTorch Example

अब एक छोटा model देखते हैं:

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

X = torch.tensor([
    [1.0],
    [2.0],
    [3.0],
    [4.0]
])

y = torch.tensor([
    [2.0],
    [4.0],
    [6.0],
    [8.0]
])

model = nn.Linear(1, 1)

criterion = nn.MSELoss()

optimizer = optim.SGD(
    model.parameters(),
    lr=0.01
)

for epoch in range(1000):

    prediction = model(X)

    loss = criterion(prediction, y)

    optimizer.zero_grad()

    loss.backward()

    optimizer.step()

print(model(torch.tensor([[5.0]])))

यहां training data roughly relation follow कर रहा है:

y = 2x

Examples:

Model training के बाद 5 के लिए value approximately 10 के आसपास learn करने की कोशिश करेगा।

यह बहुत छोटा example है, लेकिन Deep Learning की basic learning philosophy इसी से शुरू होती है।

PyTorch Model Training को आसान तरीके से समझें

मान लीजिए कोई student पहली बार maths question solve करता है।

Teacher कहता है:

Your Answer = 50
Correct Answer = 80

Student अपनी mistake देखता है और अगली बार method improve करता है।

Deep Learning model के साथ similar conceptual cycle होता है:

Student Learning	Neural Network
Question	Input
Student Answer	Prediction
Correct Answer	Target
Mistake	Loss
Mistake Analysis	Gradient
Learning	Weight Update
Repeated Practice	Epochs

इस analogy से training process बहुत आसानी से समझ आता है।

Training Mode and Evaluation Mode

Model training और testing के समय कुछ layers अलग behaviour कर सकती हैं।

Training के समय:

model.train()

Evaluation के समय:

model.eval()

Inference में gradient calculation की जरूरत न हो तो commonly:

with torch.no_grad():

    prediction = model(x)

use किया जाता है।

Saving a PyTorch Model

Model train करने में काफी time लग सकता है। इसलिए trained model को save किया जाता है।

PyTorch torch.save() serialization provide करता है और .pt extension commonly tensors/model-related files के लिए use की जाती है।

Example:

torch.save(
    model.state_dict(),
    "model.pth"
)

यह model parameters save करता है।

Loading a Model

Model load करने के लिए:

model = SimpleModel()

model.load_state_dict(
    torch.load("model.pth")
)

model.eval()

PyTorch की loading utilities saved tensors और model state restore करने के लिए use की जाती हैं; device mapping भी load के समय control की जा सकती है।

इसका फायदा यह है कि model को बार-बार train करने की जरूरत नहीं होती।

PyTorch and NumPy

NumPy और PyTorch दोनों multidimensional numerical arrays के साथ काम कर सकते हैं।

Beginner level पर difference इस तरह समझ सकते हैं:

Feature	NumPy	PyTorch
Numerical Arrays	Yes	Yes
Tensor Operations	Array-based	Tensor-based
Automatic Gradient	Main feature नहीं	Yes
Neural Network Tools	Built-in DL framework नहीं	Yes
GPU-oriented DL workflow	Limited/general external setup	PyTorch का core use case
Deep Learning	Additional libraries चाहिए	Built-in ecosystem

PyTorch project खुद tensor computation को NumPy-like functionality और strong GPU acceleration के साथ describe करता है।

अगर आपने NumPy पहले सीखा है, तो PyTorch tensors समझना relatively आसान हो सकता है।

Where is PyTorch Used?

PyTorch का ecosystem computer vision, NLP और other deep-learning applications के लिए libraries और tools provide करता है। Official project site distributed training और broader ecosystem support को भी highlight करती है।

Practical projects में PyTorch का use image classification, object detection, image captioning, segmentation, text classification, language models, medical image analysis, regression, generative models और research prototypes जैसे tasks में किया जा सकता है।

उदाहरण के लिए image classification system का flow:

Image
 ↓
Preprocessing
 ↓
Tensor
 ↓
CNN / Vision Model
 ↓
Features
 ↓
Classifier
 ↓
Cat / Dog

Text application का basic flow:

Sentence
 ↓
Tokenization
 ↓
Numerical Representation
 ↓
Neural Network
 ↓
Prediction

PyTorch for Computer Vision

Computer Vision में images को tensors की form में process किया जाता है।

Suppose हमारे पास RGB image है।

Conceptually:

Image
 ↓
Resize
 ↓
Convert to Tensor
 ↓
Normalization
 ↓
CNN / ViT
 ↓
Prediction

PyTorch ecosystem में image-oriented workflows के लिए torchvision जैसे tools commonly use किए जाते हैं।

Deep Learning based computer vision में PyTorch इसलिए useful है क्योंकि tensor operations, neural-network modules, gradients और GPU computations एक integrated workflow में मिल जाते हैं।

PyTorch for Deep Learning Research

Research में कई बार हमें existing architecture को modify करना पड़ता है।

Suppose standard neural network में researcher नया attention block add करना चाहता है।

PyTorch में custom classes create करके model architecture define किया जा सकता है:

class MyModel(nn.Module):

    def __init__(self):
        super().__init__()

        # custom layers

    def forward(self, x):

        # custom processing

        return x

nn.Module modules को nested structure में organize करने की ability देता है, इसलिए complex models multiple reusable components में build किए जा सकते हैं।

यही flexibility research-oriented model development में काफी useful होती है।

Important PyTorch Terms for Beginners

इन terms को clear रखना PyTorch सीखने में बहुत help करेगा:

Term	Easy Meaning
Tensor	Numerical data container
Shape	Tensor का size/structure
Device	CPU या GPU
Model	Pattern learn करने वाला system
Layer	Model का एक processing block
Parameter	Model द्वारा learn होने वाली value
Weight	Input की importance control करने वाला parameter
Bias	Additional learnable value
Forward Pass	Input से output prediction बनाना
Loss	Prediction की error
Gradient	Parameter change की direction/amount की information
Backpropagation	Gradient calculation process
Optimizer	Parameters update करने वाला algorithm
Learning Rate	Update step की size
Batch	Data का छोटा group
Epoch	Complete training dataset पर एक full pass
Dataset	Training/testing data collection
DataLoader	Dataset को batches में supply करना
Inference	Trained model से prediction करना

Beginner Learning Path for PyTorch

PyTorch सीखते समय directly complex CNN, Transformer या LLM से start करना confusion create कर सकता है।

Better learning order इस प्रकार रखें:

Python Basics
      ↓
NumPy Basics
      ↓
Basic Mathematics
      ↓
PyTorch Tensor
      ↓
Tensor Operations
      ↓
CPU / GPU
      ↓
Autograd
      ↓
nn.Module
      ↓
Loss Function
      ↓
Optimizer
      ↓
Dataset & DataLoader
      ↓
Training Loop
      ↓
Simple Neural Network
      ↓
CNN
      ↓
Advanced Models

यह sequence follow करने पर आपको केवल PyTorch code नहीं बल्कि उसके पीछे का logic भी समझ आएगा।

Common Mistakes Beginners Make in PyTorch

PyTorch सीखते समय कुछ errors बहुत common हैं।

Shape Mismatch

Expected Shape ≠ Input Shape

Neural network layer को सही input dimensions देना जरूरी है।

CPU-GPU Device Mismatch

Model GPU पर और input CPU पर होने पर operation fail हो सकता है।

इसलिए:

model = model.to(device)
x = x.to(device)

जैसी consistency रखना useful है।

Wrong Data Type

कुछ operations specific datatype expect कर सकते हैं। Classification targets और model inputs के datatype requirements अलग हो सकते हैं।

Forgetting `zero_grad()`

Training loop में gradient management समझना जरूरी है।

Using Wrong Loss Function

Regression और classification problems के लिए loss function अलग हो सकती है।

Training Without Validation

सिर्फ training loss देखकर model की quality decide नहीं करनी चाहिए। Unseen validation/test data पर performance भी check करनी चाहिए।

Advantages of Learning PyTorch

PyTorch सीखने का सबसे बड़ा फायदा यह है कि यह आपको Deep Learning के major concepts practically समझने देता है।

जब आप manually training loop लिखते हैं, तो आपको clearly दिखाई देता है:

Input कहां गया?
Prediction कैसे आया?
Loss कैसे calculate हुआ?
Gradient कब बना?
Optimizer ने weights कब बदले?

इससे Deep Learning black box जैसा नहीं लगता।

PyTorch में low-level tensor operations से लेकर high-level neural-network components तक एक ही ecosystem में available हैं। Official documentation torch.Tensor, autograd, neural-network modules, optimizers और data utilities को core building blocks के रूप में expose करती है।

A Simple Real-Life Example

Suppose हम एक system बनाना चाहते हैं जो house price predict करे।

Inputs:

Area
Number of Rooms
Age of House
Location Score

Target:

House Price

PyTorch workflow:

House Data
    ↓
Convert to Tensor
    ↓
Dataset
    ↓
DataLoader
    ↓
Neural Network
    ↓
Predicted Price
    ↓
Compare with Actual Price
    ↓
Calculate Loss
    ↓
Backpropagation
    ↓
Optimizer Updates Weights
    ↓
Repeat Training

Training के बाद:

New House Details
       ↓
Trained Model
       ↓
Predicted Price

यही basic pattern image classification, disease prediction, text classification और कई दूसरे Machine Learning applications में अलग-अलग models के साथ दिखाई देता है।

Frequently Asked Questions About PyTorch

What is PyTorch in simple words?

PyTorch एक Deep Learning framework है जो tensors, neural networks, automatic gradients और model training के लिए tools provide करता है।

Is PyTorch only for Deep Learning?

PyTorch का major use Deep Learning में होता है, लेकिन इसकी tensor library general numerical computations के लिए भी useful है।

What is Tensor in PyTorch?

Tensor numerical data को multidimensional form में represent करता है। Deep Learning operations largely tensors पर perform होते हैं।

Can PyTorch use GPU?

हाँ। PyTorch tensor computation GPU hardware पर run कर सकता है जब compatible hardware/software environment available हो।

What is Autograd?

Autograd PyTorch का automatic differentiation system है जो computational graph के आधार पर gradients calculate करता है।

What is `nn.Module`?

torch.nn.Module PyTorch neural-network modules का base class है। Custom models generally इसे subclass करके बनाए जाते हैं।

What is DataLoader?

DataLoader dataset से samples लेकर उन्हें batches के रूप में training loop तक पहुंचाता है और batching तथा data-loading options provide करता है।

What is an optimizer?

Optimizer gradients के basis पर model parameters update करने के लिए use किया जाता है। PyTorch में optimizers torch.optim package के through available हैं।

Is Python required for PyTorch?

Beginner-level PyTorch learning और सामान्य PyTorch workflows के लिए Python knowledge बहुत important है, क्योंकि PyTorch का widely used interface Python-based है।

Should I learn NumPy before PyTorch?

Compulsory नहीं है, लेकिन NumPy का basic knowledge arrays, dimensions, indexing और matrix operations समझने में काफी help करता है।

Conclusion

PyTorch को समझने का सबसे आसान तरीका केवल commands याद करना नहीं है। उसके पूरे learning process को समझना ज्यादा important है।

सबसे पहले data को Tensor में represent किया जाता है। Tensor model में जाता है और model prediction produce करता है। Prediction को actual target से compare करके Loss calculate होती है। इसके बाद autograd gradients calculate करता है और Optimizer model parameters update करता है। यह process कई batches और epochs तक repeat होती है। PyTorch के official training materials भी Dataset/DataLoader, model, loss, autograd और optimizer को इसी training workflow के core parts के रूप में explain करते हैं।

पूरे PyTorch को एक line में याद रखना हो तो:

PyTorch = Tensors + Neural Network + Automatic Gradient + Optimization + Data Handling

और Deep Learning training को:

Data → Model → Prediction → Loss → Gradient → Weight Update → Repeat

अगर यह basic cycle अच्छी तरह समझ आ गई, तो आगे ANN, CNN, RNN, LSTM, Transformer, Computer Vision और advanced Deep Learning models समझना काफी आसान हो जाता है।

TensorFlow and Keras Basics

July 12, 2025 by Anand Singh

अब जब आपने Deep Learning के theory और models (जैसे CNN, RNN, BERT) अच्छे से समझ लिए हैं —
तो अगला practical step है:
⚙️ TensorFlow और Keras के साथ Deep Learning models बनाना सीखना।

🔷 1. TensorFlow क्या है?

TensorFlow एक open-source deep learning framework है जिसे Google ने बनाया है।
यह numerical computation और large-scale machine learning models के लिए design किया गया है।

🧠 TensorFlow का नाम “Tensor” (data structure) + “Flow” (computation graph) से आया है।

✅ Key Features:

Feature	Detail
📊 Automatic Differentiation	Gradient calculation
🧮 GPU/TPU Support	तेज़ computation
🧠 High-level + Low-level APIs	Flexibility
🔧 Deployment	Android, Web, Edge devices
🤝 Ecosystem	TF Hub, TF Lite, TF.js, TF-Serving

🔷 2. Keras क्या है?

Keras एक high-level deep learning API है, जो TensorFlow के ऊपर चलता है।
यह models को लिखना, train करना और debug करना बहुत आसान बना देता है।

🎯 “Keras = Simplicity + Productivity + Modularity”

✅ Keras क्यों चुनें?

Benefit	Reason
🚀 Easy to Learn	Pythonic syntax
🧩 Modular	Layers, Optimizers, Loss अलग-अलग
🧠 Powerful	Advanced models possible
🔧 Fast prototyping	जल्दी result देखने के लिए
🔌 TF Backend	TensorFlow की ताकत use करता है

🔷 3. Tensor, Model, and Layer Basics

🔹 Tensor:

Multidimensional array (जैसे NumPy array, लेकिन GPU-compatible)

import tensorflow as tf
x = tf.constant([[1, 2], [3, 4]])
print(x.shape)  # (2, 2)

🔹 Layer:

Neural network का एक building block (Dense, Conv2D, LSTM)

from tensorflow.keras.layers import Dense
dense = Dense(units=64, activation='relu')

🔹 Model:

Input से Output तक का पूरा network architecture

from tensorflow.keras.models import Sequential

model = Sequential([
    Dense(128, activation='relu'),
    Dense(10, activation='softmax')
])

🔷 4. Keras में Model बनाना (Step-by-Step)

✅ Step 1: Import

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

✅ Step 2: Model Define

model = Sequential([
    Dense(64, activation='relu', input_shape=(100,)),
    Dense(10, activation='softmax')
])

✅ Step 3: Compile

model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

✅ Step 4: Train

model.fit(x_train, y_train, epochs=10, batch_size=32)

✅ Step 5: Evaluate

model.evaluate(x_test, y_test)

🧪 Example: Simple Binary Classifier

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

model = Sequential([
    Dense(16, activation='relu', input_shape=(2,)),
    Dense(1, activation='sigmoid')
])

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

model.fit(X_train, y_train, epochs=20)

🔧 Useful Layers in Keras

Layer	Use
Dense	Fully connected layer
Conv2D	Image convolution layer
LSTM / GRU	Sequence modeling
Dropout	Regularization
Flatten	Input flattening
Embedding	Word embedding for NLP

🧠 Visualization: Model Summary

model.summary()

📝 Practice Questions:

TensorFlow और Keras में क्या अंतर है?
Sequential model क्या होता है?
Model को compile करने में किन चीज़ों की ज़रूरत होती है?
Dense layer क्या है?
एक simple 3-layer model का कोड लिखिए।

🧠 Summary Table

Concept	Description
TensorFlow	Google का ML framework
Keras	Easy high-level API
Tensor	Multidimensional data
Layer	Model का हिस्सा (Dense, Conv)
Model	Complete NN architecture

🔷 1. 🔥 Why Use GPUs?

🔶 PyTorch में GPU का उपयोग कैसे करें?

✅ Step 1: Check GPU Availability

✅ Step 2: Model और Data को GPU पर भेजना

✅ Training Code में बदलाव:

🔷 2. GPU से Prediction (Inference)

🔷 3. Keras (TensorFlow) में GPU का उपयोग

✅ Check GPU:

✅ Tensor और Model GPU पर चलेंगे अपने आप:

✅ Manually GPU select करना:

🔷 4. Google Colab में GPU/TPU Use

✅ GPU Enable करें:

✅ Check GPU/TPU:

🔷 5. TPUs क्या होते हैं?

📝 Practice Questions:

🧠 Summary Table

🔷 1. ✅ Model Training in Keras (Step-by-Step)

📌 Step 1: Import Libraries

📌 Step 2: Define Model

📌 Step 3: Compile Model

📌 Step 4: Prepare Data

📌 Step 5: Train Model

🔷 2. 💾 Saving a Keras Model

✅ Option 1: Save Full Model (Best Practice)

✅ Option 2: Save Only Weights

🔷 3. 📂 Loading a Saved Model

✅ Load Full Model:

✅ Load Only Weights:

🔷 4. 🔁 Save and Load during Training (Checkpointing)

✅ Use ModelCheckpoint Callback

🔷 5. 🧪 Inference (Prediction)

🔧 Extra: Exporting to TF Lite (Mobile/Edge)

📝 Practice Questions:

🧠 Summary Table

🔷 1. 🔁 Model Training in PyTorch

🧱 Training Steps Overview:

🧪 Full Example (Classifier):

🔷 2. 💾 Saving a PyTorch Model

✅ Option 1: State Dict Only (Recommended)

✅ Option 2: Complete Model (Not Recommended)

🔷 3. 📂 Loading a Model

🔁 Load from State Dict (Best Practice):

🧠 Bonus: GPU Compatibility (Saving/Loading)

✅ Save on GPU, Load on CPU:

🧪 Example: Inference After Loading

📦 Advanced Tip: Save Optimizer State Too

Load Later:

🧠 Evaluation Tips

📝 Practice Questions:

🧠 Summary Table

Introduction of PyTorch

What is PyTorch?

Why Do We Need PyTorch?

Main Features of PyTorch

Installing PyTorch

Your First PyTorch Program

What is a Tensor in PyTorch?

Why Are Tensors Important?

Creating Tensors

Tensor from values

Tensor filled with zeros

Tensor filled with ones

Random Tensor

Tensor Shape

Tensor Data Type

Basic Tensor Operations

CPU and GPU in PyTorch

What is Autograd?

torch.autograd

What Does requires_grad=True Mean?

What is a Neural Network?

torch.nn in PyTorch

Understanding nn.Linear

What is the Forward Method?

Dataset and DataLoader

What is Batch Size?

What is Loss Function?

What is an Optimizer?

Complete Training Process in PyTorch

Step 1: optimizer.zero_grad()

`torch.autograd`

What Does `requires_grad=True` Mean?

`torch.nn` in PyTorch

Understanding `nn.Linear`

Step 1: `optimizer.zero_grad()`

Forgetting `zero_grad()`

What is `nn.Module`?