This model collapse simulation asks a simple question: how much real data does it take before recursive synthetic training stops drifting?

Generative AI creates an unusual feedback problem.

Models are trained on data produced by people.

Those models then generate enormous amounts of synthetic text, images, audio and code.

Some of that synthetic material eventually finds its way back into future training datasets.

That creates a natural question:

What happens when models are repeatedly trained on data generated by previous models?

Recent research has raised concerns about model collapse: degradation that can occur when generative models are recursively trained on model-generated data.

But another question is just as interesting:

How much real data is needed to slow or stabilise that degradation?

Instead of starting with a large language model, this experiment deliberately reduces the problem to something much smaller.

We will simulate a simple probability distribution, repeatedly generate synthetic data from an estimated version of that distribution, retrain on the generated data, and observe what happens across generations.

Then we will mix different amounts of real data back into the training set.

The objective is not to simulate an LLM.

It is to isolate one mechanism behind recursive synthetic training in a system simple enough to inspect completely.

1. What Is Model Collapse?

Suppose we begin with a real data distribution.

For simplicity:

X ~ Normal(μ, σ²)

We draw real samples from that distribution and estimate:

the mean μ
the standard deviation σ

We then generate synthetic samples from the estimated distribution.

Next, instead of returning to the original real distribution, we estimate a new distribution from those synthetic samples.

Then we repeat:

real data

↓

model₁

↓

synthetic data₁

↓

model₂

↓

synthetic data₂

↓

model₃

↓

…

Small sampling errors can propagate through this recursive process.

The model does not reproduce the true distribution perfectly.

It reproduces an estimate of the distribution.

The next model then learns from an estimate of an estimate.

Repeated often enough, those errors can accumulate.

In more complex generative systems, related recursive-training effects can lead to loss of information about the original distribution, particularly in low-probability regions or tails [1][2].

2. Why Use a Gaussian Toy Model?

Real generative models are enormously more complicated than a Gaussian distribution.

A language model contains billions of parameters.

Language is high-dimensional.

Training datasets contain complicated dependencies.

Human and synthetic data are difficult to separate perfectly.

So why simulate a Normal distribution?

Because simplicity gives us control.

We know:

the true distribution,
the true mean,
the true standard deviation,
how data are generated,
how the model is estimated,
how much real data enters each generation,
and exactly how recursive training is performed.

Nothing is hidden.

This makes the simulation useful for understanding a mechanism.

But the limitation must be explicit:

This experiment is a minimal simulation of recursive distributional degradation. It is not a simulation of full-scale LLM training and cannot establish how much human-generated data a real language model requires.

That distinction is central to interpreting everything that follows.

3. The Experiment

Start with a true distribution:

X ~ Normal(0, 1)

Therefore:

true μ = 0

and:

true σ = 1

Draw a finite training sample.

Estimate the distribution:

μ̂ = sample mean

σ̂ = sample standard deviation

Then generate synthetic data from:

Xsynthetic ~ Normal(μ̂, σ̂²)

Estimate another model from those generated samples.

Repeat across many generations.

The key variable we track is:

estimated standard deviation, σ̂

Why?

Because if the estimated distribution becomes narrower, it is losing variability relative to the original distribution.

4. The First Hypothesis

It is tempting to write:

“σ will decrease monotonically with every generation.”

But that is too strong.

This is a stochastic simulation.

Individual generations can move upward or downward simply because of sampling variation.

So the scientifically appropriate hypothesis is:

H1: Across repeated simulations, recursive training on synthetic data alone will tend to reduce the expected estimated standard deviation over generations relative to the original distribution.

That wording matters.

We are predicting a systematic tendency across repeated simulations, not requiring every individual run to move downward at every generation.

5. Why Variance Can Drift

Imagine that the true standard deviation is:

σ = 1.00

A finite sample might produce:

σ̂₁ = 0.97

Now we generate the next dataset from:

Normal(μ̂₁, 0.97²)

The next estimate might be:

σ̂₂ = 0.94

Then:

σ̂₃ = 0.96

Then:

σ̂₄ = 0.91

Notice something important.

The sequence is not monotonic.

It went:

0.97 → 0.94 → 0.96 → 0.91

One generation temporarily increased.

But the broader process can still exhibit systematic degradation across repeated runs.

That is why a single trajectory is not enough.

6. Run Many Independent Simulations

To separate stochastic variation from systematic behaviour, we repeat the experiment across many independent random seeds.

Conceptually:

for seed in seeds:

    initialise_real_distribution()

    for generation in generations:

        estimate_model()

        generate_synthetic_data()

        record_statistics()

