Research papers, myth by myth, Part 6: 'Bigger models get smarter in sudden, unpredictable leaps'

Every few months a new model arrives with a bigger number attached, and somewhere a chart shows an ability that was flat for small models and then shoots up. The story writes itself: make the model bigger and, at some unknowable size, new skills switch on. If that were true, the only sensible strategy would be to build the largest model you can afford and hope. This part checks that story against four papers.

The myth: “Bigger models get smarter in sudden, unpredictable leaps, so more parameters is always the answer.”

The bottom line: the core measure of a language model’s quality improves smoothly and predictably with scale, and the best use of a fixed budget balances model size against training data. Many of the famous sudden leaps appear when answers are marked all-or-nothing. Mark the same answers with partial credit and the leap often turns into a steady slope.

What do I need to know first?

Think of a child learning to spell ten-letter words. Every week they get a few more letters right. Mark each word letter by letter and you see steady progress: 5 letters out of 10, then 6, then 7. Mark each word as fully right or wrong and you see almost nothing for weeks, and then suddenly lots of words come back correct. The child did not change suddenly. The marking scheme did.

Now give the child a fixed number of study hours. A large notebook is no use if they only read a few chapters; a long reading list is wasted if the notebook is tiny. The best results come from matching the two.

Map that onto the real terms:

Model parameters are the notebook: the model’s size, its capacity to store what it learns.
Training data is the reading list, measured in tokens.
Compute is the study hours: the total arithmetic spent on training, counted in FLOPs. A handy rule from these papers is that training compute is roughly 6 x parameters x tokens.
Loss is the letter-by-letter mark. Cross-entropy loss measures how well the model predicts the next token in text it has not seen. Lower is better, and every token counts a little.
Benchmark accuracy is often the whole-word mark. Many tests use exact match: the answer is completely right or it scores zero.

The myth mixes these up. It reads a whole-word mark as if it were the underlying skill, and it treats the notebook as the only thing worth buying.

What did the researchers do?

Paper 1: the smooth curve. Jared Kaplan and colleagues, mostly at OpenAI, published Scaling Laws for Neural Language Models in January 2020. They trained many Transformer language models on a web-text dataset, ranging from 768 to 1.5 billion parameters (not counting the embedding layer) and from 22 million to 23 billion tokens, and plotted test loss against model size, data size and compute.

Paper 2: the balanced budget. Jordan Hoffmann and colleagues at DeepMind published Training Compute-Optimal Large Language Models in March 2022, with a blog post titled An empirical analysis of compute-optimal large language model training. They trained over 400 models, from 70 million to over 16 billion parameters on 5 to 500 billion tokens, to find the best split of a fixed compute budget. Then they tested the prediction by training a model called Chinchilla with the same compute as their earlier Gopher.

Papers 3 and 4: the emergence debate. Jason Wei and colleagues (Google, Stanford, DeepMind and others) published Emergent Abilities of Large Language Models in June 2022. They defined an ability as emergent “if it is not present in smaller models but is present in larger models”, and collected examples. Rylan Schaeffer, Brando Miranda and Sanmi Koyejo at Stanford replied in April 2023 with Are Emergent Abilities of Large Language Models a Mirage?, which won an outstanding paper award at NeurIPS 2023. They re-analysed the same kinds of results with different metrics.

What did they find?

Loss falls along a straight line on a log-log chart

Kaplan et al. found that loss follows a power law in model size, data size and compute, “with some trends spanning more than seven orders of magnitude”. Plotted with both axes on a logarithmic scale, a power law is a straight line.

test loss against model size on log-log axes, drawn from the fitted law in Kaplan et al. 2020, L equals (8.8 x 10^13 / N) to the power 0.076: a straight line, so every 10 times more parameters multiplies the loss by about 0.84; solid over the sizes they trained, dashed beyond, where the authors say the trend must eventually level off

Here is the mechanism with small numbers. Their fitted law for model size is L(N) = (8.8 x 10^13 / N)^0.076, where N is the parameter count. Because the exponent is fixed, multiplying N by 10 always multiplies the loss by 10^-0.076, which is about 0.84. Plug in the numbers and the fitted line gives a loss of about 4.02 at 1 million parameters, 3.37 at 10 million, 2.83 at 100 million and 2.38 at 1 billion. Each step is 16% lower than the one before, every time. Those are values on the fitted line in their setup, not measurements of any product model, but they show why there are no jumps in this measure: a power law has no special size where things change.

The paper also found that the shape of the network (wider or deeper) mattered little within a wide range, and that the size of the model and the amount of data had to grow together to avoid a penalty. Their advice for a bigger budget, though, leaned heavily towards size: grow the model fast and the data much more slowly.

A smaller model fed more data beat a bigger one

DeepMind’s team found that advice was off. In their words, “current large language models are significantly undertrained”. Most large models of the time, including GPT-3 and their own Gopher, had been trained on about 300 billion tokens while their size kept growing.

