Gradient-based data selection picks the target's answer format: single-letter answers at 14.84 times their pool share

What was published, and when

arXiv:2609.19589, posted 17 September 2026 by Sunwoo Kim, Seokwon Jung, Sohyung Kim, Seong Joon Oh and Alice Oh at KAIST, settles an argument about what gradient similarity measures. LESS, the standard gradient-based selector for instruction tuning, is described by its authors as going "beyond surface form cues to identify data that exemplifies the necessary reasoning skills". Other work reports the opposite. The two readings have never been separable because in real data the task and the answer format move together: knowledge benchmarks are multiple choice, arithmetic benchmarks end in a number.

The paper separates them by rendering the same questions in different answer formats. Five benchmarks (TriviaQA, SQuAD, GSM8K, ARC-Challenge, CRUXEval) crossed with seven formats in three structure classes gives 35 datasets, so any two can share a task without sharing a format, or the reverse.

Alignment inside a format class runs 0.39 to 0.63 disattenuated cosine whatever the task. Alignment across format classes sits at 0.00 to 0.05 even when the task is identical, against a zero reference of -0.001 with standard deviation 0.008 over the 280 pairs that share neither. The ordering holds at ten OLMo pretraining checkpoints from 1B to 4T tokens, at ten Pythia checkpoints, across base, SFT, DPO and instruct stages, at 1B, 7B and 13B, and on Llama 3.1 and Qwen3.

Our recount of the released selections

The paper's third result is the one a data team can check without a GPU: the selections LESS actually released. They are public at princeton-nlp/less_data, 169 MB, nine files, the top 5% (13,533 examples) of a 270,679-example pool for each of three targets at three seeds. The pool contains no data from any target benchmark.

We wrote our own rule-based format classifier, ran it over the pool and over all nine selection files, and computed enrichment as the share of a format among selected examples divided by its share of the pool.

The direction reproduces and so do two of the three magnitudes. The paper reports letter answers selected at 3.7 times their pool share for MMLU, chain-of-thought at 2.4 times for BBH and short answers at 1.9 times for TydiQA. We get 2.22x for reasoning-then-answer on BBH and 1.94x for short answers on TydiQA, both within a rounding step of theirs. For MMLU we get 14.84x, far above their 3.7x, because our "single letter" class is strict: the answer is one letter and nothing else, which is 1.36% of the pool. Widening the class to anything ending in a letter verdict dilutes the ratio. Both numbers describe the same effect, and the size of the ratio depends on how narrow the class is, which is worth remembering before quoting either.

The tails are where the effect is unmistakable. For the MMLU target, long-form answers are selected at 0.01 times their pool share and code at 0.05 times. Out of 40,599 MMLU-targeted selections, 41 are long form and 36 are code. MMLU is a knowledge benchmark; nothing about knowledge implies that a long answer is useless.

The source composition says the same thing in different units. MMLU pulls 79.3% of its selection from flan_v2, which is short-answer heavy. TydiQA pulls dolly at 5.05 times its pool share. BBH pulls cot at 1.67 times. oasst1, the conversational set with long answers, is at 0.02 times for MMLU: 205 examples out of 40,599.

The same target with a different seed keeps a minority of its picks

The released files carry three seeds per target, which lets us ask a question the paper does not: how much of a selection is the target, and how much is noise? We computed Jaccard overlap of example ids.

Same target, different seed: mean pairwise Jaccard is 0.377 for MMLU, 0.296 for TydiQA and 0.162 for BBH. In plain counts, two runs of the same MMLU configuration share 54.8% of their 13,533 examples, TydiQA 45.7% and BBH 27.8%. The union of the three BBH runs is 31,255 distinct examples out of 40,599 slots, so most BBH picks appear in exactly one run. Across targets the overlap is lower still, 0.038 for MMLU against BBH, which is what the format story predicts: a letter-answer target and a reasoning-trace target want different surface shapes.

Our judgement: an 0.16 Jaccard between two runs of the same method on the same target, against a selection budget of 5%, means the method is selecting a broad format-shaped stratum and sampling inside it. That is consistent with the report, cited by the paper, that LESS fails to beat random selection at large pool scales.

What this changes for a data-selection pipeline

Gradient influence is not evidence of task relevance. If you sell or buy "task-relevant" selection, the burden is now to show the effect survives when format and task vary independently. The test is cheap: render a held-out benchmark in two answer formats and check that the selector's picks do not follow the rendering.

A selection that mirrors the target's answer format will look good on that target's eval. Matching the output shape of a benchmark raises the score on that benchmark. That is a real gain and it is not the skill transfer the method claims, and it will not survive a change of answer template.

Report seed variance on any selection run. Three seeds of the same configuration sharing 16% of their picks is a fact about the method that a single-seed table hides entirely.

For annotation and data work, the lesson is upstream. If the model's gradient mostly encodes the shape of the answer, then the shape of your answers is a first-class annotation decision. Guidelines that leave answer formatting to the annotator inject a variable that selection methods will latch onto later.

Check it yourself