Then, for each generation, calculate statistics across runs.

For example:

mean estimated σ,
median estimated σ,
standard deviation across runs,
quantiles or confidence intervals.

This produces a much stronger result than selecting one visually interesting trajectory.

7. Now Add Real Data Back

The more interesting experiment is not pure synthetic recursion.

It is mixing real and synthetic data.

Suppose every new generation receives a dataset containing:

r% real data

and:

(100 − r)% synthetic data

We can test values such as:

0% real

5% real

10% real

20% real

50% real

100% real

For each mixture, we repeat the recursive-training simulation.

The question becomes:

How does the amount of real data affect the stability of the estimated distribution over generations?

8. The Second Hypothesis

Our second hypothesis is:

H2: Increasing the proportion of real data in each generation will reduce recursive distributional drift and keep the estimated distribution closer to the original distribution.

Again, notice what this does not say.

It does not claim:

“20% real data prevents model collapse.”

That would be far too general.

At most, the experiment can establish something like:

“Under this simulation, this mixture produced substantially greater distributional stability than pure synthetic recursion.”

That is the appropriate scope.

9. Measuring Collapse

We need to define what “collapse” means in this experiment.

Here, we are not measuring language quality, semantic diversity or factuality.

We are tracking properties of a one-dimensional probability distribution.

Useful measurements include:

Mean drift

|μ̂g − μtrue|

This tells us how far the estimated centre has moved from the original distribution.

Standard-deviation drift

|σ̂g − σtrue|

This tells us how much the estimated spread has changed.

Variance retention

A useful normalised quantity is:

σ̂g / σtrue

If:

σtrue = 1

and:

σ̂g = 0.70

then the estimated standard deviation retains approximately 70% of the original scale.

These metrics give us explicit definitions rather than relying on a vague statement that the distribution “looks collapsed.”

10. What Happens With 0% Real Data?

In the pure synthetic condition:

real fraction = 0

each generation is trained entirely on samples produced from the previous generation’s estimated distribution.

There is no direct connection back to the original data-generating process.

Sampling error can therefore propagate.

Across repeated runs, the distribution can drift away from the original parameters.

Some individual runs may temporarily move closer to the original distribution.

Others may move farther away.

The important observation is the distribution of outcomes across repeated simulations, not whether every line falls smoothly.

This is precisely why the original “monotonic” wording should be avoided.

11. What Happens When Real Data Is Mixed In?

Now suppose each generation includes some fresh data drawn from the original distribution.

The training distribution becomes conceptually:

training data = real component + synthetic component

The real component repeatedly reconnects the estimation process to the original data-generating distribution.

As the real-data fraction increases, we expect the recursive process to become more stable.

The interesting question is not whether real data helps.

In this simulation, we have good reason to expect that it will.

The more interesting question is:

How quickly does stability improve as the real-data fraction increases?

Is 5% enough to produce a noticeable effect?

Does 10% dramatically improve stability?

Does moving from 20% to 50% produce another large gain?

Those are empirical questions.

12. Interpreting a Threshold Carefully

Suppose the simulation shows:

Real-data fraction	Behaviour
0%	strong drift
5%	reduced drift
10%	substantially more stable
20%	close to original
50%	highly stable

It would be tempting to conclude:

“10% real data prevents model collapse.”

That would be the wrong conclusion.

The appropriate statement would be:

“In this particular simulation, mixtures containing at least around 10% real samples substantially reduced the measured distributional drift under the chosen sample size, number of generations and estimator.”

Those qualifiers matter.

Change:

sample size,
dimensionality,
estimator,
distribution,
number of generations,
synthetic-generation process,

and the apparent threshold can change.

There is no universal percentage implied by this experiment.

13. “Slowing” Is Different From “Stopping”

This is why I prefer the title:

How Much Real Data Slows Model Collapse?

rather than:

How Much Real Data Stops Model Collapse?

“Stops” suggests a universal boundary:

Above this amount, model collapse no longer occurs.

The simulation cannot establish that.

At best, we can observe that particular real-data mixtures keep particular measured statistics close to the original distribution over the finite number of generations we tested.

A longer simulation could behave differently.

A different distribution could behave differently.

A high-dimensional model could behave very differently.

So throughout this experiment, stability and slowing degradation are more defensible terms than universal prevention.

14. Why Tails Matter

Variance is only one way a distribution can lose information.

Model-collapse research has highlighted another important effect:

low-probability regions can be disproportionately vulnerable.

Imagine a distribution containing rare but legitimate cases.

