Learning means adjusting numbers

A freshly built network is useless — its weights are random, so its predictions are noise. Training is the process of nudging those millions of weights, little by little, until the predictions get good. Remarkably, almost all of deep learning training is the same four-step loop, repeated over the data thousands of times.

Four steps, repeated

1. Forward pass — run inputs through the network to compute predictions.
2. Loss — measure how wrong those predictions are with a loss function (a single number; lower is better).
3. Backward pass — backpropagation works backward through the network to compute the gradient: how much each weight contributed to the error.
4. Update — the optimizer nudges every weight a small step in the direction that reduces the loss.

for x, y in loader:
    pred = model(x)
    loss = loss_fn(pred, y)
    loss.backward()                          # backprop: compute gradients
    optimizer.step(); optimizer.zero_grad()  # update weights, then reset

Repeat this over the whole dataset many times (each full pass is an epoch) and the loss steadily drops as the network improves.

Gradient descent, intuitively

Imagine standing on a foggy hillside trying to reach the valley. You can't see the bottom, but you can feel which way is downhill and step that way. Do it repeatedly and you descend. That's gradient descent: the gradient is the "downhill direction" in the landscape of possible weights, and each update is one step toward lower error. The learning rate sets the step size — too big and you overshoot, too small and it crawls.

Why this demystifies everything

Backprop and optimization sound intimidating, but every framework automates steps 3 and 4 — you rarely write them yourself. What matters is the picture: predict, measure error, find the downhill direction, step. Every model from a tiny classifier to a giant LLM is trained by this same loop.

Training isn't magic — it's repetition. Guess, measure how wrong you are, step a little less wrong, and do it a few million times. The whole field rests on that loop.

Try this: Picture the loss as a number that starts high and should fall each epoch. If it stops falling, or bounces around wildly, the learning rate is usually the culprit — too small or too big. Holding that one image makes real training runs far less mysterious.