Training loops from scratch — Hinglish notes

3.3.5 · AI-ML › Deep Learning Frameworks

Training loop kya hai?

Training loop ek iterative process hai jo random weights ko ek trained model mein badalta hai. Iske core mein yeh empirical risk minimization implement karta hai: woh parameters $θ$ dhundo jo training data par average loss minimize karein.

YEH components kyun? Har step ek specific problem solve karta hai:

Forward pass: "Mera current model kya predict karta hai?"
Loss: "Main kitna galat hoon?" (error ka scalar measure)
Backward: "Kis weight ki wajah se yeh error hua?" (gradient flow)
Update: "Error kam karne ke liye weights kaise adjust karoon?"
Iteration: "Kya main generalize kar raha hoon, ya sirf memorize?"

Training loop ko first principles se derive karna

Shuruaat: Optimization objective

Hum expected risk minimize karna chahte hain: $R (θ) = E_{(x, y) \sim D} [L (f (x; θ), y)]$

YEH form kyun? Hum unseen data ki performance ki parwah karte hain jo distribution $D$ se aata hai, na ki sirf training examples ki.

Kyunki hum $D$ nahi jaante, hum empirical risk se approximate karte hain: $\hat{R} (θ) = \frac{1}{N} \sum_{i = 1}^{N} L (f (x_{i}; θ), y_{i})$

Average kyun? Raw sum dataset size ke saath badhta hai; averaging loss magnitude ko dataset-independent banata hai.

Objective se iterative updates tak

Direct minimization intractable hai neural networks ke liye (non-convex, millions of parameters). Iski jagah, hum gradient descent use karte hain:

$θ_{t + 1} = θ_{t} - η \nabla_{θ} \hat{R} (θ_{t})$

Yeh kyun kaam karta hai: Gradient $\nabla_{θ} \hat{R}$ loss mein steepest increase ki taraf point karta hai; opposite direction mein jaana (negative gradient) loss locally decrease karta hai.

Problem yeh hai: $\nabla_{θ} \hat{R}$ compute karne ke liye full-dataset pass chahiye—jo bahut expensive hai!

Solution: Stochastic Gradient Descent (SGD) gradient ko mini-batch use karke approximate karta hai:

$\nabla_{θ} \hat{R} \approx \frac{1}{B} \sum_{i \in batch} \nabla_{θ} L (f (x_{i}; θ), y_{i})$

Batches kyun? Single examples bahut noisy hote hain; full dataset bahut slow hai; mini-batches variance aur computation ke beech balance karte hain.

Scratch se implementation: Step-by-step

Worked example Minimal training loop (bina kisi framework ke)

Chalo ek 2-layer network ko synthetic data par train karte hain.

import numpy as np
# Generate data: y = x1*w1 + x2*w2 + noise
np.random.seed(42)
N, D = 1000, 2
X = np.random.randn(N, D)
true_w = np.array([3.0, -2.0])
y = X @ true_w + 0.1*np.random.randn(N)
 
# Initialize model: 2 → 4 → 1 network
W1 = np.random.randn(D, 4) * 0.1  # WHY small init? Prevent saturation
b1 = np.zeros(4)
W2 = np.random.randn(4, 1) * 0.1
b2 = np.zeros(1)
# Hyperparameters
lr = 0.01  # Learning rate
batch_size = 32
epochs = 50
# Training loop
for epoch in range(epochs):
    # Shuffle data (WHY? Breaks correlation between consecutive batches)
    indices = np.random.permutation(N)
    X_shuffled = X[indices]
    y_shuffled = y[indices]
    
    epoch_loss = 0.0
    for i in range(0, N, batch_size):
        # 1. Extract batch
        X_batch = X_shuffled[i:i+batch_size]
        y_batch = y_shuffled[i:i+batch_size]
        
        # 2. FORWARD PASS
        z1 = X_batch @ W1 + b1  # Linear layer 1
        a1 = np.maximum(0, z1)   # ReLU activation
        # WHY ReLU? Non-linearity without vanishing gradients
        z2 = a1 @ W2 + b2        # Output layer
        y_pred = z2.squeeze()
        
        # 3. LOSS COMPUTATION
        loss = np.mean((y_pred - y_batch)**2)  # MSE
        # WHY MSE? Differentiable, penalizes large errors quadratically
        epoch_loss += loss
        
        # 4. BACKWARD PASS (manual gradients)
        B = len(X_batch)
        dloss_dy = 2 * (y_pred - y_batch) / B  # d(MSE)/d(y_pred)
        
        # Output layer gradients
        dW2 = a1.T @ dloss_dy.reshape(-1, 1)
        # WHY this form? Chain rule: dL/dW2 = dL/dz2 * dz2/dW2 = dL/dy * a1
        db2 = np.sum(dloss_dy)
        
        # Hidden layer gradients
        da1 = dloss_dy.reshape(-1, 1) @ W2.T
        dz1 = da1 * (z1 > 0)  # ReLU derivative: 1 if z>0, else 0
        # WHY multiply by (z1>0)? Backprop through ReLU activation
        dW1 = X_batch.T @ dz1
        db1 = np.sum(dz1, axis=0)
        
        # 5. PARAMETER UPDATE
        W2 -= lr * dW2
        b2 -= lr * db2
        W1 -= lr * dW1
        b1 -= lr * db1
    
    if epoch % 10 == 0:
        print(f"Epoch {epoch}, Loss: {epoch_loss/(N//batch_size):.4f}")
