Skip to content
AI.info

Generative AI

Synthetic Data and Model-Generated Supervision

Create, filter, and evaluate synthetic prompts, responses, preferences, critiques, and adversarial cases for generative AI development.

By the end you can

Example

Cheap examples can create expensive certainty

A model that grades its own writing gives it better marks. Two summarization tasks, three graders: GPT-3.5 Turbo, GPT-4 and Llama 2 each scored their own summaries above other summaries that human annotators had rated of equal quality. Panickssery and two co-authors published the measurement at NeurIPS in 2024.

The mechanism is recognition. “GPT-4 is 73.5% accurate at distinguishing its outputs from those of two other LLMs and humans.” The judge knows its own handwriting, and nobody trained it to. GPT-3.5 and Llama 2 passed 90% self-recognition accuracy after fine-tuning on 500 examples. Self-preference strength rose linearly with self-recognition ability.

So a team generates fifty thousand support conversations with one strong model, fine-tunes a smaller model on them, then grades the result with prompts from the same model family. It is not measuring quality. It is measuring family resemblance, and the offline scores will rise.

  • Generator monoculture: Prompt style and task assumptions reflect one model's habits, and no amount of volume corrects for it.
  • Shared evaluator: The same model grades the outputs it inspired. Self-preference strength rose linearly with self-recognition ability, and GPT-3.5 and Llama 2 pushed that ability above 90% after fine-tuning on 500 examples.
  • Coverage illusion: Large volume repeats a narrow set of scenarios and phrasings — Self-Instruct's 52,445 surviving instructions stayed distinct only because a numeric similarity filter enforced it.
  • Error inheritance: Unsupported explanations become labeled examples for the student model, in the same fluent register as the correct ones.
  • Real-world gap: User typos, incomplete context, and organizational constraints remain absent; the generator can only produce what it already knows how to produce.

Comparison

Synthetic data can play several legitimate roles

The validation burden depends on what the synthetic record claims to represent. Input augmentation — new prompts, paraphrases, rare scenario combinations — expands linguistic and scenario coverage, but it repeats generator style. It stands or falls on deduplication and diversity checks. Target generation — candidate answers, rationales, structured outputs — scales demonstration production and requires strong semantic review, because a fabricated fact arrives in the same register as a correct one. It is defensible where validators exist. Adversarial generation — prompt injection, ambiguity, unsafe requests, edge cases — widens stress-test coverage, but it misses attacks the generator has never seen. So it belongs beside a human red team, and the evaluation cases it produces must stay protected.

Preference and critique generation is the one role with a published head-to-head behind it. Google ran the comparison and reported it at ICML in 2024. Human evaluators preferred the policy trained on model-written preferences over the supervised fine-tuned baseline 71% of the time on summarization, against 73% for the policy trained on human preferences. On helpful dialogue the two figures were 63% and 64%. Neither difference was statistically significant, and head-to-head, RLAIF against RLHF was indistinguishable from a 50% win rate.

On harmless dialogue the model-written labels did better than the human ones: “For harmless dialogue generation, RLAIF achieves a harmless rate of 88%, outperforming both RLHF and SFT, which score 76% and 64%, respectively.”

Cheaper labels can match expensive ones on some axes. That is a measured result on three tasks, not a general licence to stop asking humans.

FigureComparison · 4 columns

Input augmentation

Generate new prompts, paraphrases, or rare scenario combinations.

  • Expands linguistic and scenario coverage
  • Can repeat generator style
  • Labels may come from existing rules or experts
  • Needs deduplication and diversity checks

Target generation

Create candidate answers, rationales, or structured outputs.

  • Scales demonstration production
  • Requires strong semantic review
  • May introduce fabricated facts
  • Useful when validators are available

Preference or critique generation

Produce comparisons, scores, or error analyses.

  • Reduces annotation cost
  • Evaluator bias becomes label bias
  • Can create self-reinforcing preferences
  • Needs human calibration