how to spend ten times more training compute: Kaplan et al. 2020 advised growing the model about 5.5 times and the data about 1.8 times; Chinchilla found model size and tokens should grow in equal proportion, about 3.2 times each, so every doubling of model size needs a doubling of data

Their result is a simple rule: “for every doubling of model size the number of training tokens should also be doubled”. The paper contrasts this with Kaplan et al., who suggested that for 10 times the compute, the model should grow 5.5 times and the data only 1.8 times. Since compute is roughly parameters times tokens, both splits spend about the same budget: 5.5 x 1.8 is about 10, and so is 3.2 x 3.2.

To test it, they predicted that for Gopher’s compute budget the best model would be four times smaller and trained on four times more tokens. They built it:

Gopher versus Chinchilla at the same training compute of 5.76 x 10^23 FLOPs: Gopher has 280 billion parameters trained on 300 billion tokens, Chinchilla has 70 billion parameters trained on 1.4 trillion tokens, about 20 tokens per parameter, and it scores higher on MMLU, 67.5% against 60.0%

Chinchilla, with 70 billion parameters trained on 1.4 trillion tokens, used the same compute as Gopher, with 280 billion parameters trained on 300 billion tokens. Chinchilla “uniformly and significantly” outperformed Gopher, and also GPT-3 (175B), Jurassic-1 (178B) and Megatron-Turing NLG (530B) across a large range of tasks. On MMLU it reached an average of 67.5%, against Gopher’s 60.0%. Because it is a quarter of the size, it is also cheaper to run for every answer afterwards.

You will often see this summarised as “about 20 tokens per parameter”. The paper does not state it as a rule, but its own projections imply it: Table 3 pairs 1 billion parameters with 20.2 billion tokens, 10 billion with 205.1 billion, and 67 billion with 1.5 trillion. Chinchilla itself, at 1.4 trillion tokens for 70 billion parameters, is exactly 20.

Many “sudden leaps” depend on the marking scheme

Wei et al.’s examples look dramatic. On a test of 3-digit addition and subtraction and 2-digit multiplication, GPT-3 and LaMDA scored close to zero for several orders of magnitude of training compute, then jumped “to sharply above random” at about 2 x 10^22 training FLOPs (13 billion parameters) for GPT-3 and 10^23 FLOPs (68 billion parameters) for LaMDA. Their abstract concludes that such abilities “cannot be predicted simply by extrapolating the performance of smaller models”.

Schaeffer et al. noticed something about where these leaps appear. More than 92% of the emergent abilities on BIG-Bench showed up under just two metrics, Multiple Choice Grade and Exact String Match, both of which score 1 or 0 with nothing in between. Their argument is the spelling test. Suppose a model gets each digit of a 10-digit answer right with probability p, and p improves smoothly with size. Exact match needs all ten digits right, so the score is roughly p multiplied by itself ten times.

illustrative numbers in the style of Schaeffer et al.: seven models answer 10-digit sums; the chance of getting each digit right rises smoothly from 50% to 98%, so digits correct out of ten climbs steadily, but scoring only exact whole answers (each digit chance to the power ten) stays near zero and then shoots up

Walk through the numbers in the diagram, which are illustrative. At p = 0.50, exact match is 0.50^10, about 0.1%. At p = 0.81 it is still only 12%. At p = 0.89 it is 31%, and at p = 0.98 it is 82%. Plotted against model size, that looks like nothing, nothing, then a leap, even though the per-digit skill rose steadily the whole time. Mark the same answers by how many digits are right and you get the smooth curve on the left.

They tested this in three ways: on the GPT-3 and InstructGPT family for arithmetic tasks claimed to be emergent, in a survey of BIG-Bench results, and by deliberately producing “emergent abilities” in image models just by choosing the metric. For the arithmetic tasks, switching from exact accuracy to a partial-credit metric (token edit distance) turned the leap into a smooth curve. Adding more test questions also helped: with enough data, the smaller models turned out to have small but above-chance accuracy, which a small test set had rounded down to zero.

The original emergence paper had already flagged this possibility. Wei et al. wrote that exact string match “may disguise compounding incremental improvements as emergence”, and that cross-entropy loss improved even at small scales where the task metrics looked flat. They also argued that metric choice is “at best an incomplete explanation”, because emergence still appeared on many classification tasks.

So is the myth true?

Mostly false, with one true kernel. Taking it piece by piece:

“Unpredictable”: false for the core measure. Loss improves smoothly with parameters, data and compute, which is exactly why labs can forecast a large run from smaller ones.
“Sudden leaps”: partly an artefact. Many headline jumps sit on top of all-or-nothing metrics and small test sets. Schaeffer et al. are explicit that they are not “claiming that large language models cannot display emergent abilities”, only that many claimed ones may be produced by the analysis.
“More parameters is always the answer”: false. At a fixed budget, Chinchilla beat a model four times its size by spending the budget on data instead.
The true kernel: it is still hard to predict which specific task will cross a useful threshold, and when. A user feels the whole-word mark, not the letter-by-letter one, so a smooth underlying gain can still feel like a sudden new skill.

