teaching

Five open courses, all running in your browser.

Each course stands on its own and builds every idea by hand before handing it to a library. The notebooks open in Google Colab with one click, so there is nothing to install. The first two courses start from a first line of Python. The other three assume you can already program.

Want to write your own code alongside the notebooks? Open a blank Colab notebook.


From Python to Deep Learning and Fine-Tuning

A complete, self-contained course that takes you from a first line of Python to fine-tuning a modern Transformer model. The notebooks run directly in the browser via Google Colab: nothing to install.

Each concept is first explained in depth, then implemented by hand, and only then handed to a library. That order is deliberate: it is what turns these systems from black boxes into things you genuinely understand.


Module A: Python Foundations

# Notebook  
1 Hello World and Python Fundamentals: variables, types, input/output Open in Colab
2 Control Flow and Functions: decisions, loops, writing your own functions Open in Colab
3 Data Structures: lists, dictionaries, sets, and comprehensions Open in Colab
4 Modular Code and OOP: modules, classes, and inheritance Open in Colab

Module B: Scientific Python

# Notebook  
5 NumPy: arrays, vectorisation, and the linear algebra behind ML Open in Colab
6 Pandas: loading, cleaning, and exploring real data Open in Colab
7 Data Visualisation: turning numbers into insight Open in Colab

Module C: Machine Learning

# Notebook  
8 ML Concepts and Workflow: core ideas, overfitting, and evaluation metrics Open in Colab
9 Regression: first models and gradient descent by hand Open in Colab
10 Classification: logistic regression, decision trees, and evaluation Open in Colab
11 Beyond the Basics: scaling, cross-validation, ensembles, clustering, PCA Open in Colab

Module D: Deep Learning

# Notebook  
12 From ML to Neural Networks: build a network from scratch in NumPy Open in Colab
13 Backpropagation and Training: how networks learn; introduction to PyTorch Open in Colab
14 Convolutional Neural Networks: deep learning for images Open in Colab
15 Sequence Models and Attention: text, time series, and the road to Transformers Open in Colab

Module E: Transformers and Fine-Tuning

# Notebook  
16 The Transformer Architecture: self-attention explained in detail Open in Colab
17 Pretrained Models and Transfer Learning: standing on the shoulders of giants Open in Colab
18 Fine-Tuning a Model: adapt a state-of-the-art model to your own data Open in Colab

From Zero to Data Structures and Algorithms in Python

A complete, practice-first course that takes you from a first line of Python to building your own stacks, linked lists, hash tables and search trees. It assumes no programming experience. The notebooks run directly in the browser via Google Colab: nothing to install.

Each concept is first explained in plain words, then shown in small worked examples, and then practised: the 18 notebooks contain more than 140 exercises, each with a hidden solution. Every claim about speed is measured rather than asserted, with timing experiments you run yourself.


Module A: Python from Zero

# Notebook  
1 First Steps in Python: printing, variables, types, arithmetic, input Open in Colab
2 Making Decisions: if / elif / else, comparisons, logical operators Open in Colab
3 Loops: for, while, range, accumulators, nested loops Open in Colab
4 Functions: parameters, return values, defaults, scope Open in Colab
5 Lists, Strings and Dictionaries: the everyday containers Open in Colab
6 Writing Robust Programs: validating input, handling errors, solving problems step by step Open in Colab
7 Classes and Objects: bundling data and behaviour, inheritance Open in Colab

Module B: Mini Projects

# Notebook  
8 Games of Chance: the random module, Guess the Number, Rock–Paper–Scissors Open in Colab
9 A To-Do List Application: designing a program from functions, saving to a file Open in Colab
10 An ATM as a State Machine: organising a program around its states Open in Colab

Module C: Algorithms and Complexity

# Notebook  
11 Big O Notation: measuring how code scales, with real timing experiments Open in Colab
12 Recursion: functions that call themselves, the call stack, memoisation Open in Colab
13 Searching: linear search and binary search Open in Colab
14 Sorting: bubble, selection, insertion and merge sort, compared on the clock Open in Colab

Module D: Data Structures

# Notebook  
15 Stacks and Queues: last-in-first-out and first-in-first-out Open in Colab
16 Linked Lists: nodes and references, built by hand Open in Colab
17 Hash Tables: how dictionaries find things instantly Open in Colab
18 Trees and Binary Search Trees: hierarchical data and fast ordered lookup Open in Colab

