Deep Learning ki Kahani zero se exam-ready tak

Python · Raju ki machine ka loss

temps = [10, 20, 30]      # x: inputs (features)
cups  = [80, 60, 40]      # y: asli answers (labels)

def predict(x, w, b):     # model: ek line
    return w * x + b

def mse(w, b):            # loss: galti ka meter
    total = 0
    for x, y in zip(temps, cups):          # har example pe
        total += (y - predict(x, w, b)) ** 2   # galti ka square jodo
    return total / len(temps)              # average

for w, b in [(0, 50), (-1, 80), (-2, 100)]:   # teen knob settings
    print(f"w={w}, b={b} -> loss={mse(w, b):.2f}")

Lab 5 · data ko X aur y me baantna

df = pd.read_csv('...breast-cancer data.csv')   # Wisconsin Breast Cancer data
df.shape                                         # (569, 33): 569 rows, 33 columns

# 'id' koi feature nahi (bas patient number), 'Unnamed: 32' khaali column hai
df.drop(columns=['id', 'Unnamed: 32'], inplace=True)
df.shape                                         # (569, 31) = 30 features + 1 label

X = df.drop(columns=['diagnosis'])   # features: (569, 30)
y = df['diagnosis']                  # label:    (569,)  values 'M' / 'B'

sklearn · Lab 5 split + validation ke liye do-step split

from sklearn.model_selection import train_test_split
import numpy as np

X = np.random.rand(569, 30)              # Lab 5 jitna dummy data: 569 patients, 30 features
y = np.random.randint(0, 2, 569)         # 0/1 labels
# Lab 5 wali line: 20% test alag, random_state se har baar same split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)
print(X_train.shape, X_test.shape)

# Validation bhi chahiye? do baar split karo (60/20/20):
X_temp, X_te = train_test_split(np.arange(1000), test_size=0.2, random_state=42)   # 800 / 200
X_tr, X_val = train_test_split(X_temp, test_size=0.25, random_state=42)            # 800 ka 25% = 200
print(len(X_tr), len(X_val), len(X_te))

sklearn · Lab 5 style scaling aur label encoding (sahi tareeka)

import numpy as np
from sklearn.preprocessing import StandardScaler, LabelEncoder

X_train = np.array([[2.0], [4.0], [6.0]])   # chhota demo: 1 feature, 3 train samples
X_test  = np.array([[8.0]])                 # 1 test sample
y_train = np.array(['M', 'B', 'B'])
y_test  = np.array(['B'])

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)   # fit = train ka mu, sigma seekho; transform = lagao
X_test  = scaler.transform(X_test)        # sirf transform! train wale mu, sigma hi use honge
print(scaler.mean_, scaler.scale_)        # seekha hua mu aur sigma
print(X_train.ravel(), X_test.ravel())

encoder = LabelEncoder()
y_train = encoder.fit_transform(y_train)  # 'B' -> 0, 'M' -> 1 (alphabetical)
y_test  = encoder.transform(y_test)       # same mapping test pe
print(y_train, y_test, encoder.classes_)

PyTorch · Lab 5 style

import torch
import torch.nn as nn

# HYPERPARAMETERS: hum khud likhte hain (Lab 5)
learning_rate = 0.1
epochs = 25

# PARAMETERS: model ke andar, optimizer seekhega
model = nn.Linear(30, 1)
print(model.weight.shape, model.bias.shape)          # weights aur bias ka shape
print(sum(p.numel() for p in model.parameters()))    # total kitne knobs

net = nn.Sequential(nn.Linear(2, 4), nn.ReLU(), nn.Linear(4, 1))
print(sum(p.numel() for p in net.parameters()))      # 2 -> 4 -> 1 network

PyTorch · DataLoader se ginti (DataLoader poora Chapter 14 me)

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

X = torch.randn(455, 30)                      # 455 samples, 30 features (Lab 5 jaisa)
y = torch.randint(0, 2, (455,)).float()       # 0/1 labels
loader = DataLoader(TensorDataset(X, y), batch_size=32, shuffle=True)

print(len(loader))                            # iterations per epoch
print([xb.shape[0] for xb, yb in loader])     # har batch ka size
epochs = 25
print(epochs * len(loader))                   # total updates

PyTorch · Lab 0 · GPU hai ya nahi, aur kitna tez

import torch, time

if torch.cuda.is_available():                  # GPU mila?
    print("GPU is avl")
    print(f"using gpu:{torch.cuda.get_device_name(0)}")
else:
    print("GPU not avl")

device = torch.device('cuda')
size = 10000                                   # 10000 x 10000 matrices
matrix_cpu1 = torch.rand(size, size)
matrix_cpu2 = torch.rand(size, size)
matrix_gpu1 = matrix_cpu1.to(device)           # GPU pe copy
matrix_gpu2 = matrix_cpu2.to(device)

start_time = time.time()
result_cpu = torch.matmul(matrix_cpu1, matrix_cpu2)
print(f"CPU time: {time.time() - start_time} seconds")

start_time = time.time()
result_gpu = torch.matmul(matrix_gpu1, matrix_gpu2)
torch.cuda.synchronize()                       # GPU ka kaam khatam hone ka wait (warna time galat aayega)
print(f"GPU time: {time.time() - start_time} seconds")

PyTorch · ndim, shape, numel

import torch
s = torch.tensor(92.0)                          # scalar
v = torch.tensor([92., 85., 78., 88., 95.])     # vector
M = torch.tensor([[1, 2, 3], [4, 5, 6]])        # matrix: 2 rows, 3 cols
T = torch.zeros(3, 30, 5)                       # 3 sections x 30 students x 5 subjects
imgs = torch.zeros(64, 3, 32, 32)               # 64 colour photos, 32x32
for t in [s, v, M, T, imgs]:
    print(t.ndim, t.shape, t.numel())           # dimensions, shape, total numbers

PyTorch · Lab 0 · torch.dot

import torch
vector1 = torch.tensor([1, 2])
vector2 = torch.tensor([3, 4])
print(torch.dot(vector1, vector2))        # 1*3 + 2*4

