This chapter builds a machine-learning workspace that someone else can rerun, using uv, a lock file, git and a documented MNIST download. It also covers what a random seed can and cannot guarantee, and how uv 0.12 changes the project that uv init creates.

Episode page & show notes

Visit website

Why "it worked on my machine" happens

A notebook that runs on one laptop and fails on another usually has one of four ordinary causes: a different Python version, library versions that drift, hidden notebook state left in the kernel, or data fetched from somewhere nobody wrote down. From this point the course starts making claims about models, and each claim assumes someone else could rerun the work and get the same answer.

A workspace that another person can rebuild

Each cause gets its own fix. uv, from Astral, manages the Python version, an isolated environment and pinned dependencies. uv init creates the project and its pyproject file. uv add numpy matplotlib scikit-learn records the dependencies, builds the private .venv and writes uv.lock, which stores exact versions, hashes and sources. Jupyter tools are added as dev dependencies, and uv run jupyter lab opens a notebook inside the project environment. That setup follows uv's guide to using Jupyter. Git tracks everything that describes and rebuilds the project. A .gitignore keeps out the environment, data files, checkpoints, caches and any .env secrets.

First contact with MNIST

The data loads through one documented route, scikit-learn's fetch_openml, as mnist_784 version 1 (ID 554). The arrays come back as 70,000 × 784 images and 70,000 labels. The labels are text, not numbers. The standard split keeps the first 60,000 images for training and the last 10,000 for testing. The first image is displayed next to its label, a five, as a check that the two agree. The class counts are uneven: ones are the most common at just under 7,000, and fives the least at just over 5,400. A text cell in the notebook records where the data came from.

Proving it reruns

"Restart and run all" catches hidden state. The stronger test is a clean clone followed by uv sync. A fixed random seed makes a single run repeatable. It does not guarantee the same results across library versions or hardware, and it does not show whether a result is typical. The milestone is a written learning-problem statement for MNIST. Its baseline always predicts "1" and scores about 11% on the test set. A useful result must clearly beat that baseline on the held-out test images, and training accuracy does not count. A repository that describes a clean clone is not proof that one happened, so the exercise is to actually do it and compare the outputs line by line.

uv 0.12 changes the project uv init creates