From Words to Meaning: Natural Language Processing in Python

A complete course on how machines work with human language, from a single string of characters to systems that search, translate, summarise and answer questions. It assumes you can already program in Python. The notebooks run directly in the browser via Google Colab: nothing to install.

One question runs through all 18 notebooks: how do we turn text into numbers without losing what it means? Each idea is first explained in plain words, then built by hand in a few lines of Python, and only then handed to a library. Every method is measured against a simple baseline, and the result is reported even when the simple method wins.

The course does not repeat the foundations of machine learning and neural networks. Those are covered in From Python to Deep Learning and Fine-Tuning, and the notebooks here point to the exact notebook there whenever they rely on it.


Module A: Text as Data

# Notebook  
1 Text as Data: characters, Unicode, counting words, Zipf’s law Open in Colab
2 Regular Expressions: describing patterns in text, cleaning messy data Open in Colab
3 Tokenisation and Normalisation: tokens, stop words, stemming, lemmatisation Open in Colab

Module B: The Structure of Language

# Notebook  
4 Formal Languages and Automata: finite automata by hand, the Chomsky hierarchy Open in Colab
5 Grammars and Parsing: context-free grammars, parse trees, ambiguity, CKY Open in Colab
6 Part-of-Speech Tagging and Named Entities: a hidden Markov model and the Viterbi algorithm Open in Colab

Module C: Counting Words

# Notebook  
7 N-gram Language Models: predicting the next word, smoothing, perplexity Open in Colab
8 Bag of Words, TF-IDF and Search: documents as vectors, a small search engine Open in Colab
9 Text Classification with Naive Bayes: a classifier built from word counts Open in Colab

Module D: Meaning as Vectors

# Notebook  
10 Word Embeddings: co-occurrence, PPMI, Word2Vec by hand, analogies Open in Colab
11 Topic Modelling: discovering themes in an unlabelled collection Open in Colab

Module E: Neural Networks for Text

# Notebook  
12 LSTMs and Text Generation: gates, memory, a character-level language model Open in Colab
13 Sequence-to-Sequence Models and Translation: encoder, decoder, the BLEU score Open in Colab
14 Convolutions over Text: phrase detectors that learn Open in Colab

Module F: Language Models in Practice

# Notebook  
15 Subword Tokenisation and Decoding: byte-pair encoding by hand, temperature, top-p, beam search Open in Colab
16 Text from the Web: collecting text properly and responsibly Open in Colab
17 Summarisation: extractive and abstractive methods, the ROUGE score Open in Colab
18 Semantic Search and Retrieval-Augmented Generation: finding by meaning, answering from sources Open in Colab

From One Table to a Cluster: Working with Data at Scale

A complete course on what happens to data once there is a lot of it: SQL and indexes, data warehouses, columnar files, NoSQL, MapReduce, Spark, streaming and the cloud. It assumes you can already program in Python, and no knowledge of databases. The notebooks run directly in the browser via Google Colab: nothing to install.

One question runs through the first 12 notebooks: what changes when the data no longer fits? In one table, in the time a query has, in memory, on one machine, and finally in time itself. Each idea is first explained in plain words, then built by hand in a few lines of Python, and only then handed to a professional tool. Every claim about speed or size is measured, including the cases where the simple approach beats the heavy machinery. The six notebooks of the last module take one real data warehouse, Microsoft’s AdventureWorks sample, through every idea of the course.

The course does not repeat what the others cover. Working with tables in pandas and machine learning are in From Python to Deep Learning and Fine-Tuning. Big O, binary search, hash tables and trees are in From Zero to Data Structures and Algorithms in Python.


Module A: Data at Rest

# Notebook  
1 Tables and SQL: the relational model, keys, first queries, transactions Open in Colab
2 Joins and Aggregation: combining tables, grouping, window functions Open in Colab
3 Indexes and Query Plans: why some queries are instant and others crawl Open in Colab
4 Data Warehouses: facts, dimensions and the star schema Open in Colab

Module B: Beyond Tables

# Notebook  
5 Files and Formats: rows against columns, CSV against Parquet Open in Colab
6 NoSQL: documents, key-value stores, sharding, replication and the CAP theorem Open in Colab

