01What "synthetic data" actually means

Synthetic data is artificially generated data that imitates the statistical patterns and structure of real-world data, but is produced by a model or algorithm rather than collected from real records. Instead of scraping the web or paying people to write examples, you have a capable model manufacture the training examples — questions and answers, labelled images, tabular records — and then train another model on them.

Why bother? Three motivations show up again and again. Scarcity: there may not be enough real examples of the task you care about. Privacy: generating statistically similar data with no one-to-one link to real individuals lets teams work with healthcare or financial patterns without exposing real people — often paired with differential-privacy guarantees. Cost and speed: a model can produce thousands of examples in the time it takes to commission a handful from human annotators.

• Made, not collected: the data comes from a generator that mimics real data's structure, not from real observations.
• A means, not an end: synthetic data exists to train or evaluate another model — quality of the downstream model is the real test.
• Privacy is a headline use case: statistically similar records with no direct mapping to real people (per Gretel, MOSTLY AI, and AWS guidance).

02The breakthrough: bootstrapping instructions from a model

The idea that made synthetic data famous for language models is Self-Instruct (Wang et al., 2022). You start with a small seed set — the paper used 175 hand-written tasks — and ask a base language model to generate new instructions, plus inputs and outputs for them. Invalid and near-duplicate samples are filtered out, and the surviving examples are used to fine-tune the same model. Reported result: vanilla GPT-3 improved by roughly 33% absolute on the Super-NaturalInstructions benchmark — a large jump from data the model essentially wrote for itself.

Stanford's Alpaca turned this into a recipe heard around the world: it generated about 52,000 Self-Instruct-style examples from a stronger teacher model (text-davinci-003) and fine-tuned LLaMA 7B for a 2023 reproduction cost the authors estimated at under ~$600. Vicuna took a sibling approach — fine-tuning on ~70K shared ChatGPT conversations and reporting (via an LLM-as-judge evaluation) roughly 90% of ChatGPT's quality for ~$300. Both are examples of distillation: transferring a bigger "teacher" model's behaviour into a smaller "student."

• Self-Instruct: a model writes, filters, and learns from its own instruction data, starting from a tiny seed pool.
• Distillation: rooted in Hinton, Vinyals & Dean (2015) — train a student on a teacher's "soft" outputs; the modern version uses a teacher's generated text.
• Caveat: the 2023 cost and quality figures are point-in-time estimates and exclude the teacher's API and base-model pretraining costs.

03Making the data better: evolve, explain, then filter

Raw generated examples are a starting point, not a finished dataset. Several techniques push quality higher. Evol-Instruct (WizardLM) iteratively rewrites seed instructions into harder variants (in-depth) and more varied ones (in-breadth), synthesizing a complexity-graded set rather than a flat one. Orca uses "explanation tuning" — training a smaller model on detailed step-by-step reasoning traces from a teacher, so it imitates the reasoning process, not just the final answer. And Microsoft's phi models showed that curated, "textbook-quality" synthetic data can substitute for raw scale: phi-1 (1.3B parameters) reached 50.6% pass@1 on HumanEval trained partly on generated textbooks and exercises.

The other half of modern pipelines is filtering. A common pattern is generate-then-rank: an instruct model produces candidates, and a reward model scores them so weak samples are dropped. NVIDIA's Nemotron-4 340B pipeline pairs an Instruct generator with a Reward model that grades on helpfulness, correctness, coherence, complexity, and verbosity; NVIDIA reported that over 98% of the model family's alignment data was synthetically generated. Good synthetic data is as much about what you throw away as what you generate.

• Evolve: rewrite instructions into harder and broader variants for a complexity-graded set (Evol-Instruct).
• Explain: teach the reasoning trace, not just the answer (Orca's explanation tuning).
• Filter: generate many, then rank/keep with a reward model — quality over raw quantity.

04See it work: generate, then watch it collapse

This interactive has two parts. First, a Self-Instruct-style generator: it expands a few seed tasks into many synthetic examples and filters the duplicates — the bootstrapping loop in miniature. Second, a model-collapse demonstrator: train on your own outputs over successive generations and watch the spread of the data narrow and quality decay — the "curse of recursion." Flip the mix in real data switch to see how keeping real examples in the loop slows the decline going forward — it's a preventative measure, so it anchors future generations but won't restore diversity already lost. The numbers and shapes are illustrative — they show the mechanism, not measured results from any specific model.

05Using synthetic data responsibly

Synthetic data is powerful, but it comes with strings attached. Model collapse is a real but debatable risk. The strongest collapse results assume fully recursive training that replaces real data each generation. Later work argues that mixing or accumulating real data alongside synthetic data, plus serious filtering, mitigates or avoids it. Treat collapse as a documented risk to manage — keep real data in the loop and watch your distributions — not as an inevitability.

There's also a legal and ethical dimension. Distilling from a proprietary teacher model (the way Alpaca and Vicuna used another provider's outputs) can violate that provider's terms of service — it's not purely a technical recipe. And surveys of synthetic data for language models (Google DeepMind, 2024) stress responsible criteria: factuality (don't generate confident falsehoods), fidelity (match the real distribution you care about), and unbiasedness (don't amplify the generator's biases). Vendor claims about fidelity and privacy should be read as vendor-reported; lean on peer-reviewed work for general mechanism claims.

• Keep real data in the loop: the simplest, best-supported guard against collapse.
• Mind the terms of service: generating training data from a closed model may breach its usage rules.
• Check factuality, fidelity, and bias: generated data can be confidently wrong, off-distribution, or skewed.

06Check your understanding

07Take it with you & go deeper