Models
A model is the artifact that training produces: a file full of learned weights that transforms inputs into predictions. Everything an AI system "knows" lives inside that file.
Learning Objectives
- Define what a model actually is (a file of learned numbers).
- Explain the relationship: data + training → model → predictions.
- Read a model card: size, capabilities, limitations.
- Distinguish model families and what each is for.
- Understand model versioning and why "the model changed" matters.
Why This Matters
"Model" is the most-used word in AI, and the fuzziest. Cutting through: a model is a file. You can copy it, version it, ship it, delete it. GPT-4 is a file (a very large one) sitting on servers. Grasping this concreteness clarifies the industry: model releases, model sizes, open-weights debates (AI-066), and why swapping models can silently change your product's behavior.
Everyday Analogy
A model is like a trained employee's brain at the end of an apprenticeship. The apprenticeship (training) took years and cost a fortune; the resulting expertise is now portable: the employee can walk into any office and apply it in seconds. You cannot open the brain to read the expertise, but you can test it: give tasks, observe quality. Models are the same: expensive to create, cheap to use, evaluated by behavior rather than inspection.
What's Actually In a Model?
Concretely, a model file contains:
- The architecture recipe: how many layers, what shape (the skeleton from AI-004).
- The weights: billions of learned numbers filling that skeleton (the knowledge from AI-005).
That's essentially it. A 7-billion-parameter model at 2 bytes per weight is a ~14 GB file. Download it, and you hold everything it learned: no database, no internet connection, no rules. This is why "open-weights" releases (AI-066) matter so much: sharing the file shares the capability.
The Pipeline in One Line
DATA → TRAINING → MODEL → PREDICTIONS
(AI-006) (AI-005) (this) (AI-008)
The model is the frozen middle: training writes it once; inference reads it forever. It does not learn from your conversations, does not update itself overnight, and does not remember yesterday (a source of endless confusion; see AI-061 on context).
Model Families: A Field Guide
| Family | Input → Output | Everyday example |
|---|---|---|
| Classifiers | Item → category | Spam filter, defect detection |
| Regressors | Item → number | House price, delivery ETA |
| Vision models | Image → labels/boxes/masks | Face unlock, medical imaging |
| Speech models | Audio ↔ text | Voice assistants, subtitles |
| Embedding models | Content → meaning-vector | Search, recommendations (AI-014) |
| Language models (LLMs) | Text → next-token predictions | ChatGPT, Claude (AI-009) |
| Generative image/video | Text prompt → media | Midjourney, Sora |
Most real products chain several: a voice assistant runs speech-to-text → LLM → text-to-speech, three models in a pipeline (AI-021 covers architecture).
Reading a Model Card
Model releases ship with a "model card": the spec sheet. The fields that matter:
- Parameters (7B, 70B, 671B): capacity, and a proxy for memory/cost. Watch for total vs active on MoE models (AI-064).
- Context window (8K–1M tokens): working memory size (AI-061).
- Training cutoff: the date the model's knowledge ends.
- Modalities: text-only, or also images/audio (AI-052).
- License: what you may build with it (AI-066).
- Evals: benchmark scores: useful, gameable, never the whole story (AI-025).
Take a real card: "Llama 3.1 8B, 128K context, cutoff Dec 2023, open weights." You can now parse every clause.
Versions: Same Name, Different Behavior
Models are versioned like software (GPT-4 → GPT-4o, Claude 3 → 3.5 → 4), and behavior changes between versions, sometimes dramatically. A prompt tuned for one version may degrade on the next. This is why production teams pin exact model versions, run regression evals before upgrading (AI-022, AI-026), and treat "the provider silently updated the model" as a real operational risk (AI-057 covers prompt/version management).
Real-World Showcase
- Hugging Face hosts over a million downloadable models: a public library of frozen expertise, searchable by task.
- Apple ships dozens of models inside every iPhone: keyboard prediction, photo curation, handwriting, heart-rhythm analysis, all quietly running as files on your device.
- The DeepSeek-R1 release (2025): one uploaded model file measurably moved stock markets, the clearest demonstration that the file is the asset.
Try It Yourself
- Browse huggingface.co/models. Filter by task ("image-classification"), open any model, and read its card. Identify: parameters, license, intended use. You are now reading the industry's core document format.
- Spot the pipeline: dictate a message to your phone assistant and count the models involved (speech→text, language understanding, text→speech: at least three files cooperating).
- Ask the same question to two versions of one chatbot family (e.g., a "mini" and a flagship). The behavioral difference you notice is parameters and training: the file's contents, nothing else.
Common Mistakes
- Thinking the model contains its training data: it actually contains only patterns distilled from it (AI-004).
- Assuming models keep learning after deployment. They are frozen until someone retrains or fine-tunes (AI-051).
- Ignoring version pinning, even though silent model updates have broken countless production prompts.
- Reading benchmark scores as guarantees. Evals are narrow; your use case needs its own testing (AI-025, AI-026).
- Confusing the model with the product: ChatGPT is a product wrapping a model with chat UI, memory, tools, and safety layers.
Key Takeaways
- A model is a file: architecture + learned weights. Copying the file copies the capability.
- Frozen after training: it does not learn from use or update itself.
- Families map to tasks: classifiers, regressors, vision, speech, embeddings, LLMs, generative.
- Model cards are spec sheets: parameters, context, cutoff, license, evals.
- Versions change behavior, so pin them and re-evaluate before upgrading.
Glossary
- Model
- A file containing an architecture recipe plus billions of learned weights. Copy the file and you copy the capability. A 7B-parameter model at 2 bytes per weight is a ~14 GB file holding everything it learned, no database or internet required.
- Model Card
- The spec sheet shipped with a model release: parameters, context window, training cutoff, modalities, license, and benchmark evals. Learning to parse "Llama 3.1 8B, 128K context, cutoff Dec 2023, open weights" is the practical skill this lesson teaches.
- Parameters
- The count of learned numbers in the model (7B, 70B, 671B), a proxy for capacity, memory footprint, and cost. On mixture-of-experts models, watch for total versus active parameters. (see AI-064)
- Context Window
- The model's working-memory size, from 8K to 1M tokens, meaning how much text it can consider at once. It is a model-card field, not a learning mechanism. (see AI-061)
- Training Cutoff
- The date at which the model's knowledge of the world ends, because the weights are frozen after training. Anything that happened later is simply not in the file.
- Model Version
- A specific release of a model (GPT-4 → GPT-4o, Claude 3 → 3.5 → 4) whose behavior can differ dramatically from its siblings. Production teams pin exact versions and run regression evals before upgrading. (see AI-026)
- Classifier
- A model family mapping an item to a category, such as spam filters or defect detection. One of several families (regressors, vision, speech, embeddings, LLMs, generative) that real products often chain into pipelines. (see AI-021)
- Open Weights
- Releasing the model file itself so anyone can download and run it. Sharing the file shares the capability. The DeepSeek-R1 release showed a single uploaded file can move markets. (see AI-066)
References
Diagram
Knowledge Check
8 questions