Model Architecture
The blueprint that says how a model's layers stack and connect
- Model architecture is the blueprint that spells out how many layers to stack, what goes in each one, and how they connect.
- A person draws the blueprint, but the numbers that fill it in are set by training. The two are different things entirely.
- Two models built from the same blueprint can do completely different jobs depending on what they learned.
- Which architecture fits well depends on the shape of the data. Images and sentences call for different designs.
- Change the architecture and what was learned usually can't carry over — you generally have to start training over from scratch.
Contents
1The analogy
Unroll the blueprint for an apartment building and certain things are always written on it: how many floors to build, how each floor's rooms are laid out, and which floors the stairwell and elevator connect. That drawing is the model architecture.
Two buildings put up from the identical blueprint can turn out completely different once the furniture and belongings inside them differ. Models work the same way. Same blueprint, but fill it in with different numbers from training, and you get a model that translates in one case and a model that summarizes in another.
Furniture can be swapped out any time, but moving a wall means rebuilding the place from the ground up. Changing the architecture of a model is exactly that kind of change — far more disruptive than it first looks.
2In detail
Three things a blueprint spells out
The first is the number of layers — a shallow handful, or dozens or hundreds stacked deep. Deeper stacks can hold more complicated rules, but training gets trickier as they grow.
The second is what goes inside each layer. There are parts with different jobs: one that scans small patches of an image, one that lets pieces of a sentence look at each other, one that refines a value before passing it along. The third is how they connect — straight up one after another, with shortcuts that skip several layers, or split off sideways into two branches.
The blueprint and the furniture are different things
The two things people mix up most when talking about models are architecture and weights. Architecture is the empty skeleton; weights are the numbers training fills it with. A skeleton alone can't produce any answer, and weights alone don't tell you where they belong.
When you download a model published online, what's usually inside the file is mostly the weights. The architecture is written separately, in the code or configuration that defines the model. The two have to match exactly for the model to come alive — like furniture arriving on a truck with no blueprint, you'd need that drawing to know which room each piece belongs in.
The shape of the data decides the architecture
In an image, neighboring dots tend to be closely related, so an architecture that slides a small square window across works well. Sentences are different — the first word and the last word can connect directly, so an architecture where far-apart pieces can look straight at each other suits them better.
Sound cares about the order things happen in, and numbers arranged in a table often get by with something quite simple. Choosing an architecture is really telling the model, ahead of time, what kind of data it's dealing with. Pick one that fits well, and the same data produces good results with far less training.
What a designer has to weigh
Deep versus wide is the first fork in the road. Going deep means passing through many steps to capture complicated rules; going wide means handling more information at once within a single layer. At the same overall size, which is better depends entirely on the problem.
Performance isn't the only concern. How fast an answer needs to come back, whether it fits in graphics memory, how expensive training will be — all of that comes bundled in. A model meant to run on a phone starts from a different blueprint than one meant to run in a data center.
That an architecture change wipes out what was learned is also a real burden. The moment a wall moves, the furniture already placed no longer fits. That's why it's common to reuse a proven blueprint and just scale it up or down, rather than draw a new one. Bringing out a brand-new architecture needs a clear enough advantage to justify it.
3More precisely
Architecture is the skeleton that fixes the path a computation takes. It defines things like the number of layers, the width of numbers each layer handles, and how many branches to split into — values training never touches, which is why they're classified as something a person has to set in advance.
Most large language models today use fairly similar architectures. So performance differences often come more from a model's size and the amount and quality of its training data than from novelty in the architecture. That doesn't mean architecture stops mattering — it means that, once a design settles into place, other factors tend to weigh more.
The analogy breaks down in one place. A building's blueprint is fixed the moment construction finishes, but a model's isn't. Only part of the layers might get cut out and reused, a small part might get grafted onto an existing architecture to teach it something new, or connections that turn out to matter little might get trimmed away later to make it lighter.
A blueprint also can't be tested cheaply before the building goes up, while a candidate architecture usually gets tried at a small scale first — trained briefly, checked for obvious problems, and only then scaled up to its full size for the real run.
4Try it yourself
- Netron (model structure viewer) ailearn.space Upload a model file and it lays out the order the layers connect in as a diagram
- LLM Visualization (3D language model walkthrough) ailearn.space Spin the path numbers take between layers around in 3D and follow it yourself
- TensorSpace Visualization ailearn.space Compare how the layer setup changes when the same problem is solved with a different architecture
5Common misconceptions
It's easy to think a good architecture alone guarantees good performance, but actually once an architecture has settled into place, the amount and quality of data and the model's size often decide the outcome more.
It's easy to think a single model file contains the architecture too, but actually it often holds only the numbers, with the architecture managed separately in code or configuration.
It's easy to think adding more layers always makes a model smarter, but actually if the training signal can't reach the earliest layers, performance can drop instead.
7One-line summary
In shortModel architecture is the blueprint for how layers stack and connect, and the numbers that fill it in are decided by training.
Spotted an error or have a better analogy? Suggest an edit · Last updated2026-09-02