Key points
- 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 whole, though a sentence it saw many times can sometimes be remembered almost word for word.
- 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 usually means training it 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.
The 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.
In 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. In a neural network model, a person decides the skeleton — how many layers to stack, say — plus what to show it and how to train it, while training works out each of the numbers that fill it in.
Open up one of the neural network models widely used today and there's no rule inside that a person can read. Just an endless stream of numbers. Each of those numbers is a parameter. Today's large language models hold hundreds of billions, in some cases trillions, and lightweight versions hold hundreds of millions to a few billion. Simple models such as decision trees, whose rules can be read as they are, exist too.
That's where it parts ways with the pattern. A knitting pattern is written so a person can read it, but a neural network model's version of that pattern is written in numbers that are hard for a person to 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. Per run, this side can take as little as milliseconds, and a model that thinks for a long time before answering can take a few minutes, but that's still very short next to months of training. 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. For the most part 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 is, for the most part, not the material but 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 with the numbers saved partway through or at the end of training is called a checkpoint (published finished model files are often called that too), 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.
More 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. Saving a model takes both structure information — which layers connect in which order — and the parameter values that fill that structure in. Depending on the format, they may sit in one file, or the values may be in one file with the structure settings kept separately.
The pattern analogy breaks down in a few places. A pattern can be read and understood by a person, but the contents of a neural network model, as widely used today, 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 — usually the way to change it is to train it further. Editing some of the numbers directly to change one specific fact is being researched, but it's still of narrow use. 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.
Try it yourself
Common 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, so the numbers inside it don't change during a conversation. A service may still keep chat logs separately or, depending on its settings, use them to train a later model.
It's easy to think the training material is sitting inside the model as-is, but actually what's stored is mostly a numerical trend pulled out of the material. A model can still remember parts of material it saw many times almost word for word, and how to view that is still debated in research and courts.
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.
One-line summary
A 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 updated 2026-10-18