Predicting benchmark accuracy from small models, with intervals that cover

Before committing a large training run, teams want to know what it will score on the benchmarks that matter. The usual method is to train a ladder of small models, fit a curve and extrapolate. This note shows why that curve is a sigmoid in log-compute, why "emergent" jumps are often a property of the metric rather than the model, which metrics make extrapolation tractable, and how to build a prediction interval that actually contains the answer. In our seeded simulation, intervals that ignore model-to-model scatter covered the truth 57 to 87% of the time when they claimed 90%.

A worked example: six small models and one large bet#

Suppose you have trained six small models on the same data mix, from $10^{20}$ to about $1.8\times 10^{21}$ training FLOPs, and evaluated each on a 1,000-item, four-option multiple-choice benchmark. Their accuracies climb from about 30% to the low 40s. The run you are planning uses $3\times 10^{23}$ FLOPs, more than two orders of magnitude beyond the largest small model. Leadership wants to know whether it will clear 75%.

A straight line through the six points will not do: accuracy is bounded below by chance (25%) and above by 100%, and it bends at both ends. The standard move is to fit an S-shaped curve to accuracy against log-compute and read off the value at the target. Our simulation does exactly that, many times over, against a known ground truth. The fit at the target lands near the true 80% on average, but any single fit can be off by several points, and with only four small models the median error is 14 points. The interesting question is not the point estimate. It is how wide the error bar should be, and whether the method you use to compute it is honest.

Everything below uses one generative model, described in the next section, so that every claim can be checked against the truth. It is a simulation: no real training runs were involved, and real model ladders have additional sources of error discussed under failure modes.

Why accuracy is sigmoidal in log-compute#

Start with one item. Item response theory (see our note on IRT for LLM evals) models the probability that a model answers item $i$ correctly as

where $\theta$ is the model's ability, $d_i$ is the item's difficulty, and $g$ is the guessing floor (0.25 for four options). The intuition: a model far below an item's difficulty guesses, a model far above it nearly always succeeds, and the transition is smooth.

Now tie ability to scale. Within one model family trained on one data mix, a convenient and empirically reasonable assumption is that ability rises linearly in log-compute:

where $C$ is training compute in FLOPs, $\beta$ is the ability gained per decade of compute, $x_0$ is the compute at which ability equals the average item difficulty, and $u$ is a model-specific deviation (seed, data order, small recipe differences) with standard deviation $\tau$. Benchmark accuracy is the average of $P_i$ over items, which, for difficulties spread around a mean, is itself a smoothed S-curve. In practice it is summarised by a two-parameter sigmoid with a fixed floor:

where $A$ is expected accuracy, $s$ is the slope (in logits per decade of compute) and $c$ is the log-compute at the curve's midpoint. Owen [1] and Ruan, Maddison and Hashimoto [2] found sigmoids of this kind describe many benchmarks well across families, and the four-option floor matters: fitting a sigmoid that runs from 0 to 1 to multiple-choice accuracy biases both parameters.

Simulation setup. A fixed benchmark of 1,000 items with difficulties $d_i\sim \mathcal{N}(0,1)$, $g=0.25$, $\beta =1.25$ per decade, $x_0=22.5$ and $\tau =0.2$. Each simulated model answers every item once, so its observed accuracy carries binomial noise (about 1.4 points at 50%). The target model at $x=23.5$ has a true expected accuracy of 80.5%. Small models sit at $x=20.0,20.25,\dots$, so a ladder of $K$ models reaches $x=20+0.25(K-1)$.

Emergence as a metric artifact#

Wei and colleagues catalogued "emergent abilities": tasks where performance sits near zero for small models and then rises sharply past some scale [3]. Schaeffer, Miranda and Koyejo argued that many such jumps come from the metric [4]. If a model must get every one of $L$ tokens right to score on exact match, and its per-token accuracy $p$ improves smoothly, the task score is

which stays near zero while $p$ is moderate and then rises steeply once $p$ approaches 1. Raising a number below one to a high power squashes everything except values close to one.

The practical consequence for prediction is direct. Small models on the flat part of the exact-match curve give you points that are all near zero, so they say almost nothing about where the rise will start. The per-token curve, by contrast, moves at every scale. The log-probability of the full answer, $L\log p$, is close to linear in $x$ over the low range, which makes it the easiest of the three to extrapolate.

Two caveats keep this from being the whole story. Du and colleagues showed that, holding data and architecture fixed, some tasks stay at chance until pre-training loss crosses a threshold even under continuous metrics [5], so not every jump is an artifact. And Schaeffer and colleagues later traced why multiple-choice accuracy in particular is hard to predict: it depends on how probability mass moves between the correct option and a few specific distractors, not just on the mass assigned to the correct answer [6]. Choosing a continuous metric helps, but which continuous metric matters.