Adversarial generation

Search for prompt injection, ambiguity, unsafe requests, and edge cases.

  • Expands stress-test coverage
  • Generator may miss unfamiliar attacks
  • Should be combined with human red teams
  • Evaluation cases must remain protected

Visual

Synthetic generation needs an independent acceptance path

The generator should not be the sole authority for its own outputs. The path runs like this. Define the missing coverage: tasks, slices, difficulty or attacks absent from real data. Generate with variation — multiple prompts, models, seeds and controlled scenario variables. Apply deterministic filters for schema, duplicates, policy constraints, calculations and source references. Review a risk-based sample, using experts for consequential content and disagreement cases. Measure diversity and realism against the real data's style, length, topics, errors and feature distributions. Approve only when the target production behavior improves on real held-out data.

The fourth step is the one teams try to automate away, and there is a measurement of how far that can go. Zheng and colleagues put GPT-4 in the judge's seat and checked it against people, at NeurIPS in 2023: “Our results reveal that strong LLM judges like GPT-4 can match both controlled and crowdsourced human preferences well, achieving over 80% agreement, the same level of agreement between humans.” The released evidence base is 3K expert votes and 30K conversations with human preferences. The same paper documents position, verbosity and self-enhancement biases in LLM judges.

Both halves of that finding are load-bearing. A model judge agrees with people about as often as people agree with each other, which is why an automated acceptance path is worth building. It is also wrong in patterned, nameable ways. That is what the human sample is for: the pattern is the thing it catches.

FigureProcess · 6 steps
  1. 1

    Define the missing coverage

    Specify tasks, slices, difficulty, or attacks absent from real data.

  2. 2

    Generate with variation

    Use multiple prompts, models, seeds, and controlled scenario variables.

  3. 3

    Apply deterministic filters

    Check schema, duplicates, policy constraints, calculations, and source references.

  4. 4

    Review a risk-based sample

    Use experts for consequential content and disagreement cases.

  5. 5

    Measure diversity and realism

    Compare style, length, topics, errors, and feature distributions with real data.

  6. 6

    Test on real held-out data

    Approve only when the target production behavior improves.

Key idea

Recursive synthetic training can narrow the distribution

When models train repeatedly on model-generated content, rare modes and real-world irregularities can disappear. The student becomes smoother while losing coverage of unusual but important cases. The useful question is what causes that — the synthetic data itself, or what the synthetic data displaces.

It is displacement. A 2024 study trained models both ways: replacing the real data with each generation's synthetic output, and accumulating the synthetic output alongside the real data. Only the first collapsed. Fourteen authors, presented at COLM, and the abstract says it in one sentence: “We confirm that replacing the original real data by each generation's synthetic data does indeed tend towards model collapse, then demonstrate that accumulating the successive generations of synthetic data alongside the original real data avoids model collapse; these results hold across a range of model sizes, architectures, and hyperparameters.” Analytically, accumulating leaves test error with a finite upper bound independent of the number of iterations.

That turns standing advice into a design rule with a demonstration behind it. Retain the high-quality human and primary-source data rather than overwriting it. Track synthetic proportions. Evaluate tail behavior. More synthetic volume does not compensate for real evidence you deleted to make room for it.

Collapse follows from replacing real data, not from adding synthetic data to it.

Case

Generation after generation of model-made data lost the tails

Train a model on the output of the model before it, then do it again, nine times over, and the tails of the distribution go. Shumailov and five colleagues published the failure case in Nature in July 2024. The abstract states the result plainly: “We find that indiscriminate use of model-generated content in training causes irreversible defects in the resulting models, in which tails of the original content distribution disappear. We refer to this effect as ‘model collapse’ and show that it can occur in LLMs as well as in variational autoencoders (VAEs) and Gaussian mixture models (GMMs).”