Since 0.12.0, uv init sets up a packaged project with a src layout by default. Adding --no-package skips that structure. The release also refuses MD5 digests and strictly enforces required hashes. Later patch releases added a check command and support for downloading Python 3.15 release candidates. Python 3.15 is still a release candidate, and the stable line is 3.14 (see Python's release versions).

A walk through the four learning settings — supervised, unsupervised, reinforcement, self-supervised — organised around what feedback the world actually returns and when, with MNIST, tic-tac-toe and next-word prediction as the worked cases. Closes with the GLM-5.3 release read as an example of reward-driven training.

Episode page & show notes

Visit website

The one question behind four names

Supervised, unsupervised, reinforcement, self-supervised are not four families of algorithms. They are four answers to one question: what does the system get told, and when. Everything here follows from that.

Answers already written down

MNIST as the worked case: pixels paired with a digit a person chose. The correct answer sits beside every guess, which makes the feedback immediate — and paid for in human labour. Sixty thousand images means sixty thousand decisions, and the price climbs when the judgment is a chest X-ray two radiologists may read differently, an email that is angry or merely brisk, or a cyclist boxed frame by frame.

Throw the labels away

The same pile of pixels with nothing attached. What remains is structure: which images resemble each other, and how much of the seven hundred eighty-four dimensions is redundant. The awkward part gets stated plainly — with no answer key there is no clean test. Six customer groups or eight? Nothing in the data holds an opinion, so you judge by downstream usefulness or by whether someone who knows the domain recognises the groups.

A number that arrives at the end

Tic-tac-toe as Sutton and Barto set it up in Reinforcement Learning: An Introduction: pick a free square, receive nothing, and after three to five of your own moves one number arrives. It says how things went, not what you should have done — the credit assignment problem. Values propagate backward along the path actually walked, one step at a time. And because the learner only sees consequences of moves it chose, it must sometimes act against its own current judgment to find out.

Targets hidden in the data

Cover a word and ask for it. A five-hundred-word page becomes roughly five hundred examples, and nobody annotated anything. It uses supervised machinery on invented targets, and it usually is not the last step — pretraining is followed by fine-tuning on far fewer real labels.

What you have, not what sounds advanced

Loan repayment records, uncategorised support transcripts, and a home-screen recommender that can be read either way. The four settings are not a ranking.

GLM-5.3, read through its reward

Z.ai's GLM-5.3 release keeps GLM-5.2's 743-billion-parameter base with no further pretraining and scales the reinforcement learning: verified multi-step environments. Reported jumps on Terminal-Bench 3.0 and DeepSWE are evidence about those benchmarks and nothing else. The open weights were held back around two weeks after cyber capability scaled faster than expected.

This chapter traces artificial intelligence from Turing's 1950 test through the Dartmouth meeting, two funding collapses, expert systems, statistical learning, and the deep learning and transformer breakthroughs, then applies the same evidentiary habits to a newly released AI model.

Episode page & show notes

Visit website

A seventy-five-year argument about who supplies the rule

The line drawn last time — between problems where a rule can be written down and problems where only examples can reveal it — turns out to be the entire history of artificial intelligence. Alan Turing opened it in 1950 by replacing "can a machine think" with a checkable game of blind interrogation, laid out in his original paper in Mind. Six years later the Dartmouth proposal bet that any feature of intelligence could be described precisely enough for a machine to simulate it, and the first decade delivered real wins in search, games, and Frank Rosenblatt's perceptron — a machine that adjusted its own weights from wrong answers.

Then came the reckoning. Search exploded combinatorially on real problems, a single layer of weights proved unable to solve exclusive-or, and government reviews on both sides of the Atlantic — most bluntly the Lighthill Report — found promises with nothing measured behind them, and funding stopped. The next era hand-wrote expert knowledge instead, and it worked: XCON cut computer-configuration errors from over thirty percent to under two, saving Digital Equipment Corporation tens of millions a year, a story traced in the history of configuration technologies. It still collapsed under its own maintenance — half the rule base rewritten every year — because rules interact in ways nobody can see once the pile grows large enough.

What replaced hand-written knowledge was counting from data: speech and statistical machine translation learned their structure from text rather than grammar books. Layered networks returned in 2012 when AlexNet beat hand-designed image features by eleven points on ImageNet, and in 2017 attention mechanisms let every position in a sequence look directly at every other, becoming the transformer behind today's large models. The chapter closes on what scaling has actually proven versus only claimed, and on five ideas — weight adjustment, held-out evaluation, learned probabilities, learned features, and attention — that survived every collapse along the way.

Reading a release without the hype

A current example puts that habit to work: Google's Gemini 3.6 Flash cuts output tokens by roughly seventeen percent and resolves about half of real software issues on one benchmark, yet an independent vision evaluation found its object-localization accuracy got worse — one release, improving on one measure while sliding on another.

This chapter contrasts problems with hand-writable rules against problems like spam filtering and digit recognition where only examples work, sorts out five commonly confused terms in the field, and walks a vague "reduce churn" request into a fully specified, checkable prediction problem.

Episode page & show notes

Visit website

When rules fail and examples work

The chapter opens with two small programs that look equally simple but aren't. Withholding tax from a paycheck is a rule someone already wrote down — you code it in six lines and check it by hand. Spam filtering looks the same size but collapses: every fix (bad spelling, hidden HTML, image text, padding with harmless prose) is immediately worked around, and the rules start fighting each other until nobody can say what the filter does. Yet a person can still sort spam from real mail in seconds. That gap — recognizable but not describable, with plenty of examples on hand — is where learning from data belongs instead of hand-written logic, a distinction laid out clearly by pieces comparing rule-based and machine learning approaches to language tasks and when to choose one system over the other. Handwritten digit recognition tells the same story without any adversary involved: loops that don't close, sevens with and without a bar, forced the field toward systems like MNIST that learn the rule from labelled pixels instead of hand-coded shape logic.

From there the chapter separates five words people use loosely and interchangeably — artificial intelligence, machine learning, deep learning, statistics, and data science — giving each one a problem it actually owns, from shortest-path search to A/B test confidence intervals to the messy plumbing of real datasets. It rejects the idea that these sit on a ladder with deep learning at the top, pointing out that a hand-written rule, a plain average, or a significance test is frequently the correct and more honest answer.

Turning a wish into a stated problem

The back half works a single example end to end: a vague request to "reduce churn" gets turned into a fully specified prediction problem — one subscriber, one month, features known before the fact (with a live demonstration of leakage via a cancellation-reason field filled in only after someone leaves), a yes/no target, historical labels drawn straight from billing records, and a baseline ("always say no," 96% accurate and useless) that any real model has to beat. It closes by turning to MNIST itself — sixty thousand labelled digit images reduced to raw pixel brightness with no notion of a line or curve — as the plainest way to see what a model is actually handed before it learns anything.