Model
A block of rules saved as-is, left over once training finishes
- A model is a whole block of rules, saved as-is, left over once training finishes. It's closer to a saved state than a program.
- What's stored inside isn't the examples themselves — it's a huge number of numbers pulled out of the examples. The material it learned from isn't sitting in there directly.
- It takes a long time to make, but it's fast to use. Making it is training; using it is inference.
- Once training ends, the model sets into that state. It doesn't grow on its own — changing it means training it all over again.
- A model built with deep learning is one kind of machine learning model, and a machine learning model is one of several ingredients that go into building artificial intelligence.
Contents
1The analogy
Picture a knitting pattern printed on a single sheet of paper. It lists how many stitches to cast on and where to switch up the pattern. There's no yarn on that sheet, and no scarf — only instructions for how to knit.
Making the pattern takes a long time. It takes knitting it over and over, unraveling it, and knitting it again to work out which sequence produces a pattern that looks good. But once the pattern is finished, everything after that is fast. It can be copied and handed out to other people, and whoever receives it just has to follow it and knit.
The pattern's limits carry over too. A pattern with only a scarf pattern written on it can't knit a sweater. And the paper doesn't change on its own — adding a new pattern means knitting it out again to revise the sheet. A model is exactly that one sheet of paper.
2In detail
A model is grown, not written line by line
Ordinary software gets written by a person, one line at a time. Whoever wrote a given line knows exactly what it does. A model doesn't get made that way. A person decides only the broad skeleton — how many layers to stack, say — and training works out the numbers that fill it in.
Open up a model file and there's no rule inside that a person can read. Just an endless stream of numbers. Each one of those numbers is a parameter, and today's large models hold billions of them.
That's where it parts ways with the pattern. A knitting pattern is written so a person can read it, but a model's version of that pattern is written in numbers a person can't read. What it does is the same, though — what output comes out for a given input is baked into those numbers.
The time it takes to make and the time it takes to use are different
A model's life splits into two stretches. The first is training: material gets shown, and the numbers inside get nudged a little at a time. A large model can take months and a huge budget for this stretch alone.
The second is inference: the finished numbers stay put, and a new input gets passed through them to pull out an answer. This side takes anywhere from milliseconds to a few seconds per run. It's like how a pattern can take weeks to design, but knitting from that finished pattern is just an evening's work.
Almost everything that happens when we use an AI service is this second stretch. A question doesn't make the model learn all over again — it just passes through numbers that are already set.
The original material isn't sitting inside the model
It's easy to assume a model has the text and photos it trained on stored inside it whole. It doesn't work that way. A model built from hundreds of gigabytes of material often turns out far smaller than that. What's stored isn't the material — it's a trend pulled out of the material.
There's a rare case where a sentence that appeared over and over, or something unusually distinctive, comes back out almost word for word. Even so, the basic nature of what's stored is closer to a summary than a copy. It's the same as how the pattern isn't a photo album of scarves — it's a set of instructions for producing a pattern.
That's why asking a model to spit back the exact original document it trained on usually doesn't work. When the precise original text is needed, the usual approach is to keep the material separate, outside the model, and have it fetched on demand instead.
More than one copy is out there
Even with the same skeleton, what gets shown to it while training decides what model comes out. That's why models get managed with a name and a version, and several copies circulate at once. A version saved partway through training is called a checkpoint, and feeding a finished model a bit more material to shift its character is called fine-tuning.
Size splits into a range too. More parameters means a wider range of things it can handle, but it also gets heavier and slower. So the same family often ships a big version alongside a lightweight one. Whatever runs inside a phone is usually the lightweight version.
3More precisely
A model is a single function: a fixed structure filled in with parameter values set by training. It takes an input as a bundle of numbers, runs it through a fixed sequence of calculations, and produces an output as numbers. Saved to a file, it carries both structure information — which layers connect in which order — and the parameter values that fill that structure in.
The pattern analogy breaks down in a few places. A pattern can be read and understood by a person, but a model's contents are a number array a person can't easily interpret. A pattern can be edited one line at a time, but picking a single number in a model and tweaking it doesn't reshape it the way you'd want — retraining it is, in practice, the only real way to change it. And a pattern always produces the same result following the same steps, while a model that writes text is often set up to give a slightly different answer to the same question each time. One sheet of pattern makes only one kind of scarf; a single model, within the range of what it learned, keeps producing different answers for endlessly different inputs.
4Try it yourself
5Common misconceptions
It's easy to think a model keeps learning as it holds a conversation, but actually once training ends, a model sets into that state, and conversation content doesn't get stored inside it.
It's easy to think the training material is sitting inside the model as-is, but actually what's stored isn't the material — it's a numerical trend pulled out of it.
It's easy to think a model and a service are the same thing, but actually a model is a component, and the service we use is a finished product built by attaching search, safeguards, and a screen on top of that component.
7One-line summary
In shortA model is a saved block of rules left over from training — slow to make, but once it's made, it can be copied and used quickly, over and over.
Spotted an error or have a better analogy? Suggest an edit · Last updated2026-09-02