Build intuition from absolute zero. Every concept from first principles, with interactive simulations, step-by-step math, and quizzes. No prerequisites beyond curiosity.
From absolute zero to understanding every line of Karpathy's 243-line GPT.
Self-attention, multi-head, KV cache, MoE — the architecture behind everything.
Split an image into patches, treat them as tokens, run a Transformer. How ViT unified vision and language architectures.
Why one design rules everything — retrofitting patterns, cross-attention, conditioning zoo, composition.
Linear recurrence, selective scan — the O(n) alternative to attention.
Add noise, learn to reverse it. The dominant generative paradigm.
Straight paths from noise to data — simpler, faster than diffusion.
A 2.4B music model you can jam with in ~200 ms on a laptop — frame-level codec LM, attention sinks, pianoroll & style control.
Replace the U-Net with a Transformer. adaLN-Zero conditioning, scaling laws, and how DiT powers SD3, FLUX, and Sora.
The secret plumbing — variational inference, codebooks, tokenization.
Generator vs discriminator — the adversarial game.
The glue connecting images and text in a shared space.
Teaching language models to see — vision encoder + LLM fusion.
The data layer under every vision model: trace one image from raw bytes through layout, resize, normalization, and patchify all the way to the tokens a VLM reads — and the silent bugs at each step.
Foundation models that physically act in the world.
Learning to imagine before acting — prediction as intelligence.
Reconstructing 3D worlds from 2D photographs.
RLHF, DPO, Constitutional AI — making AI do what we want.
From vibe checks to rigorous testing. Graders, pass@K/pass^K, τ-bench, Terminal-Bench, the Swiss cheese model.
Scaling without paying for it: experts & routing, top-k gating, the collapse problem & load-balancing loss, capacity/token-dropping, Switch, Mixtral & DeepSeek, expert parallelism.
Letting the model think longer: self-consistency, best-of-N & verifiers, chain-of-thought as compute, tree search, o1-style reasoning RL, the train-vs-test tradeoff, and the overthinking trap.
Seeing every pixel: encoder-decoder, the bottleneck blur, skip connections (the one big idea), upsampling & checkerboards, Dice loss, and why it became the backbone of diffusion models.
Escaping the quadratic wall: where the n² comes from, the kernel/associativity trick, the recurrent dual form, the recall catch, RWKV’s decay & gating, the Mamba/RetNet family, and hybrid models.
The LSTM reborn: the two fatal flaws, saturating sigmoids, exponential gating + normalizer (sLSTM), matrix memory (mLSTM), parallelizability, the revision lab, the block, and the recurrent-revival family.
The impossible triangle: retention (attention minus softmax plus decay), and one mechanism computed three equivalent ways — parallel to train, recurrent to deploy, chunkwise to scale. Multi-scale heads & the family.
Attention by convolution: a sequence-length filter, made practical by implicit filters (any length, few params), the FFT (n log n), and data-controlled gating — plus the recurrence=convolution duality.
The hybrid that works: interleave mostly-Mamba layers with a few attention layers (for recall) plus MoE (for cheap capacity) — why a few attention layers suffice, the KV-cache memory win, and the hybrid era.
Google DeepMind’s RNN-speed transformers: a gated linear recurrence (RG-LRU) for cheap global memory + local attention for sharp recall. Linear recurrence → parallel scan → stability → gating → the hybrid stack → constant-size inference.
Yann LeCun’s Joint Embedding Predictive Architecture: stop predicting pixels, predict meaning. Why pixel loss blurs → latent prediction → collapse & the EMA fix → predictor + mask tokens → masking → the full I-JEPA loop → world models.
One architecture for any modality: funnel a huge input through a small latent bottleneck with cross-attention. The n² wall → latent workspace → cross-attention → latent thinking → Fourier position → iteration → arbitrary outputs via query arrays.
Networks with infinite, continuous depth. A residual block is one Euler step — take the limit and depth becomes a flow field solved by an ODE solver: adaptive computation, O(1)-memory adjoint gradients, and the continuous-normalizing-flow ancestor of diffusion.
Kolmogorov–Arnold Networks: flip the MLP — put learnable 1-D functions (splines) on the edges, let nodes just sum. The result is a network you can read, prune, refine, and turn into a symbolic formula.
MIT’s tiny, robust brains: continuous-time neurons whose response speed adapts to the input. Leaky neuron → liquid time constant → bounded stability → robustness → neural circuit policies → closed-form CfC. 19 neurons can drive a car.
How machines learned to hear: turn sound into a log-mel picture, run a vanilla transformer encoder-decoder over it, control the task with prompt tokens, and train on 680,000 hours of the messy internet. The audio front-end behind all modern speech models.
Sora-style spacetime diffusion: compress video into a spacetime latent, chop it into patches spanning space and time, and denoise the whole clip with a diffusion transformer whose attention crosses frames — coherence by construction, plus emergent world-model behavior.
The denoising that paints images can drive a robot. Instead of regressing one action (and averaging multimodal demos into a crash), it generates an action chunk from noise — committing to a mode, conditioned on observations, replanned in a closed loop. The action head behind modern VLAs.
The journey from a raw pressure wave to the log-mel spectrogram every audio model eats: sampling & Nyquist, the Fourier transform, the STFT, the spectrogram, and the mel/log perceptual scales — plus MFCCs and learned front-ends.
How EnCodec/SoundStream turn sound into discrete tokens a language model can generate: conv autoencoder, vector quantization, residual codebooks (coarse→fine, scalable bitrate), and the GAN that keeps it crisp. The bridge to AudioLM, MusicGen, VALL-E.
From robotic to human: text frontend (G2P), acoustic model, vocoder, the alignment problem, and the one-to-many trick — through Tacotron, FastSpeech, VITS, and modern diffusion & codec-token TTS, plus voice cloning.
BERT for audio: Wav2Vec 2.0 & HuBERT learn speech from unlabeled sound by masking spans and predicting discrete speech units — so ten minutes of transcripts can train a recognizer. Pretrain+fine-tune, contrastive vs cluster-predict.
From text prompt to song: tokenize audio, model long-range structure with semantic + acoustic tokens, the AudioLM hierarchy and MusicGen delay pattern, joint text-music embeddings, and diffusion approaches (Stable Audio). The capstone of the Audio track.
Deep learning on unordered 3D point sets: permutation invariance via max pooling (PointNet), hierarchical local features (PointNet++), point transformers, and ICP registration. Where convolutions can’t go.
Learning on nodes and edges via message passing: each node gathers neighbor messages, aggregates symmetrically, and updates. GCN, GAT, over-smoothing, and the unifying view (a transformer is a GNN on a full graph).
Predicting the future with its uncertainty: lookback→horizon, trend/seasonality decomposition, probabilistic (quantile) forecasts, global models, N-BEATS, the Temporal Fusion Transformer, PatchTST, and zero-shot foundation models.
Fit a distribution over functions, not one curve — getting calibrated uncertainty for free. Kernels, conditioning, error bars, the n³ wall, and the broader uncertainty toolkit (deep ensembles, MC dropout, conformal prediction).
The engines behind Netflix/Amazon/YouTube: matrix factorization, user & item embeddings, the two-tower retrieval model, the retrieve-then-rank funnel, DLRM, and hard problems (cold start, feedback loops). Personalization at billion-item scale.
How text becomes the integers a model sees: the word-vs-character trade-off, byte-pair encoding built from scratch, encoding by merge-replay, WordPiece & Unigram, byte-level BPE (no OOV ever), and SentencePiece’s ▁ spaces. Why models can’t count the r’s in “strawberry.”
The model outputs a distribution, not a word — decoding turns it into text. Logits & softmax, greedy’s repetition trap, temperature, top-k, top-p (nucleus), beam search, and the modern penalty pipeline. The dial between robotic and unhinged.
Fine-tune a 70B model by training under 1% of it. The low-rank insight (the update is low-rank), LoRA’s frozen-W + B·A adapter, parameter counting, the B=0 zero-start, merge-vs-swap deployment, QLoRA’s 4-bit base, and the wider PEFT family.
MSE, cross-entropy, KL divergence, Huber, contrastive, triplet, InfoNCE — every loss derived from scratch with interactive comparisons.
SGD, momentum, AdaGrad, RMSProp, Adam, AdamW, Lion, Sophia — every update rule derived, hand-computed, and raced head-to-head.
BatchNorm, LayerNorm, RMSNorm, GroupNorm, InstanceNorm, Pre-LN vs Post-LN — every variant derived, hand-computed, and raced in the Arena.
MHA, MQA, GQA, sliding window, linear attention, FlashAttention — every variant derived with memory arithmetic and raced in the Arena.
Sinusoidal, learned, RoPE, ALiBi, NTK scaling — why transformers need position and how rotation won, with length extrapolation arena.
Sigmoid, ReLU, GELU, SiLU/Swish, SwiGLU, Mish — every nonlinearity derived with dead neuron analysis and racing arena.
Warmup, step decay, cosine annealing, 1cycle, WSD — every schedule derived with loss landscape simulations and racing arena.
Xavier, He/Kaiming, orthogonal, transformer recipes — every method derived from variance preservation with deep network explorer.
Vanishing/exploding gradients, clipping, accumulation, mixed precision, loss scaling, checkpointing — the complete stability toolkit.
ResNet residuals, Pre-LN vs Post-LN, DenseNet, Highway — why every modern architecture uses shortcuts and how to choose.
Max, average, GAP, CLS, mean, attention, GeM pooling — how to collapse features into fixed-size vectors for any task.
Token, position, segment, patch embeddings — tied weights, scaling, subword effects, and the lookup tables behind every model.
Epochs, batches, DataLoaders, shuffling, the 6-step training loop, eval mode, common bugs — the complete anatomy of training.
Flips, crops, color jitter, RandAugment, Mixup, CutMix, text augmentation, TTA — synthetic variations that prevent overfitting.
Difficulty scoring, Bengio’s classical curriculum, pacing functions, self-paced learning, teacher-student bandits, DoReMi data mixing — and when ordering doesn’t help.
Self-supervised vision without labels: InfoNCE, temperature, the projection head you throw away, MoCo’s queue, and how BYOL & DINO dodge collapse with no negatives.
Teaching a small model to think like a giant: dark knowledge, temperature softening, the KD loss, feature & attention matching, self-distillation, DistilBERT, and the capacity-gap trap.
Co-adaptation, the mask & inverted-dropout scaling, the ensemble view, spatial dropout, DropConnect, stochastic depth/DropPath, DropBlock — breaking your network on purpose to make it generalize.
LLM-guided evolutionary search over programs. Cap sets, bin packing, scoring functions, best-shot sampling, islands model.
Hands-on: implement the FunSearch loop end-to-end. Prompt design, sandbox execution, evolutionary selection, scaling experiments.
Every matrix in every model. Hand calculations, from-scratch Python, PyTorch, and 19 interactive visualizations. Scalars to SVD to backprop to numerical stability.
Self-similar problems solved by a function that calls itself: base cases, the call stack pushing and popping frames, and even_factorial derived and hand-traced — with a live Python Code Lab.
The directions a matrix only stretches. The characteristic equation by hand, the triangular shortcut, power iteration, and why eigenvalues decide the stability of dynamical systems.
From a mass-spring-damper to first-order state-space: the four damping regimes, the matrix form, and the discovery that the regimes are the eigenvalues hiding inside it. With an RK4 Code Lab.
Second derivatives that tell a bowl from a dome from a saddle. The symmetric Hessian, the second-derivative test, and how Newton's method uses curvature to take a smarter step.
Updating belief with evidence, from zero. The disease-test trap (a positive test is only fifty-fifty, not eighty), the base-rate effect, and a live posterior Code Lab.
Estimate the impossible by random sampling: the law of large numbers, the unavoidable square-root error law, why it shrugs off high dimensions, variance reduction — and how it prices options, traces light, and powers modern AI.
Sample from a proposal you can afford, then reweight to the truth — and watch a one-in-a-million event become reachable. The optimal proposal, effective sample size, rare-event tilting, off-policy RL, and importance-sampled rendering.
Stop scattering points at random — place them deterministically to fill space evenly, and watch integration error fall from one-over-root-N toward one-over-N. Discrepancy, van der Corput, Halton & Sobol, Koksma–Hlawka, effective dimension, and randomized QMC.
When you can’t sample a distribution, build a random walk that visits its points in the right proportions — then just average. Metropolis–Hastings, Gibbs, detailed balance, burn-in & mixing, autocorrelation & R-hat, and the Ising lattice where it was born.
Stop wandering — use the gradient of the log-probability to glide across high-dimensional distributions in long, high-acceptance jumps. The score, momentum & leapfrog, NUTS, Langevin & MALA — and how score-based diffusion models are Langevin sampling in disguise.
When one proposal isn’t enough: march a weighted swarm of particles through a ladder of distributions, resampling to survive — and read off the normalizing constant nobody else can. Degeneracy & resampling, tempering, annealed importance sampling, and Bayesian model evidence.
When you can’t evaluate every move, search only the promising ones — grow a tree by playing the game out at random, then let the wins steer where you look next. The four phases, UCT exploration, AlphaGo → AlphaZero → MuZero, and LLM reasoning as search (Tree of Thoughts, rStar-Math).
The average salary is $68k and almost nobody earns near it. What a percentile actually is, mean vs median, IQR, the CDF/ECDF, box & violin plots, and why heavy tails make the average lie — descriptive statistics from absolute zero.
Is that benchmark delta real or a coin flip? Standard errors, confidence intervals, the bootstrap, McNemar, power, and multiplicity — the statistics that separate signal from sampling noise.
A 99%-accurate fraud detector that catches no fraud is a metric you designed badly. Confusion matrices, ROC/PR, calibration, NDCG, aggregation traps, and Goodhart’s law.
The same numbers can be plotted into opposite conclusions. Histogram traps, honest error bars, log-log scaling fits, and a lie-detector toolkit for every eval plot you read or make.
Your feature ‘improved’ retention — because it launched before a holiday. Randomization, power & MDE, the peeking problem, CUPED, switchbacks, and why offline wins vanish online.
Your tests are green and your model is broken. Golden sets, statistical release gates, PSI/KS drift alarms, canary & shadow, and the rollback machinery that stops bad models from shipping.
Two Kalman filters, identical RMSE — one is lying about its confidence. NEES & NIS consistency, the Cramér–Rao bound, SLAM ATE/RPE, and honest robot success-rate intervals.
Classification has an answer key; generation has a taste problem. pass@k, Bradley–Terry & Elo, FID from scratch, judge-bias quantified, and inter-rater kappa — for LLMs, VLMs, and diffusion.
Your model gained 2 points and revenue dropped. Climb from module metric to P&L: driver trees, guardrails & SLOs, funnels, error analysis, and exec-ready launch memos.
The first ML algorithm done right. Fit a line, score it with squared error, then minimize two ways: roll downhill with the LMS rule (batch & SGD) and jump to the exact answer with the normal equations — and discover least squares is maximum likelihood under Gaussian noise.
How a line learns to say yes/no. Squash a score into a probability with the sigmoid, derive cross-entropy from maximum likelihood, meet the update rule that's identical to LMS, then extend to the perceptron, softmax for many classes, and Newton's method.
Re-fit a fresh classifier around every query point, trusting nearby data more. The Gaussian kernel, Newton's method, and the bandwidth as a bias/variance knob — the showcase Code Lab repaints the decision boundary as you turn it.
One recipe that produces linear regression, logistic regression, softmax, and Poisson regression. The exponential family, why the sigmoid is forced not chosen, the three-line GLM recipe, and the single gradient every GLM shares. The framework that explains the mystery.
The other half of classification: model what each class looks like, then flip with Bayes. Gaussian Discriminant Analysis (its posterior is secretly a sigmoid), generative vs discriminative trade-offs, and the Naive Bayes spam filter that defined an era — plus Laplace smoothing.
Why a model that fits perfectly can predict garbage — and why making it even bigger can fix it. Test error decomposed into bias, variance, and noise; the classical U-curve and its sweet spot; then double descent and the implicit regularization behind modern deep learning, simulated live in your browser.
How to actually find the sweet spot without cheating. The golden rule (train/validation/test), the cross-validation family (hold-out, k-fold, leave-one-out), regularization as a continuous complexity dial, L1 vs L2 (shrink vs select), and the Bayesian view where regularization is a prior.
Finding hidden groups when nobody labeled them — the first unsupervised algorithm. The assign/average two-step dance, the distortion it minimizes, why it always converges (and to a local minimum), choosing k with the elbow, and where its spherical assumption breaks.
k-means, leveled up: soft probabilistic clustering with stretchable elliptical groups. The mixture model, the chicken-and-egg problem, the E-step (Bayes’ responsibilities) and M-step (weighted re-fit), why it converges, and how k-means is just EM with hard assignments and fixed spheres.
Squeeze high-dimensional data down to the few directions that matter, via one eigenvector calculation. Centering, the max-variance projection, the covariance matrix, principal components as its eigenvectors, reduction & reconstruction, and applications from eigenfaces to noise removal.
Unmix what was blended — the cocktail party problem. The mixing model x=As, finding the unmixing W, independence as the criterion, why ICA needs non-Gaussian sources, a live un-mixing lab, and how ICA differs from PCA (independence beats uncorrelatedness).
From-scratch LM motivation, the CS336 pipeline, and building BPE tokenizers from character/byte/word up.
Tensors, fp32/bf16/fp8, FLOP counting, the 6ND rule, optimizer & activation memory, the training loop.
Pre-norm, RMSNorm, SwiGLU, RoPE, GQA, FFN ratios — every modern LLM architecture choice, derived.
Mixture of Experts: top-k gating, load-balance loss, expert capacity, router z-loss. DeepSeek, Mixtral, Llama 4.
Arithmetic intensity, the roofline model, memory coalescing, tiling, and fusion — why GPUs idle and how to fix it.
HBM traffic, kernel fusion, writing a fused Triton kernel, and FlashAttention's online-softmax recurrence.
Collective ops, data parallelism, ZeRO 1–3, ring all-reduce, tensor parallelism, and memory accounting.
Pipeline parallelism, the bubble formula, GPipe vs 1F1B, FSDP/ZeRO-3, and sequence parallelism.
Compute-optimal scaling: C=6ND, the loss law, IsoFLOP curves, Chinchilla, and the D=20N rule.
Prefill vs decode, KV-cache sizing, the roofline, KV compression, speculative decoding, and quantization.
Parametric loss fits, IsoFLOP profiling, the three Chinchilla methods, WSD, muP transfer, data-limited scaling.
Perplexity, multiple-choice scoring, majority vote, best-of-N, Elo, and contamination across MMLU, GPQA, Arena.
Where LLM corpora come from: Common Crawl, WARC vs WET, HTML→text extraction, the data-mix problem, copyright.
Cleaning web text: KenLM & fastText filtering, DSIR, Bloom filters, MinHash, and LSH deduplication.
Post-training: SFT, Bradley-Terry preferences, the RLHF KL objective, PPO, and the DPO loss derived.
RLVR with verifiable rewards: REINFORCE, baselines, GRPO group advantage. DeepSeek-R1, Kimi, Qwen 3.
Policy gradients from scratch: the PG theorem, REINFORCE variance, baselines, GAE, PPO clip, GRPO. Series capstone.
The four-module autonomy stack and the perception–action loop that ties it together — map representations, finite-state-machine executives, and a full gridworld stack you can break.
From “turn 30°” to wheel speeds: rotation matrices, SE(2) frames, holonomic vs nonholonomic constraints, and the unicycle & differential-drive models you integrate yourself.
Turn a robot+obstacles into a point searching a graph: C-space inflation, Dijkstra, admissible heuristics, and A* — run by hand on a grid, then built and flooded yourself.
When grids explode in high dimensions, sample instead: build a roadmap, grow a rapidly-exploring tree, and rewire it to optimality — you implement nearest, steer, and choose-parent yourself.
A planner gives waypoints; a robot needs a smooth, timed, dynamically-feasible trajectory. Polynomial trajectories, differential flatness (recover v & ω from the path), and the min-snap QP.
Open-loop drifts; feedback corrects. Error dynamics, P/PI/PID, pole placement, and LQR via the Riccati equation — build the controllers and watch them track a path through a disturbance.
What robots measure and how it goes wrong: encoder odometry, gyro drift, LiDAR scans, line extraction, and Iterative Closest Point — you integrate a biased gyro and align two scans with SVD.
How a camera turns 3D into pixels: the pinhole model, intrinsics K, extrinsics, the full projection P=K[R|t], lens distortion, and calibration — you project a cube and calibrate from correspondences.
Recover 3D from images: Harris corners, descriptor matching, epipolar geometry, RANSAC robust fitting (N=log(1−p)/log(1−wₛ)), triangulation and stereo depth Z=fB/d — built by hand.
From corners to meaning: template matching, IoU & non-max suppression, convolution as a learned filter, detectors and segmentation — and how a detection becomes an FSM input that stops the robot.
Build a map and localize in it at once: EKF-SLAM and its growing correlations, factor graphs, Gauss-Newton on a pose graph, sparsity, and loop closure that snaps drift away — built by hand.
Build a free/occupied map from noisy range scans via log-odds and ray-casting, then explore autonomously: detect frontiers, score them by information gain vs cost, and cover the unknown.
Fuse a noisy prediction with a noisy measurement: the Bayes filter, Gaussians, the Kalman gain as a trust dial, EKF Jacobians for nonlinear models, EKF-localization, and the unscented transform.
When the belief is multimodal a Gaussian can't capture, use a cloud of weighted samples: predict, weight, resample. Monte Carlo Localization, the kidnapped robot, and Neff — built from scratch.
Series capstone. Behavior cloning & the O(εT²) distribution-shift trap, DAgger, diffusion policies, Vision-Language-Action models, 3D Gaussian Splatting, and world models — where the classical stack meets learning.
Why one long-lived daemon owns the stateful provider connections, and everything else — operator clients, capability nodes, seven chat surfaces — is a thin client of it.
A typed request/response/event grammar over one WebSocket: the handshake, discovery, idempotent retries, and gap-detecting sequence numbers.
Capability-based trust: keypair device identity, challenge-nonce signing, role/scope RBAC, pairing approval — and what auth actually protects.
The run as a serialized state machine — intake to context to inference to tools to stream to persist — with hooks, timeouts, and four ways to end.
What the model sees and how you see it back: layered prompt assembly under a cache boundary, and block-and-preview reply streaming.
Lane-aware concurrency: per-session FIFO plus global caps, and the steer / followup / collect / interrupt modes for messages that arrive mid-run.
State partitioning and routing at scale: session keying and isolation, lifecycle and pruning, and the most-specific-wins agent router.
How a stateless model gets durable memory: a file-backed hierarchy, hybrid vector-plus-keyword search, and a dreaming process that consolidates what matters.
Treat failure as normal: retries with backoff and jitter, model failover chains, context-overflow compaction, and diagnostics that recover on their own.
The hard enforcement fence: the five-mode exec ladder, the allowlist, exec-approval flow, and sandbox modes that decide whether a command runs.
The four extension surfaces: skills loaded on demand, plugins, hooks that fire on events with precedence, and cron jobs on a schedule. The finale.
Turn noise into data by simulating a differential equation: vector fields, flows, Euler's method, Brownian motion, SDEs and the Ornstein–Uhlenbeck process — built and run by hand.
Where do the arrows come from? Train the vector field — conditional & marginal probability paths, the marginalization trick, and the simulation-free flow matching loss.
The score bridges the ODE and SDE samplers, gives denoising score matching, and powers classifier-free guidance — how a model is made to obey a prompt.
The vector field is a neural net: sinusoidal time embeddings, U-Nets, Diffusion Transformers, and diffusing in a VAE latent space — Stable Diffusion 3 and Movie Gen.
Text is discrete, so Gaussian noise won't do: continuous-time Markov chains, masking/absorbing states, and the parallel un-masking sampler behind diffusion language models.
The complete rigorous companion — the full 84-page 6.S184 notes as one interactive reference: every definition, theorem and derivation across all five lectures.
Sequential decisions in the physical world: the closed loop, the compounding-error trap that breaks naive imitation, the robot data problem, the four pillars, and a preview of the whole course.
The agent–environment loop and the reward hypothesis, a policy as a state→action map, the ladder of methods from imitation to RL, known vs learned worlds, and high-level plans over low-level skills.
Supervised learning, loss & empirical risk, linear and logistic regression by hand, gradient descent and the learning rate, overfitting, the bias–variance tradeoff, and regularization.
Why depth and nonlinearity, the MLP and backprop by hand, optimizers from SGD to Adam, CNNs, attention and Transformers, generative models, and knowing when the model is uncertain.
The MDP tuple, policies and trajectories, discounted return and value functions, the Bellman idea, and behavior cloning — plus why copying an expert is not standard supervised learning.
DAgger and how it beats the quadratic cost, privileged teachers, GAIL as distribution matching with a discriminator, and Diffusion Policy for multimodal demonstrations.
Value and Q functions, the Bellman expectation and optimality equations derived, dynamic programming — policy evaluation, policy improvement, policy iteration and value iteration — worked by hand on a gridworld.
Model-free control from samples: Monte Carlo vs TD, SARSA vs Q-learning and the off-policy max, ε-greedy exploration, the cliff, and DQN's replay buffer and target network that tame the deadly triad.
Optimize the policy directly: the log-derivative trick, the policy gradient theorem, REINFORCE, why the estimator is unbiased but high-variance, and reward-to-go and baselines that calm it down.
A learned critic cuts policy-gradient variance: the advantage function, the TD error, two networks in one loop, and the n-step / GAE dial that trades bias against variance.
The biggest safe step: natural gradients and the KL trust region, PPO's clipped surrogate, deterministic off-policy control with DDPG/TD3, and maximum-entropy RL with SAC — mapped on one 2×2 grid.
When you know the physics: state-space models, feedback, PID, stability from eigenvalues, and LQR — the optimal linear controller — with the Riccati recursion worked by hand.
Plan a whole control sequence: shooting vs collocation, the LQR backward pass derived line by line, and iLQR / DDP — linearize, solve LQR, repeat — plus sequential convex programming.
When you can't write the equations: MPC and replanning, random shooting, the cross-entropy method and MPPI, and learned-model RL — PILCO, PETS ensembles, and MBPO.
Learn a latent world model from pixels and plan inside it: Dreamer's learning-in-imagination, TD-MPC's plan-in-latent with a learned value, and how model error compounds over a rollout.
Guest lecture: model dough, beans, and fluids as particles plus relations and learn the dynamics with a graph network — message passing, permutation-equivariance, and planning with a learned simulator.
Guest lecture: learn from a fixed log with no new interaction — the out-of-distribution overestimation death spiral, and the fixes: policy constraints, conservatism (CQL), in-sample IQL, and Diffuser.
Recover the reward from demonstrations: why it's ambiguous, feature matching, max-margin, and the maximum-entropy principle — the least-committal reward that explains the expert.
The cleanest explore–exploit problem: regret, ε-greedy, UCB optimism, Thompson sampling, and dueling bandits / preference learning — the foundation under RLHF.
When rewards are sparse and random actions never stumble onto them: count-based bonuses, curiosity as prediction error, the noisy-TV trap, and Random Network Distillation.
The reality gap: why a sim-perfect policy falls on the real robot, domain randomization (reality is just sim #10,001), system identification, and champion-level drone racing.
When you can't learn from the crash: constrained MDPs, safe exploration, control barrier functions, and safety filters that project any unsafe action onto the nearest safe one.
Adapt within a step: teacher–student distillation, RMA inferring terrain from recent motion, and Neural-Fly's online residual adaptation for agile flight in wind.
Guest lecture: borrow the web's common sense — SayCan's say×can grounding, CLIPort, RT-1's tokenized actions, Code-as-Policies, and the move toward vision-language-action models.
The capstone: the two hard problems revisited, one map from imitation to foundation models, a method-selection decision tree, honest tradeoffs, and the open frontier.
Why no single sensor is enough: complementary vs competitive vs cooperative fusion, the fusion levels, and the reliability paradox — more sensors isn't always more robust.
Where and how to combine: the JDL levels, centralized vs distributed vs decentralized, and the double-counting trap — correlated estimates that fool the fused covariance into overconfidence.
The seed of all fusion: the inverse-variance weighted average. Trust each source by its precision; the fused estimate is always sharper — and it's secretly the Kalman update.
Fusion over time: keep a belief, predict it forward (it blurs), then fuse each new measurement via Bayes' rule (it sharpens). The recursive engine behind every filter that follows.
The Bayes filter for linear-Gaussian worlds: fuse a model prediction with a measurement, each weighted by its uncertainty. The Kalman gain is the trust dial — recursive inverse-variance fusion.
The cheapest fusion: blend a fast-but-drifty gyro with a slow-but-stable accel/mag by frequency — high-pass the gyro, low-pass the reference. Madgwick & Mahony attitude estimators.
Nonlinear fusion: linearize the model with its Jacobian, then run the Kalman machinery — fusing IMU motion with range/bearing GPS. The workhorse of real navigation.
Skip the Jacobian: pick a few sigma points, push them through the true nonlinearity, and recover the fused mean and covariance. More accurate than the EKF, derivative-free.
The Kalman filter inside-out: track information (inverse covariance) instead of covariance. Fusion becomes simple addition — the key that unlocks decentralized, multi-sensor networks.
When the world isn't Gaussian: represent the belief with a swarm of weighted samples. Predict, weight by the measurement, resample — non-parametric fusion that powers Monte Carlo Localization.
Fusing estimates that secretly share information: when the correlation is unknown, naive fusion grows overconfident and diverges. CI stays consistent for any correlation — the key to decentralized fusion.
The dodged half of fusion: which measurement updates which track? Validation gating, global nearest-neighbor, JPDA and MHT — because one wrong correspondence makes the best filter fuse garbage and diverge.
The sensor everything fuses with: what gyros and accelerometers really measure (specific force, not acceleration), strapdown mechanization, and why an unaided IMU's position error explodes as t³.
Bounding inertial drift with absolute fixes: loose vs tight vs deep coupling, and the error-state Kalman filter that fuses a high-rate IMU with low-rate GNSS — coasting through tunnels, snapping back on reacquisition.
The silent prerequisite for all fusion: get the sensor-to-sensor transform (hand-eye AX=XB) or the clock offset wrong and your optimal filter quietly diverges. Spatial + temporal calibration, observability, Kalibr.
The complementary masterpiece: a camera and an IMU cover each other's blind spots — and the IMU's metric acceleration resolves the monocular scale. MSCKF, VINS-Mono, and IMU preintegration.
Fusing precise 3-D LiDAR with the IMU that de-skews it — and the factor graph that unifies it all. Point-to-plane registration, LIO-SAM vs FAST-LIO2, iSAM2, and degeneracy detection.
Camera, LiDAR, and radar in a self-driving stack: their complementary blind spots, the early/mid/late fusion question, PointPainting, and the Bird's-Eye-View revolution (Lift-Splat-Shoot).
When attention learns where to fuse: BEVFormer, BEVFusion, and TransFusion replace hand-designed projection with soft cross-modal attention — gracefully down-weighting a blinded or miscalibrated sensor.
The frontier: keep the Bayesian filter's structure but learn the parts you don't know. KalmanNet learns the gain, BackpropKF learns the measurement uncertainty — model-based deep learning.
The capstone skill: how to know your fusion works. NEES/NIS chi-square tests, innovation whiteness, and robust costs (Huber, DCS, switchable constraints) that catch the silent killer — overconfidence.
The ultimate map: an interactive concept graph wiring all 21 methods together, a 1960–2024 historical timeline, and the full curated reference library. One page for the whole journey.
Frames, rotation matrices SO(3), Euler angles & gimbal lock, axis-angle, quaternions, and SE(3) transforms.
Lie groups for optimizing over rotations: so(3), hat/vee, the exp & log maps, the SE(3) Jacobian, BCH, retraction.
Control: state-space stability, PID, LQR via Riccati, quadrotor dynamics, and geometric attitude control on SO(3).
Minimum-snap trajectories: smoothness as derivative minimization, the QP formulation, and differential flatness.
Pinhole projection (x=fX/Z), intrinsic matrix K, extrinsics [R|t], full pipeline P=K[R|t], back-projection, and lens distortion.
Corners vs edges, structure tensor G, Harris & Shi-Tomasi, SIFT descriptors, ratio-test matching, KLT optical flow.
Epipolar constraint, essential matrix E=[t]×R, fundamental matrix F, 8-point algorithm, 4-fold R,t ambiguity, cheirality, triangulation, scale ambiguity.
Minimal sample → fit → count inliers → keep best → refit; iteration formula N=log(1−p)/log(1−ws); threshold tradeoffs; sample sizes line=2/homography=4/E=8.
MLE → weighted LS; normal equations (ATA)x=ATb; Jacobian as sensitivity matrix; Gauss-Newton linearize-and-step; LM damping λI trust-region; covariance = (JTΩJ)−1.
SO(3)/SE(3) as curved surfaces; tangent space; retraction R·exp(δ); ⊞/⊝ operators; on-manifold GN: perturb in tangent → solve → retract; rotation averaging; singularity-free local coords.
VO pipeline: track → relative pose → chain SE(3); drift & why it compounds; monocular scale ambiguity; IMU accelerometer & gyro; bias double-integration; VIO fusion; IMU preintegration ΔR/v/p; tight vs loose coupling.
Image retrieval framing; visual vocabulary via k-means; BoW histogram; TF-IDF weighting; vocab tree + inverted index; cosine similarity ranking; geometric verification (RANSAC); precision-over-recall; perceptual aliasing; DBoW2/FAB-MAP.
Factor graph = poses + landmarks + factors; MAP → sparse NLLS; odometry, landmark, loop-closure factors; sparsity from local measurements; Hessian block pattern; sparse Cholesky & variable ordering; bundle adjustment; smoothing vs filtering; marginalization & Schur complement fill-in.
M-estimators (Huber, Cauchy, TLS), influence functions, IRLS, non-convexity & local minima, GNC annealing, switchable constraints, PCM, SE-Sync certifiability; frontiers: NeRF/Gaussian maps, learned features, semantic SLAM, multi-robot, LiDAR, event cameras; full VNAV series cheat sheet.
Where the two halves meet: differentiable filters, neural nets inside Kalman skeletons, KalmanNet's learned gain, transformers that filter in their forward pass, and FoundationStereo front-ends on factor-graph back-ends — gated by chi-squared consistency.
The whole arc — Kalman filters to robot foundation models — plus a build ladder of 8 runnable in-browser Python labs: implement a Kalman filter, EKF Jacobian, unscented transform, particle filter, pose-graph SLAM, VIO bias estimation, Q-learning vs SARSA, and a diffusion policy yourself.
On-device training: why activations explode, TinyTL bias-only, sparse backprop, gradient checkpointing, federated learning. Finale.
Distributed training: the memory wall, ring all-reduce, ZeRO stages, pipeline bubbles, tensor & 3D parallelism.
Long context: the KV crossover, position interpolation, attention sinks, StreamingLLM, H2O, INT4 KV, DuoAttention.
Parameter-efficient fine-tuning: LoRA, QLoRA with NF4, double quantization, and multi-adapter serving.
Serving LLMs: SmoothQuant, AWQ, GPTQ, W4A16, PagedAttention, continuous batching, speculative decoding.
Efficient attention: O(N²) cost, KV-cache mechanics, MQA/GQA, sparse/linear attention, RoPE, ALiBi.
TinyEngine: loop reordering, tiling, unrolling/SIMD, im2col vs direct conv, in-place depthwise, fusion, codegen.
MCUNet: the SRAM vs Flash bottleneck, TinyNAS co-design, and patch-based inference on a 256 KB MCU.
Knowledge distillation: dark knowledge, temperature, the KD loss, feature/attention matching, self-distillation.
Hardware-aware NAS: latency tables, ProxylessNAS differentiable latency, and Once-for-All progressive shrinking.
Neural architecture search: search spaces, RL & evolutionary strategies, DARTS, and weight-sharing supernets.
The edge-hardware gap and the metrics that bridge it: model size, MACs vs FLOPs, activation memory, energy, roofline.
Exact params & MACs for Linear, Conv, depthwise-separable, BatchNorm folding, and the Transformer block.
Pruning: the formal problem, granularities, importance criteria (magnitude, BN, OBD), iterative prune–finetune, 2:4 sparsity.
Lottery Ticket Hypothesis, IMP rewinding, AMC & NetAdapt, CSR encoding, EIE, and Ampere 2:4 sparse cores.
Number formats, K-means weight clustering (Deep Compression), and linear quantization r=S(q−Z) derived.
Activation quantization, calibration (min/max, percentile, KL), QAT via the STE, SmoothQuant, GPTQ, AWQ.
SP+ML overview, applications, course roadmap, full pipeline demo.
x[n], δ[n], periodicity theorem, Nyquist sampling, aliasing.
Bennett’s theorem, SQNR, 6 dB/bit rule, proof sketch.
Non-uniform, centroid/boundary conditions, 1/3 power law, NF4 for LLMs.
Linearization, subtractive dither, NVFP4, gradient accumulation.
Fourier basis, orthogonality, DFT/IDFT, FFT butterfly.
Centroid, spread, kurtosis, entropy, flatness, flux.
Windowed DFT, spectrogram, uncertainty principle, overlap-add.
NN classifier, Hilbert spaces, Parseval, template matching.
CWT, DWT filter bank, Haar, Daubechies, multi-resolution.
Denoising, JPEG2000, wavelet families, Fourier vs wavelet.
LTI, convolution theorem, eigenvectors, circulant matrices.
Log trick, mel scale, mel filter bank, MFCC pipeline.
Bayes risk, likelihood ratio, ROC curves, Neyman-Pearson.
Stationarity, autocorrelation, Gaussian classification, LDA/QDA.
J(w) criterion, scatter matrices, simultaneous diagonalization.
Maximum margin, hard/soft margin, slack variables, multi-class.
Lagrangian, KKT, primal→dual derivation, dual SVM.
Feature maps, kernel trick, RBF, Mercer, representer theorem.
Least squares, ridge, LASSO, autoregressive models, Yule-Walker.
Bayesian regression, kernel regression, Gaussian processes.
Wiener filter, LMS algorithm, noise cancellation, echo cancel.
Hidden layers, activations, backprop, universal approximation.
Convolutional layers, spectrograms+CNN, BatchNorm, ResNets.
QKV, scaled dot-product, multi-head, transformer blocks.
Signal tokenization, causal masking, GPT-style prediction.
Forward/reverse process, noise prediction, WaveGrad.
Pilanci’s reformulation, group LASSO, double descent.
VAE, nuclear norm, Robust PCA, matrix separation.
Multiplicative updates, source separation, deep MF.
K-SVD, OMP, matching pursuit, LASSO, sparse coding.
MCU vs MPU, registers & memory map, GPIO, timers, interrupts, communication protocols, software patterns.
Bitwise ops, pointers, dynamic memory, recursion, data structures, sorting, state machines, storage maps.
SPI/I²C/UART, MCU selection, sensors, wireless (BLE/WiFi/LoRa), PCB layout, firmware testing.
Software stack, clock trees, DMA, peripheral drivers, power management, optimization, IoT case study.
STM32L475 registers, ARM assembly, timer deep dive, NVIC interrupts, ISR patterns, low-power tickless.
Rate Monotonic Analysis, scheduling algorithms, FreeRTOS, semaphores/mutexes, priority inversion.
IoT stacks, MQTT, Azure IoT Hub, sensor edge computing, BLE/LoRa, security, 5G applications.
GPIO circuits, ADC/Nyquist, UART/SPI/I²C waveforms, USB enumeration, BLE GATT, RF options.
Cross-compilation, daemons/systemd, kernel modules, device drivers, device tree, kernel building.
INT8/INT4 quantization, pruning, GPTQ/AWQ, profiling, post-training vs QAT, compression pipelines.
Depthwise separable convs, MobileNet, EfficientNet, NAS, hardware co-design, mobile deployment.
KV cache, Flash/MQA/GQA attention, continuous batching, speculative decoding, TP/PP parallelism.
The complete inference stack: tokenization, prefill/decode, GPU hardware, metrics, batching, FlashAttention, speculative decoding, quantization, parallelism, production serving.
Stanford CS 229s Fall 2023. Hardware-aware algorithm design, transformer efficiency, FlashAttention, sparsity & quantization, finetuning, parallelism, efficient architectures, cluster scheduling.
CPU vs GPU, memory hierarchy, arithmetic intensity, roofline model, tiling, operator fusion.
Training FLOPs, backward pass costs, memory analysis, prefill vs decode, KV cache, speculative decoding.
Attention taxonomy, SRAM vs HBM, tiled computation, online softmax derivation, FlashAttention-2.
Pruning (structured/unstructured), INT8/INT4, PTQ, QAT, SmoothQuant, knowledge distillation.
Zero/few-shot, CoT, instruction tuning, RLHF pipeline, reward modeling, Constitutional AI, LoRA.
SFT loss, REINFORCE derivation, PPO clipped objective, reward modeling, the full RLHF loop.
Data parallelism, AllReduce, tensor parallelism, pipeline parallelism, ZeRO stages, 3D parallelism.
State space models, discretization, HiPPO, S4, Mamba selective SSMs, convolution-recurrence duality.
Job queues, FIFO/SJF, GPU cluster analysis, Gavel heterogeneity-aware scheduling, placement, fairness.
Memory layout, strides, views vs copies, broadcasting, dtypes, GPU transfer — the byte-level foundation.
Computation graphs, chain rule, backward pass, gradient accumulation, custom functions — build micrograd.
Forward → loss → backward → step. Optimizers, dataloaders, schedulers — train a network live in-browser.
Parameter registration, hooks, containers, the __call__ protocol, JIT — what happens inside model(x).
Build a full training pipeline by hand — raw tensors to MNIST classifier — then show torch.nn does the same thing.
Gaussian, Student-t, Laplace, Beta, Gamma, Exponential, Weibull, Chi-Squared, Von Mises + 5 more.
Bernoulli, Categorical, Binomial, Poisson, Geometric, Hypergeometric, Multinomial + 2 more.
MVN, Dirichlet, Wishart, Gaussian Process, Dirichlet Process, Von Mises-Fisher + 4 more.
GMM, Particle, Horseshoe, Spike-and-Slab, Gumbel, Kumaraswamy + 4 more.
Softmax/Gibbs, SO(3)/SE(3), Normalizing Flows, Copulas, Hawkes, Diffusion + 6 more.
Discrete chains tick on a clock; real systems jump whenever they like. The generator matrix, exponential clocks racing to jump, the transition function, equilibrium, and Gillespie simulation — built from zero.
A hidden state that drifts in continuous time, watched only at scattered moments — the gap between observations becomes part of the math. Forward-backward with the matrix exponential, smoothing, and continuous-time EM.
Estimation by a cloud of weighted guesses — for multimodal, nonlinear beliefs the Kalman filter can’t represent. Predict, weight, resample; Monte Carlo Localization; the curse of dimensionality.
The modern SLAM back-end: optimize the whole trajectory + map at once as a sparse least-squares problem. Smoothing vs filtering, variables & factors, Gauss-Newton, the loop closure that snaps a drifted map straight, and bundle adjustment.
One bad measurement wrecks least squares. The two great cures: down-weight outliers (M-estimators, Huber, IRLS) and vote them out (RANSAC). Influence functions, breakdown points, and the robust kernels behind every SLAM back-end and SfM pipeline.
The mother of all filters — recursive belief update from first principles.
Track a moving object through noise — the most elegant algorithm in engineering.
When the world is nonlinear — linearize with Jacobians.
Beyond linearization — sigma points capture nonlinearity directly.
Sequences with hidden causes — Forward, Viterbi, Baum-Welch.
Prior × likelihood = posterior. The foundation of all inference.
Variables with dependencies — DAGs, d-separation, message passing.
2R/6R robot arms, geometric subproblems, 3D IK solvers, singularities, workspace — heavy 3D & 2D sims.
The chicken-and-egg problem — EKF-SLAM, particle filters, graph-based.
IMU + camera fusion — preintegration, MSCKF, tightly-coupled.
Deep features, neural implicit maps, Gaussian splatting SLAM.
Learned inertial models, transformer odometry, foundation models.
Every symbol explained, every step derived. From REINFORCE to off-policy IS to KL constraints → PPO.
Learn to estimate what’s good vs bad. MC, bootstrapping, N-step returns, PPO, SAC — the complete guide.
The practical algorithms. Clipping, GAE, replay buffers, Q-functions — from theory to real robots.
Train policies without environment interaction. AWR, AWAC, IQL — data stitching, expectile regression, and implicit policy improvement.
Where do rewards come from? Goal classifiers, adversarial training, human preferences, Bradley-Terry, RLHF, and Constitutional AI.
No policy needed. Bellman optimality, target networks, double Q-learning, N-step returns — value-based RL.
Behavioral cloning, expressive policies, diffusion policies, compounding errors, DAgger — learning from demos.
Every derivation, every proof. MDPs → Policy Gradients → TRPO → PPO → SAC → DQN → Offline RL → DPO.
Learn a simulator of the world, then practice inside it. Dyna, MBPO, MPC, CEM, value-augmented planning, AlphaGo as MBRL.
One policy, many tasks. Task conditioning, goal-conditioned rewards, HER — turning failures into free training data.
Complete midterm prep: every algorithm, every equation, 36+ practice questions, interactive exam simulator, cheat sheet.
Noam Brown’s approach: search, self-play, and RL for superhuman reasoning in language models.
The post-training frontier: reward models, PPO alignment, direct preference optimization, and beyond.
Learning to learn new tasks from a handful of episodes. Black-box architectures, exploration strategies, task inference as POMDP.
Decompose long-horizon tasks into subtask hierarchies. HL/LL policies, goal representations, DAgger for hierarchy, HIRO, skill discovery.
Crossing the reality gap: domain randomization, privileged teacher–student adaptation, real2sim residuals & actuator nets, learning from human data, and the Sim2Real 1.0→4.0 map.
Pushing a vision-language-action model past the 80% imitation plateau with RL: offline-RL-as-supervised-learning, diffusion steering, and small edit policies. When the model is too big, too weird, too expensive for textbook RL.
The capstone: deep RL as a unified toolbox, the four data settings, the seven open frontiers (no reward, prior knowledge, world models, scaling, safety, errors, evaluation) — and how to actually pick problems, front-load risk, and do research.
Four eras of NLP: rule-based translation, hand-built AI, statistical methods, neural revolution. Understanding vs pattern matching.
One-hot limitations, distributional hypothesis, Word2Vec (CBOW & Skip-gram), GloVe, negative sampling, word analogies, embedding bias.
Neurons, activations, forward pass, loss functions, chain rule, backprop algorithm, gradient descent playground, practical tips.
N-grams, neural LMs, recurrent networks, BPTT, vanishing gradients, LSTM & GRU, live text generation, attention preview.
Self-attention, scaled dot-product, multi-head attention, positional encoding, encoder-decoder, build a Transformer piece by piece.
Debugging, hyperparameter tuning, regularization, training diagnostics dashboard, evaluation & error analysis.
BERT vs GPT paradigms, masked LM, autoregressive LM, data pipelines, scaling laws, Chinchilla, Llama 3 architecture.
SFT, reward modeling, PPO with KL constraint, DPO, alignment data, evaluation, safety guardrails.
In-context learning, prompt engineering, chain-of-thought, lottery tickets, adapters, LoRA, PEFT playground.
Retrieval-augmented generation, dense retrieval, ReAct reasoning loops, Toolformer, agent simulator.
MMLU, HELM, LLM-as-judge, benchmark explorer dashboard, data contamination, metric saturation.
Chain-of-thought, self-consistency, zero-shot CoT, process rewards, DeepSeek-R1, GRPO & DAPO.
Process reward models, best-of-N, speculative decoding, RoPE, context extension, test-time compute scaling.
BPE, WordPiece, SentencePiece, multilingual fertility, XLM-R cross-lingual transfer, tokenizer explorer.
Linear probes, attention visualization, sparse autoencoders, agentic interpretability, concept discovery.
Bias, toxicity, misinformation, privacy, environmental cost, governance & policy.
Vision encoders, early/late fusion, Chameleon, Transfusion, scaling mixed-modal, retrieval-augmented multimodal.
When LoRA fails, regularization in PEFT, merging adapters, QLoRA, DoRA, future of adaptation.
Reasoning, grounding, efficiency, safety, multimodal frontier, interactive research map.
Why graphs? Node/edge/graph-level tasks. AlphaFold, PinSage, drug interactions, antibiotic discovery.
Encoder-decoder framework, DeepWalk, node2vec (biased walks with p,q), negative sampling, matrix factorization view.
Message passing, computation graphs, GCN (mean aggregation), GNNs generalize CNNs, transformers as GNNs.
Message + aggregation framework. GCN vs GraphSAGE vs GAT. Multi-head attention. Skip connections, over-smoothing.
Feature/structure augmentation, virtual nodes, neighbor sampling, prediction heads, loss functions, dataset splitting.
How powerful are GNNs? WL test, multiset injectivity, why GCN/GraphSAGE fail, GIN achieves maximum expressiveness.
Beyond WL: Laplacian eigenvectors, structural features, position-aware GNNs, anchor sets, higher-order k-WL.
Self-attention on graphs, positional encodings (Laplacian, random walk), Graphormer, GPS hybrid architecture.
Multiple node/edge types. RGCN (relation-specific weights), basis decomposition, HGT, metapaths.
TransE, TransR, DistMult, ComplEx, RotatE. Relation patterns: symmetry, composition, 1-to-N. KG completion.
Bipartite graphs, NGCF, LightGCN, BPR loss, PinSage scalability, cold start, GNN vs LLM.
Databases ARE graphs. Foreign keys as edges, GNNs on relational data, RelBench, vs XGBoost.
Temporal message passing, multi-hop aggregation, Griffin universal encoder, schema-specific vs universal.
Graph foundation models, pre-training, explainability, equivariant GNNs, dynamic graphs, practical tips.
Inductive KG reasoning, ULTRA, cross-schema transfer, foundation models for knowledge graphs.
LLMs as feature encoders, GNNs as structure encoders, joint pipelines, graph-augmented LLMs.
ReAct, Reflexion, graph-grounded agents traversing KGs step by step. Tool use, PPO/DPO optimization, STaRK benchmarks.
GraphRNN two-RNN sequential generation, GCPN RL-guided design, JT-VAE motifs, diffusion on graphs, molecular benchmarks.
Full arc from node embeddings to graph foundation models. Open problems, research frontiers, practical advice for GNN practitioners.
k-NN, L1/L2 distance, hyperparameter tuning, cross-validation.
Score function Wx+b, hinge loss, cross-entropy, regularization.
MSE, cross-entropy, KL divergence, Huber, contrastive, triplet, InfoNCE — every loss derived from scratch with interactive comparisons.
Gradients, SGD, chain rule, computation graphs, gate patterns.
Neurons, activation functions, layers, representational power.
Data preprocessing, weight init, batch norm, dropout.
Loss curves, learning rates, momentum, Adam, hyperparameter search.
Build a 2-layer net from scratch. Live training visualization.
Convolution, filters, pooling, LeNet to ResNet.
Feature extraction vs fine-tuning, freezing layers.
RNNs, LSTM, BPTT, vanishing gradients, char-level LM.
Perception-action loop, model-based planning, imitation learning, diffusion policies, VLAs & foundation models.
CLIP, LLaVA, Flamingo, Molmo, SAM — contrastive learning, VLMs, promptable segmentation, model chaining.
Point clouds, meshes, SDFs, PointNet, NeRF, 3D Gaussian Splatting — from representations to neural rendering.
L1/L2, cross-entropy, SGD, momentum, Adam, learning rate schedules, weight initialization.
Computational graphs, chain rule, gate patterns, Jacobians — backprop from first principles.
Convolution operation, stride, padding, pooling, receptive field, depthwise separable convolutions.
Data augmentation, batch norm, dropout, AlexNet → VGG → ResNet → EfficientNet → ConvNeXt.
Vanilla RNN, BPTT, vanishing gradients, LSTM gates, GRU, char-level LM, image captioning.
Bahdanau attention, self-attention, multi-head, transformer blocks, positional encoding, ViT.
FCN, U-Net, R-CNN family, YOLO, Mask R-CNN, GradCAM, adversarial examples.
Naming the whole place, not the parts: Places365, holistic context, CNN→ViT→InternImage, top-1 vs top-5.
Hearing the place from the soundscape: log-mel spectrograms, device mismatch, tiny edge models, PaSST distillation.
Conv locality + attention globality on a phone: MobileViT, FastViT reparameterization, EfficientViT, the latency-accuracy Pareto.
Land-use from orbit: multispectral tiles, NDVI, SatMAE/SpectralGPT foundation models, and the multi-label sigmoid shift.
Indoor scenes with depth: SUN RGB-D, why geometry disambiguates layout, two-stream RGB+depth fusion.
How accuracy scales with params, data, compute: power laws, ViT-G, compute-optimal, the label-noise ceiling.
Vision on a phone: depthwise-separable conv, inverted residuals, SE, compound scaling, hardware-aware NAS.
Classic ASR: HMM sequences, GMM→DNN emissions, the posterior/prior trick, Viterbi forced alignment.
Kill the flicker: linear-chain CRF, Viterbi, HSMM durations, smoothing frame-level predictions into stable segments.
Two-branch scenes: a holistic CNN fused with an object-relation GNN — the recipe that broke 90% on Indoor67.
Two-stream networks, 3D convolutions, I3D, SlowFast, TSM, video transformers, VideoMAE.
Single-frame to SlowFast to video transformers. Two-stream, 3D conv, skeleton-based, temporal detection.
Brightness constancy, Lucas-Kanade, Horn-Schunck, FlowNet, RAFT. Dense motion estimation from zero.
GPU hardware, data/pipeline/tensor parallelism, FSDP, ring all-reduce, 3D parallelism — training at scale.
Pretext tasks, MAE, InfoNCE, SimCLR, MoCo, CPC, DINO — learning without labels.
Density functions, MLE, autoregressive models, PixelCNN, autoencoders, VAEs — the full ELBO derivation.
GANs, rectified flow, classifier-free guidance, latent diffusion, DiT, text-to-image & video generation.
Research-backed system design lessons. Real architectures, real numbers, real tradeoffs — with interactive Canvas simulations that trace requests, visualize scale, and simulate failures.
Practical distributed systems engineering — networking, consensus, CRDTs, transactions, caching, load balancing, resiliency patterns, observability, and deployment. Interview-grade depth with interactive simulations.
TCP, TLS, flow control, congestion control, QUIC — the networking layer.
DNS, REST APIs, gRPC, idempotency — how services find and talk to each other.
Failure detection, physical/logical/vector clocks, HLC — time in distributed systems.
Raft, state machine replication, consistency models, chain replication.
CRDTs, gossip protocols, Dynamo, CALM theorem, causal consistency.
ACID, isolation levels, 2PC, sagas, outbox pattern.
HTTP caching, reverse proxies, CDN architecture, cache invalidation.
Range/hash partitioning, consistent hashing, blob storage.
DNS, L4, L7 load balancing — distributing traffic across servers.
Replication, NoSQL taxonomy, caching patterns, eviction policies.
Microservices, API gateways, service mesh, control/data planes.
Message queues, pub/sub, Kafka, exactly-once, backpressure.
Cascading failures, redundancy, shuffle sharding, cellular architecture.
Timeouts, retries, circuit breakers, rate limiting, load shedding.
Test pyramid, chaos engineering, CI/CD, canary deploys, rollbacks.
Metrics, SLIs/SLOs, alerting, logs, distributed tracing, dashboards.
Deep interactive lessons from foundational distributed systems papers. Every definition derived, every algorithm implemented, every proof traced.
Chapter-by-chapter deep dive into the classic algorithms textbook. Each chapter is a standalone interactive lesson with interview-grade depth, Canvas simulations, coding drills, and mastery challenges.
Insertion sort, merge sort, algorithm analysis — the foundations of algorithmic thinking.
Big-O, Omega, Theta — the language of algorithm efficiency.
Max subarray, Strassen, Master theorem — breaking problems into pieces.
Binary heaps, heapsort, priority queues — scheduling and selection.
Partition, randomize, conquer — the fastest practical sorting algorithm.
Counting sort, radix sort, bucket sort — breaking the O(n log n) barrier.
Hashing, chaining, open addressing, perfect hashing — O(1) lookup.
Search, insert, delete, traverse — ordered data made fast.
Self-balancing BSTs — guaranteed O(log n) with coloring rules.
Rod cutting, LCS, edit distance, knapsack — the paradigm that dominates interviews.
Activity selection, Huffman, fractional knapsack — locally optimal = globally optimal.
Aggregate, accounting, potential — the true cost of operation sequences.
BFS, DFS, topological sort, SCCs — the foundation of every graph question.
Kruskal, Prim, Union-Find — connecting everything at minimum cost.
Dijkstra, Bellman-Ford, DAG shortest paths — optimal routes through graphs.
Ford-Fulkerson, max-flow min-cut, bipartite matching — optimizing network flow.
Quickselect, median of medians — finding the k-th element in linear time.
Disk-optimized search trees — billions of keys with just 2-3 disk reads.
Amortized O(1) decrease-key — the theoretical champion for graph algorithms.
O(log log u) predecessor queries — when the universe is your friend.
Union-Find — nearly O(1) connected component queries with path compression.
Floyd-Warshall, Johnson's — shortest paths between every pair of vertices.
Fork-join, work/span, parallel merge sort — harnessing multiple cores.
LU decomposition, least squares, Cholesky — the linear algebra engine.
Simplex, duality, LP reductions — the universal optimization framework.
DFT, FFT, convolution — O(n log n) polynomial multiplication.
GCD, modular arithmetic, RSA, primality — the math behind cryptography.
KMP, Rabin-Karp, finite automata — finding patterns in text efficiently.
Convex hull, closest pair, line intersection — algorithms in 2D space.
P vs NP, reductions, SAT, TSP — the limits of efficient computation.
Vertex cover, TSP, set cover — good-enough solutions with guarantees.
Databases, ML, compilers, networking, crypto, graphics — where every CLRS chapter shows up.
Chapter-by-chapter deep dive into Martin Kleppmann's DDIA. Each chapter is a standalone interactive lesson with interview-grade depth, Canvas simulations, design challenges, debug scenarios, and mastery components.
Reliability, scalability, maintainability — the vocabulary of systems design interviews.
SLAs, percentiles, capacity planning, load testing — quantifying system quality.
Relational, document, graph — choosing how to structure and query your data.
B-trees, LSM-trees, column stores — how databases actually store and find your data.
JSON, Protobuf, Avro, schema evolution — how data survives change.
Leader-follower, multi-leader, leaderless — keeping copies consistent across machines.
Hash partitioning, range partitioning, rebalancing — splitting data across machines.
ACID, isolation levels, MVCC, serializability — the guarantees that keep your data correct.
Network faults, clock drift, process pauses — everything that can go wrong, will.
Linearizability, Raft, Paxos — how distributed nodes agree on the truth.
MapReduce, Spark, dataflow engines — processing massive datasets efficiently.
Kafka, Flink, event sourcing, windowing — processing data as it arrives.
Streaming philosophy, bias, privacy, responsibility — the human side of data systems.
Tokenization, FLOP/memory accounting, architecture, MoE, GPUs, parallelism, scaling laws, inference, alignment — derive every number.
MACs, pruning, INT8/K-means quantization, NAS, distillation, MCUNet SRAM, KV-cache, LoRA/QLoRA — squeeze models onto tiny hardware.
SE(3), camera projection, features, epipolar geometry, RANSAC, Gauss-Newton, manifold retraction, VIO drift, BoW, robust SLAM.
54 hands-on exercises covering scaling laws, chinchilla, compute-optimal training, loss prediction, data mixing, emergent abilities.
52 exercises across 5 modes: derive, trace, build, design, debug. Parameter counts, attention FLOPs, memory budgets, KV caches, throughput estimation.
Chain rule by hand, gradient shapes, cross-entropy, Adam optimizer, batch norm, learning rate schedules, mixed precision, training diagnostics.
Bayes rule, distributions, MLE, MAP estimation, Kalman filter math, HMM forward/Viterbi, information theory, sensor fusion.
Bellman equations, value iteration, Q-learning updates, policy gradients, advantage estimation, PPO clipping, exploration strategies.
Forward process, noise schedules, DDPM loss, score functions, sampling, classifier-free guidance, latent diffusion, flow matching, ODE/SDE.
Tensor/pipeline/data parallelism, continuous batching, PagedAttention, speculative decoding, quantization, cost optimization.
Rotation matrices, homogeneous transforms, EKF predict/update, SLAM graphs, inverse kinematics, Jacobians, PID control.
Implement softmax, linear layers, attention, layer norm, positional encoding, BPE tokenizer, cross-entropy, Adam, KV cache, sampling.
Asymptotic analysis, recurrences, sorting, hash tables, BSTs, dynamic programming, greedy, graph algorithms, shortest paths, MST.
Multi-dimensional KF, EKF Jacobians, range-bearing updates, UKF sigma points, particle filters, sensor fusion, observability, noise tuning.
EKF-SLAM, landmark observation, data association, loop closure, graph SLAM, visual odometry, RANSAC, factor graphs, occupancy grids.
Graph basics, node embeddings, GCN/SAGE/GAT, over-smoothing, spectral theory, knowledge graphs, link prediction, graph generation.
Word vectors, Word2Vec gradients, dependency parsing, perplexity, attention, subword tokenization, pretraining, PEFT, evaluation metrics.
Discrete signals, DFT by hand, quantization, Lloyd-Max, STFT, wavelets, MFCC pipeline, Bayes classifiers, SVM margins.
Ring AllReduce, ZeRO stages, gradient accumulation, LR scaling, pipeline parallelism, tensor parallelism, checkpointing, mixed precision.
Convolution math, receptive fields, pooling, anchors/IoU, NMS, ResNet, segmentation, stereo vision, homography.
Matrix operations, Gaussian elimination, eigenvalues, SVD, PCA, matrix calculus, least squares, norms, positive definiteness.
Floating point, catastrophic cancellation, condition numbers, iterative methods, Newton's method, gradient descent, integration, sparse matrices.
Entropy, joint/conditional entropy, KL divergence, cross-entropy loss, source coding, channel capacity, rate-distortion, VAE connection.
Convexity, gradient descent, SGD variants, constrained optimization, KKT conditions, duality, proximal operators, convergence rates, Newton's method.
Reward modeling, RLHF objective, PPO for RLHF, DPO loss, CQL, IQL, model-based RL, reward shaping, multi-agent RL.
Mode collapse, flow matching arithmetic, REINFORCE credit assignment, actor-critic n-step returns, Q-learning TD targets, offline RL, IQL expectile loss, goal-conditioned RL.
Bayesian networks, Dirichlet inference, value of information, Bellman backups, kernel smoothing, MCTS/UCB1, policy gradients, POMDPs, alpha vectors.
Quantization (PTQ, QAT, STE), pruning (magnitude, structured, lottery ticket), knowledge distillation, LoRA, mixed precision, compression pipelines.
Deep-dive lessons built around real engineering roles. Classical foundations, modern tools, real papers, interactive sims. Built for interview prep with real depth.
Customer discovery, rapid prototyping, production deployment at customer sites, SDK integration, debugging in customer environments, demo engineering, incident response.
RAG architecture, agent design, fine-tuning, prompt engineering, evaluation, streaming, production AI infrastructure, safety & guardrails.
Information retrieval, dense embeddings, learning to rank, recommendation systems, serving a web index, the convergence of search + recs + transformers.
API design, request lifecycle, database optimization, caching, rate limiting, auth, observability, scaling patterns, developer experience.
GPU clusters, LLM serving, distributed systems, cost optimization, reliability engineering, CI/CD, monitoring — keeping AI systems running at scale.
Docs, SDKs, community, content strategy, conference talks, launches, feedback loops, measuring impact — with AI company DevRel woven throughout.
Experiment-driven sprints, eval-based acceptance criteria, data pipeline management, research-to-production handoffs, agentic AI project management.
DVA model testing, sim-to-real validation, safety compliance, CI/CD for robotics, 20 interview questions + cheat sheet.
Camera models, epipolar geometry, SfM, bundle adjustment, SLAM, dense reconstruction, point tracking, DUSt3R/VGGT — the full stack for robotics perception.
GPU architecture, profiling, mixed precision, distributed training, model compression, TensorRT, serving at scale, real-time autonomous driving stacks.
Physics simulation, contact models, MuJoCo/Isaac Sim, kinematics, motion planning, control, sim-to-real, RL, ROS2 — the full robotics stack.
Quantization, CUDA kernels, TensorRT, FlashAttention, KV-cache, distributed training, BEV perception, edge deployment, VLA — the full AV inference stack.
Test design, automation, reliability engineering, incident response, safety-critical testing, debugging, observability — onsite interview prep for robotics QE.
Agent SDK, RAG, evaluation, data pipelines, inference serving, monitoring, security, distributed systems — the full agentic AI platform stack.
Pre-training, RLHF, evals, safety, scaling laws, infra, on-call, paper reading, experiment tracking — what a frontier lab researcher actually does.
The practical toolkit for building with AI models. Embeddings, retrieval, RAG, agents, evals, safety — everything between "I have a model" and "I have a production app."
What embeddings are, how they encode meaning, distance in high-D space, embedding models, multimodal embeddings.
Cosine, dot product, Euclidean, Jaccard, learned metrics — measuring "how alike" in vector space.
FAISS, HNSW, IVF, product quantization — storing and searching millions of vectors in milliseconds.
Fixed, sentence, recursive, semantic, structure-aware — how to split documents for embedding and retrieval.
The full pipeline: chunk → embed → store → retrieve → rerank → generate. Eval, failure modes, advanced patterns.
Images, tables, PDFs in RAG. Vision embeddings, ColPali, document parsing, hybrid retrieval.
USB-C for AI: tools, resources, prompts. Build MCP servers and clients. The standard for AI integrations.
System prompts, few-shot, chain-of-thought, structured output, testing — systematic, not vibes-based.
LLM-as-judge, human eval, automated metrics, regression detection, A/B testing for AI systems.
Content filtering, jailbreak prevention, PII detection, output validation, red teaming, defense in depth.
When to fine-tune vs prompt, data prep, LoRA/QLoRA, eval pipelines, deployment, cost analysis.
Function calling, ReAct, multi-step agents, state management, error recovery, guardrails for agents.
Teach Claude a workflow in a folder of Markdown: SKILL.md, progressive disclosure, triggering descriptions, the five patterns. Build one live.
Single agents to multi-agent orchestration: the workflow-vs-agent divide, sequential/parallel/evaluator patterns, hierarchical vs swarm, and an interactive chooser for picking the right one.
The adoption playbook behind the systems you build — coalition, governance, pilot selection, metrics, scaling, and a readiness calculator. Engineer's lens, real case studies (L'Oréal, Shopify, Lotte).
Most music AI assumes a piano. How DDSP serves Thai 7-tone tunings, Carnatic meend, and the Guqin — model vs dataset bias, and when not to ship a model at all.
The four-stage startup lifecycle — Idea, MVP, Launch, Scale — read line by line. Interactive exit criteria, the Sean Ellis test, TAM/SAM/SOM and CAC/LTV calculators, the data-flywheel moat, and when to reach for Chat vs Cowork vs Code.
The fourth layer above the harness: stop prompting the agent, design the system that prompts it. The five moves of one turn, the six parts, the generator/evaluator "say no", the five failure modes, and the four silent costs.
The system around the model — three design patterns, a coding agent's tool belt, and why the deployment layer rivals raw intelligence.
From prompts to optimizer code: ACE playbooks, MCE bi-level skill evolution, Meta-Harness Pareto search, ADAS, and AFlow's MCTS.
STOP's improver improving itself, AlphaEvolve, the Darwin Gödel Machine, SIA — and seven bottlenecks on the road to RSI.
Record yourself teaching on a whiteboard with optional camera. Export as MP4. The ultimate Feynman test: if you can teach it, you understand it.