Q-Tuning Trains SmolLM2-1.7B on 12.5% of an SFT Set's Tokens and Beats Full-Data Training by 38%

What did Q-Tuning claim, and when?

On 28 September 2025 a twelve-author team spanning the Qwen Team at Alibaba Group, Shanghai Jiao Tong University's EPIC Lab, Nanjing University, Beijing Jiaotong University and HKUST posted Winning the Pruning Gamble: A Unified Approach to Joint Sample and Token Pruning for Efficient Supervised Fine-Tuning (arXiv:2509.23873v1, cs.CL). A revision on 3 February 2026 (v2) is the version accepted to ICLR 2026, and the one every number in this article comes from. The authors call the method Q-Tuning.

Most prior data-selection methods prune on one axis: how hard a sample is (loss or perplexity) or how uncertain the model is about it (entropy), rarely both. Q-Tuning scores each sample on an Error-Uncertainty plane. Error is perplexity, the exponentiated average negative log-likelihood over trainable tokens (Eq. 4); Uncertainty is the average token-level predictive entropy (Eq. 5). That produces four named quadrants (Section 3.1): Harmful Noise (high error, high uncertainty) is "unreliable or mislabeled data that actively harms learning" and is discarded outright; Redundant Knowledge (low error, low uncertainty) is "mastered content offering diminishing returns" and is also discarded; Valuable Misconception (high error, low uncertainty) is a "confidently wrong" answer, kept but pruned at the token level so only the locally harmful tokens are cut; Calibration Data (low error, high uncertainty) is a "hard but reliable" example, kept with every token intact because, in the paper's words, "every token contributes to improving model calibration."

A per-batch bisection search finds the perplexity and entropy quantile cutoffs that keep exactly a target sample fraction r_sample: both thresholds start at the interval [0, 0.5] and are halved toward the kept proportion at each step (Eq. 6), typically converging in under 10 iterations. Inside the kept Valuable Misconception examples, a second pass scores each token with a neighbor-smoothed perplexity, s_i = 0.5·PPL_i + 0.5·(PPL_(i-1) + PPL_(i+1)) at the paper's default smoothing weight (Eq. 7), and keeps only the top r_token fraction by that score.

How much does the result change, and does it change the same way for every model?

Random pruning at the same budget underperforms full-data training in every row below. Q-Tuning's quadrant logic does not just close that gap, it crosses the full-data baseline, and by how much depends heavily on model size.

"Gain over full" is (Q-Tuning minus full dataset) divided by full dataset, computed by BLOMEGA from the paper's own reported averages; the paper states the SmolLM2-1.7B figure directly in its abstract as "+38%." All model scores from arXiv:2509.23873v2, Tables 1 to 3. DEITA, LESS, Alpagasus and DS2 are named as sample-pruning baselines in the related-work and experimental-setup text; we could not locate a numeric score for any of them in the paper's tables.

The introduction's own teaser number does not reconcile with the tables we could extract: it states "with LLaMA3-8B on GSM8K, Q-Tuning reaches 48.07 using only 35% of the data," but no LLaMA3-8B row at a 35%-sample setting appears among the tables available to us, and the 25%-sample row we do have shows Q-Tuning at 36.32 on GSM8K alone against 32.90 for full-data training. We flag this as unreconciled rather than wrong: it may sit in a table or appendix section our extraction did not reach.

Extreme budgets hold up too. Even keeping only 6.25% of WizardLM's samples and 50% of each one's tokens, 3.125% of the full token count, Mistral-7B still scores above full-data training (46.23 vs. 45.84). Pushing token retention from 50% to 70% at the same 12.5% sample rate moves the average from 46.92 to 46.79, a small decline, so more tokens kept is not automatically better once the sample-level triage is fixed.

What does token pruning do that sample pruning alone cannot?

