# Traditional ML: YOU design the features
import numpy as np
from sklearn.ensemble import RandomForestClassifier

# Feature engineering (manual) -- this is where the real work lives
def extract_features(image):
    features = []
    features.append(np.mean(image))  # brightness -- simple but lossy
    features.append(np.std(image))   # contrast -- captures variation
    features.append(count_edges(image))  # edges -- requires domain knowledge
    features.append(color_histogram(image))  # colors -- you hope this matters
    # ... 100 more hand-crafted features -- weeks of domain expert time
    return np.array(features)

# Train on hand-crafted features
X = np.array([extract_features(img) for img in images])
model = RandomForestClassifier()
model.fit(X, labels)

# Deep Learning: The network LEARNS the features
import torch
import torch.nn as nn

class CNN(nn.Module):
    def __init__(self):
        super().__init__()
        # No hand-crafted features -- the network discovers what matters
        self.conv1 = nn.Conv2d(3, 32, 3)   # Layer 1: will learn edge detectors
        self.conv2 = nn.Conv2d(32, 64, 3)  # Layer 2: will learn shape detectors
        self.conv3 = nn.Conv2d(64, 128, 3) # Layer 3: will learn object-part detectors
        self.fc = nn.Linear(128 * 4 * 4, 10)  # Final: maps features to 10 classes
    
    def forward(self, x):
        x = F.relu(self.conv1(x))  # learns edges automatically from data
        x = F.relu(self.conv2(x))  # combines edges into shapes
        x = F.relu(self.conv3(x))  # combines shapes into object parts
        return self.fc(x.flatten(1))  # classifies based on learned features

# Train end-to-end -- just give it raw pixels and labels
model = CNN()
# The network figures out which features matter. That is the revolution.

1. FORWARD PASS (make a prediction)
   Input → [Layer 1] → [Layer 2] → ... → [Layer N] → Prediction
   
2. LOSS COMPUTATION (measure how wrong we are)
   Compare Prediction vs. Ground Truth → Loss Value (a single number)
   
3. BACKWARD PASS (figure out who is responsible for the error)
   Compute gradients of loss w.r.t. each parameter using backpropagation
   
4. PARAMETER UPDATE (adjust to do better next time)
   parameters = parameters - learning_rate × gradients
   
5. REPEAT for all data, many epochs (one epoch = one pass through all data)

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# 1. LOAD DATA
# transforms.Compose chains preprocessing steps -- order matters!
transform = transforms.Compose([
    transforms.ToTensor(),              # Convert PIL image to tensor (also scales 0-255 to 0-1)
    transforms.Normalize((0.1307,), (0.3081,))  # Normalize with MNIST mean and std
    # Why normalize? It centers data around 0, which helps gradients flow evenly
])

train_data = datasets.MNIST('./data', train=True, download=True, transform=transform)
test_data = datasets.MNIST('./data', train=False, transform=transform)

# batch_size=64: process 64 images at once (a balance between speed and memory)
# shuffle=True for training: prevents the model from learning the order of examples
train_loader = DataLoader(train_data, batch_size=64, shuffle=True)
test_loader = DataLoader(test_data, batch_size=1000)  # Larger batches for eval (no gradients stored)

# 2. DEFINE NETWORK
class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.flatten = nn.Flatten()          # 28x28 image -> 784-dim vector
        self.fc1 = nn.Linear(28 * 28, 512)   # First hidden layer: compress to 512 features
        self.fc2 = nn.Linear(512, 256)        # Second hidden layer: compress further to 256
        self.fc3 = nn.Linear(256, 10)         # Output layer: 10 classes (digits 0-9)
        self.relu = nn.ReLU()                 # Non-linearity -- without this, the network is just linear regression
        self.dropout = nn.Dropout(0.2)        # Randomly zero 20% of neurons during training to prevent overfitting
    
    def forward(self, x):
        x = self.flatten(x)                          # Flatten image to vector
        x = self.dropout(self.relu(self.fc1(x)))     # Layer 1: linear -> ReLU -> dropout
        x = self.dropout(self.relu(self.fc2(x)))     # Layer 2: same pattern
        return self.fc3(x)                           # Output: raw logits (no activation -- CrossEntropyLoss handles softmax)

model = SimpleNet()
print(f"Parameters: {sum(p.numel() for p in model.parameters()):,}")
# ~535K parameters -- tiny by modern standards, but enough for MNIST

# 3. SETUP TRAINING
criterion = nn.CrossEntropyLoss()  # Combines LogSoftmax + NLLLoss -- the standard for classification
optimizer = optim.Adam(model.parameters(), lr=0.001)  # Adam adapts learning rate per-parameter

# 4. TRAINING LOOP -- this is the core rhythm of all deep learning
def train_epoch(model, loader, criterion, optimizer):
    model.train()  # Enable dropout and batch norm training behavior
    total_loss = 0
    correct = 0
    
    for batch_idx, (data, target) in enumerate(loader):
        optimizer.zero_grad()             # CRITICAL: clear old gradients (PyTorch accumulates by default)
        output = model(data)              # Forward pass: input -> prediction
        loss = criterion(output, target)  # How wrong are we? (single number)
        loss.backward()                   # Backward pass: compute gradient of loss w.r.t. every parameter
        optimizer.step()                  # Update each parameter: param -= lr * gradient
        
        total_loss += loss.item()
        pred = output.argmax(dim=1)       # Pick the class with highest score
        correct += pred.eq(target).sum().item()
    
    return total_loss / len(loader), 100. * correct / len(loader.dataset)

# 5. EVALUATION -- always evaluate on data the model has never seen
def evaluate(model, loader, criterion):
    model.eval()  # Disable dropout -- use all neurons for prediction
    total_loss = 0
    correct = 0
    
    with torch.no_grad():  # No gradient computation needed -- saves memory and speeds up inference
        for data, target in loader:
            output = model(data)
            total_loss += criterion(output, target).item()
            pred = output.argmax(dim=1)
            correct += pred.eq(target).sum().item()
    
    return total_loss / len(loader), 100. * correct / len(loader.dataset)

# 6. TRAIN!
for epoch in range(1, 11):
    train_loss, train_acc = train_epoch(model, train_loader, criterion, optimizer)
    test_loss, test_acc = evaluate(model, test_loader, criterion)
    print(f"Epoch {epoch}: Train Acc: {train_acc:.2f}%, Test Acc: {test_acc:.2f}%")

Parameters: 535,818
Epoch 1: Train Acc: 93.82%, Test Acc: 96.51%
Epoch 2: Train Acc: 97.42%, Test Acc: 97.33%
...
Epoch 10: Train Acc: 99.12%, Test Acc: 98.15%

import matplotlib.pyplot as plt

# Get first layer weights
weights = model.fc1.weight.data.cpu().numpy()

# Visualize some learned features
fig, axes = plt.subplots(4, 8, figsize=(16, 8))
for i, ax in enumerate(axes.flat):
    # Reshape weight to 28x28 image
    feature = weights[i].reshape(28, 28)
    ax.imshow(feature, cmap='RdBu', vmin=-0.3, vmax=0.3)
    ax.axis('off')
plt.suptitle("First Layer Learned Features")
plt.show()

Raw Pixels → [Layer 1: Edges] → [Layer 2: Shapes] → [Layer 3: Parts] → [Layer 4: Digits]