The curriculum
Written for people who already hold a data-science or AI degree and want their technical knowledge sharp: every lesson carries the full derivation, an interactive figure wherever one explains more than prose, and — where the playground covers it — a lab that runs the real thing on your own machine. All 94 lessons are live.
T0
Start Here
One short story before the mathematics: where this field came from, why it took over the world, and what it is doing out there right now.
Orientation
Read this first — it is why everything after it exists.
T1
Mathematical Foundations
The mathematics every model in this curriculum stands on — taught as the working knowledge of a practitioner, not a lecture course.
Origins
One story before the symbols: where this mathematics actually came from, and why it looks the way it does.
Optimization
Almost every learning algorithm is an optimizer in disguise. This module builds gradient descent from first principles up to AdamW and the geometry of non-convex landscapes.
1 Calculus and Taylor approximationThe derivative as the best local lie, Taylor series as controlled lying to higher order — watched converging and diverging live — and why every 'expand to first order' in this curriculum is this lesson working. live 2 Convexity and the geometry of loss surfacesConvex sets and functions, first- and second-order conditions, why convexity buys global guarantees — and where ML gives them up. live 3 Gradient descentThe algorithm, its exact behaviour on quadratics, the condition number, and how the learning rate divides convergence from divergence. live 4 Stochastic gradient descentMinibatch gradients as noisy estimators: variance, the noise ball, learning-rate schedules, and why noise is sometimes a feature. live 5 Momentum and adaptive methodsHeavy ball, Nesterov, RMSProp and Adam/AdamW — derived, compared, and raced on the surfaces that break plain gradient descent. live 6 Non-convex landscapesSaddle points, plateaus, ravines; why local minima are less scary in high dimensions, and what loss-landscape research actually shows. live 7 Optimization: self-checkTen questions across the module, graded in your browser — 8+ says you own it. Every miss shows the answer and the lesson logic behind it. live
Linear Algebra for ML
Vectors to SVD, the eigendecompositions behind PCA, and the matrix calculus used everywhere in deep learning.
1 Vectors and linear mapsVectors as data, inner products as similarity, and matrices as transformations you can watch act on the plane — with the determinant as area. live 2 Eigenvectors and eigenvaluesThe directions a map only stretches: eigendecomposition, power iteration (the algorithm inside PageRank), and the spectral theorem that runs this whole curriculum. live 3 The singular value decompositionEvery matrix is rotate → stretch → rotate. Eckart–Young optimal low-rank approximation, compressed live — the theorem under PCA and LoRA alike. live 4 Projections and orthogonalityOrthogonal projection as the geometry of least squares and PCA — find the best line by hand, then snap to the eigenvector that beats you. live 5 Matrix calculusGradients, Jacobians and Hessians without index agony: the few identities that generate deep learning’s derivatives, and the quadratic-form geometry behind them. live 6 Linear algebra: self-checkTen questions across the module, graded in your browser — 8+ says you own it. Every miss shows the answer and the lesson logic behind it. live
Probability & Statistical Inference
Random variables to MLE and Bayesian reasoning — the inferential backbone of every model that follows.
1 Random variables and distributionsThe working vocabulary: expectation and variance as operators, the distribution zoo with its parameters live, and conditioning — the most important operation in ML. live 2 The law of large numbers and the CLTWhy averages concentrate, why the Gaussian is everywhere, and the 1/√n error law that prices every Monte Carlo estimate, SGD batch and test-set metric. live 3 Maximum likelihoodOne principle that generates the curriculum’s losses: least squares as Gaussian MLE, cross-entropy as Bernoulli MLE — with the likelihood surface under your cursor. live 4 Bayesian inferencePriors, posteriors and conjugacy — watch a Beta prior digest evidence — plus the exact sense in which ridge regression is a Gaussian prior. live 5 Estimators, uncertainty and the bootstrapSampling distributions, standard errors and confidence intervals — including the bootstrap, resampling its way to an error bar with no formula at all. live 6 Hypothesis testingp-values as they actually are, power, the multiple-comparisons trap — the most-used industry statistical skill, taught with its failure modes attached. live 7 A/B testing and experimentationSample-size arithmetic, sequential testing and the peeking problem, guardrail metrics — the experiment platform every product team runs, from first principles. live 8 Causal inferenceDAGs and confounding — watch adjustment recover a truth you control — difference-in-differences, instrumental variables, and the collider trap that makes 'control for everything' actively harmful. live 9 Probability: self-checkTwelve questions across the module, graded in your browser — 10+ says you own it. Every miss shows the answer and the lesson logic behind it. live
Information Theory
Shannon's 1948 gift: surprise, entropy and divergence as measurable quantities — the concepts every loss function in this curriculum has been quietly built on.
1 Entropy and informationSurprise quantified, entropy as the price of describing a source, optimal codes matching −log p — with a distribution under your fingers and its bit-cost live — and cross-entropy as the cost of coding with the wrong beliefs. live 2 KL divergence and mutual informationThe gap between believed and true, its famous asymmetry felt by fitting one Gaussian to two humps both ways, mutual information — and the reveal that half this curriculum's objectives were KL all along. live 3 Information theory: self-checkEight questions across the module, graded in your browser — 6+ says you own it. Every miss shows the answer and the lesson logic behind it. live
T2
Practitioner's Toolkit
Not "learn Python" — the professional workbench: reproducible environments, GPUs that actually work, and code fast enough to experiment with.
The Working Environment
Environments with uv/conda done right, CUDA and drivers, vectorized NumPy, profiling, and reproducibility discipline.
1 Python environments without tearsWhy environments break, how the resolver actually works, uv/venv/conda compared honestly, lockfiles, and the editable-install trap that costs everyone an afternoon. live 2 GPUs, CUDA and memory arithmeticThe driver/toolkit/torch triangle, why torch.cuda.is_available() lies to you, mixed precision — and the VRAM arithmetic that predicts your OOM before it happens, on a calculator. live 3 Vectorization and profilingWhy NumPy is 100× your loop: memory layout, broadcasting rules, cache lines — and profiling discipline, because the bottleneck is never where you think. live 4 Reproducibility and experiment disciplineSeeds and the determinism they don't buy, config-as-code, experiment tracking that survives a month, and the run-naming discipline of people who find their results again. live 5 Toolkit: self-checkTen questions across the module, graded in your browser — 8+ says you own it. Every miss shows the answer and the lesson logic behind it. live
T3
Machine Learning
Supervised and unsupervised learning at full mathematical depth: from the geometry of regularization to the EM algorithm, with honest treatment of evaluation.
Supervised Learning
Linear models to gradient boosting, each with its objective, its optimizer, and its failure modes — every estimator fitted live in the page.
1 Linear regressionLeast squares from three angles — optimization, geometry (projection), statistics (Gauss–Markov) — and when to solve vs iterate. live 2 Regularization and the bias–variance trade-offRidge as spectral shrinkage (via the SVD), lasso's corners and sparsity, and the bias–variance decomposition — derived, then measured live. live 3 Logistic regression and calibrationBernoulli MLE to cross-entropy, the geometry of the decision boundary, why the threshold is not part of the model, and what calibrated probabilities mean. live 4 SVMs and the kernel trickMaximum margin, the hinge as a convex surrogate, soft margins, and the kernel trick — with γ as a bias–variance dial you can turn. live 5 Decision trees and random forestsCART's greedy axis-aligned splits, why single trees overfit, and how bagging plus feature decorrelation turns them into forests. live 6 Gradient boostingGradient descent in function space: residual fitting, shrinkage vs rounds, and the second-order objective XGBoost actually optimizes. live 7 Evaluation and cross-validationGeneralization measured honestly: k-fold done right, leakage traps, ROC vs precision–recall under imbalance, and reporting with error bars. live 8 Supervised learning: self-checkTen questions across the module, graded in your browser — 8+ says you own it. Every miss shows the answer and the lesson logic behind it. live
Unsupervised Learning
Clustering, density estimation and dimensionality reduction — including what t-SNE and UMAP plots do and do not mean.
1 k-meansThe within-cluster objective, Lloyd's algorithm as alternating minimization, k-means++ and why initialization is half the algorithm — stepped through live, iteration by iteration. live 2 Gaussian mixtures and EMSoft clustering as maximum likelihood on a latent-variable model: responsibilities, the EM derivation via Jensen, the k-means limit — with the ellipses fitting themselves before your eyes. live 3 DBSCAN and density-based clusteringClusters as dense regions, not centroids: core/border/noise, the ε–minPts dials, where centroid methods fail and density wins — and where density fails too. live 4 t-SNE, UMAP and reading embedding plotsWhat the KL objective actually preserves, perplexity as a neighborhood size, and the honest guide to what cluster sizes and distances in these plots do NOT mean — with t-SNE running live. live 5 Anomaly detectionMahalanobis distance, reconstruction error and isolation — three definitions of 'weird', when they disagree, and the threshold arithmetic of alarms you can afford. live 6 Recommender systemsCollaborative filtering as matrix factorization — the SVD lesson's machinery earning billions, with ALS running live — implicit feedback, ranking losses, and the feedback loops that make recommenders eat their own tail. live 7 Unsupervised learning: self-checkTen questions across the module, graded in your browser — 8+ says you own it. Every miss shows the answer and the lesson logic behind it. live
T4
Forecasting
Time series as its own discipline: classical state-space thinking through modern global models, with the backtesting rigor most tutorials skip.
Time Series & Forecasting
Decomposition, ETS, ARIMA, Kalman filtering, and the neural forecasters that actually win competitions.
1 Decomposition and stationarityTrend, seasonality and remainder — pulled apart live — plus the ACF as a stethoscope, and stationarity: the assumption every later model quietly makes. live 2 Exponential smoothing and ETSSES to Holt–Winters as one recursive family: what α, β, γ each smooth, the state-space view that earns the prediction intervals, and why these 1950s methods still beat neural nets on short series. live 3 ARIMA and Box–JenkinsAR and MA processes with their ACF/PACF fingerprints — simulate them and learn to read the signatures — plus differencing, the backshift algebra, and honest model identification. live 4 State space and the Kalman filterHidden state, noisy observations, and the optimal predict–update recursion derived in full — watched tracking a moving level it can never see directly. live 5 Neural and global forecastingThe local-to-global shift: one model across thousands of series, DeepAR and N-BEATS anatomies, what the M-competitions actually showed, and when deep learning loses to ETS. live 6 Backtesting and forecast evaluationRolling-origin evaluation done right, the leakage traps unique to time, MASE and scaled metrics, and per-horizon error curves — animated over a series origin by origin. live 7 Forecasting: self-checkTen questions across the module, graded in your browser — 8+ says you own it. Every miss shows the answer and the lesson logic behind it. live
T5
Deep Learning
Backpropagation derived by hand, the architectures that matter, and the optimization tricks that make them trainable.
Deep Learning
From a two-layer network you differentiate yourself to transformers.
1 Backpropagation from scratchA two-layer network differentiated by hand, the computational-graph view, and why reverse mode costs only 2× the forward pass — then watch the same math train a net live in the page. live 2 Initialization and normalizationVariance propagation through depth, Xavier and He derived from one recursion, batch/layer norm, and residual connections — with a 50-layer signal you can watch die or survive. live 3 Convolutional networksConvolution as an inductive bet — locality plus weight sharing — receptive fields, the parameter-count miracle, and kernels you can apply to an image live. live 4 Recurrence and LSTMsBPTT as one long chain rule, the vanishing-gradient theorem made visceral, and the gated cell that fixed it — with gradient decay through time plotted for both. live 5 Attention and transformersQueries, keys and values derived from first principles, why the √d matters, multi-head, position, and the block that ended recurrence — with an attention matrix under your hands. live 6 Regularization and generalizationDropout, weight decay done right (the AdamW subtlety), augmentation, early stopping — and double descent, live: watch test error fall, spike at interpolation, then fall again. live 7 Training in practiceThe liturgy that makes networks actually train: AdamW + warmup + cosine, gradient clipping, mixed precision, overfit-one-batch-first, and the debugging order that finds the bug. live 8 Diffusion and generative visionVAE to DDPM to flow matching — with reverse diffusion running live on an exact score — classifier-free guidance derived, latent diffusion's arithmetic, and CLIP, the contrastive bridge that lets text steer images. live 9 Deep learning: self-checkTen questions across the module, graded in your browser — 8+ says you own it. Every miss shows the answer and the lesson logic behind it. live
T6
Reinforcement Learning
The track the playground was built for: search through deep RL to agentic training — every lesson runnable live on your own machine.
Search to Agentic RL
Each chapter pairs the theory with a playground lab you can run.
1 PathfindingBFS, DFS, Dijkstra, A*, weighted and bidirectional variants — one shared skeleton, and the expansion gap that is the whole lesson. live 2 Deep reinforcement learningMDPs, Bellman equations, the DQN family and the policy-gradient family, at the same depth as Pathfinding. live 3 Teaching an LLM (distillation + RLAIF)SFT, then DPO derived from the RLHF objective; evaluation with win-rates, rubrics, perplexity and ROUGE. live 4 Reasoning loopsGenerate → critique → refine as an inference-time policy; Self-Refine, Reflexion, self-consistency. live 5 Curriculum agents (University)A Dean agent that plans, teaches to mastery, and re-teaches — curriculum learning applied to model training. live 6 AI agents and tool useFunction calling, the agent loop, orchestration and MCP-era patterns — the field's current center of gravity, built on this track's reasoning-loop foundations. live 7 Agent evaluation and reliabilityWhy agents fail compositely, trajectory-level evaluation, guardrails and containment — engineering reliability into systems that act. live 8 Reinforcement learning: self-checkTen questions across the module, graded in your browser — 8+ says you own it. Every miss shows the answer and the lesson logic behind it. live
T7
Language Models & LLMs
Tokenizers to RLHF: how modern language models are built, tuned, evaluated and served.
Language Models
The full stack behind every AI product, opened up.
1 TokenizationBPE trained live in front of you: the merge loop, the vocabulary-size trade, and why tokenizers are behind half of LLM arithmetic failures and pricing surprises. live 2 EmbeddingsFrom one-hot to dense vectors: the word2vec objective as matrix factorization, cosine geometry, contextual embeddings — with a tiny skip-gram model training in the page. live 3 The language-modeling objectiveNext-token prediction as maximum likelihood, causal masking, perplexity as the honest metric — and an n-gram model you can train on any text to feel exactly where it breaks. live 4 Scaling lawsKaplan to Chinchilla: the power laws, the compute-optimal frontier, the ~20 tokens-per-parameter rule — explored on an interactive isoFLOP curve. live 5 LoRA and parameter-efficient fine-tuningThe low-rank update hypothesis, LoRA's exact math (rank, α, which matrices), QLoRA — with the rank/quality trade measured live on a real low-rank update. live 6 Alignment: RLHF and DPOBradley–Terry reward modeling, the KL-anchored RLHF objective, DPO's derivation as its closed form, and reward hacking — the training loop behind every assistant you talk to. live 7 Inference and servingKV-cache memory arithmetic, temperature/top-k/top-p derived and played with live, speculative decoding, and why serving is a memory-bandwidth problem, not a FLOPs problem. live 8 RAG and evaluationRetrieval-augmented generation's anatomy and failure modes, plus the hard problem: evaluating systems whose outputs are prose — benchmarks, win-rates, judges, and contamination. live 9 Evaluation engineeringEval-set design, judge calibration and guardrails as an engineering discipline — the fastest-growing skill in the LLM job market, taught at working depth. live 10 Language models: self-checkTen questions across the module, graded in your browser — 8+ says you own it. Every miss shows the answer and the lesson logic behind it. live
T8
DevOps & Cloud
Ship what you build: containers, CI/CD and infrastructure as code, then the cloud platforms underneath — AWS in depth, with the Azure and GCP translations.
Shipping Software
The delivery pipeline this very platform uses, generalized.
1 Containers and images that behaveWhat a container actually is, images as layer stacks, the build-cache economics you can watch invalidate live — and the multi-stage pattern behind every production Dockerfile. live 2 CI/CD pipelinesThe pipeline as a gauntlet of gates: build, test, scan, deploy — run it, inject failures, and watch what a security gate actually stops. Includes the anatomy of a real GitHub Actions workflow. live 3 Terraform and infrastructure as codeInfrastructure as a reconciliation loop: desired state in code, actual state in the cloud, and plan/apply/drift played live — plus the state-file discipline that keeps teams from destroying each other's resources. live 4 Secrets and configurationThe hierarchy from .env to OIDC-federated short-lived credentials: where secrets live at each maturity level, the leak vectors that actually happen, and config separation across environments. live 5 Multi-repo architectureHow separate repositories compose into one system: the contract surfaces — registries, APIs, schemas, IAM — where they meet, and a change-propagation map you can probe scenario by scenario. live 6 Model monitoring and driftThe pipeline shipped the model — now operate it: covariate vs concept drift on a live 120-day simulation, PSI and the label-delay problem, retraining triggers, shadow and canary deployment. live 7 Shipping software: self-checkTen questions across the module, graded in your browser — 8+ says you own it. Every miss shows the answer and the lesson logic behind it. live
Cloud Platforms for ML Deployment
The AWS building blocks (S3, CloudFront, IAM, EC2/ECS, Lambda, SageMaker) and how the same architecture maps onto Azure and GCP.
1 Static delivery: S3, CloudFront, DNS and cachingA request's full journey — DNS to edge to origin — with the cache-control dials live in your hands, including the stale-deploy trap this very platform hit in production and how hashed assets end it. live 2 Compute for ML: training vs servingThe compute menu — VMs, containers, functions, managed ML platforms — chosen per workload shape, with the serverless-vs-always-on cost crossover computed live on your own traffic numbers. live 3 IAM and security boundariesPrincipals, policies, roles and trust: least privilege as an engineering practice, OIDC federation that ends long-lived CI keys, and the blast-radius thinking behind every boundary. live 4 Cloud cost mechanicsThe bill's actual shape: egress as the silent tax, storage classes, spot economics, per-request pricing — and the estimation habit that catches the $3,000 surprise at design time. live 5 The Azure/GCP rosetta stoneEvery AWS concept this module used, mapped to its Azure and GCP counterpart — with the genuine differences flagged, because the translations are 90% clean and the 10% bites. live 6 Cloud platforms: self-checkTen questions across the module, graded in your browser — 8+ says you own it. Every miss shows the answer and the lesson logic behind it. live
Theory here, compute on your machine.
Reading is free and instant, no account. The labs run through a small open worker you start locally — your GPU, your models, your API keys, none of it leaves your machine.
New lessons and videos, about twice a month. No spam, unsubscribe in one click.