qty   = torch.tensor([2., 1., 3.])        # chai, samosa, biscuit
price = torch.tensor([10., 15., 5.])
print(torch.dot(qty, price), (qty * price).sum())   # dono tareeke same
print(torch.linalg.norm(torch.tensor([3., 4.])))    # length = sqrt(9 + 16)

PyTorch · haath se aur nn.Linear se (Lab 1 style weights set karna)

import torch
import torch.nn as nn

x = torch.tensor([2.0, 3.0])
w = torch.tensor([0.5, -1.0])
b = 1.0
print(w @ x + b)                      # 1-D @ 1-D = dot product, fir bias

layer = nn.Linear(2, 1)               # 2 inputs, 1 output neuron
layer.weight.data = torch.tensor([[0.5, -1.0]])   # shape (out, in) = (1, 2)
layer.bias.data = torch.tensor([1.0])             # shape (out,) = (1,)
print(layer(torch.tensor([[2.0, 3.0]])))          # input (batch=1, features=2)

PyTorch · @ aur torch.matmul (Lab 0)

import torch
A = torch.tensor([[1, 2, 3], [4, 5, 6]])          # (2, 3)
B = torch.tensor([[7, 8], [9, 10], [11, 12]])     # (3, 2)
print(A @ B)                  # (2,3)@(3,2) -> (2,2)
print(torch.matmul(A, B))     # same cheez, function wala naam
print(B @ A)                  # (3,2)@(2,3) -> (3,3): bilkul alag!
try:
    A @ A                     # (2,3)@(2,3): andar wale 3 != 2
except RuntimeError as e:
    print("RuntimeError:", e)

X = torch.randn(455, 30)      # Lab 5 jaisa batch
W = torch.randn(1, 30)        # nn.Linear(30, 1) ka weight shape (out, in)
print((X @ W.T).shape)        # (455,30)@(30,1) -> (455,1)

PyTorch · Lab 0 · transpose

f = torch.tensor([[5., 8., 2.], [5., 5., 2.]])
print(torch.transpose(f, 0, 1))      # dim 0 aur dim 1 ki adla-badli
print(f.T)                           # shortcut (2-D ke liye)
print(f.shape, f.T.shape)
# A, B upar 2.4 wale hi hain
print(torch.equal((A @ B).T, B.T @ A.T))   # (AB)^T = B^T A^T check

PyTorch · ek line pe points

x = torch.tensor([0., 1., 2.])
print(2 * x + 1)          # m = 2, c = 1 -> har x ka y ek saath (broadcasting, Ch 3.16)

PyTorch · Lab 0 · torch.exp

print(torch.exp(torch.tensor([0., 1., 2., -1., -2.])))
f = torch.tensor([[5., 8., 2.], [5., 5., 2.]])     # Lab 0 wala f
print(torch.exp(f))                                # har element ka e^x

PyTorch · Lab 0 · torch.log (ye ln hai!)

import math
print(torch.log(torch.tensor([1.0, math.e, 0.5, 0.1, 10.0])))
print(torch.log(f))                               # Lab 0: ln 5, ln 8, ln 2
print(torch.log(torch.tensor([0.0, -1.0])))       # ln 0 = -inf, ln(negative) = nan
print(torch.log10(torch.tensor(100.0)), torch.log2(torch.tensor(8.0)))  # base 10, base 2 alag functions

p = torch.tensor([0.9, 0.8, 0.7])
print(torch.prod(p), torch.log(torch.prod(p)), torch.log(p).sum())   # guna ka log = log ka jod
print(torch.tensor(0.5) ** 200)                   # float32 underflow -> 0

Python · derivative ko numbers se pakadna

def f(x):
    return x ** 2

for h in [0.1, 0.01, 0.001]:
    slope = (f(3 + h) - f(3)) / h        # (naya - purana) / chhota kadam
    print(f"h={h}: slope ~ {slope:.4f}")

Python · saare rules ko numbers se verify karo

import math

def d(func, x, h=1e-5):                  # central difference: dono taraf thoda chalo
    return (func(x + h) - func(x - h)) / (2 * h)

checks = [
    ("constant 7",      lambda x: 7,                 2, 0),
    ("power x^3",       lambda x: x**3,              2, 3 * 2**2),
    ("5x^2",            lambda x: 5 * x**2,          3, 10 * 3),
    ("x^2+3x+4",        lambda x: x**2 + 3*x + 4,    2, 2*2 + 3),
    ("e^x",             math.exp,                    1, math.exp(1)),
    ("ln x",            math.log,                    4, 1 / 4),
    ("x^2 * e^x",       lambda x: x**2 * math.exp(x), 1, 3 * math.e),
    ("x/(x+1)",         lambda x: x / (x + 1),       1, 1 / (1 + 1)**2),
]
for name, func, x, rule in checks:
    print(f"{name:12s} at x={x}: numeric={d(func, x):.4f}  rule={rule:.4f}")

PyTorch · sneak peek: autograd khud chain rule lagata hai (detail Ch 12)

x = torch.tensor(1.0, requires_grad=True)   # "is x ka derivative chahiye" - bata diya
y = (3 * x + 1) ** 2                         # forward: PyTorch graph yaad rakhta hai
y.backward()                                 # backward: chain rule apne aap
print(x.grad)                                # dy/dx at x = 1

PyTorch · do knobs ka gradient (autograd sneak peek)

w = torch.tensor(1.0, requires_grad=True)
b = torch.tensor(1.0, requires_grad=True)
f = (2 * w + b - 5) ** 2          # ek neuron ki squared error (x=2, y=5)
f.backward()                      # saare partial derivatives ek saath
print(f.item(), w.grad, b.grad)   # f, df/dw, df/db

Python · gradient descent ka pehla loop

x = 3.0          # shuruaat
lr = 0.1         # eta: kadam ka size (learning rate)
for step in range(5):
    grad = 2 * x                 # f(x) = x^2 ka slope
    print(f"step {step}: x={x:.4f}, f(x)={x*x:.4f}, slope={grad:.4f}")
    x = x - lr * grad            # slope ke ULTE chalo

Python · do knobs ek saath (wahi 2.12 wala f)

