Foundations — Model versioning and registries
Start with a picture, not a symbol
Before any notation, picture what "training a model" physically produces.
You feed a recipe (left) into a training run (middle) and out comes a big bag of numbers (right). Those numbers are the model. The whole topic exists because that bag of numbers is (a) huge, (b) hard to reproduce, and (c) easy to lose track of.
Everything below is one ingredient of that recipe or one label we attach to the bag.
The symbols, in build order
1. Weights (the bag of numbers)
Picture: the yellow bag on the right of Figure s01. Why the topic needs it: these numbers are the actual thing we serve and must protect. They are large (often 200 MB+) and binary, which is exactly why ordinary tools for versioning text (Git) struggle — that struggle is the reason registries exist.
2. Hyperparameters (the dials)
Picture: the knobs on the training box in Figure s01. Why: two identical datasets trained with different dials give different weights. So to rebuild a model, we must record the dial positions. In the parent's 4-tuple this appears as .
3. The random seed (pinning the dice)
Training uses randomness: it shuffles data, initialises weights randomly, and (on GPUs) even adds tiny timing noise. Randomness means same recipe, different result — a disaster for reproducibility.
Picture: see Figure s02 below.
More on this lives in Reproducibility and random seeds.
4. A hash (turning bytes into a fingerprint)
Now the key symbol. Parent writes . Let us earn every piece.
- = the bytes of a file. A file is ultimately a long string of 0s and 1s; just names that string.
- = a hash function: a machine that eats any amount of data and spits out a short, fixed-length fingerprint (for SHA-256, always 256 bits ≈ a 64-character code).
Why a hash and not just a filename? A filename is a promise a human makes ("this is the good one") — promises get broken and reused. A hash is computed from the content itself, so it cannot lie: change one weight, the fingerprint changes. That is why the parent calls it content-addressable — the address is the content's fingerprint.
5. Immutable vs mutable (frozen vs a sticky note)
Two words the parent uses constantly.
Picture: Figure s04 below — frozen ice cubes (versions) that never change, and a movable arrow (the sticky note) pointing at whichever one is live.
Why the topic needs this split: rollback becomes a pointer flip. You don't rebuild or move a 200 MB artifact; you slide the sticky note back to the old, still-frozen version. That is the entire secret behind "rollback in seconds."
6. A registry (the labelled freezer)
Picture: the whole freezer in Figure s04 — the name on the door, the frozen cubes inside, one glowing "Production".
7. Lineage and the DAG (the recipe's ancestry)
Why acyclic matters: to reproduce a model you walk the arrows backward until you hit pinned, unchangeable inputs. If there were a loop, that walk would never end. No loops ⇒ the ancestry always terminates ⇒ reproduction always halts.
8. The reproducibility 4-tuple (all four, together)
How the foundations feed the topic
Read top to bottom: ingredients form the tuple → the tuple guarantees a rebuild; the weights become bytes → hashed into an immutable ID; immutable versions plus a mutable pointer plus lineage make up the registry the parent topic is all about.
Equipment checklist
Cover the right side and answer each before you continue.
- Weights are ::: the millions of learned decimal numbers that are the model.
- Hyperparameters are ::: the settings/dials you choose before training (learning rate, depth, ...).
- A random seed does ::: pins the random-number sequence so training is repeatable — same seed, same weights.
- A hash function turns ::: any bytes into a short fixed-length fingerprint; same input → same code, any change → different code.
- means ::: an artifact's identity is the hash of its own bytes — content-addressable, cannot lie about its contents.
- Immutable means ::: can never change after creation (the frozen version).
- A mutable stage/alias is ::: a movable sticky note (
Production,champion) pointing at one immutable version. - A registry maps ::: a name → an ordered list of immutable versions, each with metrics/metadata and one movable stage.
- A DAG is ::: dots joined by one-way arrows with no loops — so walking ancestry backward always terminates.
- The reproducibility 4-tuple is ::: .
Once every answer feels obvious, you are ready for the parent note Model versioning and registries and its neighbours Model serving and deployment patterns and Model monitoring and drift detection.