If those cases are underrepresented in one generation of synthetic data, the next model sees fewer examples of them.

That model may then generate them even less frequently.

The next generation sees fewer again.

Conceptually:

rare → rarer → nearly absent

This can create a feedback loop.

In real machine-learning systems, those rare cases may represent:

uncommon linguistic expressions,
minority behaviours,
unusual images,
edge cases,
rare events,
specialised knowledge.

That is one reason recursive synthetic training is more than simply a question of average model accuracy.

15. Why Synthetic Data Is Not Inherently Bad

It would also be wrong to interpret this experiment as:

“Synthetic data is dangerous.”

Synthetic data can be extremely useful.

It can help:

augment small datasets,
balance classes,
simulate rare events,
protect privacy in some settings,
generate training examples,
support distillation,
reduce data-collection costs.

The issue is not:

synthetic data = bad

The issue is:

What happens when synthetic data recursively replaces information from the original data-generating process?

That is a much more specific question.

16. Real Data Acts Like an Anchor

A useful way to interpret the experiment is to think of real data as an anchor.

With pure recursive synthetic training:

generation g learns from generation g − 1

Errors can propagate.

When real data is introduced:

generation g learns partly from generation g − 1

and partly from:

the original distribution

That second source repeatedly reintroduces information that may have been weakened or lost in previous synthetic generations.

In this minimal simulation, increasing the real-data fraction should therefore reduce drift.

The important research question becomes:

How strong does that anchor need to be under a particular recursive-training process?

17. What This Experiment Actually Demonstrates

The simulation can support conclusions such as:

1. Recursive synthetic training can create distributional drift

When each generation learns only from data generated by the previous estimated model, estimation errors can propagate.

2. Individual trajectories are noisy

A statistic such as estimated σ does not need to decline monotonically in every generation for a systematic degradation process to exist.

3. Reintroducing real data can stabilise the process

Mixing samples from the original distribution into later generations can reduce drift.

4. The amount of real data matters

Different mixture ratios can produce different levels of stability.

5. Any apparent threshold is experiment-specific

A percentage that works in this simulation should not be interpreted as a universal requirement for generative AI systems.

18. What This Experiment Does NOT Demonstrate

This section is particularly important.

The experiment does not tell us:

what percentage of human-written text GPT-like models need.

It does not tell us:

when future internet-scale training datasets will collapse.

It does not prove:

synthetic data inevitably damages large language models.

It does not establish:

a universal real-to-synthetic data ratio.

And it does not reproduce:

the full mechanism of model collapse in high-dimensional generative models.

The simulation is deliberately minimal.

Its value comes from making one recursive mechanism visible—not from pretending that a Gaussian estimator is an LLM.

19. Why Real Generative Models Are More Complicated

A real language-model training pipeline introduces many factors absent from this experiment.

For example:

enormous dimensionality,
heterogeneous data sources,
filtering,
deduplication,
data weighting,
reinforcement learning,
human feedback,
model architecture,
decoding strategy,
temperature,
sampling procedures,
curriculum,
continual arrival of new human data,
deliberate synthetic-data generation.

Synthetic data can also be generated strategically rather than recursively sampled without controls.

High-quality synthetic examples selected or verified by humans may behave very differently from uncontrolled synthetic data scraped from the internet.

Therefore, extrapolating a numerical threshold from this toy simulation to LLM training would be scientifically inappropriate.

20. A Better Follow-Up Experiment

The next experiment should make the problem harder.

Instead of a single Gaussian, use a mixture distribution.

For example:

95% common population

plus:

5% rare population

Then recursively train the estimator.

Track not only:

mean,
standard deviation,

but also:

representation of the rare component,
tail probability,
divergence from the original distribution.

This would test whether recursive synthetic training disproportionately damages rare modes.

Another extension would compare:

Random synthetic sampling

against:

Quality-filtered synthetic sampling

and:

Synthetic data mixed with real data

That would move the experiment closer to questions relevant to modern generative-model training.

21. Measure Distributional Distance Directly

Instead of tracking only mean and standard deviation, a stronger experiment could calculate the distance between the current distribution and the original distribution.

Possible measures include:

Wasserstein distance,
Jensen-Shannon divergence,
KL divergence where appropriate.

Then each generation receives a direct measure of:

How far have we moved from the original distribution?

This would make the simulation more general than monitoring σ alone.

22. The Bigger Lesson

The interesting lesson from model collapse is not:

“AI-generated data is bad.”

It is about feedback loops.

Machine-learning systems increasingly influence the environment from which future machine-learning systems collect data.

