machine-learning

One derivative becomes three objects once a function has many inputs and many outputs. This lesson builds the gradient, the Jacobian and the Hessian, shows what each one actually tells you, and explains why curvature decides how many steps an optimiser needs and why nobody ever writes the Hessian down.

Machine learning uses the derivative as a search strategy, not a symbolic exercise. This lesson builds it as the best local linear approximation, derives the gradient descent update from it, and shows why estimating derivatives numerically loses half your digits and costs one function evaluation per parameter.

A deployed recommender chooses its own future training data: it shows items, users respond to what was shown, and those responses become the next model's ground truth. This lesson maps the loop's consequences, exposure bias, popularity compounding, narrowing candidate pools, explains why offline metrics reward imitation of the loop, and covers the exploration budget that keeps the system learning.

The ranker is a prediction machine, and the hard question is what it should predict. Clicks are plentiful and poisonous, watch time bends toward length, likes are rare and unrepresentative. This lesson covers implicit feedback, the position bias baked into every training log, multi-objective ranking, and calibration.

A recommender has milliseconds to pick ten items from millions, and no model good enough to rank them all is cheap enough to run on them all. The industry's answer is a funnel: cheap candidate generation cuts millions to hundreds, an expensive ranker orders those hundreds. This lesson builds that architecture, its latency arithmetic, and the multi-source retrieval layer real systems run.

A model that has stopped working returns answers with the same confidence as one that still does. This lesson covers the difference between data drift and concept drift, what to monitor when labels arrive months late, the triggers that should start a retraining run, and the cases where retraining is the wrong response.

The most common way a good model fails in production is that the features it is served differ from the ones it was trained on. This lesson covers where that divergence comes from, why point-in-time correctness is harder than it looks, what a feature store actually solves, and when you do not need one.

Google's MLOps guidance describes three maturity levels, from a fully manual handoff to a pipeline that tests and deploys itself. This lesson covers what is automated at each level, the six stages of an ML CI/CD pipeline, and why level 2 is the wrong target for most teams.

A trained model is a small box inside a large system, and the system is what decays. This lesson covers the failure modes that are specific to machine learning: why changing one feature moves every weight, why hidden consumers break silently, and why data dependencies cost more than code dependencies.

An aggregate metric tells you a model is worse than you hoped and nothing about why. Evaluation that writes results back onto each sample turns a number into a set of images you can look at. This lesson covers the evaluation methods and their protocols, per-sample true and false positive counts, how a confusion matrix cell becomes a view, and where this workflow stops.

A query can only ask about what is recorded, so the harder half of curation is generating fields that surface where to look. This lesson covers the analysis methods FiftyOne bundles as the Brain: embedding visualisation and its four reduction methods, uniqueness and representativeness, mistakenness and hardness, and similarity indexes for near-duplicate detection and text search.

Most computer vision projects are limited by their dataset rather than their architecture, and most teams cannot see their dataset. This lesson covers why a tool for inspecting visual data exists, the data model FiftyOne uses to make a dataset queryable rather than a folder of files, why it sits on a database, and where curation fits against annotation and experiment tracking.

Speech recognition's hard problem is that audio and text have different lengths and nobody labelled which frame goes with which letter. CTC, RNN-T and attention encoder-decoders are three answers, and which one a system uses decides whether it can stream. This lesson covers all three, why Whisper's weak supervision worked, and the failure that follows from a recogniser containing a language model.

Before a model can process speech it has to be discretised, and audio resists that harder than text does. This lesson covers why raw waveforms are the wrong representation, how neural audio codecs learn a discrete one, what residual vector quantization actually does, and the arithmetic that governs every speech model: a minute of talking is around 195 text tokens or 36,000 audio tokens.

The paper is concrete about what an experiential agent would differ on, and names four: it lives in a continuous stream rather than episodes, acts in the world rather than emitting text, takes rewards from grounded signals rather than human judgement, and plans in terms it worked out rather than imitating human chain of thought. This lesson works through each.

David Silver and Richard Sutton argue that the current approach has a ceiling built into it, because a system trained to predict what humans wrote is aiming at human performance by construction. This lesson works through their three eras, the claim about data exhaustion, why they think superhuman performance needs a different learning signal, and the honest counter-arguments.

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.

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.

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.

The formal machinery that makes causal questions answerable: structural causal models, graphs as assumptions you can inspect, the three ways variables become associated, and why prediction and intervention are different problems.

Displacement error is the field's default metric and it rewards the wrong behaviour: hedged average predictions, physically impossible trajectories, and best-of-many reporting that flatters diverse nonsense. What to measure instead.

