MLOps Foundations: Versioning and Reproducibility (ML-101)
A model that scored 0.91 in your notebook scores 0.87 when a teammate retrains it, and neither of you can say why. A model is live in production and finance asks which data it was trained on — the code is in Git, but the 8 GB training file and the trained weights are on a laptop that was reimaged last month. A week of hyperparameter tuning lives in a spreadsheet nobody trusts. None of these are modeling problems. They are discipline problems, and this course teaches the discipline that prevents them.
ML-101 is the Foundation course for the School of MLOps. It assumes you can already train a simple model and focuses entirely on making that work reproducible, versioned, and traceable — the habits that turn a clever notebook into an ML system a team can operate. You will pin randomness and environments so a run repeats exactly, fingerprint code, data, and models so you always know which version produced which result, and track experiments so the winning run is never a mystery.
- Define reproducibility precisely: same code, same data, same config yields the same model - Eliminate the common sources of nondeterminism with seeds and pinned environments - Version the three ML artifacts — code, data, and models — and explain why Git alone is not enough - Fingerprint a dataset or model with a content hash and detect any change to it - Record experiment runs as params, metrics, and artifacts, then compare runs to pick a winner - Assemble these habits into a small, runnable reproducible-experiment logger
Who this course is for
ML-101 is the discipline course that gates every Practitioner course in the school. It is written for:
- The data scientist going to production who trains good models in notebooks and now has to hand them to a team that will retrain, serve, and monitor them.
- The software engineer moving into ML who knows Git and Docker and needs the ML-specific twist: data and models are artifacts too, and randomness is a first-class hazard.
- The analyst or data engineer leveling up who wants the reproducibility and versioning foundation before taking on CI/CD, serving, and monitoring in the 200-level courses.
Prerequisites
You should be comfortable with intermediate Python (functions, modules, the standard library), fluent enough with Git to branch and commit, familiar with Docker basics (build, run, compose), and able to read basic SQL. The DE-1xx coursework satisfies this, or equivalent experience does. You do not need a paid cloud account or a GPU: every example and the lab in this first slice run on Python 3.10 or newer using only the standard library, in keeping with the platform's $0 posture.
Modules
ML-101 is roughly fourteen hours of effort across six modules. This first slice delivers three core lessons and your first hands-on lab, covering reproducibility, versioning, and experiment tracking — the spine the rest of the course builds on.
| # | Module | What you leave with |
|---|---|---|
| 1 | Why ML systems rot | The ML lifecycle and what "reproducible" means |
| 2 | Environment reproducibility | Lockfiles, containers, seeds, and determinism |
| 3 | Data versioning | Content-addressed storage and immutable raw data |
| 4 | Experiment tracking | Runs, params, metrics, and artifacts |
| 5 | Model versioning and registries | Models as artifact plus metadata plus lineage |
| 6 | Project structure and handoff | The "new teammate reproduces you in 30 min" test |
The three lessons and the lab below cover the core of Modules 2, 3, and 4 and give you the reproducibility skill the rest of the course extends.
Outcomes
By the end of ML-101 you can:
- Take a messy ML project and make it reproducible: pinned environment, seeded randomness, versioned data and models, tracked experiments.
- Explain why "works on my machine" fails and remove the causes one by one.
- Fingerprint any artifact with a content hash and prove whether two things are byte-for-byte identical.
- Record and compare experiment runs so the winner is reproducible, not remembered.
- Tell a lineage story — this model came from that data and that commit — that survives a laptop being wiped.
Where this leads
Everything in this school converges on ML-390: Deploy and Operate a Model with Full Observability, the capstone where you ship a model and run it in production with monitoring and drift detection. The reproducibility and versioning habits from ML-101 are the foundation that CI/CD (ML-201), serving (ML-202), and monitoring (ML-203) all assume. The experiment logger you build in this course's lab is a hand-rolled version of the tracking servers those courses adopt — you will understand what those tools do because you built a tiny one first.
Do the lessons in order. Each one feeds the lab: the lab seeds its run like Lesson 1, hashes its dataset like Lesson 2, and appends run records like the tracking log in Lesson 3.