6.1.1 · D2Scaling & Efficient Architectures

Visual walkthrough — Neural scaling laws (Chinchilla, compute-optimal)

2,108 words10 min readBack to topic

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.

Figure — Neural scaling laws (Chinchilla, compute-optimal)

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:

Figure — Neural scaling laws (Chinchilla, compute-optimal)

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:

Figure — Neural scaling laws (Chinchilla, compute-optimal)

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:

Figure — Neural scaling laws (Chinchilla, compute-optimal)

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:

Figure — Neural scaling laws (Chinchilla, compute-optimal)

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:

Figure — Neural scaling laws (Chinchilla, compute-optimal)

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:

Figure — Neural scaling laws (Chinchilla, compute-optimal)

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.

Figure — Neural scaling laws (Chinchilla, compute-optimal)

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

Figure — Neural scaling laws (Chinchilla, compute-optimal)

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.


Flashcards

Why does the substitution help the derivation?
It uses the fixed budget to remove one variable, turning a two-variable minimization into single-variable calculus.
At the compute-optimal point, what balances?
The downward pull of the parameter term exactly cancels the upward push of the data term (slope zero).
What happens to loss as ?
Both power-law terms vanish and , the irreducible floor — you approach but never beat data entropy.
When would and both scale as exactly ?
Only in the special case ; the fitted gives and instead.