6.1.1 · D4Scaling & Efficient Architectures

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

2,269 words10 min readBack to topic

This page is a self-test. Every problem states cleanly what to find, and every solution is hidden inside a collapsible callout so you can attempt first, then reveal. We climb five levels: L1 Recognition → L2 Application → L3 Analysis → L4 Synthesis → L5 Mastery.

Everything here rests on the parent note: Neural scaling laws (Chinchilla, compute-optimal). Before you start, keep three objects in your head — we will never use a symbol we did not name:

Two figures below support the analysis problems.

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

Level 1 — Recognition

Recall Solution L1-Q1

As , . As , . Both reducible terms vanish, leaving . It is the irreducible loss — the data's own entropy / Bayes error. No amount of brain or experience beats the inherent unpredictability of the text itself.

Recall Solution L1-Q2

FLOPs. The 6 :

  • 2 = one multiply and one add per parameter per token (a multiply-add is two FLOPs).
  • 3 = forward pass (1×) plus backward pass ( forward), so . Multiplying: .
Recall Solution L1-Q3

.


Level 2 — Application

Recall Solution L2-Q1

. , so . (This is the Chinchilla-70B budget from the parent's worked example.)

Recall Solution L2-Q2

tokens/param. Target is 20; Gopher sits at , roughly 18× below the ideal. Yes — badly data-starved: far too much brain for far too little experience.

Recall Solution L2-Q3

. Since , params grow . . Since , tokens grow . In words: roughly double both, with data getting a touch more of the growth. Check: ✓ — the two factors multiply back to the compute increase.


Level 3 — Analysis

Recall Solution L3-Q1

Substitute the two scalings into the compute law: For to hold for all , the exponents must match: . The picture (figure s01, dashed line): the and growth-rate bars are two pieces of one whole. Chinchilla's ✓ — data simply takes the larger slice.

Recall Solution L3-Q2

Differentiate (why: the minimum is where the slope crosses zero, and is unimodal — first term falls, second rises): Move terms apart: Divide both sides by (collecting powers: ): So , i.e. . Take the -th root: . With : exponent ✓.

Recall Solution L3-Q3

The reducible loss is . The param term () is 6× larger, so it is the dominant bottleneck. Spending on more params attacks the big term; spending on data only chips at the already-small . Spend on . In figure s02 the tall coral bar is the param-shortage term — you always push down the tallest bar first. This is exactly why balanced scaling wins: you keep both bars near equal so neither is a hidden bottleneck.


Level 4 — Synthesis

Recall Solution L4-Q1

Doubling : . Doubling : . New reducible loss vs old . Drop . Why balanced wins: both terms started equal and both shrank — no single bottleneck was left behind hogging the loss.

Recall Solution L4-Q2

(a) Gopher: FLOPs. Chinchilla: FLOPs. Ratio — Chinchilla used only ~17% more compute, essentially comparable. (b) Gopher's makes its (data-shortage) term huge — it drowned in a lack of tokens. Chinchilla moved budget from params into tokens: the shed of far outweighed the small rise in from the smaller model. Net: lower total loss. Smarter split, not just more FLOPs.

Recall Solution L4-Q3

Use in : , so . . Then . This lands exactly on the real Chinchilla-70B design — the 20 tokens/param heuristic and the compute law together pin down from a single budget .


Level 5 — Mastery

Recall Solution L5-Q1

, and likewise . So is exactly the condition that makes both exponents . The famous " each" is therefore the special case ; Chinchilla's real fit () breaks it, tilting to and . The shortcut is a rounded approximation, not the truth.

Recall Solution L5-Q2

At the optimum both terms fall at the same rate. with gives . The same exponent appears for the data term. So . Plug in: . To halve loss: need to drop by 2, i.e. -factor . Punchline: halving the reducible loss needs ~90× the compute — power-law scaling is brutally slow, which is why every fraction of the split matters.

Recall Solution L5-Q3

Compute per token is driven by the parameters actually used on that token, so the FLOP law uses the active count: . This decouples capacity (B, which helps the representation term) from compute cost (set by B). MoE therefore lets you buy a big- representation without paying full dense FLOPs — the dense Chinchilla optimum is a lower bound these architectures try to beat by making .


Recall One-line self-check before you leave

Compute-optimal scaling ::: split every compute increase so grows and — roughly balanced, data slightly faster, exponents summing to 1.