Skip to content
AI360XpertBeta

Synthetic Data for Post-Training

You use a stronger model to write the prompt-answer pairs you cannot afford to write by hand, then you train a smaller model on the filtered set.

Eight human seeds expand into 24 teacher drafts, filters keep 15 and dedup leaves 12 rows that train the student
Eight human seeds expand into 24 teacher drafts, filters keep 15 and dedup leaves 12 rows that train the student

Why Does This Exist?

You want to fine-tune a model, and the fine-tune wants examples. Not a dozen. Hundreds or thousands of prompt-answer pairs, all in the same shape, all correct. Write them yourself and you'll spend weeks arguing about style. Scrape them and you get inconsistency. That shortage is the whole problem.

Synthetic data is the shortcut: you ask a stronger model to write the pairs for you. You give it a few good examples, it produces many more in the same style, and you train your smaller model on that output. It works because the small model doesn't need new facts here. It needs repetition in the right shape.

This page covers the generate-then-filter loop and the math that keeps it honest. The training step that eats the data is supervised fine-tuning. The file hygiene around it is fine-tuning data preparation. The verifier-filtered cousin that samples from the same model it trains is rejection sampling fine-tuning.

Think of It Like This

The head baker's recipe box

You run a bakery and you need to train an apprentice. You own 8 family recipe cards that customers love. The head baker reads those 8 and writes 24 variations: same structure, new fillings. You taste every one. Nine are too salty, so they go in the bin. Three are near-copies of each other, so you keep one of each. Twelve survive, and the apprentice cooks those twelve on repeat until the shape sticks.

That maps part for part. The 8 cards are your seeds. The head baker is the teacher model. Tasting is the verifier. Binning copies is dedup. The 12 survivors are the training set.

Where it stops: the apprentice learns your head baker's habits too, heavy salt included. And no stack of variations teaches a cake the baker never baked. Coverage grows. Knowledge does not.

How It Actually Works

Here is the loop in four moves: seed, draft, filter, train. Each move assumes the last one did its job, so a miss early shows up late as a confident, wrong student.

The one idea you need first

Supervised fine-tuning trains a model to imitate example answers token by token, with loss on answer tokens only. Synthetic data changes nothing about that step. It changes only where the examples come from: a teacher model instead of human hands. If that sentence feels new, read that page first, then come back.

Seed, draft, filter, train

Start with a seed set SS. That means a small pile of human-written prompts, where each prompt ss in SS is one example of the task done right. Say mm means the count of seeds, so m=8m = 8 here.

Feed SS to a teacher model TT. That means a stronger model you prompt with a few seeds and ask for more tasks in the same style, then answers for each. Call the output NN drafts, where NN means total candidates before any check. Here N=24N = 24.

Score each draft with a verifier rr. That means whatever judges correctness: a test, a checker script, a second model, or a human spot read. Pick a threshold τ\tau, where τ\tau means the minimum passing score, and keep drafts with r≥τr \ge \tau. Call the survivors KK, where KK means kept rows. Here K=15K = 15.

Then dedup. That means dropping near-copies that would buy extra votes in training. Call the final set DD, where DD means rows after dedup. Here D=12D = 12. One SFT run on DD is the payoff.

Worked example: 8 seeds to 12 rows

Eight seeds go in. Twenty-four drafts come out. The verifier passes 15 and fails 9, because 24−15=924 - 15 = 9. Dedup removes 3, because 15−12=315 - 12 = 3.

acceptance=KN=1524=0.625\text{acceptance} = \frac{K}{N} = \frac{15}{24} = 0.625

So 62.5 percent of drafts survive verification. Final yield is lower:

yield=DN=1224=0.50\text{yield} = \frac{D}{N} = \frac{12}{24} = 0.50

Half the drafts become training rows. Those are the numbers drawn above: 8 on the left, 24 in the middle, 15 kept, 12 on the right. If your run keeps far more than three in five, your τ\tau is doing no work. If it keeps far fewer, you are paying for drafts you throw away.

What it costs and when to skip it

The trade is compute for coverage. You pay teacher calls for NN drafts plus scoring, and you get DD rows without hiring writers. That trade wins when checks are cheap and the task has a right answer: code with tests, math with answers, extraction with schemas.

Skip it when there is no trustworthy check. On open taste, humor, or advice with only a weak judge doing the scoring, the loop distills the judge's habits, flaws included. Then you are better off with human demonstrations or preference data from real raters. And never train on your own student's unchecked output round after round. Each round narrows the range a little, rare styles vanish first, and the model gets sure about a smaller world. That is the assumption underneath: the teacher already knows the skill, and the filter can tell good from bad. When either fails, the student learns the failure.

Code

The point is the check you will run on every batch: kept over drafted, final over drafted, and the two drop counts. Same numbers as above.

drafted: int = 24kept: int = 15final: int = 12

def pct(part: int, whole: int) -> float:    return 100.0 * part / whole

print(f"{pct(kept, drafted):.1f}%")  # -> 62.5%print(f"{pct(final, drafted):.1f}%")  # -> 50.0%print(drafted - kept)  # -> 9print(kept - final)  # -> 3

If your loader prints anything else, the filter or the dedup step changed, not the math. Sixty-two point five is the verifier at work. Fifty point zero is what training ever sees.

Watch Out For

You trained on unfiltered teacher output

Symptom: the student copies the teacher's pet phrases, agrees with false premises, and scores fine on teacher-style prompts but slips on real ones. Loss fell the whole time, so nothing looked wrong until eval.

Fix it with a real gate before SFT. Score every draft, keep only r≥τr \ge \tau, dedup the survivors, and mix in human data so one style does not own the file. Then eval on held-out real prompts the teacher never saw. If that score does not move, your filter is decoration.

You recycled outputs until variety died

Symptom: round two looks like round one with the serial numbers filed off. Ask eight times and you get near-identical answers with near-identical flaws. Single-sample scores climb while best-of-8 stalls, because there is no best left to pick.

Fix it by stopping early. Run one or two synthetic rounds, mix winners with the original human-heavy data, and track spread, not just mean: distinct answers per prompt and rare-style survival. When spread falls, fresh human seeds help. Another synthetic round does not.

The Quick Version

  • Synthetic post-training drafts prompt-answer pairs with a teacher model, then filters them for SFT.
  • Eight seeds can yield 24 drafts, 15 verifier passes, and 12 rows after dedup, which is 62.5 percent kept and 50.0 percent final yield.
  • The verifier is load-bearing: tests and checkers transfer skill, while a weak judge transfers its taste.
  • Dedup matters because copies buy extra gradients and teach memorization instead of pattern.
  • Skip synthetic data when no trustworthy check exists, and never refit on unchecked self-outputs round after round.
  • Synthetic coverage never adds teacher-missing knowledge, so eval must run on real prompts the teacher never saw.