Kaplan Scaling Laws › Loss vs. Parameters

Michael BrenndoerferJanuary 13, 20255 min read
Language AI HandbookAll chapters
Part 23 of 67Scaling Laws
Chapter 163Kaplan Scaling Laws › Loss vs. Parameters
Reading section 3 of 15 · Loss vs. Parameters · 5 minSection 3 of 15 · 5 min

Book contents

Section 3 of 15 · 5 min read

Kaplan Scaling Laws › Loss vs. ParametersOne section · Sections in this chapter3 / 15 ↓
Reading tools Definitions & inline links

Choose your expertise level to adjust how many terms are explained. Beginners see more tooltips, experts see fewer to maintain reading flow. Hover over underlined terms for instant definitions.

Article links

Make inline references clickable

The first major finding concerns how test loss decreases as models grow larger. This relationship answers a basic question practitioners face: if I make my model bigger, how much better will it perform? Before scaling laws, researchers had only rough intuitions. More parameters generally helped, but by how much? And for how long?

To understand why a power law might govern this relationship, consider what happens as you add parameters to a neural network. Early parameters learn common language patterns: basic grammar, frequent word associations, and simple semantic relationships. These patterns appear consistently in training data, so the model learns them reliably and they help reduce loss a lot. As you add more parameters, the model learns increasingly subtle and rare phenomena: unusual grammatical constructions, domain-specific terminology, and subtle contextual dependencies. Each new layer of complexity appears less frequently in the data and helps less with performance. This diminishing return is exactly what power laws describe.

When training models to convergence with effectively unlimited data, the relationship follows a power law:

L(N)=(NcN)αNL(N) = \left(\frac{N_c}{N}\right)^{\alpha_N}

where:

  • LL: the cross-entropy loss on held-out text, measuring how well the model predicts the next token
  • NN: the number of non-embedding parameters (trainable weights excluding embeddings)
  • NcN_c: a fitted constant representing the "characteristic scale" of parameters (approximately 8.8×10138.8 \times 10^{13})
  • αN\alpha_N: the scaling exponent (approximately 0.076), which determines how quickly loss decreases with more parameters
  • (NcN)\left(\frac{N_c}{N}\right): the ratio of the characteristic scale to the actual model size. When NN is small compared to NcN_c, this ratio is large, yielding higher loss

Let's examine this formula's structure. The characteristic scale NcN_c is a reference point, an astronomically large number of parameters (88 trillion) that is a normalizing constant. Think of NcN_c as the scale where the ratio Nc/NN_c/N equals 1. This makes the loss contribution from this term equal to 1. Since no practical model approaches this scale, the ratio Nc/NN_c/N is always much greater than 1 for real models. This produces loss values that decrease predictably as NN grows.

The power-law form appears because each additional parameter gives diminishing returns. The ratio Nc/NN_c/N captures how far the model is from some theoretical limit, and raising it to a small power αN\alpha_N yields the smooth, predictable decay we observe. Kaplan et al. found:

  • αN≈0.076\alpha_N \approx 0.076
  • Nc≈8.8×1013N_c \approx 8.8 \times 10^{13}

The exponent αN=0.076\alpha_N = 0.076 shows exactly how much improvement you get from scale. This small value tells us that each 10x increase in parameters yields a factor of 100.076≈1.1910^{0.076} \approx 1.19 reduction in the loss ratio (Nc/N)αN(N_c/N)^{\alpha_N}, or equivalently about a 16% decrease in the excess loss. In simpler terms: doubling the model size reduces loss by about 5%. This might seem modest, but loss improvements compound multiplicatively and cross-entropy loss relates exponentially to perplexity. Small loss reductions can mean noticeably better text generation.

In[3]:
Code
import numpy as np

# Kaplan scaling law parameters for loss vs N
alpha_N = 0.076
N_c = 8.8e13

# Generate parameter counts from 10M to 100B
N_values = np.logspace(7, 11, 100)  # 10^7 to 10^11 parameters

# Calculate predicted loss
L_N = (N_c / N_values) ** alpha_N

# Calculate improvement from doubling
doubling_improvement = 1 - (0.5**alpha_N)

# Define alpha_D and D_c here for use in later cells
alpha_D = 0.095
D_c = 5.4e13
Out[4]:
Visualization
Log-log plot showing test loss decreasing linearly with increasing model parameters.
Power-law relationship between test loss and model parameters. Each 10x increase in parameters produces a consistent decrease in loss, with the relationship remaining linear on log-log axes across four orders of magnitude.

The linearity on log-log axes confirms the power-law relationship. This was not obvious beforehand. The loss could have plateaued, shown diminishing returns, or shown more complex behavior. Instead, the relationship holds remarkably cleanly across four orders of magnitude in model size. The straight line you observe when plotting both axes on logarithmic scales is the defining signature of a power law, and its consistency across such a wide range suggests that the underlying phenomenon reflects something fundamental about how neural networks learn from data.