# Final weights approximate true_w via learned representation
print(f"True weights: {true_w}")
print(f"Learned mapping effective weights: ~3.0, ~-2.0 (hidden in W1, W2)")

Har step kyun:

Shuffle: Model ko batch order artifacts seekhne se rokta hai
Batch extraction: Parallel gradient computation enable karta hai
Forward: Input ko learned parameters ke zariye prediction mein transform karta hai
Loss: Prediction quality quantify karta hai (learning signal drive karta hai)
Backward: Compute karta hai ki har parameter ne error mein kitna contribute kiya
Update: Error kam karne ke liye parameters adjust karta hai is batch par

Worked example Real-world training loop (PyTorch style)

Modern frameworks gradient computation automate kar dete hain:

import torch
import torch.nn as nn
# Same synthetic data
X_torch = torch.randn(1000, 2)
y_torch = X_torch @ torch.tensor([3.0, -2.0]) + 0.1*torch.randn(1000)
# Define model
model = nn.Sequential(
    nn.Linear(2, 4),
    nn.ReLU(),
    nn.Linear(4, 1)
)
# Loss and optimizer
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
 
# Training loop
batch_size = 32
for epoch in range(50):
    perm = torch.randperm(len(X_torch))
    for i in range(0, len(X_torch), batch_size):
        indices = perm[i:i+batch_size]
        X_batch, y_batch = X_torch[indices], y_torch[indices]
        
        # Forward
        y_pred = model(X_batch).squeeze()
        loss = criterion(y_pred, y_batch)
        
        # Backward + Update
        optimizer.zero_grad()  # WHY? Clear old gradients
        loss.backward()        # Autograd computes all gradients
        optimizer.step()       # Apply update rule
    
    if epoch % 10 == 0:
        print(f"Epoch {epoch}, Loss: {loss.item():.4f}")

Scratch se key differences:

loss.backward() manual gradient computation replace karta hai
optimizer.step() manual parameter updates replace karta hai
Wahi underlying math hai, code zyada clean hai

Common mistakes aur unke fixes

Common mistake Mistake 1: Gradients zero karna bhool jaana

Galti:

for batch in dataloader:
    loss = compute_loss(batch)
    loss.backward()
    optimizer.step()
    # Missing: optimizer.zero_grad()

Yeh sahi kyun lagta hai: "backward() gradients compute karta hai, step() use karta hai, ho gaya!"

Yeh galat kyun hai: PyTorch default mein gradients accumulate karta hai (gradient accumulation ke liye useful). zero_grad() ke bina, pichle batches ke gradients jud jaate hain, jisse:

Galat gradient magnitudes (current batch ki jagah sum)
Kaafi steps mein exploding gradients
Model current batch pattern nahi seekhta

Fix: backward() se pehle hamesha optimizer.zero_grad() ya model.zero_grad() call karo.

Jab accumulation intentional ho: Bada effective batch size:

accumulation_steps = 4
for i, batch in enumerate(dataloader):
    loss = compute_loss(batch) / accumulation_steps
    loss.backward()  # Accumulate gradients
    if (i+1) % accumulation_steps == 0:
        optimizer.step()
        optimizer.zero_grad()  # Now clear

Common mistake Mistake 2: Gradient accumulation mein galat loss scaling

Galti:

for i, batch in enumerate(dataloader):
    loss = compute_loss(batch)  # No division!
    loss.backward()
    if (i+1) % accum_steps == 0:
        optimizer.step()
        optimizer.zero_grad()

Yeh sahi kyun lagta hai: "Main accumulate kar raha hoon, toh gradients naturally average ho jayenge."

Yeh galat kyun hai: Gradients accumulation steps mein sum ho jaate hain. Agar accum_steps=4 hai, toh intended se 4× bade gradients milte hain. Yeh effectively 4× bada learning rate hai.

Fix: Gradient magnitude normalize karne ke liye loss ko accumulation_steps se divide karo, ya learning rate scale down karo.

Common mistake Mistake 3: Training mode vs eval mode ka confusion

Galti:

# Training
for batch in train_loader:
    outputs = model(batch)  # model.train() never called
    loss = criterion(outputs, targets)
    ...
# Evaluation
with torch.no_grad():
    for batch in val_loader:
        outputs = model(batch)  # model.eval() never called

Yeh sahi kyun lagta hai: "no_grad() gradients disable karta hai, eval ke liye itna kaafi hai."

Yeh galat kyun hai: Dropout aur BatchNorm jaise layers training aur inference mein alag behave karte hain:

Dropout training mein randomly activations zero karta hai, lekin eval mein sab rakhta hai
BatchNorm training mein batch statistics use karta hai, eval mein running statistics

model.eval() bhoolne ka matlab hai validation training-mode behavior use karta hai (galat statistics, random drops), jo pessimistic metrics deta hai.

Fix:

model.train()  # Before training loop
# ... training code ...
model.eval()   # Before evaluation
with torch.no_grad():
    # ... evaluation code ...

Common mistake Mistake 4: Training data shuffle na karna

Galti:

for epoch in range(100):
    for batch in dataloader:  # dataloader has shuffle=False
        # training code

Yeh sahi kyun lagta hai: "SGD waise bhi stochastic hai, order se koi fark nahi padta." Yeh galat kyun hai: Shuffling ke bina, model har epoch mein identical batch sequences dekhta hai:

Early batches mein sirf class 0 ho sakti hai, late batches mein class 1 → catastrophic forgetting
Consecutive batches mein correlated samples → biased gradient estimates
Model true patterns ki jagah batch order artifacts seekhta hai

Fix: DataLoader(..., shuffle=True) ya har epoch mein manual permutation.

Advanced: Learning rate scheduling aur early stopping

Ek fixed learning rate aksar underperform karta hai. Learning rate scheduling training ke dauran $η$ ko adapt karta hai.

Schedule kyun? Early training mein initialization se nikalne ke liye bade steps chahiye; late training mein minima mein settle hone ke liye chhote steps chahiye.

Early stopping validation loss monitor karke overfitting rokta hai:

best_val_loss = float('inf')
patience = 10  # Epochs to wait for improvement
patience_counter = 0
 
for epoch in range(max_epochs):
    train_loss = train_one_epoch(model, train_loader, optimizer)
    val_loss = evaluate(model, val_loader)
    if val_loss < best_val_loss:
        best_val_loss = val_loss
        save_checkpoint(model, 'best_model.pth')
        patience_counter = 0
    else:
        patience_counter += 1
    if patience_counter >= patience:
        print(f"Early stopping at epoch {epoch}")
        break

Yeh kyun kaam karta hai: Validation loss tab badhti hai jab model training noise memorize karne lagta hai → overfitting aur kharab hone se pehle rok do.

Diagram: Training loop flow

Recall Ek 12-saal ke bacche ko samjhao

Socho tum blindfold hokar basketball free throws seekh rahe ho, aur sirf feel kar sakte ho ki kitna miss hua.

Training loop aise practice routine ki tarah hai:

Ball shoot karo (forward pass) - apni current technique se shot maaro
Feel karo ball kahan giri (compute loss) - left miss hua, right, short, ya long?
Pata lagao kya galat hua (backward pass) - kya elbow zyada upar tha? Zyada power laga diya?
Apna form adjust karo (update parameters) - elbow thoda kam moro, power thodi kam karo
Phir shoot karo (next iteration) - adjusted technique se try karo