Module C: Too Big for One Machine

# Notebook  
7 Larger than Memory: streaming through data that does not fit Open in Colab
8 MapReduce by Hand: divide, map, shuffle, reduce Open in Colab
9 Spark, RDDs and DataFrames: a cluster engine in your notebook Open in Colab
10 Spark SQL and Pipelines: and when a cluster is the wrong tool Open in Colab

Module D: Data in Motion and in the Cloud

# Notebook  
11 Streaming: windows, late data and answers that are never final Open in Colab
12 The Cloud and an End-to-End Pipeline: counting the cost, putting it all together Open in Colab

Module E: A Real Warehouse, End to End

# Notebook  
13 Meet a Real Warehouse: an inventory, the grain, missing values, keys and personal data Open in Colab
14 Building the Warehouse: enforced keys, views, indexes and summary tables Open in Colab
15 From Warehouse to Documents: the same sales as MongoDB documents, and what each shape costs Open in Colab
16 Exploring the Data with Spark: an exploratory data analysis that brings back only answers Open in Colab
17 Machine Learning with Spark MLlib: pipelines, honest evaluation, leakage and customer segments Open in Colab
18 Measuring Scale: pandas, SQLite and Spark on growing data, and when one machine is enough Open in Colab

From Random Moves to Winning Agents: Reinforcement Learning with Games

A complete course on agents that learn by trial and error. Nobody shows them the right answer: they act, receive a reward, and work out for themselves how to get more of it. Every idea is taught with a game, from a row of slot machines to Snake, a lunar lander, Flappy Bird and Connect Four, and in almost every notebook you watch a video of the agent you have just trained. The notebooks run in Google Colab without a GPU.

Each method is first explained in plain words, then written by hand in a few lines of Python, and only then taken from a library: Q-learning, deep Q-networks, policy gradients, PPO, tree search and self-play. Results in this field vary a great deal from one run to the next, so the course measures before it claims, and says so when an experiment shows no clear difference.

The course assumes you can program in Python. From Module C on the agents are neural networks in PyTorch, which are covered in From Python to Deep Learning and Fine-Tuning. Most cells finish in seconds. A few train an agent for some minutes, and the notebook says so beforehand.


Module A: Foundations

# Notebook  
1 Learning by Trial and Error: slot machines, estimating values, exploring and exploiting Open in Colab
2 Worlds, States and Rewards: environments, returns, policies, the Gymnasium library Open in Colab
3 Planning with the Bellman Equations: value functions, policy iteration, value iteration Open in Colab
4 Learning from Complete Episodes: Monte Carlo methods, Blackjack learned from wins and losses Open in Colab

Module B: Learning with a Table

# Notebook  
5 Learning Step by Step: SARSA and Q-learning, on-policy and off-policy Open in Colab
6 Building Snake: a game of our own as an environment, observations and rewards Open in Colab
7 A Snake That Learns: Q-learning on Snake, exploration, reward hacking, the limits of tables Open in Colab

Module C: Deep Value-Based Learning

# Notebook  
8 When the Table Is Too Big: a network as Q-function, and why it is unstable Open in Colab
9 Deep Q-Networks: experience replay, target networks, landing a spacecraft Open in Colab
10 Better Deep Q-Networks: Double DQN, dueling networks, prioritised replay, Flappy Bird Open in Colab
11 Learning from Pixels: convolutional agents, frame stacking, Atari, the Pokémon Red project Open in Colab

Module D: Policy-Based Learning

# Notebook  
12 Policy Gradients: policy networks, REINFORCE, baselines Open in Colab
13 Actor-Critic Methods: advantages, a critic, generalised advantage estimation, A2C Open in Colab
14 Proximal Policy Optimisation: the clipped objective, by hand and from a library Open in Colab
15 Continuous Actions: Gaussian policies, swinging up a pendulum, off-policy control with SAC Open in Colab

Module E: Beyond a Single Agent

# Notebook  
16 Planning and Tree Search: Dyna-Q, minimax, Monte Carlo tree search, the idea of AlphaZero Open in Colab
17 Opponents and Self-Play: self-play, games without a best move, a monster-battle tournament Open in Colab
18 Reinforcement Learning in Practice: seeds and confidence intervals, reward design, your own project Open in Colab