Generative AI
Scaling Laws, Data Budgets, and Compute Allocation
Interpret scaling results as empirical planning tools and connect model size, data, compute, and downstream serving cost.
By the end you can
- Explain what empirical scaling laws relate and what they do not guarantee
- Distinguish parameter count, training tokens, training compute, and inference cost
- Identify undertraining, overtraining, and data-quality constraints under a fixed budget
- Evaluate scaling claims using comparable objectives, data, and downstream requirements
Parameter count is only one coordinate of the training plan
More parameters do not settle the question. The cleanest demonstration is a published scaling prescription that a later experiment reversed.
Cross-entropy loss falls as a power law in model size, dataset size and training compute. That was the finding of Scaling Laws for Neural Language Models in 2020, fitted across trends spanning more than seven orders of magnitude. The prescription that came with it was explicit: “Larger models are significantly more sample-efficient, such that optimally compute-efficient training involves training very large models on a relatively modest amount of data and stopping significantly before convergence.”
Two years later Chinchilla overturned exactly that prescription. A larger model can underperform a smaller model trained on more appropriate data or for more tokens. How well the training goes depends on how model capacity, dataset size, optimization and compute are allocated together.
Note what did not fail in 2020. The power law was real. It was fitted over more than seven orders of magnitude, and it still did not survive a different allocation of the same compute.
That is what a scaling law is: an empirical trend inside a measured regime. It is useful for estimating tradeoffs. It is not a guarantee of product quality, safety, or transfer to a different architecture and data distribution. Kaplan and colleagues named their regime honestly. Readers two years later were the ones who treated it as permanent.
A parameter count without data, compute, objective, and evaluation context is not a capability explanation.
Visual
Four budgets constrain a foundation-model program
A decision that improves one stage can increase cost elsewhere. The link between training and serving has now been priced rather than merely asserted.
Serving cost belongs inside the law. Beyond Chinchilla-Optimal, from Sardana and colleagues in 2023, modified the Chinchilla laws to include inference and trained 47 models to validate the result: “We conduct our analysis both in terms of a compute budget and real-world costs and find that LLM researchers expecting reasonably large inference demand (~1B requests) should train models smaller and longer than Chinchilla-optimal.” In their analysis quality kept improving out to 10,000 tokens per parameter.
The number that moves the optimum is a demand forecast — roughly 1 billion inference requests — not an architecture choice. A team that expects that volume and optimizes the training budget alone will build the wrong model, correctly.
- 01
Data budget
Available tokens, quality, rights, languages, and refresh possibilities.
- 02
Training budget
Accelerator time, energy, optimizer state, retries, and experiment overhead.
- 03
Inference budget
Latency, memory, throughput, context length, and generated tokens per request.
- 04
Adaptation budget
Post-training data, evaluation, safety testing, and downstream integration work.
Comparison
Three ways to spend additional compute
Each choice changes the evidence needed for success. Two of the three now have a measured limit rather than a caution.
Repeating data pays almost as well as fresh data at first, and then less and less. Scaling Data-Constrained Language Models, from Muennighoff and colleagues in 2023, ran roughly 400 training runs, up to 900 billion training tokens and 9 billion parameters: “We find that with constrained data for a fixed compute budget, training with up to 4 epochs of repeated data yields negligible changes to loss compared to having unique data. However, with more repetition, the value of adding compute eventually decays to zero.” Four epochs is a number to plan against. Past it, each further pass is worth less than fresh text; the paper finds meaningful gains up to around 16 epochs and almost none by 40.
Inference compute has a measured payoff and a stated precondition. Snell and colleagues allocated test-time compute per prompt according to difficulty and improved efficiency by more than 4x over a best-of-N baseline. That was 2024. The FLOPs-matched comparison is the striking one: “Additionally, in a FLOPs-matched evaluation, we find that on problems where a smaller base model attains somewhat non-trivial success rates, test-time compute can be used to outperform a 14x larger model.” Read the condition as carefully as the 14x. The payoff was measured on problems where the small model already had non-trivial success rates. That is precisely where extra deliberation has something to work with.
Increase parameters
Expand capacity while keeping architecture broadly similar.
- May improve loss within a scaling regime
- Raises memory and serving demands
- Needs enough training data and updates
- Can increase fine-tuning and evaluation cost
Train on more tokens
Expose the model to more examples or repeated passes.
- Can reduce undertraining
- Data quality and duplication become limiting
- Raises legal and provenance burden
- May improve smaller models substantially
Spend more at inference
Generate candidates, deliberate longer, retrieve more, or use verifiers.
- Targets difficult requests selectively
- Adds latency and variable cost
- Needs a stopping policy
- Does not repair missing evidence automatically
Predict first
Does a famous fit survive a replication?
The compute-optimal rule behind Chinchilla was fitted three different ways, and the third way published a formula with confidence intervals on its coefficients. In 2024 an independent team rebuilt that third fit from the data points in the paper's own figure and asked whether the published numbers held.
Guess before reading on. How many training runs would it take to earn confidence intervals as narrow as the published ones: a few hundred, a few thousand, or hundreds of thousands?
Settle on an answer, then read on — the next section is the reveal
Key idea
Compute-optimal is conditional, not eternal
Compute-optimal studies estimate how model size and token count should scale under specific objectives, architectures, datasets and budgets. Their conclusions can change when the recipe or the deployment goal changes. A product team should use such results as priors for experiments. It should not treat a fitted exponent as a law that overrides current data quality, inference constraints, or task evaluation.
There is a stronger reason than caution. The most-cited fitted coefficients in this literature failed a replication. Besiroglu and colleagues at Epoch AI tried in 2024 to reproduce the third estimation procedure behind Chinchilla, and reported: “We find that the reported estimates are inconsistent with their first two estimation methods, fail at fitting the extracted data, and report implausibly narrow confidence intervals”. The arithmetic of that last point is the memorable part. Intervals that narrow would require over 600,000 experiments. The Chinchilla authors likely ran fewer than 500.
The rederived law, L(N,D) = 1.8172 + 482.01/N^0.3478 + 2085.43/D^0.3658, is consistent with the paper's other two approaches. The headline finding survived; a set of published exponents did not. Anyone planning a budget from a third-party fit is planning from an estimate that carries error the paper may not have printed.
Scaling laws narrow a search space; they do not replace a workload-specific decision.
Case
Seventy billion parameters ahead of two hundred and eighty
Chinchilla is the worked example, and its numbers are worth carrying. A 70-billion-parameter model, trained on four times more data than Gopher at the same compute budget, scored 67.5% on MMLU. That is more than 7% above Gopher and its 280 billion parameters. The result held against GPT-3 (175B), Jurassic-1 (178B) and Megatron-Turing NLG (530B) as well. Hoffmann and colleagues published it in 2022.
The headline is not the finding. The experiment behind it is. Their abstract states the base and the rule in one sentence: “By training over 400 language models ranging from 70 million to over 16 billion parameters on 5 to 500 billion tokens, we find that for compute-optimal training, the model size and the number of training tokens should be scaled equally: for every doubling of model size the number of training tokens should also be doubled.” Four hundred models, three orders of magnitude of parameters, two of tokens. The verdict on the large models of the day was that they were significantly undertrained. Chinchilla's 70B against Gopher's 280B is that rule spent on the other side of the ledger: a quarter of the parameters, four times the data, one compute budget.
The 67.5% deserves the same treatment, because it is an average and not a score. MMLU was introduced in 2020 by Hendrycks and colleagues, and it covers 57 subjects. Their account of how it was built: “We collected 15908 questions in total, which we split into a few-shot development set, a validation set, and a test set. The few-shot development set has 5 questions per subject, the validation set may be used for selecting hyperparameters and is made of 1540 questions, and the test set has 14079 questions.” At least 100 test examples sit under each subject. So 67.5% is an average accuracy over 57 tasks scored on 14,079 test questions, and a margin of more than 7% over Gopher is a margin between two such averages. That is a far more interesting claim than a single number. It is also a far weaker one than a single number sounds.
FigureInteractive
Five zero-based bars give the parameter counts Hoffmann and colleagues compare: Megatron-Turing NLG at 530B, Gopher at 280B, Jurassic-1 at 178B, GPT-3 at 175B and Chinchilla, the model that outperforms all four, at 70B. Gopher carries exactly 4.0 times Chinchilla’s parameters, while Chinchilla was trained on 4× more data than Gopher under the same compute budget — the same factor spent on the other side of the ledger. A second panel shows Chinchilla’s 67.5% average accuracy on MMLU with a dashed line at 60.5%: the paper states the margin, “greater than a 7% improvement over Gopher”, and not Gopher’s own score, so 60.5% is drawn as a ceiling rather than as a bar.
Analogy
A factory can buy machines, materials, or operating time
A factory with a fixed capital budget can buy more machines, supply more materials, or run selected production lines for longer. Model capacity, training data and inference effort are the three purchases. They are worth costing separately.
The prices do not hold still. Reused stock is worth almost as much as fresh stock for the first four passes, and its value then decays toward nothing. Operating time, allocated by how hard each order is, goes more than 4x as far as operating time spread evenly; it pays on the easy and middling orders and buys little on the hardest ones, where a bigger machine helps more. And the machine you buy depends on how many orders you expect to fill. Model training is a coupled optimization process. The value of each resource changes with architecture and data quality.
Ask how each unit of compute changes the measured system, not merely how large the final model becomes.
Experiment · One budget, two sides of the ledgerInteractive
An experiment on the numbers above. It needs JavaScript; the section itself works through the same numbers.
Steps
Build a compute-allocation experiment
Compare alternatives under the same decision target. Every anchor above is an experiment someone ran because a plausible argument was not enough: over 400 models for the equal-scaling rule, roughly 400 runs for the repetition threshold, 47 models to price inference into the law. The steps below are the small version of the same discipline.
1. Fix the product metric
Choose a workload-shaped quality and safety target.
2. Define comparable budgets
Include training, tuning, evaluation, and serving.
3. Vary one allocation
Change model size, tokens, or inference effort while controlling the rest.
4. Measure the frontier
Plot quality against cost, latency, and memory rather than one score.
5. Record the regime
Document architecture, objective, data mixture, and extrapolation limits.
Example
A compute-allocation experiment, computed
The five steps can be run on an invented budget, using two pieces of this lesson: the Epoch refit L(N,D) = 1.8172 + 482.01/N^0.3478 + 2085.43/D^0.3658, and the cost form Sardana and colleagues minimise, about 6 × N × D training FLOPs plus 2 × N per generated token. The product, the budget and the demand forecast are invented; every figure is computed from those inputs.
- Fix the product metric: in this invented case, a code-review assistant judged on pass rate over 2,000 held-out internal review tasks, with a p95 latency target of 1.5 s. The fitted loss below only ranks candidates for that test; it is not the test.
- Define comparable budgets: training compute is fixed at 6 × 10²¹ FLOPs, and the forecast is 1 billion requests of 500 generated tokens each. Serving then costs 2 × N × 5 × 10¹¹ FLOPs, which is counted in the same budget, not after it.
- Vary one allocation: spend the same training compute three ways. 7B parameters on 142.9B tokens (20.4 tokens per parameter), 3B on 333.3B (111) or 1.5B on 666.7B (444). The refit predicts losses of 2.172, 2.188 and 2.226.
- Measure the frontier: serving costs 7.0, 3.0 and 1.5 × 10²¹ FLOPs, so the totals are 13.0, 9.0 and 7.5 × 10²¹. The 3B option gives up 0.016 of predicted loss for 31% less total compute (4.0 ÷ 13.0 = 0.308). Which point wins is decided on the 2,000 tasks and the latency target, not on the loss.
- Record the regime: the refit was fitted to Chinchilla's extracted data, so the record names that limit. 444 tokens per parameter sits inside the range Sardana and colleagues trained (quality kept improving out to 10,000), and if the unique stock is smaller than 333B tokens, the 3B run repeats data, which stays almost as good as fresh data only up to about four passes.
Scale creates options and obligations
Larger training programs can produce broad capabilities. They also increase data, evaluation, security and serving obligations. And the smaller model wins often enough that it deserves a named case rather than a hedge.
LLaMA is that case. Touvron and colleagues at Meta AI trained 7B–65B models in 2023 on trillions of tokens from publicly available datasets only, and reported: “In particular, LLaMA-13B outperforms GPT-3 (175B) on most benchmarks, and LLaMA-65B is competitive with the best models, Chinchilla-70B and PaLM-540B.” Thirteen billion parameters against 175 billion. The smaller model is also the one you can afford to serve.
Small models can dominate when latency, privacy or specialization matters, and the published record now says they can also dominate on capability at a fraction of the size. The next lesson examines benchmarks and contamination. A scaling claim becomes useful only when the evaluation evidence measures the behavior the product needs — which is why it mattered, above, that 67.5% turned out to be an average over 57 subjects and 14,079 test questions.
Key takeaways
- Scaling laws are empirical and revisable. The 2020 power-law fit spanned more than seven orders of magnitude and prescribed very large models on relatively modest data, stopped before convergence — the prescription Chinchilla overturned two years later.
- The equal-scaling rule came out of over 400 models, from 70 million to over 16 billion parameters, trained on 5 to 500 billion tokens: for every doubling of model size, double the training tokens.
- Undertraining is capacity without exposure. Chinchilla's 70 billion parameters, trained on four times Gopher's data, beat Gopher's 280 billion at the same compute budget, scoring 67.5% on MMLU — an average over 57 subjects and 14,079 test questions.
- A fitted exponent is an estimate. Besiroglu and colleagues at Epoch AI found the published Chinchilla estimates inconsistent with the paper's own first two methods, with intervals so narrow they would require over 600,000 experiments against likely fewer than 500 runs.
- Serving cost belongs in the law, not after it. Sardana and colleagues trained 47 models and found that expected demand near 1 billion requests moves the optimum to smaller models trained longer, while test-time compute allocated by difficulty beat a 14x larger model FLOPs-matched on problems where the smaller model already had non-trivial success rates.
- A smaller specialized model can dominate on the relevant frontier: LLaMA-13B outperformed GPT-3 (175B) on most benchmarks and LLaMA-65B was competitive with Chinchilla-70B and PaLM-540B, all from publicly available datasets only.