w, b = 1.0, 1.0
lr = 0.05
for step in range(4):
    u = 2 * w + b - 5                    # andar wala hissa
    gw, gb = 2 * u * 2, 2 * u * 1        # df/dw, df/db (chain rule)
    print(f"step {step}: w={w:.2f}, b={b:.2f}, f={u*u:.4f}, grad=({gw:.1f}, {gb:.1f})")
    w, b = w - lr * gw, b - lr * gb      # dono knobs ek saath update

Python + PyTorch · Σ = sum()

print(sum(range(1, 5)), sum(i**2 for i in range(1, 4)))   # range(1, 5) = 1,2,3,4 (5 nahi!)

y_true = torch.tensor([3., 5., 2.])
y_pred = torch.tensor([2.5, 5., 4.])
print(torch.sum((y_true - y_pred) ** 2))    # Sigma (y - y_hat)^2
print(torch.mean((y_true - y_pred) ** 2))   # (1/n) Sigma ... = MSE

NumPy vs PyTorch · default ALAG hai (coding trap!)

import numpy as np
marks = [2., 4., 4., 4., 5., 5., 7., 9.]
a = np.array(marks)
t = torch.tensor(marks)

print(np.mean(a), np.var(a), np.std(a))       # numpy default: 1/n (population)
print(np.var(a, ddof=1), np.std(a, ddof=1))   # ddof=1 -> 1/(n-1)
print(t.mean(), t.var(), t.std())             # torch default: 1/(n-1) (sample)!
print(t.var(unbiased=False), t.std(unbiased=False))   # torch me 1/n (naya naam: correction=0)

PyTorch · randn = normal, rand = uniform [0, 1)

torch.manual_seed(0)                      # har baar same random numbers
z = torch.randn(100000)                   # N(0, 1) se 1 lakh numbers
print(z.mean(), z.std())                  # ~0 aur ~1
print(((z > -1) & (z < 1)).float().mean(), ((z > -2) & (z < 2)).float().mean())  # ~68%, ~95%

u = torch.rand(100000) * 2 - 1            # [0,1) ko [-1,1) me khinch ke khiskaya: a + (b-a)*rand
print(u.min(), u.max(), u.mean(), u.var())   # var ~ 1/3

h = 5 + 2 * torch.randn(100000)           # mu + sigma * randn  ->  N(5, 2^2)
print(h.mean(), h.std())

PyTorch · BCE = average negative log-likelihood (Ch 11 preview)

bce = nn.BCELoss()                              # Lab 5 wala loss
p = torch.tensor([0.8, 0.8, 0.8])               # model ki P(y=1)
y = torch.tensor([1., 1., 0.])                  # asli labels
print(bce(p, y))                                # mean of -[y ln p + (1-y) ln(1-p)]

PyTorch · max aur argmax (dim wala khel Ch 3.18 me)

pp = torch.tensor([0.1, 0.7, 0.2])
print(torch.max(pp), torch.argmax(pp))          # value vs index

logits = torch.tensor([1.0, 3.0, 2.0])
print(torch.softmax(logits, dim=0), torch.argmax(logits), torch.argmax(torch.softmax(logits, dim=0)))
print(torch.argmax(torch.tensor([3, 7, 7, 1])))  # tie: pehla index

Python · types aur operators

age = 20                 # int: poora number
lr = 0.1                 # float: dashamlav wala number
name = "Riya"            # str: text (quotes me)
is_training = True       # bool: True / False (capital T/F)
best_model = None        # None: "abhi kuch nahi hai"
print(type(age), type(lr), type(name), type(is_training), type(best_model))

