Skip to content

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

This page covers synthetic data error amplification: tracing one wrong source record.Illustrative

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.

Four ways a single wrong record multiplies
PathHow the error spreadsPublic example of the mechanismWhy routine filters miss it
Direct groundingThe record is retrieved and its facts are restated in each example generated from itAny retrieval-grounded generator that cites a policy or product recordEach example is internally consistent, so fluency and format checks pass
Few-shot exemplarThe record is placed in prompts as a demonstration, and its pattern is imitated in every completionStanford Alpaca's generator samples three seed tasks into each request promptThe saved example does not say which exemplars shaped it
Bootstrapped poolGenerated outputs are added back to the pool that seeds the next round, so descendants become parentsSelf-Instruct adds filtered generations back to the task pool and repeatsLater rounds look like independent examples
Paraphrase and augmentationOne wrong statement is reworded many timesAlpaca drops new instructions whose ROUGE-L similarity to an existing one exceeds 0.7Similarity filters remove near-identical wording, not repeated wrong facts phrased differently
Recursive trainingA model trained on generated data produces the next dataset, compounding distortionsShumailov and colleagues report that recursive training on generated data makes the tails of the original distribution disappearEach 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.

What should the source error propagation and correction workflow include?
StepWhat to doOutputDone when
1. Confirm the errorVerify against the system of record or a domain owner what is wrong and what is rightError ticket with the wrong value, correct value and evidenceAn owner has signed the correction
2. Identify the source artifactName the record, prompt, template or snapshot version that carried the error, and when it was in useArtifact id and active periodEvery pipeline run in that period is listed
3. Walk the lineageFollow stored derivation links hop by hop to every generated example and every later seed poolDescendant list with path type per exampleNo hop in the chain is left unqueried
4. Search for unlinked copiesSearch generated text for the record's distinctive values and close paraphrases where links are missingCandidate list marked as estimatedSearch method and recall check are documented
5. Map dataset versions and modelsFind which released dataset versions, splits and trained models contain descendantsVersion and model impact tableEvery affected version has a row
6. Choose the fix per exampleRegenerate, remove, patch or keep with a reasonDecision logEach descendant has one decision
7. Correct the source and the stepFix the record, and change the pipeline step that let it spread, such as adding seed ids to outputsPipeline change noteA rerun records full lineage
8. Re-test on untouched real casesScore before and after on real cases never grounded on the faulty artifactComparison reportHoldout independence is confirmed
9. Record and communicateAdd the correction to the dataset changelog and tell downstream users as agreedChangelog entryRecipients 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

  1. Direct descendants: examples generated with the faulty artifact in their grounding or prompt.
  2. Indirect descendants: examples generated from a seed pool that already contained a direct descendant, by round.
  3. Estimated unlinked copies: matches found by value or paraphrase search, with the search method and a manual check of a sample.
  4. Share of each split: train, validation and any synthetic evaluation set, since an error in evaluation data hides itself.
  5. Affected releases and models: dataset versions shipped and models trained on them.
  6. 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.

Regenerate, remove, patch or keep: choosing the correction
FixWhen it fitsRiskEvidence to keep
RegenerateThe error is in grounding facts and the corrected record can drive a fresh generationNew outputs shift the dataset's distribution and need fresh quality checksOld and new example ids, generator version, corrected source version
RemoveFew descendants, or the error shapes the whole exampleRemoving many can thin coverage of a scenarioRemoved ids and the scenario counts before and after
Patch in placeThe wrong value is a short span such as a date or code and the rest of the example is soundPatched text may no longer match its reasoning or answerDiff per example and a reviewer sample
Keep with a flagThe example is meant to teach error detection, or the wrong value does not affect the taskUsers may miss the flagReason, 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.

See if your company qualifies