Har shot kuch chhota sikhata hai. Hundreds of shots (epochs) ke baad, tumhari muscle memory (weights) basket hit karne mein bahut achhi ho jaati hai. "Learning rate" waise hai jaise tum har baar kitna adjust karte ho - shuruaat mein bade changes jab bahut door ho, baad mein chhoti tweaks jab paas ho. Isme magic yeh hai ki tumhe basket dikhni nahi chahiye - sirf error feel karo aur step-by-step adjust karte jao, eventually tum ek great shooter ban jaate ho!

Connections

3.1.02-Backpropagation-algorithm - Gradients backward kaise flow karte hain (loss.backward() ke peeche ka math)
3.3.01-PyTorch-fundamentals - Tensors aur autograd jo training loops power karte hain
3.3.06-Custom-loss-functions - Loss computation step mein kya jaata hai
3.4.03-Learning-rate-schedules - Update step ke liye advanced strategies
3.4.01-Batch-normalization - Woh layers jo train vs eval mode mein alag behave karti hain
3.5.02-Data-loaders-and-batching - Loop ke liye batches kaise prepare hoti hain
4.2.01-Gradient-descent-variants - SGD, Adam, RMSprop - alag-alag update rules
5.1.01-Overfitting-and-underfitting - Kyun hum train vs validation loss monitor karte hain

#flashcards/ai-ml

Training loop ke paanch core components kya hain? :: 1. Forward pass (predictions compute karo), 2. Loss computation (error measure karo), 3. Backward pass (gradients compute karo), 4. Parameter update (optimizer apply karo), 5. Iteration (batches/epochs par repeat karo)

Hum full-batch gradient descent ki jagah mini-batch SGD kyun use karte hain?

Full-batch mein poore dataset par gradients compute karne padte hain (slow aur memory-intensive). Mini-batches gradient ko bahut kam computation mein approximate karte hain aur single-example SGD se kam noisy updates dete hain. Variance aur efficiency balance karte hain.

Empirical risk minimization kya hai?

Training data par average loss minimize karna, true data distribution par expected risk minimize karne ke proxy ke roop mein. Formula:

\hat{R} (θ) = \frac{1}{N} \sum_{i = 1}^{N} L (f (x_{i}; θ), y_{i})

backward() se pehle optimizer.zero_grad() kyun call karna zaroori hai?

PyTorch default mein gradients accumulate karta hai. Zero kiye bina, pichle batches ke gradients current gradients mein jud jaate hain, jisse galat gradient magnitudes aur exploding gradients hote hain. Sirf tab intentionally skip karo jab gradient accumulation implement kar rahe ho.

Validation mein model.eval() bhoolne par kya hota hai?

Dropout aur BatchNorm jaise layers training-mode behavior use karti hain (random drops, running statistics ki jagah batch statistics), jo galat aur aksar pessimistic evaluation metrics deta hai. Validation se pehle hamesha model.eval() aur training se pehle model.train() call karo.

Mini-batches ke saath SGD ka update rule kya hai?

θ_{t + 1} = θ_{t} - \frac{η}{∣ B _{t} ∣} \sum_{(x, y) \in B_{t}} \nabla_{θ} L (f (x; θ_{t}), y)

jahan

B_{t}

mini-batch hai,

η

learning rate hai, aur hum batch par gradient average karte hain.

Har epoch mein training data shuffle kyun karte hain?

Model ko batch order artifacts aur consecutive batches ke beech correlations seekhne se rokta hai. Shuffling ke bina, correlated samples gradient estimates bias kar dete hain aur model true underlying patterns ki jagah sequence pattern seekh sakta hai.

Early stopping kya hai aur yeh kyun kaam karta hai?

Validation loss monitor karna aur training tab rokna jab yeh improve karna band kar de (patience period ke baad). Kaam karta hai kyunki validation loss tab badhti hai jab model overfitting shuru kar deta hai (training noise memorize karna), toh is point se pehle rokna generalization preserve karta hai.

Gradient accumulation sahi tarike se kaise implement karte hain?

backward() se pehle loss ko accumulation_steps se divide karo, bina zero_grad() ke multiple batches mein gradients accumulate karo, phir accumulation_steps batches ke baad optimizer.step() aur zero_grad() call karo. Yeh ek bada effective batch size simulate karta hai.

Learning rate scheduling ka purpose kya hai?

Training ke dauran learning rate adapt karna - shuruaat mein initialization se jaldi nikalne ke liye bade steps, baad mein minima mein bina overshoot ke settle hone ke liye chhote steps. Common schedules: step decay, exponential decay, cosine annealing, reduce on plateau.