Why forecasting human motion is not a physics problem: the multimodality that makes a single correct answer impossible, the social conventions people navigate by, and the joint prediction problem where everyone is predicting everyone else.

Where this machinery earns its place: low-rank matrix completion, synchronization, and PCA. Plus the two ideas that explain why non-convex manifold problems are often solved to global optimality anyway.

Rotations, subspaces, low-rank matrices and covariances are not vectors in flat space. Why treating those constraints as penalties or projections wastes structure, and what it means to say the search space is a manifold.

What model updates actually leak, the two mechanisms that turn data minimisation into a quantified guarantee, poisoning by malicious clients, and what the Apertus project shows about openness at the other end of the spectrum.

Why local training on non-identical data pulls clients apart, how averaging their updates produces a model that suits nobody, and the control-variate fix that corrects the drift.

The federated setting: why hospitals, phones, and banks cannot pool their data, what changes when the training loop crosses a network, and the FedAvg algorithm that made the idea practical.

What it takes to train a diffusion language model to billions of parameters: the from-scratch recipe, adaptation from an autoregressive checkpoint, the supervision economics, and the capability that bidirectional training gets for free.

The formal machinery under masked text generation: categorical transition matrices, the kernel choices that were tried and discarded, the variational bound, and the two parameterizations that made the objective trainable at scale.

The monotone, cardinality-constrained case is only the entrance. This lesson maps the rest: why submodular minimization is easy while maximization is hard, how to maximize non-monotone functions, what to do under matroid and knapsack constraints, and where submodularity keeps appearing across machine learning.

The theory pays off because so many real problems are submodular in disguise. This lesson works through the landmark applications: near-optimal sensor placement, influence maximization in social networks, and document summarization, each reduced to monotone submodular maximization and solved by the greedy algorithm.

Maximizing a submodular function is NP-hard, yet the simplest possible algorithm gets provably close to optimal. This lesson presents the greedy algorithm, the celebrated (1 - 1/e) guarantee of Nemhauser, Wolsey, and Fisher, why that bound cannot be beaten, and the lazy trick that makes greedy fast at scale.

Many selection problems share one property: each new item helps less than the last. Formalized, that property is submodularity, and it is what makes otherwise intractable problems solvable with guarantees. This lesson defines it precisely, shows the everyday examples, and explains why it is called the discrete analog of convexity.

The theory becomes useful through libraries, and its flagship job is tuning machine-learning models. This lesson covers that application, the Tree-structured Parzen Estimator behind Hyperopt and Optuna, the tools you would actually reach for, batching, and the honest limits of the method.

A Gaussian process gives a mean and an uncertainty everywhere; the acquisition function turns them into one decision about where to spend the next expensive evaluation. This lesson covers Expected Improvement, GP-UCB and its no-regret guarantee, and Thompson sampling, and how each resolves exploration against exploitation.

Bayesian optimization needs a model that predicts the objective everywhere and knows how unsure it is. The Gaussian process delivers exactly that. This lesson builds the GP as a distribution over functions, shows how a kernel encodes assumptions, and explains why its posterior variance is the engine of the whole method.

Some functions cost hours or dollars to evaluate once, give no gradient, and must be optimized in as few tries as possible. This lesson sets up that problem, shows why grid and random search waste the budget, and introduces the surrogate-model loop that Bayesian optimization is built on.

Technical work is probabilistic and stakeholders want guarantees. This lesson covers communicating error rates in terms people can act on, why the two kinds of mistake are not interchangeable, setting expectations before deployment rather than after, and saying no to a request that will not work.

The decision is only half the work. This lesson covers what building each actually involves: parameter-efficient fine-tuning with LoRA and why it made the technique accessible, the training data problem that stalls most projects, the retrieval pipeline end to end, and how to combine them into one system.

Fine-tuning and retrieval are usually presented as alternatives when they change different things. This lesson separates them precisely: fine-tuning adjusts weights and teaches behaviour, retrieval supplies context and teaches nothing, and the question that decides between them is whether your problem is knowledge or form.

Fairness has several formal definitions that sound equally reasonable and cannot all hold at once. This lesson covers demographic parity, equal opportunity, equalized odds and calibration, the impossibility result proved independently by Chouldechova and by Kleinberg and colleagues, and how to choose one deliberately and defend it.

The word bias carries three unrelated meanings that get argued past each other. This lesson separates them, then traces the six points where disparity enters a machine learning system, from historical data through label definition and objective choice to deployment, and explains why removing a protected attribute does not remove its influence.

