Python / PyTorch Fundamentals Interview Questions

Transfer learning reuses a model pretrained on a large dataset and adapts it to a new task. Freezing layers (setting requires_grad=False) prevents their weights from updating during backpropagation — useful when you want to keep pretrained features fixed and only train a new task-specific head.

import torch
import torch.nn as nn
import torchvision.models as models

# Load a pretrained ResNet-50
backbone = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V2)

# ── Strategy 1: Feature extraction — freeze ALL pretrained layers
for param in backbone.parameters():
    param.requires_grad = False     # excluded from gradient computation

# Replace the final classification layer for our task (e.g. 5 classes)
in_features = backbone.fc.in_features    # 2048 for ResNet-50
backbone.fc = nn.Linear(in_features, 5)  # NEW layer — requires_grad=True by default

# Only backbone.fc parameters will be updated by the optimizer
optimizer = torch.optim.AdamW(
    filter(lambda p: p.requires_grad, backbone.parameters()),  # only trainable params
    lr=1e-3,
)

# ── Strategy 2: Full fine-tuning with layer-wise (discriminative) learning rates
backbone2 = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V2)
backbone2.fc = nn.Linear(backbone2.fc.in_features, 5)

optimizer2 = torch.optim.AdamW([
    {"params": backbone2.layer1.parameters(), "lr": 1e-5},  # earliest layers — smallest lr
    {"params": backbone2.layer4.parameters(), "lr": 1e-4},  # later layers — bigger lr
    {"params": backbone2.fc.parameters(),     "lr": 1e-3},  # new head — largest lr
])

# ── Verify which parameters are trainable
trainable = sum(p.numel() for p in backbone.parameters() if p.requires_grad)
total     = sum(p.numel() for p in backbone.parameters())
print(f"Trainable: {trainable:,} / Total: {total:,} ({100*trainable/total:.1f}%)")

# ── Common pattern: train head first, then unfreeze and fine-tune everything
# Phase 1: only train backbone.fc for a few epochs
# Phase 2: unfreeze all layers, train with a small lr to fine-tune end-to-end
for param in backbone.parameters():
    param.requires_grad = True   # unfreeze for phase 2

Splitting a dataset into training, validation, and test subsets is a fundamental step before training. PyTorch's random_split() creates non-overlapping random subsets from a single Dataset, while preserving the lazy-loading behaviour of the original Dataset.

import torch
from torch.utils.data import Dataset, DataLoader, random_split

class MyDataset(Dataset):
    def __init__(self, n=1000):
        self.data   = torch.randn(n, 20)
        self.labels = torch.randint(0, 3, (n,))
    def __len__(self):
        return len(self.data)
    def __getitem__(self, idx):
        return self.data[idx], self.labels[idx]

full_dataset = MyDataset(n=1000)

# Split: 70% train, 15% val, 15% test
train_size = int(0.7 * len(full_dataset))
val_size   = int(0.15 * len(full_dataset))
test_size  = len(full_dataset) - train_size - val_size  # remainder, avoids rounding loss

# Use a generator for reproducible splits
generator = torch.Generator().manual_seed(42)
train_ds, val_ds, test_ds = random_split(
    full_dataset,
    [train_size, val_size, test_size],
    generator=generator,
)

print(len(train_ds), len(val_ds), len(test_ds))   # 700 150 150

train_loader = DataLoader(train_ds, batch_size=32, shuffle=True)
val_loader   = DataLoader(val_ds,   batch_size=32, shuffle=False)  # no shuffle needed
test_loader  = DataLoader(test_ds,  batch_size=32, shuffle=False)

# IMPORTANT GOTCHA: if your Dataset applies different transforms
# (e.g. data augmentation only for training), random_split alone
# does NOT let you apply different transforms per split, because
# all splits reference the SAME underlying Dataset object.
# Common workaround: split INDICES, then wrap with two separate
# Dataset instances using different transforms
from torch.utils.data import Subset
indices = torch.randperm(len(full_dataset), generator=generator).tolist()
train_idx = indices[:train_size]
val_idx   = indices[train_size:train_size+val_size]
# train_dataset_aug = Subset(MyDatasetWithAugmentation(...), train_idx)
# val_dataset_plain = Subset(MyDatasetPlain(...), val_idx)

Normalization layers stabilise training by re-centring and re-scaling activations. PyTorch provides several variants; Batch Normalization (BatchNorm) and Layer Normalization (LayerNorm) are the two most widely used, but they normalise over different dimensions and suit different architectures.

import torch
import torch.nn as nn

# ── BatchNorm — for feedforward / CNN models
class BNModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(20, 64)
        self.bn1 = nn.BatchNorm1d(64)   # 64 features
        self.fc2 = nn.Linear(64, 10)

    def forward(self, x):
        x = torch.relu(self.bn1(self.fc1(x)))
        return self.fc2(x)

# BatchNorm behaves differently in train vs eval mode!
# train: normalise using batch mean/var, update running stats
# eval:  use accumulated running_mean / running_var
model = BNModel()
model.train()   # must be in train mode during training!

# ── LayerNorm — for transformers and sequence models
class LNModel(nn.Module):
    def __init__(self, d_model=64):
        super().__init__()
        self.fc1 = nn.Linear(20, d_model)
        self.ln1 = nn.LayerNorm(d_model)   # normalise over last dim
        self.fc2 = nn.Linear(d_model, 10)

    def forward(self, x):
        x = torch.relu(self.ln1(self.fc1(x)))
        return self.fc2(x)

# LayerNorm produces the SAME result at train and eval
ln_model = LNModel()
ln_model.train()
x = torch.randn(8, 20)
out_train = ln_model(x)
ln_model.eval()
out_eval  = ln_model(x)
print(torch.allclose(out_train, out_eval))  # True — LayerNorm is mode-independent!