AI lessons & courses
214 lessons · 56 learning paths · free, quiz-checked, no signup required
How modern AI systems actually work, from the transformer architecture and attention up through retrieval, agents, evaluation, and deployment. The lessons are mechanism-first: what the math does, what the engineering trade-offs are, and where the published evidence stands. Written for engineers and technical leaders who want depth beyond the headlines.
Learning paths
Deep Learning on Limit Order Book Data
At a one-event horizon, 92 percent of mid-price labels are exactly no-change, so a model that always predicts flat scores 92 percent accuracy. That single number explains most of the gap between published order book results and what happens on a trading desk. This path covers what the book actually contains, what the architectures assume, why results fail to replicate, and the cost hurdle that decides whether a real edge is worth anything.
Reinforcement Learning for Trade Execution and Market Making
A classical execution schedule is an open-loop policy: it commits to a plan before seeing anything, and reinforcement learning's entire value here is closing that loop. This path measures what closing it is actually worth, shows how a mis-sized penalty makes leaving part of the order unexecuted rationally optimal, and demonstrates that one unverifiable queue assumption moves the simulated fill rate by a factor of two. Every figure is computed.
Financial Machine Learning: Building a Dataset That Does Not Lie
Shuffled cross-validation reports 54 percent accuracy on market data containing no signal whatsoever, and that number is why competent machine learning so often fails on markets. This path fixes the dataset rather than the model: labels that describe trades someone would actually place, features that are stationary without being amnesiac, and a validation scheme that returns chance when there is nothing there. Every figure in it is computed and reproducible.
AWS Bedrock and AgentCore: Agents as Managed Infrastructure
Running one agent is a while-loop around a model call. Running hundreds, for real users, with real credentials and real consequences, is infrastructure. This path covers what AWS provides at each layer: Bedrock's one door to many models, the runtime that isolates every session, the gateway that turns your existing APIs into agent tools, and the memory, identity and tracing that decide whether an agent survives production.
Recommender Systems: The Two-Stage Machine
No model ranks the whole catalogue: a cheap retrieval stage cuts millions of items to hundreds, an expensive ranker orders those hundreds, and the trap nobody warns you about is that the model trains on clicks it caused. This path builds the architecture, the two-tower geometry of taste, the objective functions that encode what a product values, and the feedback loops and exploration budgets that decide what the system becomes.
MLOps: Keeping a Model Working After You Ship It
Training a model is the part that works. The system around it is what decays, and it decays quietly: no exception, no alert, just answers that are slowly less right. This path covers what actually breaks. Why changing one feature moves every weight, the three levels of automation and which one you need, the skew between training and serving that no isolated test can see, and the monitoring that decides when a model has stopped earning its place.
FiftyOne: Curating Computer Vision Datasets You Can Actually See
Most vision projects are limited by their dataset rather than their architecture, and most teams cannot see their dataset. A hundred thousand images in a folder is not something you can inspect, so problems that would be obvious in ten minutes of looking go unfound for months. This path covers the tool built for that: the data model that makes a dataset queryable, views as chained questions, the analysis methods that rank where to look, and evaluation that turns a metric back into the images behind it.
How Voice Models Work: Tokens, Recognition, and Synthesis
One minute of talking is about 195 tokens as text and about 36,000 as audio. That ratio explains almost every design decision in speech systems, and this path starts there. How neural codecs turn a waveform into something a transformer can model, why speech recognition has three architectures rather than one and which of them can stream, how treating audio as tokens made cloning a voice from three seconds possible, and what the standard speech-to-text-to-speech pipeline throws away that it can never get back.
The Illusion of Thinking, and the Rebuttal That Followed
Apple researchers ran a careful experiment on whether reasoning models reason, found accuracy collapsing to zero past a complexity threshold, and the result travelled fast. Then a response appeared that disputed none of the data and argued the experiment measured something else: models were being asked to print answers longer than their output limits, some puzzles had no solution at all, and asking for a program instead of a move list restored accuracy on the same instances. This short path follows both, and ends with the rules for measuring anything.
A Definition of AGI: What Happens When You Actually Try to Measure It
AGI anchors company charters, national policy and enormous investment, and until recently nobody had an operational definition of it. A 2025 paper with more than thirty authors proposes one, by borrowing the framework psychology spent a century validating and scoring machines against all ten of its cognitive domains. The totals make headlines. The profile is more interesting: current systems are at full marks on some domains and at exactly zero on the ability to form a new long-term memory.
The Era of Experience: Reading Silver and Sutton's Argument
The man who wrote the textbook on reinforcement learning and the man who led AlphaGo published a short paper arguing the field has taken a wrong turn. Training on human data, they say, makes human performance the target by construction, and the next capability jump requires agents that learn from what actually happens instead. This short path takes the argument seriously: the three eras, the four things an experiential agent would do differently, and the published critique that its answer to safety does not yet work.
FlashAttention and the Art of Finding the Real Bottleneck
For five years attention was optimised by cutting FLOPs, and the faster algorithms kept not being faster. They were solving the wrong problem: attention spends its time moving a matrix between GPU memory tiers, not computing. This path follows the diagnosis and the fix, from the memory hierarchy through the rescaling identity that lets softmax be tiled, to writing fused kernels yourself, and ends where the same signature shows up next: normalisation, the optimizer step, and the logits tensor nobody thinks about.
Beyond Attention: Linear Attention, State Space Models, and Hybrids
At a million tokens a transformer's KV cache is 344 GB. A recurrent state doing the same job is 16.8 MB, and constant at any length. This path explains how that is possible and what it costs. Delete the softmax and attention becomes a recurrent network you can still train in parallel. Start instead from control theory and you arrive at the same object, which is the result Mamba-2 made precise. Then the honest part: a fixed state has fixed capacity, exact retrieval is what breaks first, and a few attention layers buy most of it back.
Synthetic Training Data: Generating It Without Poisoning the Model
Generating 50,000 training examples costs roughly a thousandth of annotating them, and cheapness is the least interesting thing about it. What decides whether the result works is a set of properties nobody notices until the model is trained: whether the generator holds the information at all, whether a checker can lift the ceiling above it, whether the dataset covers its input space or repeats one example, and whether the real data ever leaves the mix. This path builds the pipeline that survives all four.
Constrained Decoding: Output That Always Parses
A 5 percent JSON failure rate does not double your average latency, it doubles your p95. Constrained decoding removes the failure entirely by editing the logits before sampling, so invalid tokens have probability exactly zero. This path builds the mechanism from the decoding loop outward: how a schema compiles into an automaton and then into a per-token mask, why recursive grammars need a stack and how that cost is made near-free, and the part most teams get wrong, that a badly ordered schema constrains the reasoning as well as the output.
Distributed Training at Scale: FSDP, Tensor and Pipeline Parallelism
Mixed-precision Adam costs 16 bytes per parameter, so a 70B model needs 1120 GB of state before a single activation is stored. Getting that onto real hardware, and keeping the run alive while a component fails every three hours, is the skill behind every frontier model. This path builds it: where the memory actually goes, how ZeRO and FSDP shard what data parallelism duplicates, how tensor and pipeline parallelism split the computation itself, and what makes a fifty-day run finish.
Quantizing LLMs: From 16 Bits to 4 Without Breaking the Model
A 70B model is 140 GB at 16 bits and fits on no single accelerator. At 4 bits it is 36 GB, runs about four times faster per token, and leaves most of the card free for KV cache. Getting there without wrecking the model is a specific, teachable skill. This path builds it from the arithmetic up: what quantization does to a number, why large transformers grow activation outliers that break naive methods, how GPTQ and AWQ use calibration data, and how to measure the damage honestly before you ship.
LLMs in Trading: What the Evidence Actually Supports
Language models are poor at the job they are advertised for and genuinely good at one nobody mentions: turning unstructured text into structured data at a scale that was never affordable. This path locates them against the trading stack, then confronts the defect that makes almost every published result hard to read, since a model trained on the backtest period may already know what happened and uses that knowledge even when told not to. It reads the leading study qualifier by qualifier, and ends with the engineering and governance that survive an audit.
Causal Inference: From Correlation to Consequence
Every model whose output drives a decision is answering a causal question, whatever it was trained on. This path builds the machinery that makes those questions answerable: structural causal models and the three ways variables become associated, the identification results that say exactly when observational data suffices and by what formula, the hard limit on learning a graph from data, and where invariance across environments turns causal structure into a training signal.
Federated and Decentralized Learning
Hospitals, phones and banks hold the data that would train the best models, and none of them are allowed to share it. This path builds the field that trains on data you never see: the FedAvg round structure and why local steps are the communication lever, the client drift that heterogeneous data causes and the control variates that correct it, gossip protocols that remove the server entirely and the spectral gap that governs them, and what model updates actually leak once someone attacks them.
Easy, Hard, Impossible: Phase Transitions in Learning
When your model fails, are you short of data or short of computation? Those look identical from the outside and have completely different fixes. This path builds the statistical physics of computation, the field that made the distinction precise: planted models and the high-dimensional limit, the three-phase structure where information can be present while every efficient algorithm fails, the message-passing algorithms that reach the computational limit and predict their own error exactly, and what genuinely transfers to deep learning.
Mechanistic Interpretability: Reverse-Engineering Neural Networks
Attribution methods tell you which inputs mattered. Mechanistic interpretability asks the harder question: what algorithm is the network actually running? This path builds the field from its foundations, why individual neurons are the wrong unit and what superposition says is really happening, through the circuits that implement in-context learning, the sparse autoencoders that pulled 34 million features out of a production model, and the causal interventions that separate a tested claim from a plausible story.
Diffusion Language Models in Depth
A technical deep dive for anyone who already knows that diffusion language models generate text by iterative unmasking and wants to know how they are actually built. This path covers the formal machinery: categorical transition matrices and the variational bound that reduces to weighted masked language modelling, the from-scratch and checkpoint-adaptation training routes that carried the paradigm to 8 billion parameters, the approximate caching and confidence-aware decoding that finally made serving competitive, and the multimodal, safety, and evaluation problems that remain open.
Submodular Optimization: Diminishing Returns with Guarantees
Choosing the best subset under a budget is usually intractable, unless the objective has diminishing returns. That property is submodularity, and it turns hard selection problems into ones a simple greedy algorithm solves near-optimally. This path builds it from the definition and its convexity analogy, through the celebrated (1 - 1/e) guarantee of Nemhauser, Wolsey, and Fisher, to sensor placement, influence maximization, and summarization, and finally the wider landscape of minimization and non-monotone problems.
Computational Linguistics: The Formal Science of Language
How much computational power does human language actually require, and what can a neural network trained on it really compute? This path answers both with one tool. It builds the levels of linguistic structure and why language resists naive modelling, the Chomsky hierarchy that classifies grammar power, the finite-state methods that make morphology a solved problem, and the modern results placing RNNs and transformers on that same ladder. Grounded in the landmark results of Chomsky, Shieber, and the formal theory of language models.
Bayesian Optimization: Tuning Expensive Black-Box Functions
Some functions cost hours or dollars to evaluate once and give no gradient, so you must find their optimum in as few tries as possible. This path builds the standard method for that: why grid and random search waste the budget, how a Gaussian process predicts the objective and its uncertainty everywhere, how acquisition functions like Expected Improvement and the no-regret GP-UCB of Srinivas, Krause, Kakade, and Seeger decide where to look next, and how the tools work in practice. Grounded in the landmark papers of the field.
Fine-Tuning versus RAG: A Decision Framework
They are usually presented as alternatives when they change different things: fine-tuning adjusts behaviour, retrieval supplies knowledge. This cursus makes the choice properly. Why fine-tuning is a poor way to add facts, what it is genuinely good at, and the three questions that settle the matter on their own. Then what building each involves, from LoRA and the training-data problem that stalls most projects to the retrieval pipeline. Then the options the framing hides, long context, prompt caching, agentic retrieval, and how to revisit a decision that has expired.
Vector Databases in Depth
Exact nearest neighbour search is intractable at scale and k-d trees collapse above a couple of dozen dimensions, so every production system trades recall for speed. This cursus covers that trade properly. Why the classical indexes fail and how to measure recall against brute-force ground truth. Then HNSW as a navigable small-world graph, IVF as partition-and-probe, and the quantization schemes that decide your infrastructure bill. Then hybrid search, a tuning method that starts from a stated target, capacity planning, and the operational failures no benchmark shows.
Bias Detection and Fairness Testing
Fairness has several formal definitions that sound equally reasonable, and Chouldechova and Kleinberg proved you cannot satisfy them all at once. This cursus is the hands-on version. Separating the three meanings of bias, tracing the six points where disparity enters, and why removing a protected attribute hides the problem rather than fixing it. Then the metrics, the impossibility result, and choosing a criterion by asking which error harms the person more. Then running an audit that produces a documented, accepted trade-off rather than a claim to have removed bias.
Hallucinations: Detection, Grounding, and Abstention
A model trained to predict the next token has nothing in its objective that represents truth, so a fabricated citation is a plausible continuation rather than a malfunction. This cursus covers what follows: the taxonomy that tells you whether a failure is a generation or a corpus problem, why fluency carries no signal and why self-review does not work, grounding and the detection methods that compare output against something external, and abstention, including calibration, the coverage-accuracy trade, and building a system that can say it does not know.
LLM Guardrails and Red-Teaming
A language model receives instructions and data through one channel and cannot reliably tell them apart, which is why prompt injection has no equivalent of the parameterised query. This cursus builds the defence that follows from that fact: the threat model, from the OWASP Top 10 through indirect injection and the lethal trifecta; the control layer, with its five rail types, the false-positive budget that kills deployments, and why architectural containment beats filtering; and red-teaming that produces findings rather than reassurance.
Explainable AI: Making Model Decisions Accountable
A model that predicts well can still be impossible to justify, and "the algorithm decided" is not an answer to a rejected applicant, a clinician, or an auditor. This cursus builds the field from the mechanism up: the taxonomy and the global tools (permutation importance, partial dependence, ICE), then local attribution with LIME and SHAP including the Shapley axioms that make SHAP unique, then Integrated Gradients, Grad-CAM, and counterfactual explanations. It ends with the harder question: explanations can fail silently or be deliberately faked, so how do you check yours?
Energy-Based Models: One Lens for Machine Learning
Energy-based models replace input-to-output functions with a scalar energy that scores how compatible a configuration is, the framework Yann LeCun has advocated for decades. This cursus builds it: the energy landscape and inference as finding the lowest-energy answer, how to train one when the partition function is intractable (contrastive divergence, noise-contrastive estimation, score matching, and regularized methods), and the unifying view in which classification, self-supervised learning, JEPA, and diffusion all become one idea.
Self-Supervised Learning: How Machines Learn Without Labels
Labels are the bottleneck of deep learning, and self-supervised learning is how models learn from unlabeled data instead, the approach Yann LeCun calls the dark matter of intelligence. This cursus builds it from the ground up: pretext tasks and the shift to joint embeddings, the collapse problem that lurks underneath, contrastive methods that fix it with negatives (SimCLR, MoCo), and the negative-free families that fix it without them (BYOL, SimSiam, VICReg, Barlow Twins, MAE), with the through-line to JEPA and the energy-based view.
JEPA: Learning by Predicting Representations
Most self-supervised models either reconstruct pixels, wasting capacity on detail nobody can predict, or contrast augmented views, baking in hand-crafted bias. JEPA takes a third path: predict the representation of what is hidden, so the model can discard the unpredictable. This cursus builds it from the ground up: why predicting representations beats predicting pixels, then the machine itself, encoders, predictors, and the collapse problem that asymmetry and stop-gradients defeat, and finally I-JEPA and V-JEPA 2, where the idea becomes a world model that plans a robot's actions.
AI for Students: Study Smarter Without Cheating
AI can be the best study partner you have ever had, or a shortcut that quietly stops you from learning. This cursus shows you the difference. Learn the mindset that separates using AI to learn from using it to outsource thinking, the concrete study techniques that turn AI into a personal tutor, explaining, quizzing, and feedback, and how to use AI honestly so that the honest path and the path that actually makes you smarter turn out to be the same one.
AI for Teachers: Save Time and Teach AI Literacy
A practical guide for educators to reclaim time with AI without losing what makes teaching human. Learn the categories of teaching AI tools and their caveats, how to generate lesson plans, materials, differentiation, and feedback with the right prompts and review, and how to teach in a world where students have AI too: why detectors fail, how to design meaningful assessment, and how to teach AI literacy while protecting privacy and equity.
Voice AI Agents: How They Actually Work
Voice AI agents you can call and talk to like a person are quietly reshaping customer service and phone support, and they are more clever engineering than magic. This cursus explains how they really work: the streaming speech-to-text, LLM, and text-to-speech pipeline and why latency is everything, the turn-taking and interruption handling that makes a conversation feel human, and the architecture, tools, failure modes, and evaluation behind a production voice agent. Clear, current, and mechanism-first.
The trillion-dollar AI buildout
AI stopped being only a software story and became one of the largest construction efforts in history: warehouses of specialized chips, new power plants, and hundreds of billions in yearly spending. This cursus explains it from the ground up, why compute became the bottleneck, what an AI data center really is, why electricity is now the binding constraint, and how to judge whether the whole thing is a rational bet or a bubble. Mechanisms, not predictions.
How AI is actually used in social media
AI does three unrelated jobs on a social platform, and mixing them up causes most of the confusion. Learn the map first: what decides your feed, what generates the content, and what takes it down. Then get an honest account of where generative tools genuinely help and where they invent facts with total confidence, and why nobody, including the detectors sold for the job, can reliably tell you whether something was made by AI. No hype, no tactics, just what the machines do and how they fail.
How social media algorithms decide what you see
The same machine runs behind YouTube, TikTok, Instagram and Pinterest, and once you see it the feed stops being mysterious. Learn the two-stage funnel that picks ten items out of a hundred million in a tenth of a second, why optimizing for clicks produces clickbait as a correct answer, and how content embeddings let a post from a zero-follower account reach millions. Finish able to explain any feed's behavior from its objective, and to tell real mechanisms from the folklore creators repeat.
Generative AI: diffusion and flow models
How modern image, video, and audio generators actually work, from first principles to the frontier. Learn the denoising mechanism behind diffusion models, the guidance and sampler tricks that turn them into products, the flow-matching reframing that powers state-of-the-art generators, and how diffusion is being rebuilt for text. Finish able to read any generative-model release mechanically: corruption, path, target, and where the inference compute goes.
Loop engineering for LLM agents
Build agent loops that finish, recover from errors, stay on budget, and produce checkable work. Start with the smallest ReAct loop; layer on state management, error taxonomy, and budgets; finish with adversarial verification panels, sub-agent orchestration, and the loop-shaped anti-patterns that ship to prod more than they should.
LLM, agent, and RAG evaluation & monitoring
A compact track on how to know your LLM-powered system is actually working: LLM benchmarks vs. real evals, agent trajectory evaluation, RAG evaluation in production, and the OpenTelemetry GenAI conventions that tie traces across LangSmith, Phoenix, and Datadog LLM.
Reinforcement Learning today
A short, modern tour of where RL is actually working in 2026: the post-RLHF landscape, DPO and its variants, RL with verifiable rewards (GRPO, DeepSeek-R1 style), and how reasoning models use RL on chains of thought.
How LLMs work: from scratch
Ten lessons that build up a modern LLM end to end — neural nets and backprop, attention and transformers, tokenization, pretraining, modern architectures and MoE, scaling laws, post-training (SFT/RLHF/DPO), and inference internals like the KV cache.
Harnesses, MCP, and advanced agent techniques
How modern coding agents are actually built: the Model Context Protocol, MCP server authoring in Python and TypeScript, agent harness design, subagent orchestration, tool-use patterns, and context engineering for long-running agents.
Advanced RAG: graphs, hybrid retrieval, and evaluation
Nine lessons that take Retrieval-Augmented Generation past the cosine-search baseline. Chunking, hybrid retrieval with rerankers, query rewriting, GraphRAG and HippoRAG/RAPTOR, agentic multi-hop patterns, and how to actually evaluate the whole thing with RAGAS.
Reinforcement Learning Foundations
Go from zero to deep RL in four lessons. You will formalize sequential decision-making as a Markov Decision Process, solve small MDPs exactly with dynamic programming, implement Q-learning and SARSA from scratch, and understand DQN, policy gradients, actor-critic, and PPO well enough to use them in real projects.
Deep Learning Foundations
Build and train neural networks from scratch. By the end you will implement forward and backward passes in NumPy, tune optimizers and regularizers to close the train-val gap, design convolutional architectures for image tasks, and read transformer papers fluently — understanding self-attention, multi-head attention, and positional encodings from first principles.
AI 3D Mesh Generation: Foundations to Production
A five-lesson tour of how Meshy, Tripo, Rodin, Hunyuan3D, and Trellis actually work in 2026. Starts from the 3D representation zoo, walks through the modern image-and-text-to-3D pipeline, dives into native 3D generative models, covers texturing and PBR, and ends with the production pipeline and platform landscape.
LLM Models in Practice
Six lessons on choosing and using the right LLM for the job. Get a clear-eyed view of the 2026 model landscape, learn to compare capabilities honestly, understand the open-vs-closed tradeoff, and stop optimizing for benchmarks that don't predict your task.
LLM Basics
A single-lesson taster that introduces the most fundamental concept behind every modern LLM app: the context window. Learn what tokens are, why models forget, and what 'lost in the middle' actually means in practice.
Modern AI Beyond Text
Five lessons on AI that sees, hears, and generates. Start with the unifying idea of multimodal models, dive into vision-language models and OpenCLIP, watch video generation make the leap from research to product, then bring it home with AI-aided software development.
How Agentic AI systems work
Move beyond single prompts into agents that plan, use tools, and loop. Six lessons covering the agent mindset, the LangGraph framework, the realities of context windows, where humans belong in the loop, the security pitfalls, and how to evaluate non-deterministic systems.
How LLM apps work
A practical seven-lesson path from raw model calls to a production-ready RAG application. You'll learn how to ground LLMs in your own data, orchestrate the pieces with LangChain, observe what they actually do, and evaluate the result so you can ship with confidence.
All AI lessons
What Attention Costs, and the Trilemma Underneath
Attention costs two separate things people conflate: quadratic compute during training, and a cache that grows without bound during inference. At a million tokens that cache is 344 GB while a recurrent state is 16.8 MB and constant. This lesson separates the two costs, shows why the classical RNN alternative failed, and states the trilemma every architecture since has been negotiating.
Model Collapse, and the Rule That Avoids It
Training on your own model's output degrades it, and the widely cited result rests on an assumption people rarely notice: that synthetic data replaces real data. Follow-up work showed accumulating synthetic alongside real bounds the error instead. This lesson covers both stages of collapse, why the rule is accumulate rather than replace, how to set a mixing ratio, and the evaluation discipline.
Filtering: The Half That Decides Quality
Generation is the cheap half. What you discard determines what the student learns. This lesson orders the filters by strength: machine verification where an answer can be checked, self-consistency where it cannot, LLM-as-judge with its known position and length biases, and cheap heuristics. It ends on contamination, the failure that invalidates results rather than degrading them.
Generation: Getting Coverage, Not Just Volume
Prompt a model for a thousand examples and you get one example a thousand times, with the nouns changed. This lesson covers why raising temperature does not fix that, the seed-conditioning trick that does, how Self-Instruct and Evol-Instruct systematise it, programmatic generation where ground truth is known by construction, and how to measure whether a dataset actually covers its input space.
When Generating Data Beats Collecting It
Synthetic data is roughly three orders of magnitude cheaper than human annotation, and cheapness is the least interesting thing about it. This lesson establishes what generation can and cannot manufacture: it produces coverage and format, never information the generator lacks, and the one exception is verifiable domains, where a checker turns generation into search.
What Constraints Cannot Fix
Constrained decoding guarantees syntax and can degrade reasoning. Published work found strict formats hurt reasoning tasks while helping classification, because a schema demanding the answer first denies the model room to derive it. This lesson covers where the damage comes from, why field order is thinking order, the enum trap that manufactures confident errors, and how to measure the cost.
Grammars, Stacks, and Making It Free
Recursive formats need a machine with a stack, and a stack breaks the precomputed index because the mask now depends on context. This lesson covers context-free grammars and pushdown automata, XGrammar's split between context-independent and context-dependent tokens, why overlapping grammar work with the GPU makes overhead near zero, and how this interacts with batching and speculative decoding.
From Schema to Mask: The Automaton Index
The naive mask costs 64 million validity checks per response. The trick that made constrained decoding practical is to notice that the answer depends only on the automaton's current state, so it can be computed once per state and looked up thereafter. This lesson builds that idea: regex to DFA, why the state is a sufficient summary, how JSON Schema compiles down, and what the index costs.
Why Asking Nicely Does Not Guarantee JSON
Prompting for a format gives a high success rate, and a high success rate is not a guarantee. This lesson locates the one place in the decoding loop where a guarantee is possible, shows what masking logits does to the probability distribution, works through why a 5 percent failure rate destroys tail latency rather than average latency, and separates the three families of structured output.
Throughput, Failures, and Making a Long Run Finish
A configuration that fits is not a run that finishes. Llama 3 405B training saw 419 unexpected interruptions in 54 days on 16,384 GPUs, one every three hours, and still kept over 90 percent effective training time. This lesson covers model FLOPs utilisation, the optimal checkpoint interval and where it comes from, loss-spike triage, silent data corruption, and the habits that finish runs.
Splitting the Model Itself: Tensor and Pipeline Parallelism
Sharding distributes copies; tensor and pipeline parallelism split the computation. This lesson covers the column-then-row trick that lets a transformer block communicate only twice per layer, sequence parallelism for the parts tensor parallelism cannot reach, the pipeline bubble and why it is (p-1)/m, what 1F1B and interleaving actually fix, and how the three axes compose into a 3D layout.
ZeRO and FSDP: Sharding What Data Parallelism Duplicates
Data parallelism keeps N identical copies of everything. ZeRO removes that redundancy in three stages, and stage 3 takes a 70B model from 1120 GB per GPU to 17.5 GB across 64. This lesson covers what each stage shards, the communication each costs, how FSDP implements it with prefetch and wrapping policy, when offload is worth it, and why stage 3 is not automatically right.
The Memory Wall: Why Training Needs More Than One GPU
Training memory is dominated by things that are not the model. Mixed-precision Adam costs 16 bytes per parameter, so a 70B model needs 1120 GB of state before one activation is stored. This lesson works through where every byte goes, why data parallelism helps throughput but not memory, how accumulation and recomputation trade compute for space, and what each axis of parallelism addresses.
Measuring the Damage, and Shipping It
Quantization damage does not show up where people look for it. Perplexity barely moves while hard tasks degrade, and long reasoning suffers most because error compounds. This lesson covers building an evaluation that detects real loss, where the published cliffs are, KV cache quantization as a separate lever, end-to-end memory sizing, and the rollout that catches what evals miss.
GPTQ, AWQ, and What Calibration Data Buys You
Round-to-nearest minimises the wrong thing. The algorithms that make 4-bit weights usable minimise output error instead, using a small calibration set. This lesson works through GPTQ's Hessian-guided error compensation and AWQ's activation-aware channel scaling, why AWQ tolerates calibration mismatch better, how much data you need, and where QAT and QLoRA fit.
Outliers: Why Large Models Resist Naive Quantization
Round-to-nearest works on small models and falls apart on large ones, because beyond a certain scale transformers grow systematic activation outliers in a few fixed channels, a hundred times larger than everything else. This lesson shows arithmetically why one outlier destroys a tensor, then works through the three families of fix: decompose, smooth, and rotate.
What Quantization Actually Does to a Number
Decoding is memory-bandwidth-bound, so fewer bits per weight means more tokens per second, not fewer. This lesson builds the mechanism from the arithmetic up: the affine mapping, a worked example done by hand, why group size costs fractional bits, the difference between W4A16 and W8A8, and which formats the hardware actually accelerates.
Building Something That Holds Up
Given that the tradable-signal path is narrow and hard to evidence, the systems worth building are the ones the first lesson identified: extraction at scale. This lesson covers the engineering that makes them survive audit, the evaluation that does not depend on returns, and the governance obligations that apply once a model touches a regulated process.
Reading the Evidence Carefully
The most prominent study in this area found a language model predicting stock reactions from headlines, and it is usually reported as proving something it explicitly does not claim. This lesson reads it precisely, follows its qualifiers to their consequences, and shows why a real statistical result and a tradable strategy are different things.
The Look-Ahead Problem: Your Model Already Knows
Backtesting a language model signal has a defect no other signal has. The model was trained on text from the period being tested, so it may already know what happened next, and it uses that knowledge even when instructed not to. This lesson establishes the problem from the published evidence, shows why prompting does not fix it, and covers what does.
Where LLMs Actually Fit in a Trading Firm
The popular framing is a model that predicts prices. That is the one job the technology is worst suited to, and it obscures the one it is genuinely good at: turning unstructured text into structured data at a scale that was previously unaffordable. This lesson locates LLMs against the trading stack and rules out the places they cannot go.
Causality in Modern Machine Learning
Why prediction systems fail when deployed, how invariance across environments becomes a training signal, and where causal reasoning enters bandits, reinforcement learning, and language models.
Causal Discovery: Learning the Graph
If the graph is an assumption, can you learn it from data instead? Conditional independence testing, the equivalence classes that limit what is knowable, and what changes when unmeasured confounders are allowed.
Identification: When Observational Data Is Enough
The central question of causal inference has a precise answer. The backdoor criterion, the front-door criterion, instrumental variables, and what to do when no identification strategy exists.