The apparatus was ordinary, which is the frightening part. The language-model experiment fine-tuned Meta's OPT-125m on the wikitext2 dataset for nine successive generations, each generation trained on the previous one's output. By generation 9 the text had degenerated into repetitive nonsense about “black @-@ tailed jackrabbits”. No adversary, no corrupted source, no bug. A small model, a standard dataset, and a loop.

The gains are real as well, and they are measured too. Self-Instruct bootstrapped instruction data out of a model's own generations: 175 hand-written seed tasks and vanilla GPT-3 produced 52,445 instructions and 82,439 instances. Wang and colleagues reported it at ACL in 2023: “Applying our method to the vanilla GPT3, we demonstrate a 33% absolute improvement over the original model on Super-NaturalInstructions” — given in the paper as +33.1%, and still leaving a 5% absolute gap behind InstructGPT-001.

Nine recursive generations dissolved a distribution. One filtered bootstrap from 175 human-written seeds closed most of a gap. The difference is not whether the data was model-generated. It is what stayed in the loop alongside it.

Steps

Audit a synthetic dataset before training

Compare the dataset's claims and distribution with the evidence it is meant to supplement. Record generation lineage: model, prompt, seed, source inputs, filters, reviewer. Detect duplicates and templates by measuring lexical, semantic and structural repetition. Validate labels and facts with tools, sources, experts and cross-model disagreement. Compare vocabulary, difficulty, error types and population slices with the real data. Run ablations that train with and without the synthetic subsets under matched budgets. Keep real release cases outside the generation and selection loops.

Step 2 is where teams usually settle for an impression, and Self-Instruct shows what a published threshold looks like instead. Wang and colleagues did not inspect their pool for variety. They wrote the rule down, in the paper's “Filtering and Postprocessing” paragraph: “To encourage diversity, a new instruction is added to the task pool only when its ROUGE-L similarity with any existing instruction is less than 0.7.” Instructions containing keywords the model could not process — image, picture, graph — were excluded outright. What survived that filter was the 52,445-instruction pool: 11,584 classification tasks and 40,861 that were not.

A number someone else can recompute on your dataset is worth more than a paragraph asserting that the examples are varied. “Measure lexical repetition” is an activity. ROUGE-L below 0.7 against every instruction already in the pool is a gate.

FigureProcess · 6 steps
  1. 1. Record generation lineage

    Model, prompt, seed, source inputs, filters, and reviewer.

  2. 2. Detect duplicates and templates

    Measure lexical, semantic, and structural repetition.

  3. 3. Validate labels and facts

    Use tools, sources, experts, and cross-model disagreement.

  4. 4. Compare with real data

    Inspect vocabulary, difficulty, error types, and population slices.

  5. 5. Run ablations

    Train with and without synthetic subsets under matched budgets.

  6. 6. Protect final evaluation

    Keep real release cases outside generation and selection loops.

Synthetic supervision is an experiment, not free truth

Generated examples can produce training data faster, expose edge cases, and teach smaller models. That last claim has a worked case with numbers attached. phi-1 is a 1.3B-parameter Transformer code model, trained for 4 days on 8 A100s. Its diet was 6B tokens of filtered “textbook quality” web data plus 1B tokens of textbooks and exercises generated synthetically with GPT-3.5. Microsoft Research published it in 2023. The outcome: “Despite this small scale, phi-1 attains pass@1 accuracy 50.6% on HumanEval and 55.5% on MBPP.” A 350M-parameter variant, phi-1-small, run through the same pipeline, still scored 45% on HumanEval. What carried those results was the curation of the 1B synthetic tokens, not their quantity.

Set the two poles of this lesson side by side. Nine unfiltered generations of OPT-125m ended in jackrabbit nonsense. 1B curated synthetic tokens put a 1.3B-parameter model at 50.6% pass@1. The value of generated data depends on independent validators and real held-out gains, and that is the only difference between the two.

The next module moves into multimodal systems. Synthetic media increases both capability and provenance risk when generated artifacts resemble evidence from the world.

Key takeaways