Introduction

In 2020, a team at OpenAI noticed something strange: when they plotted the test loss of language models against model size, dataset size, or training compute, the result was not a messy cloud of points. It was a straight line on a log-log graph — a perfect power law extending over many orders of magnitude.

The finding, published by Kaplan et al., is now called the neural scaling law: for a broad class of tasks, the loss L falls as

L∝N−αL \propto N^{-\alpha}

where N is model size (or data, or compute) and α is a small positive exponent (typically 0.05–0.09 for language). Double the parameters, and loss drops by a fixed fraction — reliably, smoothly, without any phase transition.

This is not an obvious result. Deep learning is notoriously hard to predict. Yet the scaling law has held across seven or more orders of magnitude of model size. It turned AI research from an empirical guessing game into something closer to engineering: given a fixed compute budget, you can now calculate the optimal model size and token count before training begins.

Two years later, Hoffmann et al. (DeepMind, 2022) sharpened the picture with the Chinchilla models, showing the 2020 laws slightly under-counted the value of data. Their revised prescription: for every doubling of parameters, you should also roughly double the training tokens. This insight directly influenced the design of every major model since.

Try It

The chart below shows empirical cross-entropy loss versus model size for a family of language models. The x-axis is model parameters (log scale), the y-axis is held-out loss (log scale).

<div class="controls">
  <label>Noise: <input type="range" id="noise" min="0" max="0.15" step="0.005" value="0.04"></label>
  <span id="noiseVal">0.04</span>
  <button id="fitBtn" type="button">Fit power law</button>
  <button id="resetBtn" type="button" class="ghost">Reset</button>
