PyTorch Basics Explained: Tensors, Autograd, and Real Model Training

import torch

# --- Creating tensors from real data ---
# Simulating a tiny dataset: 4 house sizes (sq ft) and their prices ($k)
house_sizes = torch.tensor([750.0, 1200.0, 1800.0, 2400.0])  # 1D tensor, shape (4,)
house_prices = torch.tensor([150.0, 220.0, 310.0, 410.0])    # 1D tensor, shape (4,)

print("Sizes tensor:", house_sizes)
print("Shape:", house_sizes.shape)        # torch.Size([4])
print("Data type:", house_sizes.dtype)    # torch.float32 — default for floats

# --- 2D tensor: batch of data (rows = samples, cols = features) ---
feature_matrix = torch.tensor([
    [750.0,  3.0, 1.0],   # size, bedrooms, bathrooms
    [1200.0, 4.0, 2.0],
    [1800.0, 4.0, 3.0],
    [2400.0, 5.0, 3.0],
])
print("\nFeature matrix shape:", feature_matrix.shape)  # torch.Size([4, 3])

# --- Device awareness: check and move to GPU if available ---
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("\nUsing device:", device)

# Move tensor to the target device — always do this before operations
feature_matrix = feature_matrix.to(device)
print("Feature matrix device:", feature_matrix.device)

# --- Useful tensor operations ---
# Normalise features: (x - mean) / std — critical for stable training
means = feature_matrix.mean(dim=0)   # mean along rows, one value per column
stds  = feature_matrix.std(dim=0)    # std along rows, one value per column
normalised = (feature_matrix - means) / stds

print("\nNormalised features (first row):", normalised[0])

# --- require_grad: opting a tensor INTO gradient tracking ---
# We do NOT set this on input data — only on learnable parameters
weight = torch.tensor([0.15], requires_grad=True)  # our model's single weight
bias   = torch.tensor([10.0], requires_grad=True)  # our model's bias term

print("\nWeight requires grad:", weight.requires_grad)  # True
print("House sizes requires grad:", house_sizes.requires_grad)  # False — data, not a parameter

import torch

# Seed for reproducibility — always set this in experiments
torch.manual_seed(42)

# --- Toy linear regression: predict house price from size ---
# Ground truth: price = 0.18 * size + 5  (we want the model to discover this)
house_sizes  = torch.tensor([750.0, 1200.0, 1800.0, 2400.0])
house_prices = torch.tensor([140.0, 221.0, 329.0, 437.0])

# Learnable parameters — these are the knobs PyTorch will tune
weight = torch.tensor([0.01], requires_grad=True)  # starts as a bad guess
bias   = torch.tensor([0.01], requires_grad=True)

learning_rate = 0.0000001  # tiny LR because our inputs are large (hundreds to thousands)

for epoch in range(6):
    # FORWARD PASS: compute predictions using current weight and bias
    predicted_prices = weight * house_sizes + bias  # broadcasting: applies to all 4 houses

    # COMPUTE LOSS: Mean Squared Error — how wrong are we on average?
    loss = ((predicted_prices - house_prices) ** 2).mean()

    # BACKWARD PASS: autograd fills .grad on weight and bias
    # Must zero gradients first — they accumulate by default!
    if weight.grad is not None:
        weight.grad.zero_()
        bias.grad.zero_()

    loss.backward()  # compute d(loss)/d(weight) and d(loss)/d(bias)

    # PARAMETER UPDATE: nudge weight and bias toward lower loss
    # torch.no_grad() because we don't want this update tracked in the graph
    with torch.no_grad():
        weight -= learning_rate * weight.grad  # gradient descent step
        bias   -= learning_rate * bias.grad

    print(f"Epoch {epoch+1:2d} | Loss: {loss.item():.2f} | "
          f"weight: {weight.item():.5f} | bias: {bias.item():.5f}")

print("\nFinal model: price =", round(weight.item(), 4), "* size +", round(bias.item(), 4))
print("Target model:  price = 0.18 * size + 5")

# Inference — no gradient tracking needed, saves memory
with torch.no_grad():
    test_size = torch.tensor([2000.0])
    predicted = weight * test_size + bias
    print(f"\nPredicted price for 2000 sq ft: ${predicted.item():.1f}k")

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

torch.manual_seed(42)

# --- Dataset: Boston-style house price prediction (synthetic) ---
# 100 samples, 3 features: size(sqft), bedrooms, age(years)
num_samples  = 100
num_features = 3

# Generate synthetic features and a linear target with some noise
raw_features = torch.randn(num_samples, num_features)
true_weights  = torch.tensor([0.5, 0.3, -0.2])  # size helps, age hurts price
target_prices = raw_features @ true_weights + 0.1 * torch.randn(num_samples)

# Train / validation split: 80 / 20
train_size = int(0.8 * num_samples)
train_features, val_features = raw_features[:train_size], raw_features[train_size:]
train_targets,  val_targets  = target_prices[:train_size], target_prices[train_size:]


# --- Model definition ---
class HousePriceNet(nn.Module):
    def __init__(self, input_features: int):
        super().__init__()  # always call parent __init__

        # nn.Sequential stacks layers; no need to write forward() manually for simple nets
        self.network = nn.Sequential(
            nn.Linear(input_features, 16),  # input layer -> hidden layer (16 neurons)
            nn.ReLU(),                       # activation: turn negatives to zero
            nn.Linear(16, 8),               # hidden -> smaller hidden
            nn.ReLU(),
            nn.Linear(8, 1),                # final layer: output one price prediction
        )

    def forward(self, feature_batch: torch.Tensor) -> torch.Tensor:
        # Squeeze removes the trailing dimension: (batch, 1) -> (batch,)
        return self.network(feature_batch).squeeze(1)


model     = HousePriceNet(input_features=num_features)
loss_fn   = nn.MSELoss()                            # Mean Squared Error for regression
optimizer = optim.Adam(model.parameters(), lr=1e-3) # Adam adapts the learning rate per param

print(f"Model parameters: {sum(p.numel() for p in model.parameters()):,}")
print(model)
print()

# --- Training loop ---
for epoch in range(1, 51):
    model.train()  # sets model to training mode (enables Dropout, BatchNorm updates)

    # Step 1: Zero out stale gradients from the previous iteration
    optimizer.zero_grad()

    # Step 2: Forward pass — get predictions for the whole training set
    train_predictions = model(train_features)

    # Step 3: Compute how wrong we are
    train_loss = loss_fn(train_predictions, train_targets)

    # Step 4: Backprop — autograd computes all gradients
    train_loss.backward()

    # Step 5: Optimizer updates every parameter using its stored gradient
    optimizer.step()

    # --- Validation (every 10 epochs) ---
    if epoch % 10 == 0:
        model.eval()  # disables Dropout, fixes BatchNorm — crucial for fair evaluation
        with torch.no_grad():  # no graph needed; saves memory
            val_predictions = model(val_features)
            val_loss = loss_fn(val_predictions, val_targets)

        print(f"Epoch {epoch:3d} | Train Loss: {train_loss.item():.4f} | "
              f"Val Loss: {val_loss.item():.4f}")

# --- Single inference example ---
model.eval()
with torch.no_grad():
    new_house = torch.tensor([[1.2, 0.5, -0.8]])  # normalised features
    price_pred = model(new_house)
    print(f"\nPredicted price index for new house: {price_pred.item():.4f}")
    print(f"True expected value (approx): {(new_house[0] @ true_weights).item():.4f}")