What did the papers not show?

Kaplan et al. measured loss, not usefulness on real tasks. Their largest models had 1.5 billion parameters, far below today’s. They also state their trends “must eventually level off”, because natural language has some irreducible unpredictability, and that their equations contradict each other far beyond the range they studied.
Hoffmann et al. list their own limits: only two comparable large runs (Chinchilla and Gopher), no tests at intermediate scales, an assumed power-law frontier, some curvature at high compute that suggests they “may still be overestimating the optimal size of large models”, and training on less than one pass over the data. They also expect more data to help only “when the data is high-quality”. They explain part of the gap with Kaplan et al. by training setup: Kaplan used a fixed number of training tokens and learning-rate schedule for all models.
Chinchilla’s rule optimises training compute only. It says nothing about the cost of serving the model, which pushes many teams to train smaller models on even more data than the rule suggests. That is a separate trade-off the paper does not settle.
Schaeffer et al. studied specific claims and model families. Their work explains many leaps; it does not prove that no genuine qualitative change ever happens with scale.

Why does this matter if you build or use AI?

Do not pick models by parameter count alone. How much data, and how good, matters as much as size. A smaller, well-trained model can beat a larger one, and it costs less on every request.
Choose metrics that show progress. If you only score exact final answers, your own evals will show the same false flatness and sudden jumps. Add partial-credit measures, such as per-field accuracy or a graded rubric, alongside pass or fail. I go deeper on evals in the Production-ready agents series.
Use enough test cases. A handful of examples rounds small improvements down to zero. More cases give the resolution to see real trends.
Be sceptical of “it suddenly learned to…” claims. Ask how it was measured, and what a smoother metric shows.
Expect steady gains, not magic. Scaling helps predictably; it does not release hidden skills at a secret size.

How do I lock it in?

Term                What it is                                         Study picture
Parameters          the model's size and capacity                      the notebook
Training tokens     how much text it learns from                       the reading list
Compute (FLOPs)     total training arithmetic, about 6 x N x D         the study hours
Loss                next-token prediction error, lower is better       letter-by-letter mark
Power law           x10 input gives the same factor change every time  steady weekly progress
Compute-optimal     balance size and data for a fixed budget           notebook matched to reading
Exact match         all-or-nothing scoring                             whole-word mark
Emergence (claimed) flat, then a sudden jump at some size              "suddenly" spelling words

My view: I think the useful mental model is a dial. Scale turns the dial smoothly; some tasks only become usable past a certain point on the dial, and that threshold is what we notice. When I hear “emergent”, I now ask two questions straight away: what was the metric, and how many test cases were there.

One honest gap: these papers are about pre-training language models on text, and most were written before today’s reasoning models and heavy post-training. How much of a modern model’s behaviour follows equally smooth laws for reinforcement learning or for the extra thinking a model does at answer time is an active research question, and I have not seen a public result as clean as Chinchilla for it.

What did we learn?

Kaplan et al. (2020) showed that language model loss falls as a smooth power law in parameters, data and compute, over more than seven orders of magnitude.
On their fitted line, every 10 times more parameters multiplies the loss by about 0.84, which is why large runs can be forecast from small ones.
Chinchilla (2022) showed that model size and training tokens should grow together, and its 70 billion parameters on 1.4 trillion tokens beat the 280 billion parameter Gopher at the same compute.
“About 20 tokens per parameter” is a rule of thumb read from Chinchilla’s own projections, not a law stated in the paper.
Many claimed emergent abilities appear under all-or-nothing metrics; with partial credit and more test data, the same results often look smooth and predictable.
None of these papers settles everything: thresholds for specific tasks remain hard to predict, and these laws were measured on pre-training, not on today’s reasoning and post-training methods.

What comes next?

In Part 7 I take on the myth that more context is always better: that a model with a million-token window reads every token equally well. It is the same instinct as this part, that more of one ingredient must help, and the same habit applies: before believing a dramatic claim about AI, check what was measured and how it was scored.

Sources

Jared Kaplan et al., Scaling Laws for Neural Language Models (arXiv 2001.08361, January 2020)
Jordan Hoffmann et al., Training Compute-Optimal Large Language Models (arXiv 2203.15556, March 2022), and the Google DeepMind blog post An empirical analysis of compute-optimal large language model training
Jason Wei et al., Emergent Abilities of Large Language Models (arXiv 2206.07682, Transactions on Machine Learning Research, 2022), and the Google Research blog post Characterizing Emergent Phenomena in Large Language Models
Rylan Schaeffer, Brando Miranda and Sanmi Koyejo, Are Emergent Abilities of Large Language Models a Mirage? (arXiv 2304.15004, April 2023), NeurIPS 2023 proceedings page

Opinions are my own. Every fact in this post comes from the public documentation linked above.