AI uses for records
Synthetic data error amplification: tracing one wrong source record
By SourceX Editorial · Updated
10 sections
Short answer
To trace one incorrect source record into many derived training examples, walk forward through every step that reused it: grounding, few-shot prompts, seed pools, paraphrasing and models trained on earlier outputs. Query stored lineage links where they exist and search for the record's distinctive values where they do not. Then size the blast radius, choose to regenerate, remove, patch or keep each example, and re-test on real cases the error never touched.
Agent run
Synthetic data error
Key takeaways
- One wrong record spreads through grounding, few-shot exemplars, bootstrapped seed pools, paraphrasing and recursive training, each at a different rate.
- Similarity filters remove near-duplicate wording, not the same wrong fact phrased differently.
- Most generators save outputs without the seeds or exemplars behind them, so lineage must be added on purpose.
- Size the blast radius by split, release and model before choosing to regenerate, remove, patch or keep.
- Confirm the fix on real cases never grounded on the faulty record, after checking that holdout for the same error.
How do you trace one incorrect source record into many derived training examples?
Start from the wrong record and walk forward through every step that could have copied it: grounding retrieval, few-shot prompts, seed pools, paraphrase and augmentation passes, and any model trained on earlier outputs. For each step you need a stored link from the output back to the inputs that produced it. Where those links exist, the descendants are a query; where they do not, you fall back to searching the generated set for the record's distinctive values and accept that the result is an estimate.
Once the descendants are listed, decide per example whether to regenerate, remove, patch or keep, then retrain or re-score against real cases that were never grounded on the faulty record. Finally, fix the source and the pipeline step that let the error spread, so the next generation run does not repeat it.
This guide explains why synthetic data error amplification happens, gives a propagation and correction workflow with clear completion criteria, and walks through an illustrative case, including the awkward one where the same error also reached the real evaluation set.
Four ways a single wrong record multiplies
A generated dataset is not a flat copy of its sources. A record's influence depends on where it entered the pipeline, and some entry points multiply it far more than others.
| Path | How the error spreads | Public example of the mechanism | Why routine filters miss it |
|---|---|---|---|
| Direct grounding | The record is retrieved and its facts are restated in each example generated from it | Any retrieval-grounded generator that cites a policy or product record | Each example is internally consistent, so fluency and format checks pass |
| Few-shot exemplar | The record is placed in prompts as a demonstration, and its pattern is imitated in every completion | Stanford Alpaca's generator samples three seed tasks into each request prompt | The saved example does not say which exemplars shaped it |
| Bootstrapped pool | Generated outputs are added back to the pool that seeds the next round, so descendants become parents | Self-Instruct adds filtered generations back to the task pool and repeats | Later rounds look like independent examples |
| Paraphrase and augmentation | One wrong statement is reworded many times | Alpaca drops new instructions whose ROUGE-L similarity to an existing one exceeds 0.7 | Similarity filters remove near-identical wording, not repeated wrong facts phrased differently |
| Recursive training | A model trained on generated data produces the next dataset, compounding distortions | Shumailov and colleagues report that recursive training on generated data makes the tails of the original distribution disappear | Each generation's outputs look plausible on their own |
Why generation pipelines lose the trail back to the source
Most generation code records the output and little else. In the Stanford Alpaca generator, each request samples seed instructions into the prompt, but the saved entry keeps the instruction, input, output and similarity scores, not the identities of the seeds that were in the prompt. That is fine for a research release and a problem for correction: you cannot ask which examples a given seed influenced.
Scale makes the gap matter. The Self-Instruct repository describes a release of 52K instructions with 82K input and output instances bootstrapped from 175 seed tasks, and the authors note that in a sample of 200 instructions they found 46% of data points may have problems. A ratio of hundreds of generated examples per seed means one bad seed can reach far more examples than a reviewer would ever sample.
Provenance standards help only if you store the full chain. W3C PROV-O offers wasDerivedFrom to link one entity to another, but the PROV constraints document states there is no inference that wasDerivedFrom is transitive. If you want to ask which final examples descend from a source record through two or three intermediate steps, each hop has to be recorded and the query has to walk them.
Errors can also live in the pipeline rather than the data. The Alpaca README notes a slight error in the prompt used for generation and points users to a later fix. A prompt, a template or a grounding snapshot is a source record too, and its descendants are every example produced while it was in use.
What should the source error propagation and correction workflow include?
The workflow below runs from the moment someone reports a wrong source record to the moment the corrected dataset is re-tested. Each step has a completion test, so the correction can be audited later.
| Step | What to do | Output | Done when |
|---|---|---|---|
| 1. Confirm the error | Verify against the system of record or a domain owner what is wrong and what is right | Error ticket with the wrong value, correct value and evidence | An owner has signed the correction |
| 2. Identify the source artifact | Name the record, prompt, template or snapshot version that carried the error, and when it was in use | Artifact id and active period | Every pipeline run in that period is listed |
| 3. Walk the lineage | Follow stored derivation links hop by hop to every generated example and every later seed pool | Descendant list with path type per example | No hop in the chain is left unqueried |
| 4. Search for unlinked copies | Search generated text for the record's distinctive values and close paraphrases where links are missing | Candidate list marked as estimated | Search method and recall check are documented |
| 5. Map dataset versions and models | Find which released dataset versions, splits and trained models contain descendants | Version and model impact table | Every affected version has a row |
| 6. Choose the fix per example | Regenerate, remove, patch or keep with a reason | Decision log | Each descendant has one decision |
| 7. Correct the source and the step | Fix the record, and change the pipeline step that let it spread, such as adding seed ids to outputs | Pipeline change note | A rerun records full lineage |
| 8. Re-test on untouched real cases | Score before and after on real cases never grounded on the faulty artifact | Comparison report | Holdout independence is confirmed |
| 9. Record and communicate | Add the correction to the dataset changelog and tell downstream users as agreed | Changelog entry | Recipients and versions are named |
Estimating the blast radius before you fix anything
Size the problem before choosing a remedy, because the right fix for a dozen examples is different from the right fix for a fifth of a dataset. Report the blast radius as counts and shares that a reviewer can check.
At a glance
Estimating the blast radius before you fix anything
Checklist · 6 items
- Direct descendants: examples generated with the faulty artifact in their grounding or prompt.
- Indirect descendants: examples generated from a seed pool that already contained a direct descendant, by round.
- Estimated unlinked copies: matches found by value or paraphrase search, with the search method and a manual check of a sample.
- Share of each split: train, validation and any synthetic evaluation set, since an error in evaluation data hides itself.
- Affected releases and models: dataset versions shipped and models trained on them.
- Influence on behavior: whether a model trained on the set repeats the wrong value when asked, tested with a handful of direct prompts.
0 of 6 ticked. Tick each item as you go.
Regenerate, remove, patch or keep: choosing the correction
No single fix suits every descendant. The choice depends on how deeply the error is woven into the example and on what the example is for.
| Fix | When it fits | Risk | Evidence to keep |
|---|---|---|---|
| Regenerate | The error is in grounding facts and the corrected record can drive a fresh generation | New outputs shift the dataset's distribution and need fresh quality checks | Old and new example ids, generator version, corrected source version |
| Remove | Few descendants, or the error shapes the whole example | Removing many can thin coverage of a scenario | Removed ids and the scenario counts before and after |
| Patch in place | The wrong value is a short span such as a date or code and the rest of the example is sound | Patched text may no longer match its reasoning or answer | Diff per example and a reviewer sample |
| Keep with a flag | The example is meant to teach error detection, or the wrong value does not affect the task | Users may miss the flag | Reason, flag field and the reviewer who approved it |
Re-testing against real cases the error never touched
Measure the effect of the correction on real records that were not grounded on the faulty artifact. If the evaluation set was itself generated from the same sources, it carries the same error and will reward the model for repeating it.
Check the real holdout too. Northcutt, Athalye and Mueller estimated label errors of at least 3.3% on average across the test sets of ten widely used datasets and showed that such errors can change which model ranks higher. A real holdout is the reference point, not proof of correctness, so sample it for the same error before trusting the comparison.
Use the re-test to look for what the synthetic mixture never represented. Compare the scenario types in the real holdout with those in the generated set: rare exceptions, unusual record combinations and edge cases that the seeds did not cover will show up as real cases where the corrected model still fails. Those gaps call for more real records, not more generation.
Worked example (illustrative): a wrong policy date copied into support dialogues
This example is invented; all counts are illustrative. A team generates customer support dialogues grounded on a retailer's policy documents. One policy record states the wrong return window, because an outdated version was exported. The record is used in grounding for a few hundred dialogues and appears as a few-shot exemplar in a smaller number of prompts.
Because the pipeline stored grounding document ids but not exemplar ids, the direct grounding descendants are found by query in minutes. The exemplar descendants are found by searching for the wrong number of days and two common paraphrases, and a reviewer checks a sample of the matches. The team regenerates the grounded dialogues from the corrected record, removes the exemplar-shaped ones, and changes the generator to save exemplar ids with every output.
The exception: the same outdated policy had been quoted by agents in a handful of real tickets used as the evaluation holdout. Those tickets are correct records of what happened but wrong about the policy. The team keeps them, labels the policy statement as historically inaccurate, and scores them separately so the corrected model is not penalized for giving the right answer.
When to stop generating and fix the source instead
Pause generation when an error traces to a source that feeds many prompts, such as a policy library, product catalog or seed pool, until the source is corrected and versioned. Generating more from a known bad source only enlarges the blast radius.
Narrow the scope when lineage is missing and the value search cannot reach acceptable recall; it is often cheaper to discard the affected scenario and regenerate it with full lineage than to hunt for copies. Bring in a domain validator when the error is a judgment rather than a fact, such as an incorrect resolution in an expert workflow, because value search cannot find a wrong decision phrased correctly.
Get counsel involved when the faulty record concerns a person, or when corrected data must be passed to licensees under a contract. Correction obligations and notice terms depend on the specific agreement and law.
Starting from licensed real records with known versions
The easiest errors to trace are those in sources with stable ids, version history and a clear owner. Teams seeding a generation pipeline can ask SourceX for such records; it sources them on request from U.S. businesses, and the request can specify the scope, format, versioning and timing a traceable pipeline needs. Version history arrives only after the supplying company has approved the scope and terms and signed the agreement.
Frequently asked questions
What is synthetic data error amplification?
It is the way one wrong source record, prompt or seed reaches many generated training examples because generation reuses inputs. Grounding, few-shot prompting, bootstrapped seed pools, paraphrasing and recursive training each multiply the error in a different way, and most quality filters check form rather than facts.
Can a similarity filter catch a repeated error?
Usually not. Filters such as a ROUGE-L threshold remove examples whose wording is close to an existing one, which reduces near-duplicates. A wrong fact restated in different words passes the filter, so error detection needs checks against the corrected source.
What lineage should a generator store with each example?
At minimum, the ids and versions of grounding records, the exemplars or seeds in the prompt, the prompt template version, the generator model and settings, and the generation round. With those, finding descendants of a faulty record becomes a query instead of a search.
Is it better to regenerate or delete affected examples?
Regenerate when the corrected source can drive a fresh example and the scenario matters for coverage. Delete when there are few descendants or the error shapes the whole example. Either way, keep the old and new ids so the change can be audited.
How do I know the correction worked?
Re-test on real cases that were never grounded on the faulty record, and ask the retrained model directly about the corrected fact. Check the real holdout for the same error first, because a contaminated reference can reward the wrong answer.
Sources
- The Stanford Alpaca generator samples three seed instructions into each request prompt, discards new instructions whose ROUGE-L similarity to an existing instruction exceeds 0.7, and saves outputs without the ids of the seeds used. Source
- The Stanford Alpaca README describes 52K generated instruction-following examples and notes a slight error in the generation prompt, with a pointer to a later fix. Source
- Self-Instruct bootstraps from 175 seed tasks, adds filtered generations back to the task pool, released 52K instructions with 82K instances, and reports that 46% of 200 sampled data points may have problems. Source
- Shumailov and colleagues report in Nature that indiscriminate training on model-generated content causes irreversible defects in which the tails of the original distribution disappear. Source
- PROV-O defines prov:wasDerivedFrom for forming provenance chains between entities, where a derivation transforms one entity into another. Source
- The PROV constraints document states that there is no inference that wasDerivedFrom is transitive. Source
- Northcutt, Athalye and Mueller estimate label errors of at least 3.3% on average across ten widely used test sets and show such errors can change model rankings. Source
Tell us what data you need
Share scope, volume, format, timing and licensing needs. Datasets are sourced on request.