Paper Breakdowns  /  GPT-4 Report
Paper 86~10 min readOpenAI 2023worked math + runnable code
Paper Breakdown

The GPT-4 report,
explained.

The GPT-4 report is famous for what it doesn't say — no architecture, no parameter count, no training data. But buried in the redactions is one genuinely remarkable claim: OpenAI knew roughly how good GPT-4 would be before they trained it. Using runs with up to a thousand times less compute, they fit a curve and read the answer off the far end. A frontier model — the most expensive bet in tech — turned into an engineering forecast. That's predictable scaling, and here's the math that makes a giant run knowable in advance.

Video breakdown
The animated walkthrough is in production.
Read the full breakdown below in the meantime ↓
01

Knowing before training

Training a frontier model is one of the largest capital commitments in technology — months of time on tens of thousands of accelerators. Historically you found out whether it worked after you paid. The GPT-4 report's most important methodological claim flips that: OpenAI reported predicting GPT-4's final loss from a series of models trained with up to ~1000× less compute, and landing close to the mark.

This is predictable scaling. It rests on the scaling laws: a model's loss falls off as a smooth power law in training compute, and that curve is stable over many orders of magnitude. If it's that smooth, you don't need the giant run to know where it lands — you fit the curve on cheap small runs and extrapolate. The rest of the report is redacted; this idea is the part that changed how frontier labs work.

The one-sentence version

Loss follows a smooth power law in compute, so fit it on small, cheap runs and extrapolate to predict a giant run's final loss — knowing the outcome before spending the compute.

02

A curve you can trust

The reason extrapolation works is the shape of the loss curve. Across compute scales, loss follows a power law with an irreducible floor: a piece you can never remove (the inherent unpredictability of language) plus a reducible piece that shrinks as a power of compute. Plot loss against compute on log-log axes and the reducible part is a straight line — and a straight line is the easiest thing in the world to extend.

That straightness is what makes a 1000× extrapolation credible. A power law has no wiggles to surprise you: fit its slope and intercept on a handful of points and the line keeps going. The catch is that the fit must be on the reducible loss, so you need the floor — either known or fit jointly — before the log-log line appears. Get that right and the curve becomes a ruler you can lay across three orders of magnitude of compute.

03

De-risking the bet

Predictable scaling turns model development from a gamble into a plan. Before committing to the full run, you validate the recipe and infrastructure at small scale, fit the scaling curve, and confirm the final loss will land where you need it. If the small runs don't sit on a clean line, you've found a bug cheaply instead of expensively.

From cheap runs to a confident commit
Small runsTrain a ladder of cheap models across a range of compute.
FitFit the power law (slope + intercept) on the log-log line.
ExtrapolateRead off the predicted loss at 1000× the compute.
CommitLaunch the giant run knowing where it should land — a forecast, not a gamble.

It also lets you compare design choices at small scale and trust that the ranking holds at large scale — a much cheaper way to iterate than running everything at full size. This is how frontier labs now operate: a scaling study of small models de-risks the one enormous run that matters. The expensive run becomes the confirmation of a prediction, not an exploration into the unknown.

04

Fit small, predict big

Write the loss as an irreducible floor plus a power-law reducible term in compute C:

L(C)  =  L  +  a·C−b

L is the irreducible floor; a·C−b is the part compute buys down. As C grows, the second term vanishes and L approaches L.

Subtract the floor and take logs — the reducible loss is linear in log-compute, so a straight-line fit recovers the exponents:

log(L − L)  =  log a − b·log C   ⟹   fit (a, b) on small C,   then predict L(1000·C)

Because the relationship is a straight line in log-log space, the fit from small-compute runs extends across a huge gap with tiny error — that's why a prediction made from ~1000× less compute can be trusted. The runnable version below fits the law on small runs and nails the loss of a run using 1000× more compute.

RUN IT YOURSELF

Forecast a giant run from small ones

Predictable scaling is a straight-line fit in disguise. Loss is an irreducible floor plus a power-law term in compute; subtract the floor, take logs, and the reducible loss is linear in log-compute. Fit that line on a handful of small, cheap runs and it recovers the true exponents — then extrapolate to ~1000× more compute and the predicted loss matches the actual to within a whisker, far below any small-run loss. That's how you know a giant run will land before you pay for it. Change the small runs, the exponents, or the target compute and watch the forecast hold.

CPython · WebAssembly
05

What it showed

The report is thin on model details but rich in results and method:

ResultSignificance
Loss predicted from ~1000× less computeThe headline: accurate extrapolation of final loss, validating scaling as a planning tool.
Human-level exam performanceStrong scores on bar exams, SAT, AP tests and more — a broad capability leap over GPT-3.5.
Multimodal (image input)Accepts images as well as text, extending the model beyond language.
Deliberately closedWithheld architecture, size, and data — citing competition and safety — a notable shift toward opacity.

The report also predicted performance on a specific coding benchmark (HumanEval) by extrapolating from smaller models — a capability, not just a loss — showing prediction can sometimes reach downstream skills. But it candidly flagged the opposite too, which is where the honest limits of the method appear.

06

The limits of prediction

Predictable scaling is powerful precisely because it's about loss — a smooth, aggregate quantity. Individual capabilities are dicier. Some appear abruptly at scale (emergent abilities), and the GPT-4 report itself flagged a task where performance ran opposite to the small-scale trend — a case of inverse scaling. So while the report predicted its overall loss beautifully, it was candid that predicting which specific skills a given loss unlocks remains unsolved.

That tension defines the frontier. Loss is a ruler; capabilities are a surprise. The lasting influence of the GPT-4 report isn't a specific number — it's the operating model it legitimized: treat a frontier run as a forecast to be validated, not a mystery to be discovered, and invest in scaling studies so the one giant run is a near-sure thing. Every serious lab now builds this way. The report's redactions made headlines; its scaling methodology quietly reshaped how big models get built.

Worth knowing

Predicting loss is not the same as predicting usefulness. Two models with the same loss can differ in emergent skills, and a benchmark can even invert with scale — so labs still run the big model to discover capabilities, even when the loss was known in advance.

Frequently asked

Quick answers

What is the GPT-4 report known for?

OpenAI's 2023 technical report — light on model details, but famous for demonstrating predictable scaling: forecasting GPT-4's loss from far smaller runs.

What is predictable scaling?

Loss follows a smooth power law in compute, so you fit it on cheap small runs and extrapolate to predict a much larger run's final loss.

Why does it matter?

It turns an enormously expensive training run from a gamble into a forecast — you know roughly where it lands before spending the compute.

Where does it break?

Loss is predictable, but specific capabilities can emerge abruptly or even invert with scale, so skill-level prediction is still unsolved.

Finished this one? 0 / 101 Paper Breakdowns done

Explore the topic

See this alongside everything else on the same subject — handbooks, system designs, challenges and tools, in one place.

More Paper Breakdowns