Search engines generate summaries.

LLMs generate web pages.

Image models generate images.

Coding assistants generate code.

Those outputs can become part of future datasets.

The traditional assumption:

training data exists independently of the model

becomes less reliable.

Instead:

models influence data

and:

data influence future models

That creates a feedback system.

And feedback systems need to be studied as systems, not simply as isolated model-training runs.

23. Conclusion

A model trained on synthetic data generated by a previous model is not learning directly from the original distribution.

It is learning from an approximation.

Repeated recursively, small estimation errors can propagate and the learned distribution can drift.

This minimal simulation makes that mechanism visible.

It also shows why introducing real data matters.

Fresh real samples reconnect each generation to the original data-generating process and can substantially reduce recursive drift.

But there is no universal percentage hidden in this experiment.

The scientifically defensible conclusion is:

In this controlled simulation, increasing the proportion of real data stabilises recursive training and reduces distributional drift. The amount required depends on the experimental conditions and should not be extrapolated directly to large generative models.

That may be less dramatic than saying:

“X% real data stops model collapse.”

But it is much closer to what the experiment actually demonstrates.

And that is the point of running the experiment in the first place.

References and Further Reading

[1] Shumailov, I., Shumaylov, Z., Zhao, Y., Papernot, N., Anderson, R., & Gal, Y. (2024). AI models collapse when trained on recursively generated data. Nature, 631, 755–759.
A major empirical and theoretical treatment of model collapse under recursive training on generated data.
https://doi.org/10.1038/s41586-024-07566-y

[2] Alemohammad, S., Casco-Rodriguez, J., Luzi, L., et al. (2024). Self-Consuming Generative Models Go MAD. International Conference on Learning Representations (ICLR).
Examines degradation in generative models trained recursively on synthetic outputs.
https://arxiv.org/abs/2307.01850

[3] Gerstgrasser, M., Schaeffer, R., Dey, A., et al. (2024). Is Model Collapse Inevitable? Breaking the Curse of Recursion by Accumulating Real and Synthetic Data.
Explores conditions under which retaining or accumulating real data can mitigate recursive-training degradation.
https://arxiv.org/abs/2404.01413

[4] Briesch, M., Sobania, D., & Rothlauf, F. (2023). Large Language Models Suffer From Their Own Output: An Analysis of the Self-Consuming Training Loop.
An investigation of recursive training using model-generated text.
https://arxiv.org/abs/2311.16822

Reproducibility and Interpretation Note

This article describes a minimal stochastic simulation of recursive distribution estimation.

It is designed to isolate the effect of repeatedly learning from samples produced by previous estimated distributions.

The simulation should not be interpreted as a quantitative model of large-language-model training.

In particular, any real-data percentage that appears to stabilise the process is specific to the chosen:

probability distribution,
sample size,
estimator,
number of generations,
real/synthetic mixing procedure,
and evaluation metric.

Individual simulation trajectories may also fluctuate non-monotonically. Conclusions about systematic degradation or stabilisation should therefore be based on repeated runs and aggregate behaviour rather than a single random trajectory.

Generative AI creates an unusual feedback problem.

1. What Is Model Collapse?

2. Why Use a Gaussian Toy Model?

3. The Experiment

4. The First Hypothesis

5. Why Variance Can Drift

6. Run Many Independent Simulations

7. Now Add Real Data Back

8. The Second Hypothesis

9. Measuring Collapse

Mean drift

Standard-deviation drift

Variance retention

10. What Happens With 0% Real Data?

11. What Happens When Real Data Is Mixed In?

12. Interpreting a Threshold Carefully

13. “Slowing” Is Different From “Stopping”

How Much Real Data Slows Model Collapse?

How Much Real Data Stops Model Collapse?

14. Why Tails Matter

15. Why Synthetic Data Is Not Inherently Bad

16. Real Data Acts Like an Anchor

17. What This Experiment Actually Demonstrates

1. Recursive synthetic training can create distributional drift

2. Individual trajectories are noisy

3. Reintroducing real data can stabilise the process

4. The amount of real data matters

5. Any apparent threshold is experiment-specific

18. What This Experiment Does NOT Demonstrate

19. Why Real Generative Models Are More Complicated

20. A Better Follow-Up Experiment

Random synthetic sampling

Quality-filtered synthetic sampling

Synthetic data mixed with real data

21. Measure Distributional Distance Directly

22. The Bigger Lesson

23. Conclusion

References and Further Reading

Reproducibility and Interpretation Note

Related Reading

Similar Posts

Leave a Reply Cancel reply