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.
As N→∞, A/Nα→0. As D→∞, B/Dβ→0. Both reducible terms
vanish, leaving E. 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
C≈6ND FLOPs. The 6=2×3:
2 = one multiply and one add per parameter per token (a multiply-add is two FLOPs).
3 = forward pass (1×) plus backward pass (≈2× forward), so 1+2=3.
Multiplying: 2×3=6.
C=6ND=6×(70×109)×(1.4×1012).
70×1.4=98, so C=6×98×1021=588×1021≈5.9×1023FLOPs.
(This is the Chinchilla-70B budget from the parent's worked example.)
Recall Solution L2-Q2
D/N=280B300B≈1.07 tokens/param.
Target is 20; Gopher sits at ≈1.1, roughly 18× below the ideal. Yes — badly
data-starved: far too much brain for far too little experience.
Recall Solution L2-Q3
N→N×40.45. Since 40.45=20.9≈1.87, params grow ≈1.9×.
D→D×40.55. Since 40.55=21.1≈2.14, tokens grow ≈2.1×.
In words: roughly double both, with data getting a touch more of the growth. Check:
40.45×40.55=41.0=4 ✓ — the two factors multiply back to the compute increase.
Substitute the two scalings into the compute law:
C≈6ND∝Ca⋅Cb=Ca+b.
For C∝Ca+b to hold for allC, the exponents must match: a+b=1.
The picture (figure s01, dashed line): the logN and logD growth-rate bars are two pieces
of one whole. Chinchilla's 0.45+0.55=1.00 ✓ — data simply takes the larger slice.
Recall Solution L3-Q2
Differentiate (why: the minimum is where the slope crosses zero, and f is unimodal — first
term falls, second rises):
dNdf=−αAN−α−1+βB(6/C)βNβ−1=0.
Move terms apart:
αAN−α−1=βB(6/C)βNβ−1.
Divide both sides by Nβ−1 (collecting powers: N−α−1−(β−1)=N−α−β):
αAN−α−β=βB(6/C)β.
So N−α−β=αAβB(6/C)β, i.e. Nα+β=βBαA(C/6)β∝Cβ.
Take the (α+β)-th root: Nopt∝Cβ/(α+β).
With β=0.28,α+β=0.62: exponent =0.28/0.62≈0.45 ✓.
Recall Solution L3-Q3
The reducible loss is 0.30+0.05=0.35. The param term (0.30) 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 0.05. Spend on N. 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.
Doubling N: A/(2N)α=0.10×2−0.34=0.10×0.790=0.0790.
Doubling D: B/(2D)β=0.10×2−0.28=0.10×0.824=0.0824.
New reducible loss =0.0790+0.0824=0.1614 vs old 0.20.
Drop =0.200.20−0.1614=0.193≈19%.
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: C=6×280B×300B=6×8.4×1022=5.04×1023 FLOPs.
Chinchilla: C=6×70B×1.4T=6×9.8×1022=5.88×1023 FLOPs.
Ratio 5.88/5.04≈1.17 — Chinchilla used only ~17% more compute, essentially comparable.
(b) Gopher's D/N≈1.1 makes its B/Dβ (data-shortage) term huge — it drowned in
a lack of tokens. Chinchilla moved budget from params into tokens: the shed of B/Dβ far
outweighed the small rise in A/Nα from the smaller model. Net: lower total loss.
Smarter split, not just more FLOPs.
Recall Solution L4-Q3
Use D=20N in C=6ND: C=6N(20N)=120N2, so N=C/120.
N=5.9×1023/120=4.917×1021≈7.01×1010=70B.
Then D=20N=20×70B=1.4T.
This lands exactly on the real Chinchilla-70B design — the 20 tokens/param heuristic and the
compute law together pin down (N,D) from a single budget C.
Nopt∝Cβ/(α+β)=C0.5/1.0=C0.5, and likewise Dopt∝C0.5.
So α=β is exactly the condition that makes both exponents 0.5. The famous
"∝C0.5 each" is therefore the special caseα=β; Chinchilla's real fit
(α=0.34=β=0.28) breaks it, tilting to C0.45 and C0.55. The shortcut is a
rounded approximation, not the truth.
Recall Solution L5-Q2
At the optimum both terms fall at the same rate. A/Nα with N∝Cβ/(α+β)
gives N−α∝C−αβ/(α+β). The same exponent appears for the data term.
So γ=α+βαβ.
Plug in: γ=0.620.34×0.28=0.620.0952≈0.1535.
To halve loss: need C−γ to drop by 2, i.e. C-factor =21/γ=21/0.1535=26.51≈91×.
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: C≈6NactD=6×40B×D. This decouples
capacity (N=600B, which helps the A/Nα representation term) from compute cost (set by
Nact=40B). MoE therefore lets you buy a big-N representation without paying full dense
FLOPs — the dense Chinchilla C≈6ND optimum is a lower bound these architectures try to
beat by making N>Nact.
Recall One-line self-check before you leave
Compute-optimal scaling ::: split every compute increase so N grows ∝C0.45 and D∝C0.55 — roughly balanced, data slightly faster, exponents summing to 1.