The math machine learning runs on, made hands-on. Drag the dots, move the sliders, and watch the formulas do what they describe. Pick a topic to begin.
Drag the start dot anywhere on the surface. Then press Step, or Run to animate.
Training a model means finding the settings (θ) that make its error (L) as small as possible. The error forms a landscape. Gradient descent just walks downhill: the gradient ∇L points to the steepest way up, so we step the opposite way. α is the learning rate, the size of each step.
Try a tiny α (slow crawl) and a large one (it overshoots and can fly off). Then stretch the bowl and watch the path zig-zag, the reason ill-shaped error surfaces are slow to train.
A model is a machine with a set of dials, called parameters and written θ. Different dial settings make different predictions, and some settings are better than others.
We score "better" with a single number, the error or loss (written L): how wrong the model is on our data. Training is just the hunt for the dials that make L as small as possible.
Picture every possible setting of the dials spread out on the ground, with the error L as the height above each spot. Together they form a surface: a landscape of hills and valleys.
The best model sits at the lowest point. The picture above shows that landscape seen from above, where each ring is one height and the center is the bottom of the valley.
Standing on the surface, we want the direction that drops fastest. That comes from the gradient, written ∇L, which points the way the surface rises most steeply.
So to go down, we head the exact opposite way. The green arrow above always points along the downhill step.
One move is the update rule that runs underneath almost all of machine learning:
θ ← θ − α · ∇L(θ)
Read it as: new setting equals old setting, minus a small step in the uphill direction, which means downhill. Repeat it and you roll to the bottom. α (alpha) is the step size, the learning rate.
Set α too small and training crawls, taking thousands of tiny steps. Set it too large and each step overshoots the valley, bouncing back and forth or flying off entirely.
Try it: drag the learning-rate slider above to a large value and press Run. Watch the path overshoot and diverge.
When the valley is a long, narrow ravine instead of a round bowl, one step size cannot suit both directions at once, so the path zig-zags down slowly.
This is why practitioners reshape their data with scaling and normalization, and reach for smarter optimizers: a rounder bowl is far easier to roll down.
Try it: raise the "bowl stretch" slider above and watch the path begin to zig-zag.
Drag the tip of either arrow.
The dot product measures how much two vectors point the same way. Same direction gives a big positive number, perpendicular gives zero, opposite gives a negative number. It is the single operation under almost every score a neural network computes.
The dashed line is the projection of a onto b: the shadow a casts on b's direction.
A 2×2 matrix is a recipe for bending the whole plane. Its two columns say where the basis arrows î (right) and ĵ (up) land. Every other point follows along, so the grid rotates, scales, or shears as one piece.
The determinant is how much area gets multiplied. A negative determinant means space got flipped over.
A vector is just an ordered list of numbers, like (3, 1.4). You can read it as an arrow from the origin to that point, with a direction and a length.
This matters because in machine learning almost everything is a vector: a data point, a word, an image, a prediction. They are all lists of numbers pointing somewhere in space.
The length of a vector, written |a|, is how far its arrow reaches, found with the Pythagorean theorem. It often stands in for "how big" or "how strong" something is, like the size of an error or the strength of a signal.
The dot product takes two vectors and returns one number that says how much they point the same way:
a · b = |a| |b| cosθ
Same direction gives a big positive number, a right angle gives exactly zero, and opposite directions give a negative number. Nearly every "score" a neural network computes is a dot product underneath.
Try it: drag the two arrows above until they are perpendicular and watch a·b fall to zero.
The dot product also gives the projection: how much of one vector lies along another, like the shadow it casts. That "how much of a points along b" idea is the heart of similarity search and of the attention used in modern language models.
A matrix is a rule that moves every point in space at once. The simplest way to read a 2×2 matrix: its two columns tell you where the two unit arrows, right and up, end up. Every other point follows along, so the whole grid rotates, stretches, or shears as one piece.
A neural network layer is exactly this: multiply the data by a matrix to rearrange it into something more useful, then repeat.
Try it: open the "Matrix as a transform" tab above and drag the sliders to bend the grid.
One number, the determinant, summarizes how much a matrix scales area. Above 1 it expands space, between 0 and 1 it shrinks it, and a negative value means space got flipped over like a mirror. A determinant of zero means the transform squashed everything flat and lost a dimension.
Drag the dot left and right along the curve.
The derivative f′(x) is just how steep the curve is at one point, the slope of the straight line that grazes it there. Positive means rising, negative means falling, zero means flat (a peak or a valley). Learning is mostly about finding where slopes are zero.
On a surface with two inputs, the slope becomes a little arrow: the gradient. It points in the direction the surface climbs fastest, and its two parts are the partial derivatives, the slope along x and the slope along y. Gradient descent simply walks the other way.
Pick a point on a curve and ask: if I nudge the input a little, how fast does the output change? That rate is the slope at that point, the steepness of the curve right there.
The derivative, written f′(x), is just the slope of the curve at the point x. Positive means the curve is rising, negative means falling, and the bigger the number, the steeper the climb.
Try it: drag the dot along the curve above and watch the slope change sign at the peaks and valleys.
Where the slope is zero, the curve is momentarily flat: the top of a hill or the bottom of a valley. Remember the first module? Training looks for the bottom of the error valley, which is exactly a place where the slope is zero. That link is why derivatives run all of learning.
Real models have many inputs, not one. With two inputs you can ask for the slope along x while holding y still, and the slope along y while holding x still. Each of those is a partial derivative, written with a curly ∂.
Stack those partial slopes into a vector and you get the gradient:
∇f = ( ∂f/∂x , ∂f/∂y )
It is an arrow pointing in the steepest uphill direction. Now the first module clicks into place: gradient descent simply walks the opposite way, downhill.
Try it: open "The gradient (2D)" tab above and drag the point to see the uphill arrow and its downhill opposite.
A neural network is many simple functions stacked in a chain. To improve it, we need the slope of the final error with respect to every dial buried inside. The chain rule says you can get it by multiplying the slopes of each link in the chain. Running that multiplication backward through the network is called backpropagation, and it is how every deep model is trained.
Move the sliders. Press Sample to draw random points.
The normal distribution describes things that cluster around an average: the mean μ sets where the peak sits, and the standard deviation σ sets how wide it spreads. About 68% of everything lands within one σ of the mean (the shaded band).
Press Sample to scatter random draws and watch them pile up into the curve.
Bayes' theorem turns a test result into an updated belief. The surprise: when a condition is rare, even an accurate test produces mostly false alarms. Drop the base rate and watch the orange (false positives) swamp the green (true positives).
Data is noisy and the future is never certain, so models rarely deal in a flat yes or no. They work in probabilities: numbers between 0 and 1 that say how likely something is. Learning to read them is half of understanding a model's output.
A distribution describes how likely each value is. The most common is the normal distribution, the bell curve: most values cluster near an average and rare values trail off on both sides.
Two numbers define it. The mean μ sets where the peak sits, and the standard deviation σ sets how wide it spreads.
Try it: move the μ and σ sliders above to slide and stretch the bell.
For a bell curve, about 68% of everything lands within one σ of the mean (the shaded band above), about 95% within two, and about 99.7% within three. That single fact lets you judge what counts as normal and what counts as a surprise.
Take many random draws from a distribution, tally them up, and the pile recreates the curve. This is how models simulate, estimate, and generate: lots of random samples that, together, follow the underlying shape.
Try it: press Sample above a few times and watch the bars grow into the bell.
Often you start with a hunch and then see evidence. Bayes' theorem is the rule for updating: combine your starting belief (the prior) with how telling the evidence is, to get a sharper belief (the posterior).
P(D | +) = sensitivity × prior ÷ P(+)
Here is the lesson that catches everyone. When something is rare, even a very accurate test produces mostly false alarms, because there are so many more healthy people to misflag than sick people to catch. A test that is "99% accurate" for a one-in-a-thousand condition can still be wrong most times it fires.
This is why machine learning never trusts accuracy alone on rare events, and why metrics like precision and recall exist.
Try it: open "Bayes' theorem" above and drag the base rate down. Watch the orange false alarms swamp the green true cases.
Everything here runs locally in your browser, with no data leaving the page. It is built for intuition first: the goal is to feel why each idea works before meeting its notation. These four pieces, optimization, linear algebra, calculus, and probability, are the load-bearing math under nearly every machine learning system. Once they feel natural, the rest of the field reads like applications of them.