Choosing a metric that moves#

The goal is a quantity that changes measurably across your small-model ladder and maps monotonically onto the score you care about. Candidates, roughly in order of how smooth they are in log-compute:

The two-step approach uses this structure explicitly. Step one fits a smooth trend of a continuous quantity against compute; step two maps that quantity onto accuracy with a link function. Gadre and colleagues predicted downstream averages from loss this way [7], Bhagia and colleagues predicted the accuracy of 7B and 13B models on four multiple-choice tasks within about two points, using ladder models that cost 1% of the target compute [8], and Ruan and colleagues fitted the link on a large set of public models from many families, which is what makes it identifiable when your own ladder sits on the flat part of the curve [2].

We simulated a version of this. The continuous metric is the mean margin over items, which in our generative model moves one-for-one with ability. Step one is an ordinary least-squares line of mean margin against $x$ on the $K$ small models. Step two is a sigmoid link from margin to accuracy, fitted on 40 reference models from four other simulated families that span $10^{20}$ to $10^{25}$ FLOPs (link error 1.4 points RMS). Note what this buys: the reference models reach the top of the curve, so the link's shape is learned from data your ladder never sees.

Prediction intervals that cover#

A prediction interval for the target model has to account for four things:

1. Item sampling noise in each small model's measured accuracy, $A(1-A)/n$ for $n$ items.
2. Model-to-model scatter: two models at the same compute differ by $u$, so the small-model points scatter around the curve by more than binomial noise.
3. Parameter uncertainty in $s$ and $c$, which grows quickly with extrapolation distance.
4. The target model's own deviation $u_{\text{target}}$, which no amount of small-model data removes.

A delta-method approximation makes the structure visible. Writing $\hat{z}=\hat{s}(x_t-\hat{c})$ for the fitted logit at the target compute $x_t$,

where ${\sigma }^{\prime }(z)=\sigma (z)(1-\sigma (z))$ is the sigmoid's slope, $\Sigma$ is the covariance of $(\hat{s},\hat{c})$, $\nabla \hat{z}$ is the gradient of the logit with respect to those two parameters, ${\tau }^2$ is the model-level variance in logit units, and the last term is the target's own item noise. In words: parameter uncertainty and model scatter both enter in logit space and are scaled by how steep the curve is at the target, and item noise is added on top. The gradient with respect to $c$ is $-\hat{s}$, and with respect to $s$ it is $x_t-\hat{c}$, so the variance grows with the square of the extrapolation distance.

The delta method is unreliable when the fit is barely identified, so in practice we use a parametric bootstrap: simulate new small-model accuracies from the fitted curve with both binomial noise and scatter, refit, add a draw of the target's deviation and item noise, and take quantiles. The "naive" version keeps only binomial noise. The "honest" version adds scatter with $\hat{\tau }$ estimated from residuals of sigmoid fits to the four reference families ($\hat{\tau }=0.15$ logits, a median-based estimate).

We repeated the whole procedure 400 times for each ladder size $K$, each time drawing fresh small models and a fresh target model, and recorded how often the 90% interval contained the target's observed accuracy.

Three findings stand out.

Naive intervals get worse with more data. At $K=10$ the binomial-only interval is a median 7.5 points wide and covers 57% of the time. The fit is precise about the curve through these particular models, but the target is a different model, and its deviation alone is a few points of accuracy. Coverage falls as $K$ rises because the parameter uncertainty that was masking the missing term shrinks.

Honest intervals are wide, and that is the correct answer. With four models still near chance, the honest 90% interval is about 50 points wide. That is not a failure of the method; it is what the data say. A ladder that never leaves the floor cannot tell you where the rise starts. Even the honest intervals undercover by 6 to 9 points at larger $K$, because $\hat{\tau }$ is itself estimated from only four reference families and the bootstrap does not propagate that uncertainty.

The two-step method cuts error by roughly a third. Median absolute error falls from 14.4 to 9.3 points at $K=4$ and from 6.9 to 4.2 at $K=6$. Its intervals undercover when $K\le 4$, because a line fitted to three or four points gives a poor residual variance estimate. The gain is an upper bound: in this simulation the margin metric is exactly linear in ability and the link is shared across families, which are the method's assumptions. Real metrics are noisier and real families share links only approximately [2, 6].

Practice: a checklist for scaling predictions#

The core of the honest bootstrap is short. This is the Python we used, minus plotting:

import numpy as np
from scipy.special import expit

def fit(x, y, s=1.0, c=22.5, iters=60):
    # Gauss-Newton for y = .25 + .75 * sigmoid(s * (x - c))
    for _ in range(iters):
        z = s * (x - c); g = 0.75 * expit(z) * (1 - expit(z))
        J = np.stack([g * (x - c), -g * s], 1)
        r = y - (0.25 + 0.75 * expit(z))
        ds, dc = np.linalg.solve(J.T @ J + 1e-6 * np.eye(2), J.T @ r)
        s = np.clip(s + np.clip(ds, -.5, .5), .15, 4); c = np.clip(c + np.clip(dc, -1, 1), 19, 27)
    return s, c

