Curriculum
Every masterclass starts with Unit 1 and runs in order. The Foundation masterclass ends after Unit 8, the Advanced masterclass after Unit 12, and Advanced + Large Language Models takes all 16.
Foundations of AI
The AI Researcher's Toolkit
The vectors, probabilities, and derivatives that every later unit uses
About this unitEvery learning machine, from the perceptron of 1958 to a language model, holds its knowledge as numbers, measures how wrong it is, and changes the numbers to become less wrong. This unit teaches the mathematics behind those three ingredients: data as vectors and the dot product, probability and Bayes' rule, logarithms, the derivative and the gradient, and what it means for an algorithm to be fast, with a closing page on how numbers reach a computer.
- Vectors and the dot product
- Matrices
- Probability and Bayes' rule
- Logarithms
- Derivatives and gradients
- Algorithms and floating point
Search and Planning
How a program finds a route or a winning move by exploring a tree of possibilities
About this unitA route planner, a puzzle solver, and a chess computer all describe their task as states, actions, and a goal, and then explore a tree of possibilities. This unit shows how breadth-first, uniform cost, and A* search organize that exploration, why the work grows as b to the power d, how an admissible heuristic tames it, and how minimax with alpha-beta pruning chooses a move. It ends with the numbers that explain why chess fell to search in 1997 and Go resisted until 2016.
- States, actions, and goals
- Breadth-first and uniform cost search
- The branching factor
- Heuristics and A*
- Minimax and alpha-beta pruning
- Planning with STRIPS
Reasoning under Uncertainty
Bayesian networks, the naive Bayes spam filter, and the Markov property
Free sample unitRead the full unit online or as PDFA machine that acts in the world must decide with evidence that is sometimes wrong. This unit shows how a joint probability distribution answers every question and why it is far too large to store, how a Bayesian network shrinks it with conditional independence, and how inference by enumeration and Bayes' theorem turn an observed effect into the probability of its cause. The naive Bayes spam filter and a Markov chain of the weather are worked through with every number, and a hidden Markov model infers rain from umbrellas.
- Joint distributions and conditional independence
- Bayesian networks and inference by enumeration
- Bayes' theorem and the base rate
- The naive Bayes classifier
- Markov chains and hidden Markov models
Learning from Data
Linear regression, the loss function, gradient descent, and overfitting
About this unitEvery learning method needs a model with parameters, a loss that measures how wrong it is, and a procedure that lowers the loss. This unit builds all three on a straight line through six house prices, derives least squares, takes the first gradient descent steps on a real loss, and then shows with polynomials why a model that fits its training data perfectly can predict badly on new data, how cross-validation and a ridge penalty control that, and why the largest modern models escape the classical picture.
- Model, loss, and procedure
- Least squares
- Gradient descent
- Overfitting and cross-validation
- Bias and variance
- Ridge regression and double descent
Classifiers and Decision Trees
Logistic regression, nearest neighbours, decision trees, and how to judge a classifier
About this unitThree classifiers built by hand on real data: logistic regression with the cross-entropy loss derived from maximum likelihood, k-nearest neighbours, and decision trees grown with entropy and information gain, with random forests as the step beyond one tree. The unit ends with the measures that tell you how good a classifier really is, the confusion matrix, precision and recall, and the ROC curve, and with the debate about readable models in high-stakes decisions.
- Logistic regression
- Cross-entropy loss
- Nearest neighbours
- Decision trees and entropy
- Random forests
- Precision, recall, and ROC curves
Neural Networks and Backpropagation
The artificial neuron, the perceptron, hidden layers, and the backward pass
About this unitA single neuron can draw one straight line through its data, and the XOR function shows why that is not enough. This unit puts neurons in layers, computes XOR with three of them, and derives backpropagation, the algorithm that finds the gradient of every weight in one backward sweep, on a network small enough to train by hand. It ends with the softmax output for many categories, a two-layer network that reads handwritten digits with 98 per cent accuracy, and what the universal approximation theorem does and does not promise.
- The artificial neuron
- The perceptron
- XOR and the hidden layer
- Backpropagation
- Softmax and cross-entropy
- Universal approximation
Training Deep Networks
Stochastic gradient descent, learning rates, initialization, and the practice of training
About this unitUnit 6 gave the gradient; this unit gives the practice that turns it into a trained network. It explains why the gradient is estimated on a minibatch, how to read a learning rate off a loss curve, what momentum and Adam add and why Adam's learning rate is so small, how the gradient vanishes through twenty sigmoid layers and what the ReLU function, batch normalization, and residual connections did about it, how weight decay, dropout, early stopping, and augmentation keep a network honest, and what a training run costs in FLOP, GPU-hours, and dollars.
- Minibatches and epochs
- Learning rate and schedules
- Momentum and Adam
- Initialization and the vanishing gradient
- Residual connections
- Regularization and early stopping
- GPUs and the cost of training
The Big Questions of Artificial Intelligence
The Turing test, the two winters, the year 2012, the Chinese room, and the questions still open
About this unitThe closing unit of the Foundation asks what the methods of the first seven units add up to. It reads Turing's 1950 paper and scores his imitation game with real numbers, tells the history of the two traditions and the two winters as a story of money, hardware, and data, and shows why 2012 was different, with the AlexNet numbers and the compute that has grown by eight orders of magnitude since. It presents the Chinese room argument and its replies fairly, examines what AlphaFold and the antibiotic halicin did and did not do, states the four questions that divide the field today without a verdict, and ends with a map of the eight units and the one equation under them.
- The imitation game
- Two traditions and two winters
- The three ingredients of 2012
- The Chinese room
- AI as a tool of science
- The open questions
Deep Learning
Convolutional Networks and Computer Vision
Convolution, feature maps, LeNet to AlexNet, and transfer learning
About this unitA fully connected layer on a photograph would need 150 million weights and would have to learn every object once for every position. This unit replaces it with a small kernel that slides over the image, computes a convolution by hand, shows how the kernels are learned by backpropagation, and follows the design from LeNet-5 in 1998 to AlexNet in 2012 and the residual networks after it. It ends with transfer learning, which is how a few hundred medical images become a working classifier, and with adversarial examples, which show that the network does not see as we do.
- Convolution and kernels
- Padding and stride
- Feature maps and pooling
- LeNet-5 and AlexNet
- Transfer learning
- Adversarial examples
Embeddings and Sequence Models
Words as vectors, recurrent networks, the LSTM, and language modelling
About this unitA word is a symbol and a sentence has no fixed length, so neither fits the networks of the earlier units. This unit turns words into vectors that carry meaning, learned from nothing except which words appear near which, and builds the recurrent networks that read a sentence one word at a time. It shows by hand why such a network forgets after a few steps, how the gates of the LSTM fix that, how an encoder and a decoder translate, and what the perplexity of a language model measures.
- One-hot vectors and embeddings
- Skip-gram and negative sampling
- Recurrent networks
- Vanishing gradients in time
- The LSTM cell
- Sequence-to-sequence models
- Language models and perplexity
Attention and Transformers
Queries, keys, and values, self-attention, and the architecture of 2017
About this unitIn 2014 a decoder was first allowed to look back at every word of the sentence it was translating, with weights it had learned, and in 2017 eight researchers kept only this looking back and dropped the recurrence. This unit works one step of scaled dot-product attention by hand on three tokens, shows why the scores are divided by the square root of the key dimension, adds heads and positional encodings, and assembles the transformer block. It counts the 65 million parameters of the original model, explains why the architecture trains so fast and why its cost grows with the square of the text length, and ends with BERT, GPT, and the vision transformer as three uses of one block.
- Attention in 2014
- Queries, keys, and values
- Multi-head attention
- Positional encodings
- The transformer block
- BERT, GPT, and vision transformers
Reinforcement Learning
Rewards, value functions, Q-learning, and the method behind AlphaGo
About this unitA learner that is told only how well it did, and only later, needs its own mathematics. This unit builds it from the agent-environment loop and the Markov decision process to the Bellman equations, runs value iteration and Q-learning by hand on a 4 by 4 gridworld, and shows what the deep Q-network changed so that the same update could learn Atari games from pixels. It ends with policy gradients, Monte Carlo tree search, and the match of March 2016 in which a policy network, a value network, and a search beat Lee Sedol 4 to 1.
- Markov decision processes
- Bellman equations
- Value iteration
- Q-learning and exploration
- Deep Q-networks
- Policy gradients
- Monte Carlo tree search and AlphaGo
Large Language Models
Pretraining and Scaling Laws
Next-token prediction, tokenization, compute, and the laws that relate loss to scale
About this unitEvery assistant began as a model trained to predict the next token of a large part of the written internet. This unit works out what that model learns and which loss it minimizes, how byte pair encoding turns text into tokens and why some languages cost six times more of them, where the data come from and who filters them, and how many floating point operations and megawatt-hours a run like GPT-3 took. It then presents the scaling laws of 2020 and the Chinchilla result of 2022, with a worked compute-optimal model, and ends with few-shot prompting, the debate about emergent abilities, and what a benchmark score does and does not say.
- Next-token prediction and the pretraining loss
- Byte pair encoding
- Training data and compute
- Scaling laws and the Chinchilla rule
- Few-shot prompting and emergent abilities
- Benchmarks and open weights
Instruction Tuning and Learning from Human Feedback
From a text predictor to an assistant: demonstrations, preferences, and reward models
About this unitA pretrained language model continues text; it does not answer. This unit follows the second phase of training that turns it into an assistant: supervised fine-tuning on written demonstrations, the Bradley-Terry model that turns pairwise comparisons into a reward model, reinforcement learning against that reward with a KL penalty as the leash, and direct preference optimization, which reaches the same goal without a reward model. It ends with what goes wrong (reward hacking, sycophancy, verbosity), how assistants are ranked by human votes, and whose preferences the whole procedure encodes.
- Supervised fine-tuning
- Bradley-Terry reward models
- RLHF and the KL penalty
- Direct preference optimization
- Reward hacking and sycophancy
- Arena ratings
Reasoning, Tools, and Agents
Chains of thought, votes over samples, retrieved documents, tool calls, and models that act over many steps
About this unitAn assistant answers in one pass, with a fixed amount of computation per token and no way to look anything up or act. This unit loosens those constraints one at a time: writing the steps before the answer, sampling several chains and letting them vote, training on problems with checkable answers, retrieving documents into the prompt, calling tools, and running the model in a loop of thought, action, and observation, which is what the field now calls an agent. It closes with what agent benchmark scores mean, why several language models are not yet a multi-agent system, and the failure modes a reader who relies on these systems must know, prompt injection first among them.
- Chain-of-thought prompting
- Temperature and self-consistency
- Verifiable rewards
- Retrieval-augmented generation
- Tool use and the ReAct loop
- Agents and prompt injection
Interpretability and Alignment
Looking inside a trained network, and making models do what their users intend
About this unitA trained network is a list of numbers, and this closing unit asks what they mean and whether the system they define does what its users intend. It works through linear probes and the Othello experiment, in which a model trained only on move sequences turned out to hold the board in its activations and to play from it, then through superposition, sparse autoencoders, activation patching, induction heads, and how far circuits have been mapped. The second half defines alignment, separates outer from inner alignment with published cases of specification gaming and hidden behaviour, explains why jailbreaks work and why scalable oversight is open, and gives the policy record of 2023 to 2026 as fact, ending with the open problems of the field and how to read a research paper.
- Linear probes and the Othello experiment
- Superposition and sparse autoencoders
- Activation patching and circuits
- Outer and inner alignment
- Jailbreaks and scalable oversight
- The policy record since 2023