Visual walkthrough — Neural scaling laws (Chinchilla, compute-optimal)
Parent: Neural scaling laws (Chinchilla, compute-optimal)
This page rebuilds the central Chinchilla result — given a fixed pile of compute, how big should the model be and how much data should it eat? — from the ground up, one picture per step. We assume you know nothing except "computers do arithmetic". Every symbol is earned before it is used.
Step 0 — The three quantities we will juggle
Before any math, meet the players. Everything on this page is a story about three numbers.
If you have never seen "FLOP", it is literally one arithmetic step — one multiply, or one add. A modern training run does about of them. That giant number is . See Compute budgets & FLOPs for where FLOPs come from.

The picture shows the three as sliders. The whole derivation is: is fixed, so if you push up you must pull down. We want the sweet spot.
Step 1 — WHAT the loss actually looks like
WHAT: We first need a formula for how wrong the model is. Call it , the loss — a single number, smaller = better. The parent note gives the empirical shape:
Reading it term by term, right where each symbol sits:
- — a fixed floor (the irreducible loss). Even a perfect infinite model hits it, because language has genuine randomness. It never changes, so remember it and set it aside.
- — the penalty for having too few parameters. is just a size constant. As (knobs) grows, grows, so the fraction shrinks. controls how fast.
- — the penalty for having too little data. Same shape: as (tokens) grows, this shrinks. .
WHY this shape and not, say, ? Because measurements show diminishing returns: each doubling of removes the same fraction of the reducible error, not a fixed amount. "Constant fractional shrink per doubling" is the exact fingerprint of a power law , never an exponential. (An exponential would keep removing a fixed slice forever and hit zero — reality doesn't.)
PICTURE:

Watch the blue curve fall steeply then flatten — that flattening is diminishing returns. The dashed line is the floor ; the curve approaches it but never touches.
Step 2 — WHAT ties and together: the compute budget
WHAT: Training cost. The parent note states the standard estimate for a dense transformer:
Term by term:
- — every one of the tokens passes through every one of the parameters, so the work scales as their product.
- the — a bookkeeping constant: (each parameter does a multiply and an add) (the backward pass that learns costs about twice the forward pass, so forward + backward the multiply-add).
WHY it matters: this is our leash. is fixed the moment your boss hands you a budget. So and are not free — they are chained: raise one, the other must fall.
PICTURE:

Every point on the yellow curve is a legal choice: same compute, different split. Up-and-left = tiny model gorged on data. Down-and-right = huge model starved of data. Our job is to find the one point on this curve where is smallest.
Step 3 — WHY we can throw away the floor
WHAT: We drop and only minimize the trade-off part:
WHY: is a constant. Adding a constant lifts the whole landscape by the same height everywhere — it never moves the location of the lowest point. Like adding 10 cm to every mountain: the tallest peak is still the tallest peak, at the same coordinates.
PICTURE:

The two curves (with and without ) are identical in shape, just shifted up. The red dot — the minimum — sits at the same in both. That's the whole justification.
Step 4 — WHAT the constraint does: collapse two variables into one
WHAT: Use the leash to eliminate . Solve it for :
then substitute into :
Term by term for the tricky second piece: . The is a fixed number (compute is fixed); the live part is , which grows with .
WHY: With the leash applied, is no longer independent — every forces a . So we have exactly one free knob, . One variable = plain single-variable calculus. This is the payoff of the constraint.
PICTURE:

Two opposing forces on one axis: the blue term falls (bigger model = less parameter-starvation), the yellow term rises (bigger model = less data left, more data-starvation). Their sum (green) is a valley. The bottom of that valley is the answer.
Step 5 — WHY a minimum exists, and WHERE (set the slope to zero)
WHAT: Find where the green valley bottoms out. The bottom of a valley is where the ground is momentarily flat — slope zero. The slope is the derivative :
WHY the derivative, and WHY this must be the minimum? The derivative is "slope of the sum curve". At the valley floor the two forces exactly balance — the downward pull equals the upward push, net slope . And we know it's a genuine minimum (not a fluke) because is unimodal: the first term strictly falls and the second strictly rises on all , so their sum falls, then rises, crossing flat exactly once. One crossing = one valley bottom. (See Overfitting vs underfitting — the two terms are literally underfitting-from-too-few-params vs the data-limited side.)
PICTURE:

The red tangent line is flat exactly at the valley floor. Left of it the slope is negative (still going down), right of it positive (climbing) — the sign flips once, confirming the single minimum.
Step 6 — WHAT the algebra gives: the scaling exponents
WHAT: Solve the balance equation. Move one term across:
Collect all 's on one side by dividing both sides by :
(the exponent simplifies: ; and ). Flip both signs of the exponents:
And since , whatever exponent takes, takes one minus it:
WHY the exponents sum to 1: because . If and , then their product must scale like itself, forcing . The whole result is just "split the exponent 1 between two players, in the ratio ."
Plugging Chinchilla's fit :
PICTURE:

On log-log axes both are straight lines whose slopes are the exponents — for , the slightly steeper for . Data climbs a touch faster: the model should stay a bit hungry.
Step 7 — Edge and degenerate cases (never skip these)
The formula hides some cliffs. Walk each one.
Case (equal exponents). Then exactly, so and — the famous "square-root each" rule. This is the special case, not the general one. Chinchilla's is why the real answer tilts to .
Case (no model). : no parameters means infinite parameter-starvation. Off the chart, useless — the valley wall on the far left.
Case (no data). : no experience means infinite data-starvation. The far-right valley wall. Both walls confirm the minimum lives strictly inside, never at an extreme.
Case (infinite compute). Both terms ; loss , the floor. You can approach perfection but never beat entropy. Scaling has a ceiling.
Case: all compute into (the pre-Chinchilla mistake). You slide to the bottom-right of Step 3's curve — huge , tiny . The term explodes even as shrinks. Net loss rises. This is exactly why the 280B Gopher lost to the 70B Chinchilla.

The figure marks all five cases on the loss-vs-split curve so you can see where each lands. (Note: Mixture-of-Experts changes the accounting because not all parameters fire per token — that's a different leash, a story for another page.)
The one-picture summary

One frame compresses the whole journey: the constraint curve (yellow), loss contours draped over it (blue), and the red dot where the contour just kisses the constraint — the compute-optimal point, sitting slightly toward the data side.
Recall Feynman retelling — the whole walkthrough in plain words
You have a fixed pile of arithmetic to spend (). You can spend it on a bigger brain (more knobs ) or on more reading (more tokens ) — but not both freely, because the pile is fixed and cost . Being wrong () comes from three things: a floor you can't fix (), too-small a brain (), and too-little reading (). Ignore the floor — a constant never moves the best spot. Use the fixed pile to turn "brain and reading" into a single dial: crank the brain up and reading auto-drops. One term falls, the other rises, so there's a valley — and the valley bottom is where their forces balance (slope zero). Solving that balance splits the growth between brain and reading in the ratio of their power exponents, and because cost is brain × reading, those two growth rates must add to one. The fit says brain grows like , reading like — nearly equal, reading a hair faster. Rule of thumb: about 20 tokens per parameter. Go all-in on brain and you starve it; that's exactly how a model four times smaller beat a giant.
Recall Quick self-check
Why do the and exponents against sum to 1? ::: Because , so and force . Why can we drop before minimizing? ::: It's a constant; adding it shifts the whole loss up equally and never moves the minimum's location. What guarantees a single minimum? ::: One term strictly falls in , the other strictly rises, so their sum is unimodal — slope crosses zero exactly once.