print(7 / 2, 7 // 2, 7 % 2, 2 ** 3)   # divide, floor-divide, remainder, POWER
print(2 ^ 3)                          # ^ = XOR, power nahi!

Python · indexing, slicing, append, len

losses = [0.67, 0.54, 0.46, 0.40]   # Lab 5 jaise epoch-wise losses
print(losses[0], losses[-1])        # pehla, aakhri (negative = peeche se)
print(losses[1:3])                  # index 1 se shuru, 3 se PEHLE ruk jao
print(losses[:2], losses[2:], losses[::2])   # shuru se 2 tak, 2 se end tak, har doosra
losses.append(0.36)                 # end me naya element
print(len(losses), losses)
losses[0] = 0.70                    # list badal sakti hai (mutable)
print(losses)

Python · dict

params = {"lr": 0.1, "epochs": 25, "optimizer": "SGD"}   # key: value
print(params["lr"])                     # key se value nikalo
params["batch_size"] = 32               # naya key-value jodo
print(params.get("dropout", 0.0))       # key nahi hai? default 0.0 do (error nahi)
for key, value in params.items():       # saare jode ek ek karke
    print(key, "->", value)
print(list(params.keys()))

Python · for, range, enumerate, zip, break

for epoch in range(3):                  # 0, 1, 2  (3 shaamil nahi)
    print("epoch", epoch + 1)
print(list(range(1, 6)), list(range(0, 10, 3)))   # (start, stop) aur (start, stop, step)

items = ["chai", "samosa", "biscuit"]
for i, item in enumerate(items):        # index + value dono ek saath
    print(i, item)

prices = [10, 15, 5]
for item, price in zip(items, prices):  # do lists ko jodi me chalao
    print(item, price)

for epoch in range(100):                # break = loop beech me tod do
    if epoch == 2:                      # (early stopping me yahi hota hai, Ch 19)
        print("ruk gaye at", epoch)
        break

Python · if / elif / else

acc = 0.85
if acc >= 0.9:
    print("Excellent")
elif acc >= 0.7:                        # pehli condition fail hui to ye check
    print("Theek hai")
else:                                   # koi bhi sach nahi to ye
    print("Aur train karo")

gpu_available = False
device = "cuda" if gpu_available else "cpu"   # ek line wala if-else
print(device)
print(3 == 3.0, 3 != 4, (acc > 0.5) and (acc < 0.9), not True)

Python · def, default args, multiple return

def predict(x, w, b=0.0):               # b ka DEFAULT 0.0 hai
    return w * x + b                    # return = function ka jawab

print(predict(10, -2, 100))             # positional: order se
print(predict(10, -2))                  # b nahi diya -> default 0.0
print(predict(x=10, w=-2, b=100))       # keyword: naam se (order matter nahi)

def stats(values):
    m = sum(values) / len(values)
    return m, max(values)               # do cheezein = ek tuple

mean_v, max_v = stats([2, 4, 9])        # unpacking: dono alag variables me
print(mean_v, max_v)

Python · class, __init__, self, method

class ChaiStall:                                  # blueprint (naksha)
    def __init__(self, owner, price=10):          # constructor: object bante hi chalta hai
        self.owner = owner                        # attribute: is object ki apni cheez
        self.price = price
        self.cups_sold = 0

    def sell(self, n):                            # method: object ka kaam
        self.cups_sold += n                       # apni hi attribute badli
        return n * self.price

raju = ChaiStall("Raju")                          # object (instance) #1
shyam = ChaiStall("Shyam", price=12)              # object #2, alag data
print(raju.sell(5), shyam.sell(5))                # same method, alag jawab
print(raju.cups_sold, raju.owner, shyam.price)

Python · inheritance, super().__init__(), override — aur bhoolne ka nateeja

class MasalaChaiStall(ChaiStall):                 # ChaiStall se INHERIT
    def __init__(self, owner, price=15, masala="elaichi"):
        super().__init__(owner, price)            # pehle parent ka __init__ chalao!
        self.masala = masala                      # fir apni nayi attribute

    def sell(self, n):                            # method OVERRIDE (naya version)
        bill = super().sell(n)                    # parent wala sell bhi use karo
        return bill + 2 * n                       # +2 rupaye masala per cup

m = MasalaChaiStall("Meena")
print(m.sell(4), m.cups_sold, m.masala, m.owner)

class Broken(ChaiStall):
    def __init__(self, owner):
        self.masala = "adrak"                     # super().__init__() BHOOL GAYE

b = Broken("Bunty")
print(b.masala)
try:
    print(b.cups_sold)                            # parent ka setup chala hi nahi
except AttributeError as e:
    print("AttributeError:", e)

Python · __call__ ka jaadu (nn.Module isi tarah forward chalata hai)

class MiniModule:
    def __call__(self, x):              # object ko function ki tarah call karo to ye chalta hai
        print("(pehle hooks/checks)")
        return self.forward(x)          # ...fir forward

class Doubler(MiniModule):
    def forward(self, x):
        return 2 * x

d = Doubler()
print(d(21))                            # d(21) -> d.__call__(21) -> d.forward(21)

PyTorch · Lab 5 ka MySimpleNN — aur super() bhoolne ka asli error

import torch
import torch.nn as nn

class MySimpleNN(nn.Module):                      # Lab 5: nn.Module se inherit
    def __init__(self, num_features):
        super().__init__()                        # nn.Module ki machinery ON (parameter tracking)
        self.linear = nn.Linear(num_features, 1)  # sub-module: weights apne aap register
        self.sigmoid = nn.Sigmoid()

    def forward(self, features):                  # computation yahan likho
        out = self.linear(features)               # (N, 30) -> (N, 1)
        out = self.sigmoid(out)                   # probability (0, 1)
        return out

model = MySimpleNN(30)
print(model)
x = torch.randn(4, 30)                            # 4 patients
print(model(x).shape)                             # model(x), model.forward(x) nahi
print(sum(p.numel() for p in model.parameters())) # 30 weights + 1 bias

class Oops(nn.Module):
    def __init__(self):
        self.linear = nn.Linear(2, 1)             # super().__init__() bhool gaye
try:
    Oops()
except AttributeError as e:
    print("AttributeError:", e)

Python · course ke standard imports

import torch                                   # poora package, naam se use: torch.zeros
import torch.nn as nn                          # lamba naam -> chhota nickname "nn"
import torch.optim as optim
import torch.nn.functional as F
import numpy as np
from torch.utils.data import TensorDataset, DataLoader   # package se sirf ye do cheezein
from sklearn.preprocessing import StandardScaler

print(nn.Linear is torch.nn.Linear)            # same cheez, bas chhota naam
print(F.relu(torch.tensor([-1.0, 2.0])))       # F = functional version

Python · Lab 5 ka print, aur formatting

epoch, loss = 3, 0.4555133879184723
print(f'Epoch: {epoch + 1}, Loss: {loss}')                # Lab 5 style: {} me koi bhi expression
print(f"Epoch {epoch + 1:02d} | loss {loss:.4f} | acc {0.9825:.2%}")   # format: 2 digit, 4 decimal, percent
print("Epoch", epoch + 1, "Loss", round(loss, 4))         # bina f-string wala tareeka

Python + PyTorch · with open, with torch.no_grad()

with open("notes.txt", "w") as fh:      # file kholi, naam fh
    fh.write("DL ka exam kal hai!\n")
print(fh.closed)                        # block khatam -> file apne aap band (error aaye tab bhi)

x = torch.tensor(2.0, requires_grad=True)
with torch.no_grad():                   # is block ke andar gradient tracking BAND
    y = x * 3
print(y.requires_grad)                  # False: koi graph nahi bana
z = x * 3                               # block ke bahar: tracking wapas ON
print(z.requires_grad)

Python · lambda, comprehension, parameter count

square = lambda v: v ** 2                         # chhota, bina naam ka function
print(square(5))

nums = [1, 2, 3, 4, 5]
print([v ** 2 for v in nums])                     # list comprehension: har v ka square
print([v for v in nums if v % 2 == 0])            # filter ke saath: sirf even

model = nn.Linear(30, 1)
print(sum(p.numel() for p in model.parameters())) # generator expression: 30 + 1
print(sorted(["relu", "elu", "tanh"], key=lambda s: len(s)))   # lambda as "key"

NumPy · array, shape, dtype, dot, broadcasting, astype

import numpy as np
a = np.array([1.5, 2.0, 3.0])
print(a.shape, a.dtype)                  # float64 = numpy ka default float!
b = np.array([1, 2, 3])
print(b.dtype)                           # int64
M = np.array([[1, 2, 3], [4, 5, 6]])
print(M.shape, M.ndim)
print(np.dot([1, 2], [3, 4]), M @ np.ones(3))      # dot product, matrix @ vector
print(M + 10)                            # broadcasting: scalar har element me
print(M + np.array([100, 200, 300]))     # (2,3) + (3,): har row me same vector
print(a.astype(np.float32).dtype)        # Lab 5 wali trick: float32 me badlo

PyTorch · 0-D se 4-D tak

loss = torch.tensor(0.6703)               # 0-D: ek number
bias = torch.zeros(16)                    # 1-D: 16 neurons ke bias
X_batch = torch.randn(455, 30)            # 2-D: (samples, features) - Lab 5
img = torch.rand(3, 32, 32)               # 3-D: (C, H, W) - ek colour photo (CIFAR-10)
mnist_batch = torch.rand(64, 1, 28, 28)   # 4-D: (N, C, H, W) - 64 grayscale digits
for t in [loss, bias, X_batch, img, mnist_batch]:
    print(t.dim(), tuple(t.shape))

PyTorch · Lab 0 · fixed values wale

print(torch.tensor([[1, 2, 4], [3, 4, 4]]))   # Python list se (data copy hota hai)
print(torch.zeros(2, 3))                       # sab 0 (float)
print(torch.ones(3, 4))                        # sab 1
print(torch.eye(3))                            # identity: diagonal pe 1
print(torch.full((2, 3), 5))                   # sab ek hi value (shape tuple me!)

PyTorch · Lab 0 · random wale (seed ke saath)

torch.manual_seed(100)                         # Lab 0: seed same -> random numbers same
print(torch.rand(3, 4))                        # uniform [0, 1)
print(torch.randn(2, 3))                       # normal N(0, 1): negative bhi
print(torch.randint(1, 100, (2, 5)))           # integers [1, 100): 100 kabhi nahi
print(torch.randint(size=(2, 3), low=0, high=10, dtype=torch.float32))   # Lab 0 style, float me

PyTorch · Lab 0 · sequences aur *_like

print(torch.arange(2, 12, 2))                  # start, stop (EXCLUSIVE), step
print(torch.arange(5))                         # 0..4
print(torch.linspace(0, 20, 10))               # 0 se 20 tak 10 barabar points (20 INCLUDED)
p = torch.tensor([[11, 11, 12], [2, 3, 4]])
print(torch.zeros_like(p))                     # p jaisa shape + dtype, sab 0
print(torch.ones_like(p))
print(torch.empty(2, 3).shape)                 # empty: memory mili, values garbage (kabhi print pe bharosa mat karo)

PyTorch · Lab 0 · shape, size, dtype, .to()

p = torch.tensor([[11, 11, 12], [2, 3, 4]])
print(p.shape, p.size(), p.size(0), p.shape[1])   # shape == size(); size(0) = rows
print(p.dtype)                                    # integers -> int64 (Long)
q = torch.tensor([1.0, 2.0])
print(q.dtype)                                    # decimals -> float32 (Float)
print(torch.tensor([1, 2, 4], dtype=torch.float64))   # dtype khud chuno
print(p.to(torch.float32))                        # Lab 0: dtype badlo
print(p.float().dtype, q.long().dtype, q.double().dtype)   # shortcuts
try:
    torch.rand_like(p)                            # Lab 0 error: int tensor pe rand nahi
except Exception as e:
    print(type(e).__name__ + ":", e)

PyTorch · Lab 5 pitfall · numpy float64 → float32

import numpy as np
X_np = np.random.rand(4, 30)                      # numpy -> float64 (Double)
layer = nn.Linear(30, 1)                          # weights float32 (Float)
try:
    layer(torch.from_numpy(X_np))                 # Double input, Float weights
except RuntimeError as e:
    print("RuntimeError:", e)

X_t = torch.from_numpy(X_np.astype(np.float32))   # Lab 5 fix: pehle float32 karo
print(X_t.dtype, layer(X_t).shape)

PyTorch · Lab 0 · element-wise aur scalar

a = torch.tensor([[1., 2., 3.], [4., 5., 6.]])
b = torch.tensor([[10., 20., 30.], [40., 50., 60.]])
print(a + b)                  # position by position
print(b - a)
print(a * b)                  # element-wise guna (matrix multiply NAHI)
print(b / a)
print(a + 2)                  # scalar har element pe (Lab 0: t1 + 2)
print(a ** 2)                 # har element ka square
print(((a * 100) // 3) % 2)   # Lab 0 wala combo: floor-divide, fir remainder

PyTorch · broadcasting row / column, aur mismatch error

a = torch.tensor([[1., 2., 3.], [4., 5., 6.]])   # (2, 3)
row = torch.tensor([100., 200., 300.])           # (3,)
print(a + row)                                   # (2,3)+(3,) -> row har row me add
col = torch.tensor([[1.], [10.]])                # (2, 1)
print(a * col)                                   # (2,3)*(2,1) -> har row apne number se guna
try:
    a + torch.tensor([1., 2.])                   # (2,3)+(2,): right se 3 vs 2 -> mismatch
except RuntimeError as e:
    print("RuntimeError:", e)

PyTorch · Lab 5 ka silent broadcasting bug

y_pred = torch.tensor([[0.9], [0.2], [0.7]])   # model output: (N, 1)
y_true = torch.tensor([1., 0., 1.])            # labels: (N,)
diff = y_pred - y_true                         # (3,1) - (3,) -> (3,3) !!
print(diff.shape)                              # error nahi aaya - CHUPA bug
print(diff)
good = y_pred - y_true.view(-1, 1)             # Lab 5 fix: target ko (N, 1) banao
print(good.shape)
print(good)

PyTorch · losses shape mismatch pe kya karte hain

y_pred = torch.tensor([[0.9], [0.2], [0.7]])   # (N, 1)
y_true = torch.tensor([1., 0., 1.])            # (N,)
try:
    nn.BCELoss()(y_pred, y_true)               # naya PyTorch: BCELoss seedha mana kar deta hai
except ValueError as e:
    print("ValueError:", e)
print(nn.MSELoss()(y_pred, y_true))            # MSELoss: sirf warning, (3,3) pe galat loss!
print(nn.MSELoss()(y_pred, y_true.view(-1, 1)))   # sahi shape -> sahi loss
print(nn.BCELoss()(y_pred, y_true.view(-1, 1)))   # Lab 5 wala sahi tareeka

PyTorch · Lab 0 · * vs @ vs dot vs transpose

A = torch.tensor([[1., 2.], [3., 4.]])
B = torch.tensor([[5., 6.], [7., 8.]])
print(A * B)                    # element-wise: 1*5, 2*6, 3*7, 4*8
print(A @ B)                    # matrix multiplication: row . column
print(torch.matmul(A, B))       # @ ka function wala naam
v = torch.tensor([1., 1.])
print(A @ v)                    # (2,2) @ (2,) -> (2,): har row ka jod
print(torch.dot(torch.tensor([1., 2.]), torch.tensor([3., 4.])))   # sirf 1-D
print(torch.transpose(A, 0, 1), A.T)

PyTorch · nn.Linear = x @ W.T + b (khud check)

torch.manual_seed(0)
layer = nn.Linear(3, 2)                 # in=3, out=2
x = torch.randn(4, 3)                   # batch of 4
print(layer.weight.shape, layer.bias.shape)          # (out, in), (out,)
manual = x @ layer.weight.T + layer.bias             # (4,3)@(3,2) + (2,) -> (4,2)
print(torch.allclose(layer(x), manual), layer(x).shape)

PyTorch · Lab 0 ka e — saare reductions

e = torch.tensor([[5., 6., 9.],
                  [2., 3., 1.]])          # Lab 0 wala matrix, shape (2, 3)
print(torch.sum(e))                       # sab ka jod
print(torch.sum(e, dim=0))                # dim 0 (rows) ko DABA do -> har column ka jod
print(torch.sum(e, dim=1))                # dim 1 (columns) ko daba do -> har row ka jod
print(e.mean(dim=0), e.mean(dim=1))
print(torch.max(e), torch.min(e))
print(torch.argmax(e), torch.argmin(e))   # bina dim: FLATTEN karke index!
print(torch.argmax(e, dim=0), torch.argmax(e, dim=1))

PyTorch · (values, indices), keepdim, accuracy pattern, int mean error

values, indices = torch.max(e, dim=1)     # dim do to (values, indices) dono milte
print(values, indices)
print(e.sum(dim=1, keepdim=True).shape, e.sum(dim=1).shape)   # keepdim: dimension bacha ke rakho

logits = torch.tensor([[2.0, 0.5, 0.1],   # sample 0: class 0 sabse bada
                       [0.2, 0.1, 3.0],   # sample 1: class 2
                       [0.3, 1.5, 0.2]])  # sample 2: class 1
labels = torch.tensor([0, 2, 0])
preds = logits.argmax(dim=1)              # har ROW (sample) me sabse bada class
print(preds, (preds == labels).float().mean())   # accuracy = 2/3
try:
    torch.tensor([1, 2, 3]).mean()        # int tensor ka mean
except RuntimeError as e:
    print("RuntimeError:", e)

PyTorch · view, reshape, -1

x = torch.arange(12)                       # [0..11], shape (12,)
print(x.reshape(3, 4))
print(x.view(2, 6))                        # same data, naya shape (12 = 2*6)
print(x.view(-1, 4).shape, x.view(3, -1).shape)   # -1 = "baaki tum khud hisaab lagao"
y = torch.tensor([1., 0., 1.])             # (3,)
print(y.view(-1, 1).shape)                 # (3, 1) - Lab 5 wala fix
try:
    x.view(5, -1)                          # 12 ko 5 se poora nahi baant sakte
except RuntimeError as e:
    print("RuntimeError:", e)

PyTorch · unsqueeze, squeeze, flatten, view vs reshape

y = torch.tensor([1., 0., 1.])             # (3,)
print(y.unsqueeze(0).shape, y.unsqueeze(1).shape)   # nayi size-1 dim: aage / peeche
z = torch.zeros(1, 3, 1)
print(z.squeeze().shape, z.squeeze(0).shape)        # size-1 dims hatao (sab / sirf dim 0)
img = torch.rand(3, 32, 32)                # ek photo (C, H, W)
print(img.unsqueeze(0).shape)              # model ko batch chahiye: (1, 3, 32, 32)

imgs = torch.zeros(64, 1, 28, 28)          # (N, C, H, W)
print(imgs.flatten().shape)                # sab kuch ek line me
print(imgs.flatten(start_dim=1).shape)     # batch dim bacha ke: CNN -> Linear (Ch 23)
print(imgs.view(imgs.size(0), -1).shape)   # same cheez view se

t = torch.arange(6).view(2, 3).T           # transpose ke baad memory "non-contiguous"
try:
    t.view(6)
except RuntimeError as e:
    print("RuntimeError:", e)
print(t.reshape(6))                        # reshape zaroorat pade to copy kar leta hai

PyTorch · Lab 0 · tensor smiley

face = torch.zeros(10, 10)                 # Lab 0: kaala canvas
face[0, :] = 1                             # top row (row 0, saare columns)
face[9, :] = 1                             # bottom row
face[:, 0] = 1                             # left column (saari rows, column 0)
face[:, 9] = 1                             # right column
face[2, 2] = 1                             # left eye: row 2, col 2
face[2, 7] = 1                             # right eye
face[7, 2:8] = 1                           # mouth: row 7, columns 2..7 (8 nahi)
print(face.int())                          # matplotlib ki jagah numbers dekh lo
# plt.imshow(face, cmap='gray') se ye smiley dikhega

PyTorch · Lab 1 · rows, columns, 0 vs 0:1, mask

X = torch.tensor([[0., 0.], [0., 1.], [1., 0.], [1., 1.]])   # Lab 1: XOR inputs
print(X[0], X[-1])              # pehli row, aakhri row
print(X[1, 1], X[1, 1].item())  # ek element (tensor) aur uska Python number
print(X[:, 0])                  # pehla column -> shape (4,)  (dim gayab)
print(X[:, 0:1])                # pehla column slice se -> shape (4, 1) (dim bachi)
print(X[1:3])                   # rows 1 aur 2

z = torch.tensor([-1.5, -0.5, -0.5, 0.5])   # Lab 1 AND ke z values
mask = z >= 0                   # boolean tensor
print(mask, z[mask], mask.int())   # mask se filter; .int() -> 0/1 prediction

PyTorch · Lab 1 · cat aur stack

h_or = torch.tensor([[0.], [1.], [1.], [1.]])     # (4, 1)
h_nand = torch.tensor([[1.], [1.], [1.], [0.]])   # (4, 1)
print(torch.cat([h_or, h_nand], dim=1))          # Lab 1: columns jod do -> (4, 2)
print(torch.cat([h_or, h_nand], dim=0).shape)    # rows jod do -> (8, 1)

a = torch.tensor([1, 2, 3])
b = torch.tensor([4, 5, 6])
print(torch.cat([a, b]))                         # existing dim me lambi: (6,)
print(torch.stack([a, b]))                       # NAYI dim banake: (2, 3)
print(torch.stack([a, b], dim=1))                # nayi dim position 1 pe: (3, 2)

PyTorch · Lab 0 · from_numpy (share) vs tensor (copy), .numpy(), .item()

import numpy as np
arr = np.array([1, 2, 3])
t_shared = torch.from_numpy(arr)       # memory SHARE (Lab 0 comment)
t_copy = torch.tensor(arr)             # data COPY
arr[0] = 100                           # numpy array badla...
print(t_shared, t_copy)                # shared wala bhi badla, copy wala nahi

t = torch.tensor([1., 2., 3.])
n = t.numpy()                          # CPU tensor -> numpy (memory share)
t[1] = 50.
print(n)

loss = torch.tensor(0.1793)
print(loss.item(), type(loss.item()))  # 1 element wala tensor -> Python float
print(torch.tensor([[1, 2], [3, 4]]).tolist())   # poora tensor -> Python list

PyTorch · requires_grad wale tensor ko numpy banana

w = torch.tensor([1.0, 2.0], requires_grad=True)
try:
    w.numpy()                              # graph se juda tensor -> numpy nahi
except RuntimeError as e:
    print("RuntimeError:", e)
print(w.detach().numpy())                  # detach = graph se alag copy-view, fir numpy

PyTorch · device-agnostic code (yahan CPU machine pe chala)

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(device)                                  # GPU mila to cuda, warna cpu

x = torch.rand(2, 3).to(device)                # data device pe
model = nn.Linear(3, 1).to(device)             # model ke parameters bhi wahi
print(x.device, next(model.parameters()).device)
print(model(x).shape)                          # dono same device -> chalega

x_back = x.cpu().numpy()                       # numpy sirf CPU pe: pehle .cpu()
print(type(x_back))

PyTorch · requires_grad, grad_fn, backward, .grad

w = torch.tensor(2.0, requires_grad=True)     # "is knob ka gradient chahiye"
x = torch.tensor(3.0)                          # data: gradient nahi chahiye
y = w * x + 1
print(y, y.requires_grad)                      # grad_fn = graph ki yaad
y.backward()                                   # dy/dw nikalo
print(w.grad)                                  # dy/dw = x = 3
print(nn.Linear(2, 1).weight.requires_grad)    # layers ke weights by default True

PyTorch · gates with hand-set weights

import torch

X = torch.tensor([[0., 0.],
                  [0., 1.],
                  [1., 0.],
                  [1., 1.]])          # 4 input pairs, shape (4, 2)

def perceptron(X, w, b):
    z = X @ w + b                    # (4, 2) @ (2,) -> (4,)  har row ka w·x + b
    return (z >= 0).int()            # step: z >= 0 -> 1, warna 0

print("AND :", perceptron(X, torch.tensor([1., 1.]), -1.5).tolist())
print("OR  :", perceptron(X, torch.tensor([1., 1.]), -0.5).tolist())
print("NAND:", perceptron(X, torch.tensor([-1., -1.]), 1.5).tolist())
x_not = torch.tensor([[0.], [1.]])   # NOT ka sirf ek input
print("NOT :", perceptron(x_not, torch.tensor([-1.]), 0.0).tolist())

PyTorch tensors · perceptron from scratch

import torch

class Perceptron:
    def __init__(self, w, b, lr):
        self.w = torch.tensor(w)          # weights, shape (2,)
        self.b = torch.tensor(b)          # bias, ek scalar tensor
        self.lr = lr                      # learning rate (eta)

    def predict(self, x):
        z = torch.dot(self.w, x) + self.b # z = w.x + b
        return 1 if z >= 0 else 0         # step activation

    def fit(self, X, y, max_epochs=10):
        for epoch in range(1, max_epochs + 1):
            mistakes = 0
            for xi, yi in zip(X, y):      # ek-ek example dekho
                y_hat = self.predict(xi)
                error = int(yi) - y_hat   # +1, 0 ya -1
                if error != 0:            # sirf galti pe update
                    self.w = self.w + self.lr * error * xi
                    self.b = self.b + self.lr * error
                    mistakes += 1
            print(f"Epoch {epoch}: mistakes={mistakes}, "
                  f"w={[round(v, 2) for v in self.w.tolist()]}, b={self.b.item():.2f}")
            if mistakes == 0:             # poora epoch bina galti -> ruk jao
                print("Converged! Ek poora epoch bina galti ke.")
                break

X = torch.tensor([[0., 0.], [0., 1.], [1., 0.], [1., 1.]])
y = torch.tensor([0, 0, 0, 1])           # AND ke labels

p = Perceptron(w=[0.4, 0.4], b=-0.1, lr=0.2)
p.fit(X, y)
print("Predictions:", [p.predict(xi) for xi in X])
print("Targets:    ", y.tolist())

Same Perceptron class, XOR labels

y_xor = torch.tensor([0, 1, 1, 0])
p2 = Perceptron(w=[0.4, 0.4], b=-0.1, lr=0.2)
p2.fit(X, y_xor, max_epochs=6)          # kabhi "Converged!" nahi aayega

PyTorch · logistic regression by hand

import torch

x = torch.tensor([[2.0, 1.0],      # customer A
                  [0.5, 2.0]])     # customer B -> shape (2, 2)
w = torch.tensor([0.8, -0.4])      # weights (bhookh +, jaldi -)
b = -0.2

z = x @ w + b                      # (2, 2) @ (2,) -> (2,)  raw scores
p = torch.sigmoid(z)               # 0 se 1 ke beech probability
pred = (p >= 0.5).int()            # threshold 0.5 -> class
print("z   :", z)
print("prob:", p)
print("pred:", pred)

PyTorch · collapse ko code me verify karo

import torch
import torch.nn as nn

torch.manual_seed(0)
layer1 = nn.Linear(2, 3)                 # 2 -> 3
layer2 = nn.Linear(3, 1)                 # 3 -> 1
x = torch.randn(5, 2)                    # 5 random samples

two_layers = layer2(layer1(x))           # bina activation ke stack

W_new = layer2.weight @ layer1.weight              # (1, 3) @ (3, 2) -> (1, 2)
b_new = layer2.weight @ layer1.bias + layer2.bias  # (1, 3) @ (3,) + (1,) -> (1,)
one_layer = x @ W_new.T + b_new                    # ek hi linear layer

print(W_new.shape, b_new.shape)
print(torch.allclose(two_layers, one_layer, atol=1e-6))   # dono same?

PyTorch · nn.Linear ko khol ke dekho

import torch
import torch.nn as nn

torch.manual_seed(0)
layer = nn.Linear(in_features=3, out_features=2)  # 3 inputs -> 2 outputs
print(layer)
print("weight shape:", layer.weight.shape)   # (out, in)
print("bias shape:  ", layer.bias.shape)     # (out,)
print("total params:", sum(p.numel() for p in layer.parameters()))  # 3*2 + 2

# random weights ki jagah apne simple weights daal do (Lab 1 wala .data tareeka)
layer.weight.data = torch.tensor([[1., 0., -1.],
                                  [2., 1.,  0.]])   # shape (2, 3)
layer.bias.data = torch.tensor([0.5, -1.])         # shape (2,)

x = torch.tensor([[1., 2., 3.],
                  [0., 1., -1.]])        # batch: 2 samples, 3 features -> (2, 3)
out = layer(x)                           # (2, 3) -> (2, 2)
manual = x @ layer.weight.T + layer.bias # wahi formula haath se
print(out)
print(torch.allclose(out, manual))

PyTorch · Lab 1 (AND Problem)

import torch
import torch.nn as nn

# AND gate data
X = torch.tensor([[0, 0],
                  [0, 1],
                  [1, 0],
                  [1, 1]], dtype=torch.float32)       # (4, 2)
y = torch.tensor([[0], [0], [0], [1]], dtype=torch.float32)  # (4, 1)

# Single perceptron: 2 inputs -> 1 output
model = nn.Linear(2, 1)

# Manually set weights and bias for AND
model.weight.data = torch.tensor([[1., 1.]])   # shape (1, 2) = (out, in)
model.bias.data = torch.tensor([-1.5])         # shape (1,)

z = model(X)                  # forward pass: (4, 2) -> (4, 1), z = x1 + x2 - 1.5
print(z)
pred = (z >= 0).int()         # step activation: True/False -> 1/0
print("Predicted:", pred.squeeze().tolist())   # tolist(): tensor -> Python list
print("Actual:   ", y.squeeze().int().tolist())

PyTorch · Lab 5 model (MySimpleNN)

import torch
import torch.nn as nn

class MySimpleNN(nn.Module):                 # nn.Module se inherit
    def __init__(self, num_features):
        super().__init__()                   # SABSE PEHLE: Module ki machinery set karo
        # Input: (Batch_Size, num_features) -> Output: (Batch_Size, 1)
        self.linear = nn.Linear(num_features, 1)   # 30 -> 1, learnable
        self.sigmoid = nn.Sigmoid()                # score -> probability (0, 1); koi parameter nahi

    def forward(self, features):             # features: (Batch_Size, num_features)
        out = self.linear(features)          # z = x @ W.T + b   -> (N, 1)
        out = self.sigmoid(out)              # y_hat = sigmoid(z) -> (N, 1)
        return out

model = MySimpleNN(30)
print(model)
print("params:", sum(p.numel() for p in model.parameters()))   # 30*1 + 1

PyTorch · Lab 5 pipeline (lab ka structure)

import numpy as np
import pandas as pd
import torch
import torch.nn as nn
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, LabelEncoder

torch.manual_seed(42)
df = pd.read_csv('https://raw.githubusercontent.com/gscdit/Breast-Cancer-Detection/refs/heads/master/data.csv')
df.drop(columns=['id', 'Unnamed: 32'], inplace=True)      # (569, 33) -> (569, 31)
X = df.drop(columns=['diagnosis'])                        # 30 feature columns
y = df['diagnosis']                                       # 'M' / 'B'
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

scaler = StandardScaler()                   # har feature: (x - mean) / std
X_train = scaler.fit_transform(X_train)     # fit SIRF train pe (no leakage)
X_test = scaler.transform(X_test)           # test pe sirf transform
encoder = LabelEncoder()                    # alphabetical: B -> 0, M -> 1
y_train = encoder.fit_transform(y_train)
y_test = encoder.transform(y_test)

# numpy float64 -> float32, warna "expected scalar type Float but found Double"
X_train_tensor = torch.from_numpy(X_train.astype(np.float32))   # (455, 30)
X_test_tensor = torch.from_numpy(X_test.astype(np.float32))     # (114, 30)
y_train_tensor = torch.from_numpy(y_train.astype(np.float32))   # (455,)  1-D!
y_test_tensor = torch.from_numpy(y_test.astype(np.float32))

learning_rate = 0.1
epochs = 25
loss_function = nn.BCELoss()                # binary cross-entropy, input = probabilities

model = MySimpleNN(X_train_tensor.shape[1])                        # 30 features
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

for epoch in range(epochs):                 # full-batch: poora train set ek saath
    y_pred = model(X_train_tensor)                               # forward: (455, 30) -> (455, 1)
    loss = loss_function(y_pred, y_train_tensor.view(-1, 1))     # target (455,) -> (455, 1)
    optimizer.zero_grad()                   # purane gradients saaf
    loss.backward()                         # naye gradients nikalo
    optimizer.step()                        # weights update
    print(f'Epoch: {epoch + 1}, Loss: {loss.item()}')

with torch.no_grad():                       # evaluation: gradient tracking band
    y_pred = model(X_test_tensor)
    y_pred_labels = (y_pred > 0.5).float()  # probability -> class (threshold 0.5)
    accuracy = (y_pred_labels == y_test_tensor.view(-1, 1)).float().mean()
    print(f'Accuracy: {accuracy.item()}')