The model-collapse cure that still forgets the glasses

Imagine teaching a photocopier from photocopies. The usual model-collapse story says each generation loses a little detail until the page becomes grey mush. This paper asks a deceptively practical question: what if you keep the earlier pages instead of throwing them away?

Gerstgrasser and colleagues repeatedly trained language models, image generators, molecular models, and a tractable linear model. Replacing yesterday's data with today's synthetic output made error grow. Accumulating every generation alongside the original data made the error level off.

A generation here is one round of fitting a model, sampling synthetic training examples from it, and fitting its successor. Each synthetic batch carries a little sampling noise. If the new batch replaces all earlier data, its error becomes the next model's reality.

The paper calls worsening performance across these rounds model collapse. Its cleanest demonstration uses linear regression: inputs x have a true relationship y = x·w* + ε, and every successor learns a new slope from labels made by the previous slope.

This is deliberately simpler than an LLM. It isolates the bookkeeping decision—replace or retain—without attention layers, tokenizers, or optimization failures getting in the way.

Let T be samples per generation, d the number of features, and σ² the label-noise variance. The paper's shared scale factor is σ²d/(T−d−1). Under replacement, every generation adds another full-strength error term:

E_replace(n) = [σ²d/(T−d−1)] n

Even making generation i contain iT synthetic samples only softens the growth to the harmonic series 1 + 1/2 + … + 1/n. It grows slowly, but it never stops.

def error_curves(n, T, d, sigma2):
    scale = sigma2 * d / (T - d - 1)
    h1 = sum(1 / i for i in range(1, n + 1))
    h2 = sum(1 / i**2 for i in range(1, n + 1))
    return {
        "replace": scale * n,
        "replace_multiple": scale * h1,
        "accumulate": scale * h2,
        "bound": scale * pi**2 / 6,
    }

With accumulation, generation i contributes only 1/i of the full training set. Squared error turns that into 1/i². Those terms are summable: their total approaches a number instead of drifting forever.

The site's TypeScript reconstruction fixes one set of scalar inputs, gives both regimes the same seeded Gaussian noise at every generation, and refits an ordinary least-squares slope from scratch. The code below is the accumulating update; replacement simply keeps the newest batch slope.

def next_generation(xs, noise, parent, old_batches, generation):
    ys = [parent * x + e for x, e in zip(xs, noise)]
    batch_slope = sum(x * y for x, y in zip(xs, ys)) / sum(x * x for x in xs)
    new_batches = old_batches + batch_slope
    new_slope = new_batches / generation
    return new_slope, new_batches

The authors pretrained small GPT-2 and Llama-2 models on TinyStories. At each round, they either replaced the corpus with text from the previous model or concatenated the new synthetic corpus to the history. Cross-entropy is the model's average surprise on held-out text; lower is better.

Growing the replacement corpus to match the accumulated corpus did not fix the trend: for the 9M-parameter GPT-2, generation-4 loss was 2.18 instead of 2.39, still above the generation-1 loss of 1.82. More synthetic samples are not equivalent to preserving an anchor to history.

There is also a compute bill. Accumulation makes generation n train on nT examples. The paper explicitly notes that one epoch therefore means more gradient steps for later accumulated models. Its growing all-synthetic control shows that size alone does not explain the benefit, but retention is not free.

• Track tail-specific recall alongside average loss, so a stable headline metric cannot hide disappearing rare concepts.
• Hold training tokens and gradient steps fixed, then compare replay, weighted sampling, and curated real-data anchors under the same compute.
• Vary who generated the synthetic data: one ancestor, many independent models, or a filtered mixture with known provenance.

To inspect the model family used in the text experiment, visit the Transformer page. For the tractable proof, the linear-regression page lets you poke at the same least-squares geometry without a recursive data loop.