PyTorch Basics Explained in Plain, Simple Language

import torch

# A single number (scalar)
x = torch.tensor(5)

# A list of numbers (vector)
v = torch.tensor([1, 2, 3, 4])

# A 2x3 grid (matrix)
m = torch.tensor([
    [1, 2, 3],
    [4, 5, 6]
])

# A random 3x2 tensor
r = torch.rand(3, 2)

# A tensor of zeros
z = torch.zeros(2, 2)

print(x.shape)   # torch.Size([])
print(v.shape)   # torch.Size([4])
print(m.shape)   # torch.Size([2, 3])

# That's it. A tensor is just a grid of numbers.
# The magic happens when you do math on them.

import torch

# Basic math on tensors
a = torch.tensor([1.0, 2.0, 3.0])
b = torch.tensor([4.0, 5.0, 6.0])

print(a + b)    # tensor([5., 7., 9.])
print(a * 2)    # tensor([2., 4., 6.])
print(a @ b)    # 32.0 (dot product)

# Why tensors matter:
# 1. They can run on GPUs (100x faster than CPU)
# 2. They track gradients automatically (autograd)
# 3. They're optimized for matrix math

# Move a tensor to GPU (if available)
device = "cuda" if torch.cuda.is_available() else "cpu"
a = a.to(device)
print(a.device)  # cuda:0 or cpu

# Behind the scenes, a neural network is
# just thousands of tensor operations
# chained together.

import torch

# Create a tensor with gradient tracking
x = torch.tensor(3.0, requires_grad=True)

# Do some math
y = x ** 2 + 2 * x + 1

# Compute the gradient automatically
y.backward()

# Print the gradient
print(x.grad)   # 8.0

# What just happened?
# If y = x² + 2x + 1
# Then dy/dx = 2x + 2
# At x = 3, dy/dx = 8
# PyTorch computed this automatically.

# You never calculate a derivative by hand.
# You just call .backward() and PyTorch figures it out.

import torch

# A realistic example: minimizing loss

# Step 1: Start with a guess
w = torch.tensor(1.0, requires_grad=True)

# Step 2: Our "truth" is 4.0
target = 4.0

# Step 3: Make a prediction with our guess
prediction = w * 2   # 2.0 (wrong — should be 4.0)

# Step 4: Compute loss
loss = (prediction - target) ** 2   # (2 - 4)² = 4.0
print("Loss:", loss.item())

# Step 5: Compute gradients
loss.backward()
print("Gradient:", w.grad)   # -4.0

# What does the gradient mean?
# If gradient is negative, increasing w will
# decrease the loss. So we should increase w.

# Step 6: Update w
optimizer = torch.optim.SGD([w], lr=0.1)
optimizer.step()
print("New w:", w.item())   # 1.4

# Repeat steps 3-6 many times and w
# converges toward 2.0 (since prediction
# = w * 2 should equal 4.0)

import torch
import torch.nn as nn

class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        # Define the layers (the "mixing steps")
        self.fc1 = nn.Linear(10, 16)   # 10 inputs → 16 features
        self.relu = nn.ReLU()          # non-linear activation
        self.fc2 = nn.Linear(16, 1)    # 16 features → 1 output

    def forward(self, x):
        # Data flows: x → fc1 → relu → fc2
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x

# Create the model
model = SimpleNet()

# Print all the parameters (weights + biases)
for name, param in model.named_parameters():
    print(name, param.shape)

# That's it. That's a neural network.
# Two linear layers with a ReLU between them.
# The "learning" part adjusts the weights.

import torch
import torch.nn as nn

class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(10, 16)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(16, 1)

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

# Create the model
model = SimpleNet()

# Create fake input data
# shape: [batch_size, features]
x = torch.randn(32, 10)   # batch of 32, 10 features each

# Get predictions
predictions = model(x)

print(predictions.shape)   # torch.Size([32, 1])
# 32 predictions (one per sample), each a single number

# What just happened:
# 1. x went through fc1 → shape [32, 16]
# 2. Went through ReLU → shape [32, 16]
# 3. Went through fc2 → shape [32, 1]
# 4. Output has one number per sample

# This is the "forward pass" — data goes in,
# predictions come out.

The Training Loop — 4 Steps, Repeated:

1. FORWARD PASS
   predictions = model(inputs)
   "What does the model think?"

2. COMPUTE LOSS
   loss = loss_fn(predictions, targets)
   "How wrong is it?"

3. BACKWARD PASS
   loss.backward()
   "Which parameters caused this error?"

4. UPDATE PARAMETERS
   optimizer.step()
   optimizer.zero_grad()
   "Adjust the parameters, then reset
    the gradients for the next round."

That's it. The model is trained by
repeating these four steps hundreds or
thousands of times.

The model gets "smarter" because each
iteration pushes the parameters slightly
in the direction that reduces loss.

import torch
import torch.nn as nn

# Setup
model = nn.Linear(10, 1)
loss_fn = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

# Training loop — repeat 100 times
for epoch in range(100):
    # 1. FORWARD PASS
    predictions = model(X_train)

    # 2. COMPUTE LOSS
    loss = loss_fn(predictions, y_train)

    # 3. BACKWARD PASS
    optimizer.zero_grad()   # clear old gradients
    loss.backward()

    # 4. UPDATE PARAMETERS
    optimizer.step()

    # Log every 10 iterations
    if epoch % 10 == 0:
        print(f"Epoch {epoch}, Loss: {loss.item():.4f}")

# What's happening inside the loop:
# ☐ Each epoch = one pass through the data
# ☐ Model makes predictions, computes loss,
#   computes gradients, updates weights
# ☐ Loss should decrease over time
# ☐ If it doesn't, either the model is too simple,
#   the learning rate is wrong, or the data is broken

# That's the whole training process.
# Real models just run more epochs and more layers.

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

# 1. Create fake data
# 100 samples, 5 features each
torch.manual_seed(42)
X = torch.randn(100, 5)
y = (X.sum(dim=1, keepdim=True) > 0).float()

# 2. Build the model
class MyNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(5, 10)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(10, 1)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        x = self.sigmoid(x)   # output between 0 and 1
        return x

model = MyNet()

# 3. Loss and optimizer
loss_fn = nn.BCELoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)

# 4. Training loop
for epoch in range(200):
    # Forward
    preds = model(X)
    loss = loss_fn(preds, y)

    # Backward + update
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if epoch % 20 == 0:
        print(f"Epoch {epoch:3d} | Loss: {loss.item():.4f}")

# 5. Evaluate
with torch.no_grad():
    preds = model(X)
    predicted_classes = (preds > 0.5).float()
    accuracy = (predicted_classes == y).float().mean()
    print(f"\nFinal accuracy: {accuracy.item() * 100:.1f}%")

# Expected output:
# Loss decreases over epochs (from ~0.7 to ~0.1)
# Final accuracy: ~95%+

What to Try Next (progress checklist):

Immediate:
☐ Change lr from 0.01 to 0.001 — what happens to loss?
☐ Add more layers — does accuracy improve?
☐ Try a different activation (ReLU → Tanh)

Intermediate:
☐ Load a real dataset from sklearn.datasets
  (e.g., load_breast_cancer)
☐ Add a train/test split
☐ Measure accuracy on unseen data

Advanced:
☐ Try MNIST (digits) with a CNN
☐ Try a text classifier with Hugging Face
☐ Save and load your trained model
☐ Deploy it with FastAPI

Where you are now:
☐ You understand tensors
☐ You understand autograd
☐ You understand models
☐ You understand training loops

Next: build something real. The fastest
way to keep learning is to ship.