Most of us here ship code against model APIs every day without ever having trained one, and that gap shows up the moment a model does something the docs do not explain. This is the mental model I wish I had earlier, written for developers rather than for a statistics class.
Learning Is Just Adjusting Numbers
Every model is a function. It takes an input and returns an output, and in between sit numbers that nobody chose by hand.
Take the smallest possible version: price = weight * square_footage + bias. Two unknowns. You show the function a real sale, measure how far off it was, and move the weight and the bias slightly in the direction that would have reduced the error. Do that a few thousand times and you have something that predicts house prices.
Nothing about that changes at scale. GPT-4 is estimated to hold over a trillion of those numbers, and every one of them was set by the same loop: guess, measure the error, adjust. The architecture decides how the numbers are wired together. Training decides what they end up being.
Three Paradigms, One Question
Supervised, unsupervised and reinforcement learning get taught as three separate topics, but they are really three answers to one question: how does the system find out it was wrong?
Supervised learning gets told. Every input arrives with the correct answer attached, so the error is available immediately. It is the most reliable of the three and it sits under image classifiers, spam filters and translation. The cost is the labels, because a person has to produce them.
Unsupervised learning is never told. There is no correct answer, so the system optimizes for structure instead, grouping things that behave alike or compressing data without losing much. Clustering and embeddings live here.
Reinforcement learning finds out later. The system acts, and a score arrives after the fact, sometimes long after. That delay is the entire difficulty, because when the score comes back bad you still have to work out which of the earlier decisions caused it. The alignment step that turned raw language models into assistants is this paradigm.
The full guide to how AI learns walks each of the three through a worked example, along with the training loop step by step.
Why The Data Sets The Ceiling
A model generalizes only inside the boundaries of what it saw. That sounds obvious, and it is still the most common reason a system tests well and then falls apart in production.
A child who touches a hot stove once learns to be careful around hot things in general. A model needs thousands of examples to find the same pattern, and it will not extend that pattern to a situation its training data never covered. If stoves were never in the data, there is no concept of a stove to reason from.
For anyone building on top of these systems, that is the practical part: when output quality is bad, the fix is usually in the data distribution rather than in the architecture or the prompt.
What Training Cannot Fix
Training is statistical, so it inherits the limits of statistics. A model can tell you what tends to follow from what. It cannot tell you what causes what, unless the causal structure happened to be visible in the correlations.
It also has no way to know what it does not know. Confidence in these systems is a measure of how well an output matches patterns in the training data, which is why a confident wrong answer looks identical, from the inside, to a confident right one.
Working out which of the three paradigms produced the behavior in front of you usually tells you whether you have a data problem, a reward problem, or a limit of the method itself. That single distinction has saved me more debugging time than any prompting technique.