The whole recount runs on a laptop in about two minutes.

curl -L -o less-data.zip \
  "https://huggingface.co/datasets/princeton-nlp/less_data/resolve/main/less-data.zip"   # 169,390,092 bytes
unzip -q less-data.zip
wc -l data/selected_data/*.jsonl        # 9 files x 13,533
python3 - <<'PY'
import json, glob, collections, itertools, statistics
def answer(ex):
    return next((m["content"] for m in reversed(ex["messages"]) if m["role"]=="assistant"), "")
pool={}
for p in glob.glob("data/train/processed/*/*.jsonl"):
    if "coding" in p: continue
    for line in open(p):
        ex=json.loads(line); a=answer(ex).strip()
        w=a.split()
        k=("letter" if len(a)<=3 and a.strip("().:").isalpha() and len(a.strip("().:"))==1
           else "short" if len(w)<=5 else "long" if len(w)>120 else "prose")
        pool[ex["id"]]=k
print("pool", len(pool), collections.Counter(pool.values()))
for t in ["mmlu-chat","bbh-icl","tydiqa"]:
    ids=[]
    for s in (3,6,9):
        ids.append([json.loads(l)["id"] for l in
            open(f"data/selected_data/{t}_adam_sim_trainp0.05_seed{s}_p0.05.jsonl")])
    c=collections.Counter(pool[i] for run in ids for i in run); n=sum(c.values())
    pc=collections.Counter(pool.values()); pn=len(pool)
    print(t, {k: round((c[k]/n)/(pc[k]/pn),2) for k in pc},
          "seed Jaccard",
          round(statistics.mean(len(set(a)&set(b))/len(set(a)|set(b))
                                for a,b in itertools.combinations(ids,2)),3))
PY

That simplified classifier reproduces the direction; the four-way split in the tables above uses eight classes, including a reasoning-then-answer class keyed on an answer marker plus length. Both give the same ordering, and neither changes the Jaccard numbers, which do not depend on the classifier at all.

What would prove this wrong

The format claim fails if someone renders one benchmark in two answer formats, selects with LESS against each rendering, and finds the two selections overlap more with each other than either does with a same-format selection for a different benchmark. The paper's Figure 2a predicts the opposite and our enrichment numbers agree with it. The seed claim fails if the three released seeds turn out to differ in something other than the random seed, for example in the checkpoint set averaged over, in which case the 0.16 Jaccard measures a configuration difference rather than run-to-run noise; the release does not document this, and we could not rule it out. A fix would be one extra run at a fourth seed with everything else pinned, published with the ids. We predict that run shares under half its picks with any existing seed, and we would revise if it shares more than 0.6.

Sources

1. Kim, Jung, Kim, Oh, Oh. Form Over Content In Gradient-Based Data Attribution Methods. arXiv:2609.19589v1, 17 September 2026, KAIST. Figures 2 to 4, Section 4.3.
2. Xia, Malladi, Gururangan, Arora, Chen. LESS: Selecting Influential Data for Targeted Instruction Tuning. ICML 2024. The method whose released selections we recount.
3. princeton-nlp/less_data on Hugging Face, 169,390,092 bytes, last modified 12 March 2024. Nine selection files and the four-part training pool. Downloaded and counted 21 September 2026.
4. Pruthi, Liu, Kale, Sundararajan. Estimating Training Data Influence by Tracing Gradient Descent. NeurIPS 2020. TracIn, the score LESS adapts.

FAQ

Does gradient-based data selection pick task-relevant data?

Not primarily. arXiv:2609.19589 renders five benchmarks in seven answer formats and finds gradient alignment of 0.39 to 0.63 disattenuated cosine between datasets that share an answer format class whatever the task, against 0.00 to 0.05 for datasets that share the task but not the format class. The zero reference, over 280 pairs sharing neither, is -0.001 with standard deviation 0.008.

What does LESS actually select?

Data that looks like the target's answers. Recounting the nine released selection files against the 270,679-example pool: for the MMLU target, single-letter answers are selected at 14.84 times their pool share, yes/no at 4.19 times, long-form answers at 0.01 times and code at 0.05 times. For BBH the enriched format is reasoning-then-answer at 2.22 times, for TydiQA short answers at 1.94 times. Source datasets skew the same way: MMLU draws 79.3% of its selection from flan_v2 against a 36.9% pool share.

How stable is a LESS selection across random seeds?

Not very. Over the three released seeds per target, mean pairwise Jaccard overlap of selected example ids is 0.377 for MMLU, 0.296 for TydiQA and 0.162 for BBH, which is a shared fraction of 54.8%, 45.7% and 27.8% of the 13,533 examples. The union of the three BBH runs covers 31,255 distinct examples out of 40,599 selection slots, so most picks appear in only one run.

How should a data team test a selection method?

Vary answer format and task independently. Render one benchmark in two answer formats, run the selector against each, and compare the two selections to a same-format selection for a different benchmark. If the selections follow the rendering rather than the benchmark, the method is tracking surface form. The check costs one extra rendering pass and no new labels.