Two methods dominate local explanation, and both perturb the input. LIME fits a small interpretable model near one prediction. SHAP borrows the Shapley value from game theory and is the unique attribution satisfying local accuracy, missingness and consistency. This lesson builds both mechanisms, compares KernelSHAP with TreeSHAP, and is precise about what a SHAP value does not mean.

A model that predicts well can still be impossible to justify. This lesson maps explainable AI: interpretable-by-design versus post-hoc, global versus local, model-specific versus model-agnostic. It covers the global workhorses (permutation importance, partial dependence, ICE), faithfulness versus plausibility, and the argument that post-hoc explanation is the wrong tool for high-stakes decisions.

Training an EBM means shaping an energy landscape so real data sits in valleys, but the intractable partition function blocks plain maximum likelihood. This lesson covers the push-down-push-up principle, contrastive methods (contrastive divergence, noise-contrastive estimation), score matching, and the regularized alternative that avoids sampling entirely.

What a digital twin is actually made of and the forms it takes. This lesson covers the virtual model (physics-based, data-driven, and hybrid), the data layer of sensors and pipelines that feeds it, the twin taxonomy from component to process scale, the fidelity-versus-cost tradeoff, and the sense-simulate-act loop that turns a model into a working twin.

Why LeCun treats energy as the common language of machine learning. This lesson shows how classification, generative models, self-supervised learning, JEPA, and diffusion all read as energy-based models, ties the contrastive-versus-regularized split back to self-supervised learning, and gives an honest account of where explicit EBMs help and where they do not.

Energy-based models replace input-to-output functions with a scalar energy that scores how compatible a configuration is. This lesson covers the energy function, inference as finding the lowest-energy answer, the energy landscape picture, the link from energy to probability via the partition function, and why this framing handles problems with many valid answers.

Self-supervised learning turns unlabeled data into its own teacher. This lesson covers why labels are the bottleneck, how a pretext task manufactures free supervision, the shift from predicting pixels to learning embeddings invariant to augmentation, and the collapse problem that every method after it must solve.

Why modern robots learn skills from demonstrations instead of hand-written controllers. This lesson covers behavior cloning (supervised observation-to-action learning), the distribution-shift and compounding-error problem that makes it fragile, DAgger as the classic fix, and how teleoperated demonstrations became the fuel for robot learning.

Banking runs on data and decisions at massive scale, which is why it was one of the earliest and heaviest adopters of AI. Learn the main ways banks use AI, fraud detection, credit and underwriting, customer service, anti-money-laundering, and personalization, and the caveats unique to finance: fairness in lending, the need to explain decisions, and heavy regulation.

Why a brand new post can reach millions on one platform and nothing on another. Learn the cold-start problem and why collaborative filtering cannot solve it alone, how content embeddings let a system rank an item nobody has touched, the difference between a social graph and an interest graph, and what actually separates YouTube, TikTok, Instagram and Pinterest.

A feed does exactly what it was told to maximize, which is rarely what anyone wanted. Learn which signals rankers actually weight and why implicit ones beat likes, how proxy objectives produce clickbait and rage-bait as correct answers to badly posed questions, and the mechanisms platforms use to pull an optimizer back toward what people value.

Every feed has the same impossible job: pick ten items out of millions, in under a tenth of a second. The answer is a funnel. Learn why recommenders split into a cheap retrieval stage and an expensive ranking stage, how two-tower models make retrieval possible, and why nearest-neighbour search is the trick that makes the whole thing fit in a budget.

Build the vocabulary that underlies all of ML: sample spaces, discrete and continuous random variables, PMFs, PDFs, and CDFs. Then tour the key distributions — Bernoulli, Binomial, Categorical, Gaussian, Poisson, Exponential, Uniform — with their parameters, mean, variance, and exactly when each appears in practice.

Master the three numbers that summarize any distribution: mean, variance, and standard deviation. Derive linearity of expectation, understand covariance and correlation, then see why the Central Limit Theorem makes the Gaussian unavoidable — with a worked numeric example from scratch.

From raw data to defensible conclusions: derive Maximum Likelihood Estimators for Bernoulli and Gaussian, understand bias-variance in estimation, construct confidence intervals, and learn what p-values actually say — and don't say — including the most common misinterpretation that has corrupted thousands of papers.

Understand what it really means to update beliefs with data. Derive Bayes' theorem from first principles, dissect the roles of prior, likelihood, posterior, and evidence, work through a complete Beta-Binomial conjugate example numerically, and see why the base-rate fallacy trips up even experts.

Dive into the world of vector databases, specialized systems designed to store and query high-dimensional vector embeddings efficiently. Learn how these databases power semantic search, recommendation systems, and large language model applications by finding semantically similar data points at scale.