Pruning only at the sample level has to choose between keeping a confidently-wrong example whole (and reinforcing its mistake) or discarding it entirely (and losing whatever correct context it also contains). Q-Tuning's quadrant layout avoids that choice for exactly one quadrant: Valuable Misconception examples are kept, but only the tokens the model gets locally wrong are kept active for the loss, the rest are pruned. Calibration Data gets the opposite treatment, kept but never token-pruned, because the paper's position is that a hard-but-correct example's value is distributed across its whole sequence, not concentrated in a few error tokens.

The paper's own ablation (Table 4, Qwen3-8B trained on OpenHermes at 12.5% samples and 50% tokens) shows the full rule, discard Harmful Noise and Redundant Knowledge at the sample level, token-prune Valuable Misconception, keep Calibration Data whole, scoring 60.19 on average across its five benchmarks. Configurations that depart from that rule, by the paper's own description, score 57.23 to 59.04, a gap of up to 2.96 points, about 5.2% relative. We could not reliably map every row of the extracted ablation table to the exact quadrant combination it tested, so we report the range rather than attribute each number to a specific partial rule; the direction, that the full four-quadrant logic beats every partial version we could identify, is what the paper states in its text.

What this means if you curate supervised fine-tuning data

Random downsampling is a trap at any of these budgets. In every row of our evidence table, random sample and token selection at the same retention rate scores below full-data training, sometimes well below it (Mistral-7B's reasoning average falls from 22.58 to 12.45). If you cannot score quadrants, training on everything you have is the safer default, not an arbitrary subset.

The capacity-constrained model is where this pays off most. SmolLM2-1.7B's 38.2% gain over full-data training, against Mistral-7B's 0.7% on the identical GSM8K+MATH setup, is our own reading of the paper's Table 2, not a claim the authors make about model size. Our judgement: a model already close to saturating a task from full-data training has little headroom left for a curation method to recover; a smaller model still leaves quality on the table that quadrant-based pruning can reclaim. Treat this as a hypothesis to test on your own model and task, not a guarantee.

Scoring is not free. Both axes require a forward pass over the candidate pool per round, separate from the training pass itself. The paper reports wall-clock and memory for the training step (65 minutes and 27% peak GPU memory for LLaMA2-7B at 12.5% samples/50% tokens, against 90 minutes and 78% for full-data training), but we found no separate figure for the scoring passes' own cost; budget for it as "not reported" rather than assuming it is negligible.

Keep hard-but-correct examples whole. Calibration Data is the one quadrant the paper never token-prunes, on the argument that a genuinely hard, correctly-answered example teaches something across its full length. That design choice, treat difficulty and error as separate signals rather than collapsing them into one score, is worth copying even if you build your own thresholds rather than the paper's bisection search.

Don't cite DEITA, LESS, Alpagasus or DS2 numbers from this paper. All four are named as prior sample-pruning methods in the related-work and setup sections, and none has a score in the tables we could extract. For a sample-selection method that does report what it actually picks against a released file, see our own recount of LESS's selections, which enrich for answer format rather than task; for a budget-allocation question one level up from which examples to keep, see how a blind 50/50 SFT-versus-RL split missed the near-optimal region; for a zero-label alternative that skips scoring on labels entirely, see Voxel51's ZCore, covered separately in this dimension.

Limits. Code and selected-sample indices are not released as of 24 October 2026 (see Check it yourself), so none of these numbers are independently reproducible from official artifacts yet. The full-detail results we found cover two training-set families (WizardLM; OpenHermes plus MathInstruct) and the model-size pattern rests on three models at one fixed budget. The introduction's LLaMA3-8B teaser figure did not reconcile with the tables available to us.

Check it yourself

The paper's selection code is not released yet, so this does not reproduce Q-Tuning's training results. It does reproduce the scoring step, perplexity and token entropy exactly as defined in Eq. 4, 5 and 7, on a small open model, so you can see what the Error-Uncertainty plane actually measures on real text.

pip install -q transformers torch
python3 - <<'PY'
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

MODEL = "HuggingFaceTB/SmolLM2-135M"   # small enough to run on CPU
tok = AutoTokenizer.from_pretrained(MODEL)
model = AutoModelForCausalLM.from_pretrained(MODEL)
model.eval()

def score(prompt, answer):
    full = prompt + answer
    ids = tok(full, return_tensors="pt")
    prompt_len = len(tok(prompt)["input_ids"])
    with torch.no_grad():
        out = model(**ids)
    logits = out.logits[0, :-1]                 # predict token t from t-1
    targets = ids["input_ids"][0, 1:]
    logp = torch.log_softmax(logits, dim=-1)
    nll = -logp[range(len(targets)), targets]   # per-token negative log-likelihood
    probs = logp.exp()
    ent = -(probs * logp).sum(-1)                # per-token entropy, Eq. 5
    trainable = slice(prompt_len - 1, None)       # only the answer tokens, Eq. 4/5
    ppl = nll[trainable].mean().exp().item()
    uncertainty = ent[trainable].mean().item()
    return ppl, uncertainty

# a correct, confident answer vs. a confidently wrong one
for prompt, answer in [
    ("Q: What is 12 + 7?\nA:", " 19"),
    ("Q: What is 12 + 7?\nA:", " 42"),
]:
    ppl, ent = score(prompt, answer)
    print(f"{answer.strip():>4}  perplexity={ppl:7.2f}  entropy={ent:5.3f}")
PY
# wrong answers should show up with higher perplexity (error) at similar
# or lower entropy if the model is still confident in the wrong token,
# which is the Q2 "confidently wrong" signature the paper scores for

To see whether the authors' own selection code has landed since this was written, check github.com/gszfwsb/Q-tuning directly: as of 24 October 2026 its README states the code is being updated and will be released soon, with no training scripts, scoring implementation, or selected-index files in the repository.

What would prove this wrong

If gszfwsb/Q-tuning releases training code and selected-sample indices, running the released WizardLM, Mistral-7B, 12.5%-sample/50%-token selection end to end should reproduce Table 1's average of 46.92 across the same five benchmarks within about 1.0 point. We expect this check to be possible by 30 June 2027, a reasonable window for a code release the repository already calls imminent. If a faithful reproduction differs by more than 2.0 points, the printed number depended on a detail not described in the ICLR 2026 version of the paper.

The model-size pattern we found but the paper does not explain, Q-Tuning's gain over full-data training falling from 38.2% (SmolLM2-1.7B) to 16.5% (LLaMA3-8B) to 0.7% (Mistral-7B) on the identical GSM8K+MATH task, predicts that running the same 25%-sample/50%-token recipe on a still-larger model from the paper's own model list, Qwen3-32B, on the same task should land at roughly 0% or a small negative gain relative to full-data training. If a follow-up instead reports a double-digit positive gain at 32B, model capacity is not the variable driving the pattern we observed, and some other difference between the three models (architecture, pretraining data, or tokenizer) would need to be ruled in instead.

Sources

1. Wang, S., Wang, J., Zhang, J., Wang, C., Min, Y., Wen, Z., Ren, X., Huang, F., Jiang, H., Lin, J., Liu, D., Zhang, L. Winning the Pruning Gamble: A Unified Approach to Joint Sample and Token Pruning for Efficient Supervised Fine-Tuning. arXiv:2509.23873v2, revised 3 February 2026 (v1: 28 September 2025), accepted ICLR 2026. Sections 3 to 5, Tables 1 to 4, Section 4.3.
2. gszfwsb/Q-tuning. Companion repository. Accessed 24 October 2026: no training code, scoring implementation, or selected-index files released; README states a release is coming.
3. Allal, L. B. et al. SmolLM2: When Smol Goes Big, Data-Centric Training of a Small Language Model. arXiv:2502.02737.
4. BLOMEGA. Gradient-based data selection picks the target's answer format: single-letter answers at 14.84 times their pool share.
5. BLOMEGA. A blind 50/50 split of the annotation budget missed the near-optimal region up to 80% of the time.
6. Griffin, B., Marks, J., Corso, J. Zero-Shot Coreset Selection via Iterative Subspace Sampling (ZCore). WACV 2026, Voxel51.