def interval(x, acc, x_t, tau, n_items=1000, B=300, rng=np.random.default_rng(0)):
    s, c = fit(x, acc)
    yhat = 0.25 + 0.75 * expit(s * (x - c))
    slope = 0.75 * expit(s * (x - c)) * (1 - expit(s * (x - c)))
    sd = np.sqrt(yhat * (1 - yhat) / n_items + (slope * tau) ** 2)   # binomial + scatter
    preds = []
    for _ in range(B):
        sb, cb = fit(x, yhat + rng.normal(0, sd), s, c)
        p = 0.25 + 0.75 * expit(sb * (x_t - cb) + rng.normal(0, tau))  # target's own deviation
        preds.append(p + rng.normal(0, np.sqrt(p * (1 - p) / n_items)))
    return np.quantile(preds, [0.05, 0.95])

Failure modes#

Recipe drift. Ladders are trained months before the target, and the target's data mix, tokenizer or learning-rate schedule changes. Every one of those moves $x_0$ and possibly $\beta$. Gadre and colleagues showed that loss under over-training (more tokens per parameter than compute-optimal) is predictable from small runs, but their scaling law has the token-to-parameter ratio as an explicit input [7]. A ladder trained at a different ratio from the target is answering a different question.

Non-monotone tasks. Some tasks get worse with scale over part of the range, for example when larger models more faithfully reproduce a misleading pattern in the prompt [9]. A sigmoid cannot represent that, and its interval will be confidently wrong.

Ceiling below 100%. If 4% of the benchmark's labels are wrong, the achievable ceiling is about 96%, and a sigmoid forced to 1 will overpredict near the top. Estimate the ceiling from the best available models or from an audit of the items, and fit it as a parameter when the target is expected to be near saturation.

Contamination. If the target's larger data mix contains benchmark items that the ladder's data did not, the target will beat the forecast for reasons unrelated to capability. See contamination detection.

Prompt and format sensitivity. Small models are more sensitive to prompt format, so ladder points can be depressed by format failures that the target does not have. Score with the formulation that is most stable across scale (Bhagia and colleagues formatted their tasks as ranked classification for their predictions [8]) and keep it fixed.

Treating aggregate predictability as task predictability. Averages over many tasks are much more predictable than single tasks: Owen reported about 6 points of error extrapolating BIG-Bench Hard averages one decade ahead, against 18 points for individual tasks [1]. A good forecast of the average says little about the one task a safety case depends on.

Ignoring the evaluation's own error bars. The target model's observed accuracy has item-sampling noise, and if items are clustered (several questions per passage) the noise is larger than binomial. Our note on clustered standard errors covers the correction.

The forecasting work cited here is what made capability prediction a routine part of planning large runs; the GPT-4 report, for instance, described predicting a coding pass rate from models trained with at most 1/1,000th of the compute [10]. The craft lies less in the curve than in the interval around it.

Frequently asked questions#

Sources#

1. D. Owen. How predictable is language model benchmark performance?, 2024. arxiv.org
2. Y. Ruan, C. J. Maddison, T. Hashimoto. Observational Scaling Laws and the Predictability of Language Model Performance, 2024. arxiv.org
3. J. Wei, Y. Tay, R. Bommasani, C. Raffel et al.. Emergent Abilities of Large Language Models, 2022. arxiv.org
4. R. Schaeffer, B. Miranda, S. Koyejo. Are Emergent Abilities of Large Language Models a Mirage?, 2023. arxiv.org
5. Z. Du, A. Zeng, Y. Dong, J. Tang. Understanding Emergent Abilities of Language Models from the Loss Perspective, 2024. arxiv.org
6. R. Schaeffer, H. Schoelkopf, B. Miranda, G. Mukobi et al.. Why Has Predicting Downstream Capabilities of Frontier AI Models with Scale Remained Elusive?, 2024. arxiv.org
7. S. Y. Gadre, G. Smyrnis, V. Shankar, S. Gururangan et al.. Language models scale reliably with over-training and on downstream tasks, 2024. arxiv.org
8. A. Bhagia, J. Liu, A. Wettig, D. Heineman et al.. Establishing Task Scaling Laws via Compute-Efficient Model Ladders, 2024. arxiv.org
9. I. R. McKenzie, A. Lyzhov, M. Pieler, A. Parrish et al.. Inverse Scaling: When Bigger Isn't Better, 2023. arxiv.org
10. OpenAI. GPT-4 Technical Report, 2023. arxiv.org