</div>
<canvas id="chart" width="480" height="300"></canvas>
<div class="info" id="info">Adjust noise or click Fit power law.</div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; margin: 0; color: #222; }
.controls { display: flex; align-items: center; gap: .7rem; flex-wrap: wrap; margin-bottom: .6rem; font-size: .9rem; }
label { display: flex; align-items: center; gap: .4rem; }
input[type=range] { width: 90px; }
button { font: 600 13px system-ui; padding: .38rem .8rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 7px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
canvas { display: block; border: 1px solid #dde3ea; border-radius: 10px; max-width: 100%; }
.info { margin-top: .5rem; font-size: .92rem; font-weight: 600; min-height: 1.3em; color: #1d3557; }

const fmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Neural Scaling Laws demo: plot log(loss) vs log(params) and fit power law.
// Ground truth: L = C * N^(-alpha) with alpha = 0.076, C = 3.1 (Kaplan-style language model law).
// Model sizes sampled log-uniformly from 100K to 10B parameters (5 orders of magnitude).

const ALPHA_TRUE = 0.076;  // true power-law exponent (Kaplan et al. GPT-3 regime)
const C_TRUE     = 3.1;    // loss coefficient (entropy of dataset floor ~2.0, this is above it)
const SIZES_LOG  = [-6, -5.5, -5, -4.5, -4, -3.5, -3, -2.5, -2, -1.5, -1]; // log10(N/10^11)
// Param counts: 10^5, 10^5.5, ..., 10^10  (100K to 10B)
const PARAM_M    = SIZES_LOG.map(l => Math.pow(10, l + 11)); // params = 10^(l+11)

let noiseLevel = 0.04;
let fitted = false;
let fitAlpha = null, fitC = null;

function truePoints() {
  return PARAM_M.map(n => ({ n, loss: C_TRUE * Math.pow(n, -ALPHA_TRUE) }));
}

function noisyPoints() {
  const rng = seededRandom(42 + Math.round(noiseLevel * 1000));
  return truePoints().map(({ n, loss }) => {
    const logLoss = Math.log(loss) + noiseLevel * (rng() - 0.5) * 6;
    return { n, loss: Math.exp(logLoss) };
  });
}

// Simple seeded PRNG (mulberry32)
function seededRandom(seed) {
  let s = seed >>> 0;
  return function() {
    s += 0x6D2B79F5; let t = Math.imul(s ^ s >>> 15, 1 | s);
    t ^= t + Math.imul(t ^ t >>> 7, 61 | t);
    return ((t ^ t >>> 14) >>> 0) / 4294967296;
  };
}

// Ordinary least squares in log-log space: log(L) = log(C) - alpha*log(N)
function fitPowerLaw(pts) {
  const xs = pts.map(p => Math.log(p.n));
  const ys = pts.map(p => Math.log(p.loss));
  const n  = xs.length;
  const mx = xs.reduce((a,b)=>a+b,0)/n;
  const my = ys.reduce((a,b)=>a+b,0)/n;
  const sxx = xs.reduce((a,x)=>a+(x-mx)**2,0);
  const sxy = xs.reduce((a,x,i)=>a+(x-mx)*(ys[i]-my),0);
  const slope = sxy/sxx;         // this is -alpha
  const intercept = my - slope*mx; // this is log(C)
  return { alpha: -slope, C: Math.exp(intercept) };
}

const canvas = document.getElementById('chart');
const ctx    = canvas.getContext('2d');

function draw() {
  const pts = noisyPoints();
  const W = canvas.width, H = canvas.height;
  const pad = { l:54, r:20, t:18, b:40 };
  ctx.clearRect(0, 0, W, H);

  // Axis ranges in log10
  const logNmin = Math.log10(Math.min(...PARAM_M));
  const logNmax = Math.log10(Math.max(...PARAM_M));
  const allLoss = pts.map(p=>p.loss);
  if (fitted && fitAlpha !== null) {
    const fitMin = fitC * Math.pow(Math.min(...PARAM_M), -fitAlpha);
    const fitMax = fitC * Math.pow(Math.max(...PARAM_M), -fitAlpha);
    allLoss.push(fitMin, fitMax);
  }
  const logLmin = Math.log10(Math.min(...allLoss)) - 0.05;
  const logLmax = Math.log10(Math.max(...allLoss)) + 0.05;

  function xPx(n)    { return pad.l + (Math.log10(n)-logNmin)/(logNmax-logNmin)*(W-pad.l-pad.r); }
  function yPx(loss) { return pad.t + (logLmax-Math.log10(loss))/(logLmax-logLmin)*(H-pad.t-pad.b); }

  // Grid & axes
  ctx.strokeStyle = '#e5eaf0'; ctx.lineWidth = 1;
  // horizontal grid
  for (let lv = Math.ceil(logLmin*10)/10; lv <= logLmax+0.01; lv += 0.1) {
    const y = pad.t + (logLmax-lv)/(logLmax-logLmin)*(H-pad.t-pad.b);
    ctx.beginPath(); ctx.moveTo(pad.l, y); ctx.lineTo(W-pad.r, y); ctx.stroke();
  }
  // vertical grid (decade markers)
  for (let lv = Math.ceil(logNmin); lv <= logNmax+0.01; lv += 1) {
    const x = xPx(Math.pow(10,lv));
    ctx.beginPath(); ctx.moveTo(x, pad.t); ctx.lineTo(x, H-pad.b); ctx.stroke();
  }

  // Axis lines
  ctx.strokeStyle = '#9aa5b0'; ctx.lineWidth = 1.5;
  ctx.beginPath(); ctx.moveTo(pad.l, pad.t); ctx.lineTo(pad.l, H-pad.b); ctx.stroke();
  ctx.beginPath(); ctx.moveTo(pad.l, H-pad.b); ctx.lineTo(W-pad.r, H-pad.b); ctx.stroke();

  // Y axis labels
  ctx.fillStyle = '#555'; ctx.font = '11px system-ui'; ctx.textAlign = 'right';
  const lossLabels = [5, 4, 3.5, 3, 2.8, 2.6, 2.4, 2.2, 2.0];
  lossLabels.forEach(v => {
    if (Math.log10(v) >= logLmin && Math.log10(v) <= logLmax) {
      const y = yPx(v);
      ctx.fillText(v.toFixed(1), pad.l-5, y+4);
    }
  });

  // X axis labels (params in millions/billions)
  ctx.textAlign = 'center';
  const paramLabels = [
    { n: 1e5, label:'100K' }, { n: 1e6, label:'1M' }, { n: 1e7, label:'10M' },
    { n: 1e8, label:'100M' }, { n: 1e9, label:'1B' }, { n: 1e10, label:'10B' }
  ];
  paramLabels.forEach(({ n, label }) => {
    if (Math.log10(n) >= logNmin-0.1 && Math.log10(n) <= logNmax+0.1) {
      ctx.fillText(label, xPx(n), H-pad.b+16);
    }
  });

  // Axis titles
  ctx.save();
  ctx.translate(13, H/2); ctx.rotate(-Math.PI/2);
  ctx.font = '11px system-ui'; ctx.fillStyle = '#444'; ctx.textAlign = 'center';
  ctx.fillText('Loss (log scale)', 0, 0);
  ctx.restore();
  ctx.font = '11px system-ui'; ctx.fillStyle = '#444'; ctx.textAlign = 'center';
  ctx.fillText('Model parameters (log scale)', pad.l + (W-pad.l-pad.r)/2, H-2);

  // Fit line
  if (fitted && fitAlpha !== null) {
    ctx.beginPath(); ctx.strokeStyle = '#e63946'; ctx.lineWidth = 2;
    const x0 = Math.min(...PARAM_M), x1 = Math.max(...PARAM_M);
    ctx.moveTo(xPx(x0), yPx(fitC * Math.pow(x0, -fitAlpha)));
    ctx.lineTo(xPx(x1), yPx(fitC * Math.pow(x1, -fitAlpha)));
    ctx.stroke();
    // Slope annotation
    ctx.fillStyle = '#e63946'; ctx.font = 'bold 12px system-ui'; ctx.textAlign = 'left';
    ctx.fillText(fmt('slope = −%fitAlpha%  (−α)', { fitAlpha: fitAlpha.toFixed(3) }), xPx(1e7)+4, yPx(fitC * Math.pow(1e7,-fitAlpha))-8);
  }

  // Data points
  pts.forEach(({ n, loss }) => {
    ctx.beginPath();
    ctx.arc(xPx(n), yPx(loss), 5, 0, 2*Math.PI);
    ctx.fillStyle = '#1d6fa5'; ctx.fill();
    ctx.strokeStyle = '#fff'; ctx.lineWidth = 1.5; ctx.stroke();
  });
}

function update() { draw(); }

document.getElementById('noise').addEventListener('input', function() {
  noiseLevel = parseFloat(this.value);
  document.getElementById('noiseVal').textContent = noiseLevel.toFixed(3);
  fitted = false; fitAlpha = null;
  document.getElementById('info').textContent = 'Adjust noise or click Fit power law.';
  draw();
});

document.getElementById('fitBtn').addEventListener('click', function() {
  const result = fitPowerLaw(noisyPoints());
  fitAlpha = result.alpha; fitC = result.C;
  fitted = true;
  draw();
  document.getElementById('info').textContent =
    fmt('Fit: L = %C% × N^(−%alpha%)  |  true α = %ALPHA_TRUE%', { C: result.C.toFixed(2), alpha: result.alpha.toFixed(3), ALPHA_TRUE: ALPHA_TRUE.toFixed(3) });
});

document.getElementById('resetBtn').addEventListener('click', function() {
  fitted = false; fitAlpha = null;
  noiseLevel = 0.04;
  document.getElementById('noise').value = '0.04';
  document.getElementById('noiseVal').textContent = '0.04';
  document.getElementById('info').textContent = 'Adjust noise or click Fit power law.';
  draw();
});

draw();
Result
Console

Click Fit power law to overlay the best-fit line and read off the exponent α. Adjust the noise slider to add measurement scatter and see how robustly the law holds. Notice that the relationship is almost perfectly linear in log-log space — that is the scaling law. The slope is −α, the intercept encodes the irreducible entropy of the dataset.

The Real Complexity

The elegance of scaling laws hides several deep caveats.

What the law predicts well:

  • Loss on the training distribution decreases smoothly as a power law in N, D, and C.
  • Compute-optimal allocation: given a fixed FLOP budget C, the Chinchilla law says set N ≈ C0.5C^{0.5} and D ≈ C0.5C^{0.5} tokens. This was a practical revelation — earlier models were massively under-trained relative to their size.
  • Extrapolation: a law fit on 10M-parameter models can predict 70B-parameter loss with surprising accuracy.

What the law does not capture:

  • Emergent capabilities — some abilities (chain-of-thought reasoning, in-context learning) appear sharply at certain scales and are invisible in smooth loss curves. These phase transitions are not predicted by the power law.
  • Domain shift: the exponent α varies across modalities (images, code, proteins) and even across tasks within language. There is no universal constant.
  • The irreducible floor: loss approaches the true entropy of the data from above but never crosses it. Near that floor, more compute yields diminishing returns invisible in log-log space.
  • Alignment and behavior: loss is a proxy. A model can have lower loss and worse values, more capable reasoning, or more dangerous outputs. Scaling laws say nothing about any of these.

Scaling laws are empirical regularities, not theorems. They have been wrong before — the 2020 Kaplan et al. exponents slightly over-valued model size, which is why Chinchilla models are smaller and better-trained than their predecessors. Future architectural innovations could bend or break the current curves entirely.

From a complexity standpoint, scaling laws are fascinating because they suggest that the optimization landscape of neural network training has an unexpected regularity — the hard, non-convex search nonetheless traces a smooth frontier. Why this is true remains an open theoretical question.

Where It Matters

Scaling laws have moved from academic curiosity to operational doctrine at every major AI lab:

  • Hardware and budget planning: if you know α and your target loss, you can back-calculate the compute needed, then decide how many GPUs to rent and for how long — before writing a single line of model code.
  • Data curation: Chinchilla showed that data is as valuable as parameters. Labs now invest heavily in dataset quality and quantity, not just model architecture. The "tokens per parameter" ratio is a first-class engineering variable.
  • Architecture search: new architectures are evaluated partly by whether they shift the scaling curve — a lower loss at the same compute is a genuine improvement, independent of any specific benchmark.
  • AI safety and forecasting: scaling laws are used to predict when a model might cross capability thresholds. Organizations like Anthropic and DeepMind use them to anticipate risks before deployment and to schedule evaluations for dangerous capabilities.
  • Scientific modeling: the same power-law behavior appears in protein language models (e.g., ESM-2), code models, and multimodal systems. Scaling laws are becoming a cross-domain tool for scientific prediction.

Understanding scaling laws is understanding why the AI industry looks the way it does: a race to accumulate compute and data, because the math says bigger almost always wins — until it doesn't, and someone finds a better architecture.

Conclusion

Neural scaling laws are one of the most practically powerful empirical discoveries in modern science. A single relationship — loss falls as a power law in model size, data, and compute — has guided the construction of every major language model of the last five years, from GPT-3 to Gemini.

They are not magic. They break near the entropy floor, they miss emergent capabilities, and the exponents shift with architecture and domain. But within their domain of validity they are startlingly predictive, turning a field famous for surprises into something that can be planned.

The deeper mystery is why they hold at all. The optimization problem behind neural network training is non-convex and astronomically high-dimensional. Yet somehow, across architectures, tasks, and modalities, loss traces a clean power law. That regularity is waiting for a theory to explain it — and finding that theory may be the next great step in understanding intelligence itself.

Share this article

Pick a channel — or use your device's native share sheet.

Comments

Loading comments...

https://www.kipuhub.com/en/article/neural-scaling-laws/Content licensed under CC BY-NC 4.0.