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

# Feature engineering (manual)
def extract_features(image):
    features = []
    features.append(np.mean(image))  # brightness
    features.append(np.std(image))   # contrast
    features.append(count_edges(image))  # edges
    features.append(color_histogram(image))  # colors
    # ... 100 more hand-crafted features
    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__()
        # Network learns features automatically
        self.conv1 = nn.Conv2d(3, 32, 3)
        self.conv2 = nn.Conv2d(32, 64, 3)
        self.conv3 = nn.Conv2d(64, 128, 3)
        self.fc = nn.Linear(128 * 4 * 4, 10)
    
    def forward(self, x):
        x = F.relu(self.conv1(x))  # learns edges
        x = F.relu(self.conv2(x))  # learns shapes
        x = F.relu(self.conv3(x))  # learns objects
        return self.fc(x.flatten(1))

# Train end-to-end
model = CNN()
# Just give it raw pixels — it figures out the features!

1. FORWARD PASS
   Input → [Layer 1] → [Layer 2] → ... → [Layer N] → Prediction
   
2. LOSS COMPUTATION
   Compare Prediction vs. Ground Truth → Loss Value
   
3. BACKWARD PASS (Backpropagation)
   Compute gradients of loss w.r.t. each parameter
   
4. PARAMETER UPDATE
   parameters = parameters - learning_rate × gradients
   
5. REPEAT for all data, many epochs

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
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

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

train_loader = DataLoader(train_data, batch_size=64, shuffle=True)
test_loader = DataLoader(test_data, batch_size=1000)

# 2. DEFINE NETWORK
class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.flatten = nn.Flatten()
        self.fc1 = nn.Linear(28 * 28, 512)
        self.fc2 = nn.Linear(512, 256)
        self.fc3 = nn.Linear(256, 10)
        self.relu = nn.ReLU()
        self.dropout = nn.Dropout(0.2)
    
    def forward(self, x):
        x = self.flatten(x)
        x = self.dropout(self.relu(self.fc1(x)))
        x = self.dropout(self.relu(self.fc2(x)))
        return self.fc3(x)

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

# 3. SETUP TRAINING
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 4. TRAINING LOOP
def train_epoch(model, loader, criterion, optimizer):
    model.train()
    total_loss = 0
    correct = 0
    
    for batch_idx, (data, target) in enumerate(loader):
        optimizer.zero_grad()        # Clear gradients
        output = model(data)          # Forward pass
        loss = criterion(output, target)  # Compute loss
        loss.backward()               # Backward pass
        optimizer.step()              # Update weights
        
        total_loss += loss.item()
        pred = output.argmax(dim=1)
        correct += pred.eq(target).sum().item()
    
    return total_loss / len(loader), 100. * correct / len(loader.dataset)

# 5. EVALUATION
def evaluate(model, loader, criterion):
    model.eval()
    total_loss = 0
    correct = 0
    
    with torch.no_grad():
        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]