ArXiv: 2509.23873

🎯 Pitch

Existing data pruning for LLM fine-tuning is shockingly broken: sophisticated methods often lose to random sampling because they prune at only one level. This paper shows that by jointly pruning samples and tokens based on a model's error vs. uncertainty, you can use just 12.5% of the data and beat full-data training by 38%.

1. Executive Summary

This paper introduces Q-Tuning, a unified dynamic data pruning framework for supervised fine-tuning of large language models that jointly coordinates sample-level and token-level pruning based on a novel diagnostic tool—the Error–Uncertainty (EU) Plane—which partitions training data into four quadrants by mapping model perplexity against predictive entropy (e.g., confidently wrong misconceptions in Q2 receive targeted token pruning, while calibration data in Q4 is preserved in full). Evaluated on WizardLM and MathInstruct across LLaMA2-7B, Mistral-7B, LLaMA3-8B, SmolLM2-1.7B, and Qwen3-series models spanning five benchmarks (ARC-E, ARC-C, GSM8K, SQuAD, TriviaQA, MATH), Q-Tuning achieves a +38% average improvement over the full-data SFT baseline on SmolLM2-1.7B using only 12.5% of the original training data while on LLaMA3-8B with GSM8K it reaches 48.07 accuracy using only 35% of the data—outperforming full-data training by 6.0 points and the strongest baseline by 9.9 points—establishing that joint sample-token pruning can exceed full-data performance only when pruning is coordinated through a diagnostic framework that differentiates harmful noise from valuable misconceptions and calibration signals.

2. Context and Motivation

The Core Problem: Joint Sample and Token Pruning Under a Unified Framework

The fundamental question this paper tackles is deceptively straightforward: how can we maximize the learning utility of every retained token and sample during supervised fine-tuning (SFT) of large language models? This matters because SFT has undergone a dramatic transformation in scale. What was once a lightweight post-training step—applying a modest amount of labeled data to align a pretrained model—has ballooned into a compute-intensive phase that now rivals mid-training in its resource demands. The paper cites the explosion of alignment datasets routinely spanning billions of tokens (Ouyang et al., 2022; Dong et al., 2024; Yang et al., 2025) as the driving force behind this shift. In this new regime, the bottleneck is no longer simply reducing raw data volume; it is about making every retained training signal count.

This is not merely an academic concern. The practical stakes are substantial:

  • Compute and carbon cost: Fine-tuning on billion-token datasets consumes enormous GPU hours. Pruning that reduces the effective training set by 4× or more—while maintaining or exceeding full-data performance—directly translates to lower electricity consumption, reduced hardware depreciation, and faster experiment cycles.
  • Reproducibility and accessibility: Smaller, higher-quality training subsets make SFT more feasible for academic labs and smaller organizations that cannot afford large-scale compute. The paper positions Q-Tuning as making "high-quality post-training more accessible" (Impact Statement).
  • The failure of simple heuristics: The paper opens with a striking observation: "even sophisticated dynamic pruning heuristics often underperform simple random sampling" (Section 1, citing Xia et al., 2024b). If the best we can do is no better than random, then the entire enterprise of data pruning is called into question. Resolving this paradox is the paper's central motivation.

The Fragmented Design of Existing Pruning Strategies

The paper identifies a structural flaw in how prior work approaches data pruning: sample-level pruning and token-level pruning have been developed as entirely separate research threads, and this fragmentation fundamentally limits what either can achieve.

Sample-level pruning methods (Qin et al., 2024; Zhou et al., 2023a; Wang et al., 2025a; Yang et al., 2024) focus on selecting which full training examples to keep. They are good at identifying high-potential examples—those likely to provide strong learning signals—but they suffer from a critical blind spot: they treat all tokens within a selected sample as equally valuable. This means a sample retained because it contains a valuable misconception may also carry substantial redundant boilerplate, verbose preamble, or even locally harmful content that dilutes the alignment signal the sample was selected for.

Token-level pruning approaches (Lin et al., 2024; Xia et al., 2025; Chen et al., 2024; Zhang et al., 2024b) take the complementary perspective, focusing on which individual tokens within a sequence are worth retaining. But these methods apply context-agnostic heuristics uniformly across the entire dataset, blind to the semantic role of each sample. As the paper puts it:

"Such a one-size-fits-all policy fails to differentiate, for instance, between a sample containing a correctable misconception—where only specific tokens need refinement—and one serving as a calibration anchor, which must be preserved holistically to maintain model stability." (Section 1)

This is the crux of the problem. A sample that is confidently wrong (the model produces an incorrect answer with low uncertainty) needs a completely different pruning treatment than a sample that is uncertain but correct (the model produces the right answer despite high uncertainty). The former benefits from surgical removal of the specific misleading tokens; the latter must be preserved in its entirety because every token contributes to reducing the model's uncertainty and improving calibration. Existing methods cannot make this distinction because they operate in only one dimension at a time.

The Paradox: Why Sophisticated Pruning Often Fails

The paper frames its motivation around a troubling empirical finding from recent work: sophisticated, dynamically adaptive pruning heuristics frequently perform worse than simply selecting a random subset of the data (Xia et al., 2024b). This is not presented as an isolated anomaly but as evidence of a fundamental disconnect between current pruning strategies and the true utility of alignment data (Section 1).

Why would this happen? The paper's implicit argument is that pruning methods that operate in isolation—either at the sample level or the token level—are making decisions with incomplete information. A sample-level pruner might select an example that looks valuable in aggregate (high loss, high gradient norm), but it has no mechanism to determine that only a fraction of the tokens in that example are actually responsible for the learning signal, while the rest is noise. Conversely, a token-level pruner might strip out what appears to be redundant content from a calibration sample, unaware that the very redundancy it is removing plays a functional role in stabilizing the model's uncertainty estimates.

The result is a kind of pruning that is simultaneously too aggressive and not aggressive enough: it retains full samples that contain substantial waste, and it aggressively prunes tokens from samples where preservation was the right strategy. Random sampling, being uniformly indifferent, avoids both failure modes—and thus can outperform methods that are wrong in precisely the wrong way.

Where Existing Approaches Fall Short

The paper surveys a substantial landscape of prior work (detailed in Appendix A) and identifies specific limitations in each category:

Dynamic sample pruning encompasses methods that adapt sample usage throughout training. InfoBatch (Qin et al., 2024) removes low-loss examples on the fly based on the intuition that already-learned examples contribute little gradient signal. RHO-LOSS (Mindermann et al., 2022) assigns importance scores using high-quality reference models to prioritize examples that are learnable but not yet learned. MATES (Yu et al., 2024) and DWM (Yu et al., 2025) reweight or select samples according to the evolving model state.

But all of these methods share a common limitation: they operate at the granularity of entire samples. When they identify a sample as "high-utility," they assume every token within it is equally useful. The paper's EU Plane analysis demonstrates that this assumption is violated in practice—high-utility samples (Q2) contain a mix of informative context and locally harmful tokens that mislead the model. Pruning the sample entirely loses the valuable signal; keeping it entirely wastes compute on the harmful components.

Token pruning has seen parallel development, particularly in pretraining (Rho-1 by Lin et al., 2024, which uses reference models to estimate token importance), in fine-tuning (Token Cleaning by Pang et al., 2025, which identifies harmful tokens as noisy labels), and in inference acceleration (FastV by Chen et al., 2024; SparseVLM by Zhang et al., 2024b; LLMLingua by Jiang et al., 2023b). These methods develop increasingly sophisticated ways to score token importance using attention patterns, hidden-state features, or excess loss relative to reference models.

The limitation is not in the scoring mechanisms themselves but in their uniform application. A token-level pruner has no way of knowing whether the sample it is pruning belongs to Q2 (where pruning is beneficial) or Q4 (where pruning is harmful). It applies the same pruning policy to both, which means it inevitably makes systematic errors—either under-pruning Q2 samples (leaving harmful tokens in place) or over-pruning Q4 samples (removing tokens that were needed for calibration).

Static sample selection methods—including Alpagasus (Chen et al., 2023), which uses a strong LLM as a quality rater; Deita (Liu et al., 2023), which jointly models instruction complexity, response quality, and diversity; and LESS (Xia et al., 2024a), which selects based on gradient alignment with target tasks—determine data subsets in advance using fixed criteria. These methods miss the dynamic nature of data utility: a sample that is redundant at epoch 1 may become informative at epoch 3 as the model's capabilities evolve, and vice versa. The paper's dynamic approach, by contrast, re-evaluates pruning criteria for each new mini-batch "allowing the data distribution used for gradient updates to evolve alongside the model's parameters" (Section 2).

How This Paper Positions Itself

The paper positions Q-Tuning as filling a conceptual and methodological gap that none of the prior work addresses: the need for a unified framework that coordinates sample-level and token-level pruning through a diagnostic understanding of why each piece of data matters.

The key conceptual contribution is the Error–Uncertainty (EU) Plane, a diagnostic lens that reveals the heterogeneous utility of training data by jointly considering two orthogonal axes: model error (quantified by perplexity) and model uncertainty (quantified by predictive entropy). This is not merely a new scoring metric—it is a partitioning scheme that reveals four qualitatively distinct categories of training data, each requiring a fundamentally different pruning treatment.

By formalizing the problem as Generalized Dynamic Data Pruning (Section 2)—a bilevel optimization framework that jointly optimizes sample and token pruners—the paper provides a mathematical scaffolding that makes explicit what prior work only addressed implicitly. In this framework, any pair of pruners (Φ, Ψ) is evaluated by the final test performance of the model they produce. Existing methods that instantiate these operators independently can be seen as specific (and suboptimal) solutions to this joint optimization problem.

The paper's position is thus not to propose a single new heuristic but to argue that coordination is the missing ingredient. Sample pruning and token pruning are not independent decisions that can be made in isolation and then naively combined; they are interdependent choices that must be informed by a shared understanding of what role each training sample plays in the learning process. Q-Tuning operationalizes this coordination through its two-stage, EU-guided strategy: first sample-level triage to separate the wheat from the chaff (and to categorize what remains), then asymmetric token pruning that treats misconception samples and calibration samples differently.

The paper also explicitly connects to the broader goal of making data pruning "a principled, performance-enhancing process" rather than a gamble (Section 3, title: "Winning the Pruning Gamble"). This framing is deliberate: it acknowledges the field's current state—where pruning often backfires—and positions the EU Plane as the diagnostic tool that transforms pruning from a risky bet into a reliable strategy.

3. Technical Approach

This is primarily a diagnostic and algorithmic paper whose core idea is that effective data pruning for supervised fine-tuning requires jointly coordinating sample-level and token-level decisions based on a principled understanding of why each piece of training data matters—specifically, whether it represents harmful noise, a valuable misconception, redundant knowledge, or a calibration signal—and Q-Tuning operationalizes this through a two-stage strategy guided by the Error–Uncertainty Plane.

3.1 Reader Orientation

What the system is: Q-Tuning is a dynamic, per-mini-batch data pruning procedure that sits between the training data loader and the model's gradient computation, intercepting each mini-batch to throw away entire samples that are harmful or redundant, and then to selectively strip out individual tokens from the remaining samples that are confidently wrong, all guided by a two-dimensional diagnostic map—the Error–Uncertainty Plane—that the system constructs on-the-fly using the model's own perplexity and entropy measurements.

What problem it solves and the shape of the solution: The problem is that existing pruning methods operate either at the sample level or the token level in isolation, and when naively combined they underperform random sampling because they fail to recognize that different categories of training data require different pruning treatments; the solution is a two-stage coordinated framework where stage one partitions all samples into four quadrants using a bisect search over perplexity and entropy quantiles to determine which samples to keep or discard, and stage two applies an asymmetric token policy that prunes tokens only from confidently-wrong samples while preserving calibration samples in full.

3.2 Big-Picture Architecture (Diagram in Words)

The system has five major components, operating in sequence on each training mini-batch:

  1. Base Language Model $f_\theta$ — the model being fine-tuned, which is used in a gradient-free forward pass at the start of each mini-batch to compute per-sample perplexity and per-sample entropy. These two scalar statistics are the sole diagnostic inputs to the entire pruning pipeline.

  2. EU Plane Constructor (Bisect Search Engine) — takes the collection of $(\text{PPL}, \text{Ent})$ pairs for all samples in the current mini-batch and determines two quantile thresholds $(\alpha, \beta)$ such that the fraction of samples falling into quadrants Q2 and Q4 exactly matches the target sample retention ratio $r_{\text{sample}}$. The quantile search runs in $O(\log(1/\varepsilon))$ bisection iterations (reported as typically fewer than 10) and produces the four-way partition Q1–Q4.

  3. Sample-Level Pruner $\Psi$ — reads the quadrant assignments and discards all samples in Q1 (Harmful Noise) and Q3 (Redundant Knowledge), keeping only Q2 (Valuable Misconception) and Q4 (Calibration Data). If this results in fewer kept samples than the target $r_{\text{sample}} \cdot |\mathcal{B}_t|$, a supplementary scoring mechanism selects additional samples from Q1/Q3 to meet the quota.

  4. Token-Level Pruner $\Phi$ — operates only on the retained samples. For samples in Q2, it computes a smoothed, neighbor-aware token-level perplexity score for every trainable token, ranks tokens by this score, and retains only the top $r_{\text{token}}$ fraction, discarding the rest. For samples in Q4, it applies no token pruning—all tokens are preserved.

  5. Pruned Mini-Batch Assembler — collects the masked Q2 samples and the intact Q4 samples into the final pruned mini-batch $\tilde{\mathcal{B}}_t$, which is then passed to the standard training loop for the forward-backward gradient step on the model.

Information flows as follows: a mini-batch is drawn from the training distribution → the base model computes PPL and Ent for every sample via a gradient-free forward pass → the bisect search partitions samples into Q1–Q4 using quantile thresholds → Q1 and Q3 are discarded → Q4 passes through intact → Q2 samples have their individual tokens scored with the smoothed PPL metric → the bottom $(1 - r_{\text{token}})$ fraction of tokens in each Q2 sample are masked out → the pruned mini-batch is sent to the optimizer for a standard gradient update → the process repeats at the next step with the model's updated parameters, causing the EU Plane to evolve dynamically.

3.3 Roadmap for the Deep Dive

  • First, the formal Generalized Dynamic Data Pruning framework (Section 2), which defines the bilevel optimization problem and the abstract operators $\Psi$ and $\Phi$, establishing the mathematical language needed to describe Q-Tuning as a specific instantiation of these operators.
  • Second, the Error–Uncertainty Plane construction (Section 3.1), including how perplexity and entropy are defined, computed at the sample level, and what each axis captures about the model–data relationship—this is the diagnostic foundation that all subsequent decisions depend on.
  • Third, the bisect search procedure that determines the quantile thresholds partitioning the EU Plane into Q1–Q4—this is the algorithmic core of Stage 1 that adapts the quadrant boundaries dynamically to meet the target sample retention ratio.
  • Fourth, the sample-level pruning logic (Stage 1 completion), including how quadrants are interpreted, which are kept and discarded, and the fallback scoring mechanism when the initial partition under-retains samples.
  • Fifth, the token-level pruning procedure (Stage 2), including the neighbor-aware smoothed perplexity score, the percentile-based thresholding criterion, the ranking and masking mechanism, and why Q4 samples are exempt from token pruning.
  • Sixth, the hyperparameters, design choices, and their justifications, pulling together the $\lambda$ smoothing coefficient, batch size sensitivity, bisection iteration budget, and the rationale for each.

3.4 Detailed, Sentence-Based Technical Breakdown

Generalized Dynamic Data Pruning: The Formal Framework

Before describing Q-Tuning itself, the paper establishes a formal optimization framework that makes explicit what it means to jointly optimize sample and token pruning. This framework is not Q-Tuning—it is the abstract problem definition that Q-Tuning (and any future method) instantiates.

The framework models the pruning process as two abstract operators applied sequentially to each training mini-batch. At training step $t$, a mini-batch $\mathcal{B}_t$ is drawn from the training distribution $\mathcal{D}$. The sample-level pruner $\Psi$ splits $\mathcal{B}_t$ into kept and discarded samples, governed by a keep ratio $r_{\text{sample}} \in [0, 1]$. The retained subset $\mathcal{B}'_t$ is:

Bt′=Bt∖Ψ(Bt)⊆Bt\mathcal{B}'_t = \mathcal{B}_t \setminus \Psi(\mathcal{B}_t) \subseteq \mathcal{B}_t

where $\Psi(\mathcal{B}_t)$ is the set of discarded samples, and the size constraint is $|\mathcal{B}'_t| = \lfloor r_{\text{sample}} \cdot |\mathcal{B}_t| \rfloor$. The absolute value bars denote set cardinality (number of samples). The floor function $\lfloor \cdot \rfloor$ ensures an integer number of kept samples.

What it computes: the set difference between the original mini-batch and the samples the pruner marks for removal, producing a smaller batch of exactly $r_{\text{sample}}$ fraction of the original size.

The token-level pruner $\Phi$ then operates on each retained sample $\mathbf{x} \in \mathcal{B}'_t$. For a sample with sequence length $L(\mathbf{x})$, $\Phi$ generates a binary mask $\mathbf{m}(\mathbf{x}) \in \{0, 1\}^{L(\mathbf{x})}$ that indicates which token positions to keep (1) or discard (0). The doubly-pruned mini-batch is:

B~t=Φ(Bt′)={m(x)⊙x∣x∈Bt′}\tilde{\mathcal{B}}_t = \Phi(\mathcal{B}'_t) = \{\mathbf{m}(\mathbf{x}) \odot \mathbf{x} \mid \mathbf{x} \in \mathcal{B}'_t\}

where $\odot$ denotes element-wise (token-wise) product, and the mask satisfies $\|\mathbf{m}(\mathbf{x})\|_1 = \lfloor r_{\text{token}} \cdot L(\mathbf{x}) \rfloor$. The $\|\cdot\|_1$ notation counts the number of ones in the binary mask (the L1 norm of a binary vector equals the number of kept tokens).

What it computes: the composition of two filters—first remove entire samples, then within each survivor, zero out a subset of tokens—producing the pruned mini-batch that will actually be used for the gradient update.

Why this form: the sequential composition $\Phi(\mathcal{B}_t \setminus \Psi(\mathcal{B}_t))$ encodes a deliberate ordering: sample-level decisions happen first because they are coarser and cheaper (you avoid computing token-level scores for samples you'll discard anyway), and token-level decisions operate only on survivors. The explicit keep-ratio constraints ensure the computational savings are predictable—the user controls exactly how much data is retained at each granularity, rather than relying on a scoring threshold that might produce variable amounts of pruning.

The central optimization problem of this framework is the bilevel program:

min⁡Φ,Ψ E(x,y)∼Dtest[Ltest(fθ∗(x),y)]\min_{\Phi, \Psi} \ \mathbb{E}_{(x,y) \sim \mathcal{D}_{\text{test}}} \left[ \mathcal{L}_{\text{test}}(f_{\theta^*}(x), y) \right]

s.t.θ∗=arg⁡min⁡θ∑t=1TEBt∼D E(x,y)∼B~t[Ltrain(fθt(x),y)]\text{s.t.} \quad \theta^* = \arg\min_{\theta} \sum_{t=1}^T \mathbb{E}_{\mathcal{B}_t \sim \mathcal{D}} \ \mathbb{E}_{(x,y) \sim \tilde{\mathcal{B}}_t} \left[ \mathcal{L}_{\text{train}}(f_{\theta_t}(x), y) \right]

where at each step $t$, $\tilde{\mathcal{B}}_t = \Phi(\mathcal{B}_t \setminus \Psi(\mathcal{B}_t))$.

What it computes: the outer loop evaluates any candidate pruner pair $(\Phi, \Psi)$ by the generalization performance (test loss) of the final model $\theta^*$ that results from training under those pruners. The inner loop defines the training procedure: starting from some initialization, gradient steps are taken on a sequence of pruned mini-batches, and the result $\theta^*$ is the parameter setting reached after $T$ steps. The constraint ties the two loops together: the outer objective can only be evaluated by first solving the inner training problem, making this a bilevel (nested) optimization.

Why this form: casting pruning as a bilevel optimization makes explicit what is implicit in heuristic pruning methods: the pruners $(\Phi, \Psi)$ are hyperparameters of the training process that should be chosen to maximize final model quality, not to minimize some intermediate proxy like training loss on the pruned set. A pruner that discards genuinely hard examples would produce low training loss quickly (because the pruned set is easy) but would fail the outer test-loss objective. The bilevel formulation prevents this failure mode by evaluating pruners on downstream generalization.

The paper notes that "all existing methods that instantiate these operators $\Phi$ and $\Psi$ can be seen as a specific solution to this alignment problem" (Section 2). Q-Tuning is then presented as a particular choice of $\Phi$ and $\Psi$ guided by the EU Plane, and the paper's empirical results demonstrate that this specific instantiation achieves better outer-loop performance than prior instantiations.

The Error–Uncertainty Plane: A Diagnostic Lens

The Error–Uncertainty Plane is the conceptual heart of Q-Tuning. It provides a two-dimensional coordinate system in which every training sample is positioned by two orthogonal measurements: how wrong the model's prediction is (error, quantified by perplexity) and how uncertain the model is about that prediction (uncertainty, quantified by predictive entropy). The key insight is that these two dimensions are not redundant—they capture fundamentally different aspects of the model–data relationship that, when crossed, reveal four qualitatively distinct categories of training samples.

Measuring Error via Perplexity (PPL). For a training sample consisting of an instruction–response pair $(\mathbf{x}, \mathbf{y})$ with sequence length $L(\mathbf{x})$, the paper defines $\mathcal{T}(\mathbf{x}) \subseteq \{1, \ldots, L(\mathbf{x})\}$ as the set of trainable token positions. This is an important distinction: the model's loss is only computed on the response tokens (the answer), not on the instruction tokens (the prompt), because during SFT the model learns to generate the appropriate response given the instruction. The sample-level perplexity is:

PPL(x,y;fθ)=exp⁡(∑i∈T(x)−log⁡p(yi∣x,y<i;fθ)∣T(x)∣)\text{PPL}(\mathbf{x}, \mathbf{y}; f_\theta) = \exp\left( \frac{\sum_{i \in \mathcal{T}(\mathbf{x})} -\log p(y_i \mid \mathbf{x}, y_{<i}; f_\theta)}{|\mathcal{T}(\mathbf{x})|} \right)

where $p(y_i \mid \mathbf{x}, y_{<i}; f_\theta)$ is the model's predicted probability for the ground-truth token $y_i$ at position $i$, given the instruction and all preceding response tokens; $|\mathcal{T}(\mathbf{x})|$ is the number of trainable positions; and $\exp(\cdot)$ is the exponential function.

What it computes: the fraction inside the exponential is the average negative log-likelihood per trainable token—the standard cross-entropy loss normalized by sequence length. Exponentiating this average loss converts it from log-space to probability-space, yielding perplexity, which can be interpreted as the effective branching factor: a perplexity of $k$ means the model is, on average, as uncertain about each token prediction as if it were choosing uniformly among $k$ equally likely options.

Why this form: averaging over trainable positions before exponentiating (rather than multiplying per-token perplexities) produces a length-normalized metric where sequences of different lengths are comparable. If the paper instead multiplied per-token perplexities directly, long sequences would have systematically inflated values, making length a confound in the EU Plane coordinate. The logarithm-exponential pair is the standard definition of perplexity and connects directly to the information-theoretic interpretation.

Measuring Uncertainty via Predictive Entropy (Ent). Independent of whether the model's top prediction is correct (which perplexity measures), the paper quantifies uncertainty using the entropy of the model's output distribution at each token position:

Ent(x,y;fθ)=∑i∈T(x)H(pθ(⋅∣x,y<i))∣T(x)∣\text{Ent}(\mathbf{x}, \mathbf{y}; f_\theta) = \frac{\sum_{i \in \mathcal{T}(\mathbf{x})} H(p_\theta(\cdot \mid \mathbf{x}, y_{<i}))}{|\mathcal{T}(\mathbf{x})|}

where $p_\theta(\cdot \mid \mathbf{x}, y_{<i})$ is the full probability distribution over the vocabulary at position $i$, and $H(p) = -\sum_{v \in \mathcal{V}} p(v) \log p(v)$ is the Shannon entropy of that distribution, with $\mathcal{V}$ being the vocabulary.

What it computes: for each trainable token position, the model's predicted distribution over the vocabulary is converted to a scalar entropy (high entropy means the probability mass is spread broadly across many tokens; low entropy means it is concentrated on a few tokens). These per-position entropies are averaged across all trainable positions, yielding a single number per sample that characterizes how "spread out" the model's predictions are, regardless of whether the highest-probability token matches the ground truth.

Why this form: entropy captures a different signal than perplexity. A model can have low perplexity (it assigns high probability to the correct token) but high entropy (it also assigns substantial probability to several alternative tokens)—this is the "uncertain but correct" regime characteristic of Q4 calibration data. Conversely, a model can have high perplexity (the correct token has low probability) but low entropy (the probability mass is concentrated on a wrong token)—this is the "confidently wrong" regime characteristic of Q2 misconception data. Perplexity alone cannot distinguish these cases because it only considers the probability of the ground-truth token; entropy is needed to capture the shape of the full distribution.

The Four Quadrants. Once every sample in the mini-batch has a $(\text{PPL}, \text{Ent})$ coordinate, the EU Plane partitions them into four regions by thresholding on both axes. The thresholds are not fixed in advance—they are computed dynamically per mini-batch via bisect search (detailed in the next subsection). The four quadrants are:

  • Q1 (Harmful Noise): High PPL, High Entropy. Samples where the model is both wrong (high perplexity) and uncertain (high entropy). The paper characterizes these as "unreliable or mislabeled data that actively harms learning" (Section 1). These are candidates for sample-level pruning because even the model recognizes that something is off—the high entropy indicates the model is not confidently latching onto a specific misconception but is confused, suggesting the sample may be genuinely noisy or misaligned with the model's knowledge.

  • Q2 (Valuable Misconception): High PPL, Low Entropy. Samples where the model is confidently wrong—it assigns high probability to an incorrect answer. The paper frames these as "powerful teaching signals" (Section 1) because the model's confidence means there is a specific misconception to correct. However, not all tokens in these samples are equally responsible for the error: the sample likely contains informative context and a few locally harmful tokens that mislead the model. This quadrant is the target for token-level pruning—surgically remove the misleading tokens while keeping the surrounding context.

  • Q3 (Redundant Knowledge): Low PPL, Low Entropy. Samples where the model is both correct and confident. These are "mastered content offering diminishing returns" (Section 1). The model already knows this material well, so additional training on it contributes little gradient signal. These are candidates for sample-level pruning.

  • Q4 (Calibration Data): Low PPL, High Entropy. Samples where the model gets the right answer but is uncertain about it—it assigns high probability to the correct token but also spreads probability across alternatives. The paper characterizes these as "hard but reliable samples essential for improving model confidence and robustness" (Section 1). Unlike Q2, where the error is localized in specific misleading tokens, the uncertainty in Q4 is distributed across the entire sequence—every token contributes to the model's calibration. Therefore, Q4 samples must be preserved in full, with no token pruning applied.

Why these four categories matter: the quadrant structure encodes a critical insight that one-dimensional pruning cannot capture: whether a sample should be pruned or preserved depends on both error and uncertainty jointly. A high-PPL sample could be Q1 (noise to discard) or Q2 (misconception to refine at the token level). A low-PPL sample could be Q3 (redundant to discard) or Q4 (calibration to preserve fully). The EU Plane resolves this ambiguity by considering both dimensions simultaneously—it is not merely scoring samples on a single axis but classifying them into categories that demand qualitatively different pruning actions.

The EU Plane's quadrant boundaries are not static hyperparameters chosen once and fixed throughout training. Instead, at each training step, the thresholds are recomputed to ensure that the fraction of samples falling into the kept quadrants (Q2 ∪ Q4) matches the target sample retention ratio $r_{\text{sample}}$. This is necessary because the model's perplexity and entropy distributions shift as training progresses—a sample that was Q2 at epoch 1 might become Q3 by epoch 3 as the model learns the misconception.

Quantile thresholds. The paper uses quantile-based partitioning rather than absolute-value thresholds. For each axis, two thresholds are needed (a lower bound and an upper bound for the "high" region):

  • $\text{ppl}_{\text{hi}} = Q_{1-\alpha}(\text{PPL})$ — the $(1-\alpha)$-quantile of the perplexity distribution, i.e., the value above which a fraction $\alpha$ of samples lie. This separates high-PPL from low-PPL samples.
  • $\text{ppl}_{\text{lo}} = Q_{\alpha}(\text{PPL})$ — the $\alpha$-quantile, below which a fraction $\alpha$ of samples lie. This is primarily used for boundary definition but plays a secondary role in the final pruning logic.
  • $\text{ent}_{\text{hi}} = Q_{1-\beta}(\text{Ent})$ — the $(1-\beta)$-quantile of the entropy distribution, separating high-entropy from low-entropy samples.
  • $\text{ent}_{\text{lo}} = Q_{\beta}(\text{Ent})$ — the $\beta$-quantile for the low-entropy boundary.

The pair $(\alpha, \beta)$ thus fully determines the quadrant boundaries: Q1 contains samples with PPL above $\text{ppl}_{\text{hi}}$ and Ent above $\text{ent}_{\text{hi}}$; Q2 contains samples with PPL above $\text{ppl}_{\text{hi}}$ and Ent below $\text{ent}_{\text{lo}}$; Q3 contains samples with PPL below $\text{ppl}_{\text{lo}}$ and Ent below $\text{ent}_{\text{lo}}$; Q4 contains samples with PPL below $\text{ppl}_{\text{lo}}$ and Ent above $\text{ent}_{\text{hi}}$.

The bisect search algorithm. The objective is to find $(\alpha, \beta)$ such that the fraction of samples in Q2 ∪ Q4 equals $r_{\text{sample}}$. Since increasing $\alpha$ shrinks the high-PPL regions (making the threshold more extreme, so fewer samples qualify as high-PPL), and similarly for $\beta$ with entropy, the relationship between $(\alpha, \beta)$ and the retained fraction is monotonic, enabling binary search.

The search initializes both axes with the interval $[0, 0.5]$ for each of $\alpha_{\text{low}}, \alpha_{\text{high}}$ and $\beta_{\text{low}}, \beta_{\text{high}}$. The $0.5$ upper bound ensures that at most half the samples can fall into the "high" regions on either axis—the quadrants are defined symmetrically. At each bisection iteration, the midpoints are computed:

α=12(αlow+αhigh),β=12(βlow+βhigh)\alpha = \frac{1}{2}(\alpha_{\text{low}} + \alpha_{\text{high}}), \quad \beta = \frac{1}{2}(\beta_{\text{low}} + \beta_{\text{high}})

The corresponding quantile thresholds are derived, samples are partitioned, and the empirical retention ratio $\gamma = \frac{|\text{Q2}| + |\text{Q4}|}{|\mathcal{B}_t|}$ is computed. The intervals are then updated:

(αlow,αhigh,βlow,βhigh)={(αlow,α,βlow,β),if γ>rsample(α,αhigh,β,βhigh),otherwise(\alpha_{\text{low}}, \alpha_{\text{high}}, \beta_{\text{low}}, \beta_{\text{high}}) = \begin{cases} (\alpha_{\text{low}}, \alpha, \beta_{\text{low}}, \beta), & \text{if } \gamma > r_{\text{sample}} \\ (\alpha, \alpha_{\text{high}}, \beta, \beta_{\text{high}}), & \text{otherwise} \end{cases}

What it computes: when the current retention ratio $\gamma$ is too high (more samples in Q2/Q4 than desired), the thresholds need to become more extreme, which means the $\alpha$ and $\beta$ quantiles need to decrease—so the search narrows the interval toward the lower end (first case). When $\gamma$ is too low, the thresholds should become less extreme, so the search narrows toward the upper end (second case). The search converges when $\alpha$ and $\beta$ stabilize within a tolerance $\varepsilon$.

Why this form: the bisect search on two axes simultaneously (rather than independently) is necessary because the retention ratio depends on the joint distribution of PPL and Ent. If $\alpha$ is varied independently of $\beta$, the quadrant boundaries on one axis might shift in ways that counteract the effect on the other axis. The simultaneous bisection ensures coordinated threshold adjustment that converges to a valid partition satisfying the retention constraint. The paper reports that "the search converges in $O(\log(1/\varepsilon))$ iterations (typically < 10), incurring negligible overhead" (Section 3.2).

Fallback when quotas are not met. In some cases, even after bisect search, the number of samples in Q2 ∪ Q4 may be slightly less than $r_{\text{sample}} \cdot |\mathcal{B}_t|$ due to discretization effects (quantile thresholds are derived from the empirical distribution of a finite mini-batch). To handle this, the paper defines a supplementary scoring function for samples in Q1 and Q3:

supp(x)=max⁡{PPL^(x)−Ent^(x), Ent^(x)−PPL^(x)}\text{supp}(x) = \max\left\{ \hat{\text{PPL}}(x) - \hat{\text{Ent}}(x), \ \hat{\text{Ent}}(x) - \hat{\text{PPL}}(x) \right\}

where $\hat{\cdot}$ denotes min–max normalization to the $[0, 1]$ range. This score captures how distant a sample is from the decision boundary—samples near the quadrant borders (where PPL and Ent are close to each other after normalization) get low scores, while samples deep in Q1 or Q3 (where one normalized coordinate dominates the other) get high scores. The top-scoring samples from Q1/Q3 are added to the retained set until the quota is met. This ensures the sample retention ratio is exactly satisfied at every step.

Stage 1: Sample-Level Pruning

With the quadrants established, Stage 1 of Q-Tuning is straightforward: discard all samples in Q1 (Harmful Noise) and Q3 (Redundant Knowledge), and retain all samples in Q2 (Valuable Misconception) and Q4 (Calibration Data). The retained set is $\mathcal{B}'_t = \text{Q2} \cup \text{Q4}$, with the supplementary scoring fallback applied if needed to reach the target size.

Why discard Q1? These are high-PPL, high-entropy samples—the model is both wrong and uncertain. Training on them risks reinforcing confusion, as there is no clear signal for the model to latch onto. The paper characterizes them as "unreliable or mislabeled" and asserts that they "actively harm learning" (Figure 1). Empirically, the quadrant ablation in Table 4 confirms this: retaining Q1 consistently yields the lowest averages across all benchmarks, with "pronounced drops on reasoning and QA tasks."

Why discard Q3? These are low-PPL, low-entropy samples—the model already knows them well. Training on them contributes negligible gradient signal (the loss is already near zero, so gradients are small), and they consume compute that could be spent on more informative examples. The paper frames this as "mastered content offering diminishing returns" and notes that removing them "improves efficiency without sacrificing performance" (Section 1).

Why retain Q2 and Q4? Q2 samples contain specific misconceptions that the model needs to correct—they are "valuable" precisely because the model is confidently wrong, indicating a learnable error signal. Q4 samples are "hard but reliable"—the model gets the right answer but lacks confidence, and training on them improves calibration and robustness. The complementary value of these two retained quadrants is the core of Q-Tuning's design: Q2 provides error-correction signals, Q4 provides calibration signals, and the asymmetric token-pruning policy in Stage 2 ensures each is treated appropriately.

Stage 2: Token-Level Pruning for Confident Errors

Stage 1 removes entire samples, but within the retained Q2 samples, not all tokens are equally valuable. A Q2 sample typically contains a mix of useful context (the instruction, the overall structure of the response) and locally harmful tokens (the specific spans that encode the misconception). Stage 2 applies token-level pruning to Q2 samples to remove the detrimental tokens while preserving the informative context. Q4 samples are exempt from token pruning entirely.

Token-level perplexity. For a Q2 sample with target sequence $\mathbf{y}$, each trainable token position $i \in \mathcal{T}(\mathbf{x})$ is assigned a token-level perplexity:

PPLi(x,y;fθ)=exp⁡(−log⁡p(yi∣x,y<i;fθ))=1p(yi∣x,y<i;fθ)\text{PPL}_i(\mathbf{x}, \mathbf{y}; f_\theta) = \exp\left(-\log p(y_i \mid \mathbf{x}, y_{<i}; f_\theta)\right) = \frac{1}{p(y_i \mid \mathbf{x}, y_{<i}; f_\theta)}

This is simply the reciprocal of the model's predicted probability for the ground-truth token at that position. A high token-level PPL means the model assigned low probability to the correct token, indicating that the token is surprising—and potentially harmful if the model is confidently wrong at that position.

Neighbor-aware smoothing. A naive approach would rank tokens by their individual PPL and prune the highest-PPL tokens. However, this risks removing rare but meaningful tokens that happen to have high PPL in isolation—for example, a key numerical value or a technical term that the model handles poorly but that is essential for the response's correctness. To address this, Q-Tuning computes a smoothed importance score that incorporates local context:

si(x,y;fθ)=(1−λ)⋅PPLi(x,y;fθ)+λ⋅[PPLi−1(x,y;fθ)+PPLi+1(x,y;fθ)2]s_i(\mathbf{x}, \mathbf{y}; f_\theta) = (1 - \lambda) \cdot \text{PPL}_i(\mathbf{x}, \mathbf{y}; f_\theta) + \lambda \cdot \left[ \frac{\text{PPL}_{i-1}(\mathbf{x}, \mathbf{y}; f_\theta) + \text{PPL}_{i+1}(\mathbf{x}, \mathbf{y}; f_\theta)}{2} \right]

where $\lambda \in [0, 1]$ balances the contribution of the token's own PPL against the average PPL of its immediate neighbors (one token to the left and one to the right). The default value is $\lambda = 0.5$.

What it computes: a convex combination of the token's own perplexity and the average perplexity of its adjacent tokens. When $\lambda = 0$, only the token's own PPL matters (recovering the naive approach). When $\lambda = 0.5$, the token's own PPL and its neighbors' average PPL are weighted equally. When $\lambda = 1$, only neighbor PPL matters.

Why this form: the smoothing reduces the risk of pruning isolated high-PPL tokens that are semantically important but happen to be difficult for the model. A token that is individually high-PPL but surrounded by low-PPL neighbors will have its smoothed score pulled down, making it less likely to be pruned. Conversely, a token that is part of a contiguous block of high-PPL tokens—indicative of a systematic misconception rather than an isolated difficulty—will have its smoothed score remain high, making it more likely to be pruned. This encodes the intuition that locally coherent blocks of surprise are more likely to be genuinely harmful than isolated surprising tokens.

Thresholding and masking. A token is considered a pruning candidate only if both its own PPL $\text{PPL}_i$ and the average PPL of its two immediate neighbors exceed a percentile-based threshold. The paper specifies "e.g., the median" as a concrete threshold: if $\text{PPL}_i > \text{median}(\{\text{PPL}_j\})$ and $\frac{1}{2}(\text{PPL}_{i-1} + \text{PPL}_{i+1}) > \text{median}(\{\text{PPL}_j\})$, the token is eligible for pruning. All tokens in $\mathcal{T}(\mathbf{x})$ are then ranked by their smoothed scores $s_i$, and only the top $r_{\text{token}}$ fraction are retained—the rest are masked to zero. This produces the binary mask $\mathbf{m}(\mathbf{x})$.

Why this two-stage criterion: the requirement that both the token's own PPL and its neighbors' average PPL exceed the median ensures that tokens are only pruned when there is converging evidence from the local context that they are part of a problematic span. A token that individually exceeds the median but is adjacent to low-PPL tokens will not be pruned, because its smoothed score will be moderate and it may not even pass the initial dual-threshold check. The ranking-by-smoothed-score step then ensures that, among the remaining candidates, the most confidently detrimental tokens are removed first, up to the budget constraint.

Q4 exemption. No token-level pruning is applied to Q4 samples. The paper's rationale is that "every token contributes to improving model calibration" (Section 3.2). In Q4, the model's uncertainty is distributed across the entire sequence, not localized to specific problematic tokens. Pruning any tokens from a Q4 sample would reduce the information available for the model to learn appropriate uncertainty estimates, potentially degrading calibration. The quadrant ablation in Table 4 confirms this: "Token-level pruning of Q4 is generally harmful, indicating that these low-PPL yet diverse tokens carry useful signal and should be preserved."

Design Choices, Hyperparameters, and Their Justifications

Perplexity and entropy as the two axes over alternatives. The paper could have used simpler one-dimensional metrics (loss, gradient norm, influence functions) or more complex representations (learned embeddings, attention patterns). The choice of $(\text{PPL}, \text{Ent})$ is defended on two grounds: interpretability (these are standard, well-understood quantities with clear semantic meanings for "error" and "uncertainty") and computational efficiency (both are available essentially for free from a single forward pass—no extra model calls, reference models, or gradient computation needed). The paper implicitly argues that the diagnostic power gained from the second dimension (separating Q1 from Q2 and Q3 from Q4) justifies the marginal conceptual complexity over using PPL alone.

Dynamic quantile-based thresholds over fixed absolute thresholds. Using fixed thresholds (e.g., PPL > 10 defines "high PPL") would be fragile—the model's overall PPL distribution shifts during training (typically decreasing as the model improves), so fixed thresholds would become increasingly extreme over time, potentially collapsing the quadrants. Quantile-based thresholds adapt automatically: as the model learns, the absolute values of the quantiles change, but the fraction of samples in each quadrant remains controlled by the $r_{\text{sample}}$ constraint via bisect search. This makes the method self-calibrating across training epochs and across different models and datasets.

Symmetric bisect search on both axes over independent search. The paper could have searched $\alpha$ and $\beta$ independently—first fix $\beta$, search $\alpha$, then fix $\alpha$, search $\beta$, and iterate. The simultaneous update in Equation 6 converges faster (both axes move toward the target in each iteration rather than taking turns) and avoids oscillation that could occur if the axes interact (changing $\alpha$ affects which samples are Q2 vs. Q1, which changes the retention ratio, which then requires a compensating change in $\beta$).

Neighbor-aware token scoring ($\lambda = 0.5$) over isolated token scoring. The ablation in Table 5 compares $\lambda = 0$ (no smoothing) to $\lambda = 0.5$ (the default). On Mistral-7B with 25% samples and 50% tokens, $\lambda = 0.5$ achieves an average of 46.79 versus $\lambda = 0$ at 45.92—a meaningful improvement. The paper also tests a "Reversed PPL" variant that inverts the ranking (keeping low-PPL tokens), which performs substantially worse (44.86), confirming that the high-PPL tokens in Q2 are indeed the harmful ones. The sensitivity analysis in Section C.5.1 (Figure 9) shows that "moderate values of $\lambda$ improve performance on GSM8K and SQuAD, whereas extreme values yield diminishing or unstable gains."

Batch size robustness. The sensitivity analysis in Figure 9 varies batch size across $\{8, 16, 32\}$ and finds that "larger batch sizes generally improve performance, especially on GSM8K and SQuAD, where the gains are more pronounced." The paper's default batch size of 8 (Table 7) is thus conservative—larger batches would likely yield better results. The robustness is attributed to the quantile-based partitioning: with larger batches, the empirical quantiles are estimated more accurately, reducing the noise in quadrant assignment.

Summation over trainable token positions only. By defining $\mathcal{T}(\mathbf{x})$ as the set of trainable positions (response tokens only, excluding the instruction), the paper ensures that PPL and Ent reflect the model's performance on the target task (generating the answer) rather than being contaminated by the instruction tokens, which the model likely handles easily. This is a subtle but important design choice: if instruction tokens were included, they would systematically lower the average PPL (since instructions are typically straightforward to predict), compressing the dynamic range of the PPL axis and making it harder to distinguish between quadrants.

4. Key Insights and Innovations

Innovation 1: The Error–Uncertainty Plane as a Diagnostic Framework That Reveals Qualitatively Distinct Data Categories

The paper's most fundamental conceptual contribution is not a new pruning algorithm but a diagnostic lens — the Error–Uncertainty (EU) Plane — that reveals that training data is not uniformly arrayed along a single "usefulness" spectrum but instead falls into four qualitatively distinct categories that demand fundamentally different pruning treatments.

What the field did before. Prior work treated data utility as a one-dimensional quantity: samples were scored by loss (InfoBatch, Qin et al., 2024), gradient norm, influence on a reference model (RHO-LOSS, Mindermann et al., 2022; LESS, Xia et al., 2024a), or some composite quality metric (Deita, Liu et al., 2023; Alpagasus, Chen et al., 2023), and then a threshold selected the "best" fraction. This one-dimensional view collapses fundamentally different phenomena — a sample that is confidently wrong versus one that is uncertain but correct — onto the same axis, where they can receive similar scores and thus identical treatment. Token-level pruning methods (Rho-1, Lin et al., 2024; Token Cleaning, Pang et al., 2025) suffered from the mirror-image problem: they scored tokens on a single dimension (typically loss or attention weight) and pruned uniformly, blind to whether the surrounding sample was a misconception that would benefit from pruning or a calibration anchor that would be degraded by it.

The EU Plane's insight is that model error (perplexity) and model uncertainty (entropy) are not redundant signals — they capture orthogonal aspects of the model–data relationship. Crossing them reveals four categories (Q1–Q4) that were previously collapsed into a single ranking. This is not an incremental refinement of a scoring function; it is a categorical shift from "how useful is this sample?" to "what kind of utility does this sample provide, and what pruning action does that utility imply?"

Why it changes thinking. The EU Plane reframes data pruning from a filtering problem (keep the top-K) to a classification-and-differential-treatment problem. This shift is significant because it explains the paradox that motivates the paper: why sophisticated pruning often underperforms random sampling. Random sampling preserves the natural distribution of the four categories, while a one-dimensional pruner systematically distorts it — for instance, a loss-based pruner might retain mostly Q1 and Q2 (high-loss) while discarding Q4 (moderate-loss calibration data), producing a training set rich in noise and misconceptions but poor in the calibration signals that stabilize learning.

The quadrant ablation in Table 4 provides direct empirical evidence for this categorical structure: retaining Q1 consistently yields the lowest averages with "pronounced drops on reasoning and QA tasks"; token-level pruning of Q4 is "generally harmful"; and pruning Q2 tokens is "crucial, as retaining high-PPL tokens degrades performance while removing them consistently improves results." These are not quantitative gradations along a continuum — they are qualitatively different effects that would be invisible in a one-dimensional view. This makes the EU Plane a diagnostic contribution of the kind that can inform future algorithm design beyond Q-Tuning itself: any future pruning method can be understood in terms of how it redistributes data across these four quadrants.

Innovation 2: Joint Coordination of Sample and Token Pruning as a Unified, Diagnosis-Driven Strategy

Prior work treated sample pruning and token pruning as independent lines of research — the paper's Appendix A surveys over a dozen methods in each category, none of which coordinate across granularities. When the paper's experiments naively pair existing sample pruners with existing token pruners (Tables 1, 2, 8–14), the results are strikingly inconsistent: many pairings improve one benchmark but degrade others, and several combinations perform worse than random-random baselines. This is not a failure of either component in isolation — it is a failure of coordination: the sample pruner selects for one property (e.g., high-entropy samples), the token pruner optimizes for another (e.g., low-attention tokens), and their interaction produces a data distribution that satisfies neither objective.

Q-Tuning's innovation is not that it does both sample and token pruning — that combination is obvious once both exist. The innovation is that it coordinates them through a shared diagnostic state (the EU Plane quadrant assignment) that determines which token policy to apply to which samples. Specifically:

  • Q1 and Q3 get sample-level pruning (discarded entirely) because their utility — or lack thereof — is a property of the whole sample: Q1 is uniformly noisy, Q3 is uniformly redundant.
  • Q2 gets token-level pruning because its value is localized: the sample as a whole is worth keeping for its informative context and misconception signal, but specific token spans are harmful and should be surgically removed.
  • Q4 gets neither sample nor token pruning because its value is distributed: every token contributes to calibration, and pruning any part degrades the uncertainty signal.

This is not "sample pruning + token pruning" applied uniformly. It is asymmetric, quadrant-conditioned treatment — the EU Plane determines not just whether to prune but which granularity of pruning is appropriate. The alternative, embodied in the baseline pairings, is to apply the same token policy to all retained samples regardless of their role, which the paper shows leads to systematic errors: token pruners like FastV and SparseVLM that prune aggressively in Q4 degrade calibration, while sample pruners that retain Q1 introduce noise. Q-Tuning avoids both failure modes by design.

Why this matters beyond Q-Tuning. This coordinated, diagnosis-driven architecture suggests a general design principle for data pruning: the pruning granularity should match the spatial structure of the data's utility. When utility is a whole-sample property (noise, redundancy), prune at the sample level. When utility is localized (specific misleading spans within an otherwise useful sample), prune at the token level. When utility is distributed (calibration), don't prune at all. This principle is not specific to the EU Plane — it could be instantiated with other diagnostic frameworks — but Q-Tuning is the first method to operationalize it, and the strong empirical results across four model families and five benchmarks (Tables 1–3, Figures 3–4) validate the principle's practical importance.

Most prior data pruning methods fall into one of two regimes: static selection, where the data subset is determined once before training (Alpagasus, Deita, LESS, DS2), or dynamic pruning with fixed thresholds, where samples are scored at each step but the keep/discard boundary is a fixed hyperparameter (InfoBatch, RHO-LOSS). Both approaches share an implicit assumption: the relationship between a sample's score and its utility is stable over the course of training.

The EU Plane's dynamic bisect search (Section 3.2) challenges this assumption directly. By recomputing quantile thresholds (α, β) at every mini-batch using the model's current PPL and Ent distributions, Q-Tuning allows the quadrant boundaries to drift as the model learns. A sample that is Q2 (high PPL, low Ent) at epoch 1 — a valuable misconception — might become Q3 (low PPL, low Ent) by epoch 3 as the model corrects the misconception. Under static pruning, that sample would have been either kept (if selected initially) or discarded (if not), with no ability to respond to the model's evolving state. Under fixed-threshold dynamic pruning, it might remain Q2 for many steps if the absolute PPL threshold is set high. Under Q-Tuning, it naturally transitions from the "keep, token-prune" regime to the "discard as redundant" regime when its relative position in the distribution shifts.

The bisect search itself is an engineering contribution — simultaneous binary search on two axes that converges in O(log(1/ε)) iterations (typically fewer than 10 per mini-batch, Section 3.2) — but its conceptual significance is larger: it makes the pruning policy self-calibrating with respect to the model's current capabilities. This is particularly important for fine-tuning, where the model's loss distribution changes rapidly in early epochs and then stabilizes. A fixed policy calibrated on epoch-1 data would be systematically mismatched to epoch-3 data; a quantile-based policy adapts automatically because "high PPL" is defined relative to the current distribution, not an absolute threshold.

The empirical evidence for the value of this adaptation is the training dynamics plot in Figure 8: Q-Tuning reduces both average PPL and average entropy more rapidly than alternative sample-pruning strategies (Entropy, InfoBatch, Longest, Random), "suggesting faster stabilization of the training signal and correlating with improved downstream performance." This is indirect evidence — a controlled ablation comparing dynamic vs. static quantile boundaries is not reported — but the pattern is consistent with the claim that adaptive boundaries accelerate learning by keeping the pruning policy aligned with the model's evolving needs.

Innovation 4: Empirical Demonstration That Coordinated Pruning Can Exceed Full-Data Performance at Extreme Sparsity

While each of the prior innovations is conceptual or architectural, the paper also makes an empirical contribution of significant practical weight: it demonstrates, across four model families and five benchmarks, that coordinated sample–token pruning can exceed full-data fine-tuning performance while using a small fraction of the training data.

The headline numbers are striking:

  • On SmolLM2-1.7B, Q-Tuning achieves a +38% average improvement over the full-data SFT baseline using only 12.5% of the original training data (Section 1, Table 2).
  • On LLaMA3-8B with GSM8K, Q-Tuning reaches 48.07 accuracy using only 35% of the data, outperforming full-data training by 6.0 points and the strongest baseline by 9.9 points (Section 1, Table 2).
  • On Mistral-7B with WizardLM at extreme budgets (Table 3), Q-Tuning with just 3.125% data retention (6.25% samples × 50% tokens) achieves an average of 46.23, already exceeding full-data fine-tuning at 45.84.

These results are not merely "competitive with full data at reduced cost" — they are better than full data at dramatically reduced cost. This is a qualitatively stronger claim than most pruning papers make, and it demands explanation.

Why would pruning improve over full data? The paper's implicit argument, supported by the EU Plane analysis, is that full training datasets contain harmful content — mislabeled examples, noisy responses, redundant repetitions — that actively degrades model performance. Full-data training exposes the model to this noise alongside the signal, and the noise can dominate if it is sufficiently prevalent. Q-Tuning's removal of Q1 (Harmful Noise) and Q3 (Redundant Knowledge), combined with surgical token pruning in Q2, effectively denoises the training distribution, producing a cleaner gradient signal than the original dataset. The fact that Q-Tuning outperforms full-data training suggests that the original datasets (WizardLM, MathInstruct) contain enough Q1 and Q3 content that removing it improves learning — the datasets are large enough that their noise-to-signal ratio is non-negligible, and Q-Tuning's diagnostic framework successfully identifies and removes that noise.

This is consistent with the finding that retaining Q1 is harmful (Table 4) and that random sampling — which preserves the natural quadrant distribution including Q1 — can outperform sophisticated pruning methods (the paradox from Section 1). Q-Tuning succeeds where random sampling fails because it actively removes harmful quadrants rather than proportionally sampling them. The fact that it outperforms full-data training is evidence that the quadrants are not merely a useful abstraction but correspond to real differences in data quality that matter for downstream performance.

Boundaries and caveats. The gains are not uniform across all settings. On the hardest reasoning problems (MATH, Table 2), improvements are more modest — Q-Tuning achieves 5.54 on MATH with 25% samples vs. 3.02 for full data on LLaMA3-8B, a meaningful but not transformative gain. On GSM8K, the gains are much larger (36.32 vs. 32.90), suggesting that the diagnostic framework is particularly effective when the base model has partial capability that can be refined by removing noise, and less effective when the task is fundamentally beyond the model's reach (where no amount of denoising can create capability that isn't there). This mirrors the finding from the reference example's Section 7 that test-time compute helps on problems within the model's capability range but not on fundamentally hard problems — a recurring pattern in data efficiency research.

5. Experimental Analysis

Evaluation Methodology

  • Dataset. The paper evaluates on two types of tasks. For alignment, it uses WizardLM (Xu et al., 2024) — a dataset of high-quality instruction–response pairs for supervised fine-tuning — and OpenHermes (Teknium, 2023), which contains diverse instruction–response pairs for general-purpose alignment. For reasoning, it uses MathInstruct (Yue et al., 2023), which contains mathematically focused instructions. The specific splits are not explicitly sized in the main text, but the paper notes that alignment datasets "now routinely span billions of tokens" (Section 1). All pruning is applied exclusively to the answer portions of training samples (Appendix B.4).

  • Base model(s). Experiments span five model families and scales: LLaMA2-7B (Touvron et al., 2023), Mistral-7B (Jiang et al., 2023a), LLaMA3-8B (Grattafiori et al., 2024), SmolLM2-1.7B (Allal et al., 2025), and the Qwen3-series at 8B, 14B, and 32B parameters (Yang et al., 2025). The paper's rationale for this breadth is to demonstrate robustness across model families and scales rather than claiming applicability to a single architecture. The Qwen3-series is used on OpenHermes for alignment; the other models are used on WizardLM (alignment) and MathInstruct (reasoning).

  • Metrics. For alignment tasks, the paper reports accuracy (%) on five standard benchmarks: ARC-E (Easy), ARC-C (Challenge) (Clark et al., 2018), GSM8K (Cobbe et al., 2021), SQuAD (Rajpurkar et al., 2016), and TriviaQA (Joshi et al., 2017). These span knowledge-intensive QA, commonsense reasoning, and reading comprehension. For reasoning tasks, evaluation uses GSM8K and MATH (Hendrycks et al., 2021). The primary aggregate metric is the average accuracy across benchmarks, reported alongside per-benchmark breakdowns. The paper emphasizes per-benchmark consistency over aggregate uplift — many baselines "improve one or two benchmarks but exhibit noticeable trade-offs on others" (Section 4.1), and Q-Tuning is evaluated on whether it delivers "consistent gains across all reported benchmarks."

  • Baselines. The paper constructs baselines by pairing sample-level and token-level pruning strategies, since prior work treats these independently. For sample-level pruning, eight methods are compared: (i) Random — uniform random sample selection; (ii) Longest — removes the longest sequences to maximize computational savings; (iii) Entropy — retains high-entropy samples assumed to be more informative; (iv) InfoBatch (Qin et al., 2024) — an information-theoretic approach removing low-loss examples on the fly; (v) Alpagasus (Chen et al., 2023) — uses a strong LLM as an automatic quality rater; (vi) Deita (Liu et al., 2023) — jointly models instruction complexity, response quality, and dataset diversity; (vii) DS2 (Pang et al., 2024) — diversity-aware data selection with score transition matrix correction; and (viii) LESS (Xia et al., 2024a) — selects data by measuring gradient-based influence with respect to few-shot target examples. For token-level pruning, six methods are compared: (i) Random — uniform random token masking; (ii) PPL — removes high-perplexity tokens; (iii) FastV (Chen et al., 2024) — prunes tokens receiving the least final-layer attention; (iv) SparseVLM (Zhang et al., 2024b) — combines attention and hidden-state features to score token importance; (v) Rho-1 (Lin et al., 2024) — scores tokens by excess loss relative to a reference model; and (vi) TokenCleaning (Pang et al., 2025) — removes tokens deemed noisy or uninformative based on token-level statistics. All pairings of these sample and token pruners are evaluated. The full-data SFT baseline (3 epochs on the complete dataset with no pruning) and the zero-shot performance of each base model are also reported as reference points.

  • Generation budget / compute accounting. The pruning budget is controlled by two explicit ratios: the sample keep ratio r_sample (fraction of samples retained per mini-batch) and the token keep ratio r_token (fraction of trainable tokens retained within each kept sample). The paper reports experiments at multiple combinations: 12.5%, 25%, and 50% sample ratios paired with 50% and 70% token ratios, producing a range of "data retention" levels from as low as 3.125% (6.25% samples × 50% tokens) to 35% (50% samples × 70% tokens). This two-dimensional budget specification is itself a contribution — prior work typically controls only one dimension — and enables the paper to study the interaction between the two pruning granularities. For efficiency analysis (Table 6), the paper also reports wall-clock training time (minutes), peak GPU memory (%), and relative FLOPs on an 8× A100 GPU setup with LLaMA2-7B.

  • Cross-validation / statistical protocol. For the Random baseline, each experiment is repeated five times and averaged results are reported (Appendix B.4). This accounts for variance in random sampling. For other baselines, the paper does not report multiple random seeds, which is a limitation — dynamic pruning methods with fixed heuristics (Entropy, InfoBatch) are deterministic given a data ordering, but the interaction of data ordering with pruning could introduce variance that is not captured. All models are trained for 3 epochs with a learning rate of 1 × 10^{-4}, batch size of 8 per device, LoRA rank 8, cutoff length 2048, gradient accumulation 4, and cosine learning rate scheduler (Appendix B.5, Table 7). Evaluation uses the OpenCompass framework (Contributors, 2023) for standardized benchmarking.

Main Quantitative Results

Alignment Performance Under Constrained Budgets

Headline result on WizardLM (Table 1). Under an extreme low-budget regime of 12.5% samples and 50% tokens, Q-Tuning achieves the best overall averages across both LLaMA2-7B (37.74) and Mistral-7B (46.92), outperforming all 24 evaluated combinations of existing sample-pruning and token-pruning methods. Critically, Q-Tuning also exceeds full-data fine-tuning on both models: LLaMA2-7B full-data achieves 35.36, and Mistral-7B full-data achieves 45.84. The improvement over the Random-Random baseline (the simplest combination) is +3.76 on LLaMA2-7B and +4.19 on Mistral-7B.

The per-benchmark breakdown reveals that Q-Tuning's advantage is not concentrated on a single task but is broadly distributed. On LLaMA2-7B, Q-Tuning improves over Random-Random on ARC-E (64.20 vs. 59.25, +4.95), ARC-C (42.03 vs. 41.02, +1.01), GSM8K (10.54 vs. 8.11, +2.43), SQuAD (18.79 vs. 12.75, +6.04), and TriviaQA (53.12 vs. 48.75, +4.37). The largest gains are on SQuAD and ARC-E, with more modest improvements on ARC-C and GSM8K. On Mistral-7B, the pattern is similar: the largest gains are on TriviaQA (57.78 vs. 52.63, +5.15) and GSM8K (29.34 vs. 22.74, +6.60), with more modest improvements on ARC-E (71.60 vs. 70.55, +1.05) and ARC-C (48.14 vs. 48.14, 0.00).

Baseline inconsistency is pervasive. Many baseline pairings show sharp degradation on specific benchmarks even as they improve others. For example, on LLaMA2-7B with the Longest sample pruner, pairing with FastV token pruning drives GSM8K down to 5.69 (vs. 8.11 for Random-Random, a -2.42 drop) while ARC-C improves to 43.05 (+2.03). Similarly, SparseVLM token pruning paired with most sample pruners causes substantial drops on TriviaQA (e.g., InfoBatch + SparseVLM on Mistral-7B: TriviaQA drops from 52.63 to 45.73, -6.90). The paper characterizes this as evidence that "naively combining independently designed sample- and token-level pruners is insufficient under a tight compute budget" (Section 4.1).

Qwen3-8B on OpenHermes (Appendix C.2, Tables 10–11). The gains are even more pronounced on this model–dataset combination. Under 12.5% samples and 50% tokens, Q-Tuning reaches an average of 60.19, outperforming the full-dataset result (55.45) by +4.74 points and the strongest baseline (InfoBatch-Random at 55.45) by the same margin. The per-benchmark decomposition shows Q-Tuning at 80.95 on ARC-E (vs. 77.78 full data), 53.56 on ARC-C (vs. 52.20), 70.51 on GSM8K (vs. 65.13), 45.76 on SQuAD (vs. 38.05), and 50.16 on TriviaQA (vs. 44.08). The largest relative gains are on SQuAD (+7.71 over full data) and GSM8K (+5.38), while ARC-E and ARC-C show more modest improvements.

At larger budgets (25% samples, 50% tokens), Q-Tuning achieves 58.80, exceeding the strongest baseline (InfoBatch-Random at 54.91) by +3.89. At 25% samples, 70% tokens, it reaches 59.20, and at 50% samples with 50% or 70% tokens, it achieves 58.39 and 57.86 respectively, consistently outperforming all pruning-based baselines by 3–6 points.

Performance at multiple budget levels (Tables 8–9). The paper systematically varies both sample ratio (12.5%, 25%, 50%) and token ratio (50%, 70%) across LLaMA2-7B and Mistral-7B on WizardLM. The key pattern: Q-Tuning's advantage over baselines is largest at the most extreme pruning levels and narrows but persists at higher budgets. At 50% samples and 70% tokens (the least aggressive pruning), Q-Tuning achieves 36.34 on LLaMA2-7B and 48.83 on Mistral-7B, compared to Random-Random at 34.85 and 44.57 respectively — gains of +1.49 and +4.26. The shrinking margin at higher budgets is expected: as more data is retained, the benefit of intelligent pruning over random sampling diminishes because random sampling preserves more signal by chance.

Reasoning Performance on Math Tasks

Headline result on MathInstruct (Table 2). Under 25% samples and 50% tokens, Q-Tuning achieves substantially higher average accuracy than any baseline on math reasoning:

  • LLaMA3-8B: Q-Tuning reaches 20.93 average (GSM8K: 36.32, MATH: 5.54), improving over Random-Random (13.26) by +7.67 and exceeding full-data training (17.96) by +2.97. On GSM8K alone, Q-Tuning's 36.32 outperforms full-data training's 32.90 by +3.42 — a significant gain despite using only one-quarter of the samples and half the tokens.

  • Mistral-7B: Q-Tuning reaches 22.74 average (GSM8K: 41.47, MATH: 4.0), improving over Random-Random (12.45) by +10.29 and roughly matching full-data training (22.58). On GSM8K, Q-Tuning's 41.47 is competitive with full-data's 42.08.

  • SmolLM2-1.7B: Q-Tuning reaches 12.87 average (GSM8K: 21.83, MATH: 3.90), improving over Random-Random (8.44) by +4.43 and exceeding full-data training (9.31) by +3.56 — this is the +38% average improvement cited in the abstract.

The fragility of token pruning on reasoning. Several token pruning methods degrade sharply on math tasks. FastV-based token pruning is particularly damaging: on LLaMA3-8B with Entropy sample pruning, FastV drops the average from 16.84 (Entropy-Random) to 9.97 (Entropy-FastV), a -6.87 drop. On Mistral-7B with InfoBatch, FastV drives the average to 3.89 versus 14.69 for InfoBatch-Random — a catastrophic -10.80 drop. The paper notes that FastV "degrades sharply (e.g., driving LLaMA3-8B average accuracy below 6% in multiple settings)" (Section 4.1). This is because attention-based token pruning was designed for inference acceleration in vision-language models, not for math reasoning where attention patterns may be less informative about token importance.

Sample quality matters more than token quality for reasoning. Among the baselines, quality-aware sample selection (Entropy, InfoBatch) consistently improves over random sampling more than token pruning methods do. Entropy-Random raises LLaMA3-8B from 13.26 (Random-Random) to 16.84 (+3.58), while the best token-pruner pairing with Random samples (Random-SparseVLM) achieves only 13.85 (+0.59). This suggests that for math reasoning, choosing the right training examples (sample-level) is more important than fine-grained token selection within examples — unless the token selection is coordinated with sample categorization, as Q-Tuning does.

Larger models benefit more. The gap between Q-Tuning and baselines grows with model scale. On LLaMA3-8B, the improvement over Random-Random is +7.67; on Mistral-7B, +10.29; on SmolLM2-1.7B, +4.43. The paper interprets this as "larger models benefit more from the joint strategy" (Section 4.1), possibly because larger models have more capacity to exploit the cleaner gradient signals that Q-Tuning provides.

Comparison with Stronger Task-Relevant Baselines

Sample-pruner baselines under matched budgets (Figure 3, top; Table 13). The paper compares Q-Tuning against stronger sample-selection methods — Alpagasus, Deita, DS2, and LESS — all paired with Random token pruning under the same sample and token budgets. On LLaMA2-7B with 12.5% samples and 50% tokens, Q-Tuning achieves 37.74, exceeding the strongest sample-selection baseline (LESS-Random at 33.69) by +4.05. On Mistral-7B under the same budget, Q-Tuning reaches 46.92 versus Alpagasus-Random at 42.90 (+4.02) and Deita-Random at 44.25 (+2.67).

When token budgets are increased to 100% (no token pruning, only sample pruning), the strongest baselines improve but Q-Tuning (which always applies token pruning to Q2) remains competitive or superior despite using fewer tokens. At 25% samples, Q-Tuning's 50% token variant (36.47 on LLaMA2-7B) outperforms Alpagasus-100% (34.59), Deita-100% (33.90), and DS2-100% (34.33).

Token-pruner baselines under matched budgets (Figure 3, bottom; Table 14). When the sample pruner is fixed to Random and token pruners vary (Rho-1, TokenCleaning, and Q-Tuning's token policy), Q-Tuning achieves the highest performance at every budget. At 12.5% samples and 50% tokens, Q-Tuning's 37.74 on LLaMA2-7B exceeds TokenCleaning at 33.82 (+3.92) and Rho-1 at 32.17 (+5.57). Notably, Rho-1 and TokenCleaning both perform worse than Random-Random (33.98) in this setting, while Q-Tuning substantially outperforms it — reinforcing the paper's claim that standalone token pruning without coordinated sample selection is unreliable.

Robustness to Extreme Data Budgets

Headline result on extreme retention (Table 3). The paper pushes Q-Tuning to data retention levels far below what prior work typically evaluates, using Mistral-7B on WizardLM:

  • At 3.125% data retention (6.25% samples × 50% tokens), Q-Tuning achieves an average of 46.23, exceeding full-data fine-tuning (45.84) and dramatically outperforming zero-shot (36.98).
  • At 4.375% data retention (6.25% samples × 70% tokens), the average rises to 46.62.
  • At 6.25% data retention (12.5% samples × 50% tokens), the average is 46.92 — the highest reported.
  • At 8.75% data retention (12.5% samples × 70% tokens), the average is 46.79.

Across all four extreme settings, the average score ranges narrowly from 46.23 to 46.92, consistently above the full-data SFT baseline. The per-task breakdown reveals interesting patterns: ARC-E and ARC-C are relatively insensitive to the budget (ranging 70.72–71.78 and 46.10–48.47 respectively), while GSM8K shows more variation (26.08–40.41). TriviaQA benefits substantially from higher token ratios (56.17–57.78 vs. 53.67 full data). SQuAD is the most variable, ranging from 16.13 at the lowest budget to 32.79 at higher budgets, suggesting that reading comprehension performance is more sensitive to the amount of retained context in the training data.

The paper characterizes this as evidence that Q-Tuning "remains highly data-efficient even when retaining only 3–9% of the original training tokens" (Section 4.1). The fact that the 3.125% retention setting already exceeds full-data performance suggests that the original WizardLM dataset contains substantial redundant or harmful content — Q-Tuning's pruning is removing actively detrimental data, not just saving compute.

Generalization Across Model Scales

Headline result on Qwen3-series (Figure 4). The paper evaluates Q-Tuning on Qwen3-8B, Qwen3-14B, and Qwen3-32B using OpenHermes under fixed budgets of 12.5% samples with 50% or 70% tokens:

  • Across all three model scales, Q-Tuning "consistently matches or exceeds full-dataset SFT across benchmarks" (Section 4.1).
  • Gains are "especially evident on reasoning- and QA-oriented tasks such as GSM8K, ARC-E, and SQuAD."
  • For the 32B model, increasing the token budget from 50% to 70% yields further improvements and "delivers the strongest overall averages."

The specific numbers from Figure 4 are reported visually (bar charts), not in tables. The key qualitative finding is that the advantage of Q-Tuning over full-data SFT does not diminish with model scale — larger models benefit at least as much as smaller ones, and possibly more. This addresses a natural concern about data pruning at scale: one might worry that larger models, with greater capacity, would benefit from seeing more data rather than less. The results suggest the opposite: larger models may be more sensitive to data quality, benefiting disproportionately from the removal of noise and redundancy.

Efficiency Analysis: Empirical Latency

Wall-clock and memory measurements (Table 6). The paper quantifies the end-to-end efficiency of Q-Tuning on LLaMA2-7B under the standard three-epoch setup with 8× A100 GPUs:

  • Full-data SFT: 90 minutes training time, 1.0× FLOPs (relative), 78% peak GPU memory.
  • Q-Tuning 12.5% samples, 50% tokens: 65 minutes total (35.88 min for sample selection + 6.96 min for token selection + training time), 0.0625× relative FLOPs, 27% peak memory — a ~28% wall-clock reduction and ~73% memory savings.
  • Q-Tuning 25% samples, 50% tokens: 70 minutes total (38.64 + 7.49 min selection), 0.125× relative FLOPs, 35% peak memory.
  • Q-Tuning 50% samples, 50% tokens: 80 minutes total (44.16 + 8.56 min selection), 0.25× relative FLOPs, 50% peak memory.

The paper acknowledges that "the screening overhead is modest relative to the overall budget and is amortized by the savings from skipping backward/optimizer updates on pruned data" (Section 4.3). The selection overhead — computing PPL and Ent via a forward pass, plus the bisect search — is non-trivial in absolute terms (35–44 minutes for sample selection across all epochs) but is more than offset by the reduced training FLOPs, resulting in net wall-clock savings at all budget levels. A subtle point: the selection time is reported cumulatively across all three epochs, meaning the per-batch overhead is small but accumulates over the full training run.

Ablation Studies and Robustness Checks

Quadrant-wise pruning strategies (Table 4, Table 15): The paper ablates which quadrants are pruned and at what granularity. On Qwen3-8B with OpenHermes under 12.5% samples and 50% tokens, the best configuration (prune Q1 at sample level, prune Q3 at sample level, prune Q2 at token level, preserve Q4 fully) achieves 60.19. Removing Q2 token pruning drops performance to 59.04 (−1.15). Retaining Q1 (no sample pruning of Q1) yields the lowest averages (58.09), with "pronounced drops on reasoning and QA tasks." Token-level pruning of Q4 is harmful: adding Q4 token pruning drops the average to 57.23 (−2.96). The pattern is consistent at 25% samples: the full Q-Tuning configuration achieves 58.80, while retaining Q1 drops to 53.79 (−5.01) and pruning Q4 tokens drops to 53.74 (−5.06). On LLaMA2-7B and Mistral-7B (Table 15), the same qualitative patterns hold: pruning Q1 and Q3 at the sample level, pruning Q2 tokens, and preserving Q4 fully yields the best performance. The ablation strongly supports the paper's claim that each quadrant requires a distinct pruning treatment and that deviating from this quadrant-specific policy systematically degrades performance.

Token pruning strategy comparison (Table 5): On Mistral-7B with 25% samples and 50% tokens, the paper compares four token pruning variants within the Q-Tuning framework: Rho-1 (45.03 average), PPL with no smoothing (λ = 0, 45.92), Reversed PPL with smoothing (λ = 0.5, keeping low-PPL tokens, 44.86), and the default neighbor-aware PPL with λ = 0.5 (46.79). The default achieves the best average and the best per-task performance on 3 of 5 benchmarks. Reversed PPL — which keeps low-PPL tokens and prunes high-PPL ones — performs worst, confirming that the high-PPL tokens in Q2 are indeed the harmful ones and that pruning them is beneficial. The smoothing (λ = 0.5 vs. λ = 0) provides a +0.87 average improvement, supporting the neighbor-awareness design.

Sensitivity to batch size (Figure 5a, Appendix C.5.1, Figure 9): On Mistral-7B across three keep-ratio configurations, varying batch size across {8, 16, 32} shows that "larger batch sizes generally improve performance, especially on GSM8K and SQuAD, where the gains are more pronounced." TriviaQA is relatively stable across batch sizes. The paper attributes this robustness to the quantile-based partitioning: larger batches provide more accurate empirical quantile estimation, reducing noise in quadrant assignment. The default batch size of 8 is therefore conservative — larger batches would likely improve results further, though at the cost of higher memory usage.

Sensitivity to neighbor awareness λ (Figure 5b, Appendix C.5.1, Figure 9): On Mistral-7B, λ is swept across {0, 0.3, 0.5, 0.7, 1.0}. "Moderate values of λ improve performance on GSM8K and SQuAD, whereas extreme values yield diminishing or unstable gains." TriviaQA shows little sensitivity. The default λ = 0.5 represents a balanced midpoint that provides consistent benefits without requiring per-task tuning.

Dynamic sample pruning vs. dynamic token pruning in isolation (Figure 6): The paper conducts a controlled ablation to isolate the effect of each pruning dimension. When only dynamic sample pruning is applied (retaining all tokens), Q-Tuning consistently outperforms sample-pruning baselines (Random, Longest, Entropy, InfoBatch) across keep ratios on both LLaMA2-7B and Mistral-7B. When only dynamic token pruning is applied (retaining all samples), Q-Tuning again outperforms token-pruning baselines. The paper interprets this as evidence that "Q-Tuning's advantage does not rely on a particular pruning axis but stems from more effective data utility modeling" — the EU Plane's quadrant classification provides better sample selection than prior sample pruners and better token selection than prior token pruners, even when each is applied in isolation. However, the full Q-Tuning (joint sample + token pruning) outperforms the isolated variants, confirming the value of coordination.

Training dynamics comparison (Figure 8): The paper tracks the average perplexity and token entropy of 100 randomly sampled training instances throughout fine-tuning under different sample-pruning strategies. Q-Tuning reduces both metrics more rapidly than Entropy, InfoBatch, Longest, and Random pruners. By the end of training, Q-Tuning achieves lower PPL and lower entropy than alternatives. The paper frames this as "suggesting faster stabilization of the training signal and correlating with improved downstream performance." This is a qualitative diagnostic rather than a controlled ablation, but it provides mechanistic intuition: Q-Tuning's quadrant-based selection exposes the model to a cleaner, more focused distribution that allows it to converge faster and to a better minimum.

Case study: semantic composition of pruned vs. retained tokens in Q2 (Figure 7): The paper conducts a microscopic analysis of 300 randomly sampled Q2 instances. Using GPT-5 (Singh et al., 2025) to annotate functional roles for 44K+ tokens, it compares category proportions between pruned and kept sets. The results show that redundant content is over-represented among pruned tokens: boilerplate/templates and formatting increase, and non-answer content shifts toward pruning. In contrast, supervision-critical signals are enriched in kept tokens: gold answer spans account for a higher proportion among retained tokens, and numbers/symbols are substantially more prevalent. For example, boilerplate/templates constitute 31.3% of pruned tokens but only 0.8% of kept tokens; gold answer spans are 23.1% of kept tokens versus 19.6% of pruned tokens. This provides qualitative validation that Q-Tuning's token pruning is not arbitrary — it preferentially removes structural filler while preserving content that directly supervises the correct answer.

Effect of larger sample and token ratios (Tables 8–12): The paper reports results at 24 combinations of sample and token ratios across multiple model–dataset pairs. The consistent finding is that Q-Tuning outperforms baselines at all budget levels, with the margin largest at the most aggressive pruning levels. This is not trivial — a method that works well at 12.5% samples might collapse at 50% samples if its pruning heuristics are calibrated for extreme sparsity. The fact that Q-Tuning maintains its advantage across a wide range of budgets suggests that the EU Plane quadrants are a robust data property, not an artifact of a particular sparsity level.

Critical Assessment

What the Experiments Genuinely Demonstrate

The experiments provide strong evidence for four specific claims, though each comes with qualifications:

1. Joint sample–token pruning coordinated through the EU Plane outperforms independent combinations of prior sample and token pruners, and usually outperforms full-data training, across multiple model families and benchmarks at matched compute budgets.

The evidence for this claim is extensive: Tables 1, 2, 8–14 cover four model families, two training datasets (WizardLM, MathInstruct), and six benchmarks (plus OpenHermes on Qwen3). The consistency of the result — Q-Tuning outperforms all baseline pairings in essentially every (model, dataset, budget) configuration — is the paper's strongest empirical contribution. The fact that Q-Tuning also exceeds full-data fine-tuning in most (though not all) configurations is a stronger statement that the paper supports at the aggregate level but with some per-benchmark variation.

However, what is not demonstrated is whether the EU Plane's specific quadrant structure — as opposed to some simpler two-dimensional scoring — is necessary. The quadrant ablation (Tables 4, 15) shows that deviating from the Q-Tuning policy degrades performance, but it does not compare against an alternative two-dimensional scoring scheme. For instance, a continuous scoring function s(PPL, Ent) that smoothly interpolates between the quadrant-based treatments might perform similarly or better. The paper's claim that quadrants reveal "qualitatively distinct" categories would be strengthened by showing that a continuous alternative performs worse.

2. The EU Plane categorizes training data into four behaviorally distinct groups that require different pruning treatments.

Table 4 and Table 15 provide reasonably strong support: retaining Q1 is harmful, pruning Q2 tokens is beneficial, pruning Q4 tokens is harmful, and discarding Q3 is neutral-to-beneficial. The ablation is internally consistent across models and datasets. The semantic analysis in Figure 7 further supports the distinction between Q2's harmful and useful tokens — the pruned tokens are structurally different from the kept tokens in interpretable ways.

However, the quadrant boundaries are defined by quantile thresholds on the current mini-batch, not by any intrinsic property of the data. This means a sample's quadrant assignment depends on what other samples happen to be in the same mini-batch. A sample that is Q2 in one batch (because the batch contains many low-PPL samples) might be Q1 in another batch (because the batch contains even higher-PPL samples). The paper does not analyze the stability of quadrant assignments across batches or across training steps. If assignments are highly unstable, the "qualitatively distinct categories" interpretation is weakened — samples are not intrinsically in one category but are placed there relative to their batch-mates. This does not invalidate the method (the pruning decisions are still effective), but it complicates the diagnostic interpretation.

3. Q-Tuning achieves substantial wall-clock speedups and memory savings while maintaining or improving accuracy.

Table 6 demonstrates a ~28% wall-clock reduction and ~73% memory savings at 12.5% samples, 50% tokens on LLaMA2-7B. However, the selection overhead (35.88 + 6.96 = 42.84 minutes for the most aggressive setting) is substantial in absolute terms — it consumes nearly half the total training time. The paper frames this as "modest relative to the overall budget," but at higher retention ratios (50% samples), the selection overhead (44.16 + 8.56 = 52.72 minutes) is a larger fraction of the total (80 minutes). The efficiency advantage is most compelling at aggressive pruning levels; at moderate levels, the overhead consumes a larger share of the savings.

Additionally, the efficiency measurements are reported only on LLaMA2-7B, and only for the WizardLM dataset. Efficiency on larger models (LLaMA3-8B, Qwen3-14B/32B) and on the math reasoning dataset (MathInstruct, which may have different sequence length distributions) is not measured. Scaling trends for the selection overhead — which involves a forward pass through the full model — are unknown. If the selection forward pass scales linearly with model size while training FLOPs scale quadratically (roughly), the overhead becomes proportionally smaller for larger models, but this is not verified.

4. Q-Tuning is robust to hyperparameters and generalizes across model scales.

The sensitivity analyses (Figures 5, 9) demonstrate robustness to batch size and λ on Mistral-7B. The Qwen3-series results (Figure 4) demonstrate scaling to 32B. However, the hyperparameter robustness is tested on a single model–dataset pair. Whether λ = 0.5 and the default batch size of 8 are equally effective on LLaMA3-8B, Qwen3-32B, or on MathInstruct is not shown. Similarly, the Qwen3-series results report visual bar charts without numerical tables, making precise comparisons difficult.

Genuine Weaknesses and Missing Experiments

No statistical significance reporting for non-random baselines. Only the Random baseline is repeated five times. For deterministic pruning methods (Entropy, InfoBatch, Q-Tuning), the paper reports single-run results. Dynamic methods depend on data ordering, model initialization, and other sources of variance. Without error bars or multiple seeds, it is impossible to assess whether the reported differences — some as small as 0.3–0.5 points on individual benchmarks — are statistically reliable. Given the 500-question test sets for ARC and GSM8K, a 1–2 point difference may fall within noise. The paper's reliance on five-benchmark averages partially mitigates this (averaging reduces variance), but per-benchmark claims of "consistent gains" need statistical backing.

No comparison against data selection methods that already include diversity or difficulty criteria. The paper compares against Alpagasus, Deita, DS2, and LESS, which are static selection methods, and against InfoBatch and Entropy, which are dynamic. But several recent methods explicitly combine diversity, difficulty, and quality — for instance, D3 (Zhang et al., 2025) uses all three. The paper cites D3 in the related work but does not include it as a baseline. Similarly, methods that use gradient-based influence (LESS) or model-based quality scoring (Alpagasus) might benefit from stronger reference models — the paper uses the default configurations without exploring whether these baselines could be tuned to perform better.

The semantic analysis in Figure 7 uses GPT-5 as an annotator, with no validation of annotation quality. The paper reports that 300 Q2 instances were sampled and "44K+ tokens" were annotated by GPT-5 for functional roles (boilerplate, templates, gold answer spans, numbers/symbols, etc.). There is no inter-annotator agreement, no human validation, and no discussion of annotation quality. If GPT-5 systematically misclassifies certain token types, the composition analysis could be misleading. This is a minor point for the paper's main claims (which do not depend on the semantic analysis), but it weakens the qualitative case study.

Missing ablation: what if quadrants are defined by absolute thresholds rather than quantiles? The paper argues that quantile-based thresholds provide dynamic adaptation, but it never ablates this choice. A comparison using fixed absolute PPL and entropy thresholds (perhaps tuned on a validation set) would quantify the benefit of dynamic thresholding. Without this ablation, the claim that dynamic quantile boundaries are valuable remains plausible but unverified.

Missing ablation: what if token pruning is applied uniformly (same policy for Q2 and Q4) but with a different keep ratio? The paper's quadrant ablation tests the extreme cases (prune all Q2 tokens, prune no Q4 tokens) and their opposites, but it does not test a uniform token pruning policy applied to both quadrants at the same overall token budget. Such a comparison would isolate whether the asymmetry of the policy matters or simply the amount of token pruning.

Single training recipe. All experiments use 3 epochs, learning rate 1 × 10^{-4}, LoRA rank 8, and batch size 8. The interaction of pruning with training hyperparameters (especially learning rate and number of epochs) is not explored. Pruning reduces the effective dataset size, which may interact with the optimal number of epochs — a model trained on 12.5% of the data for 3 epochs sees far fewer total tokens than a model trained on 100% of the data for 3 epochs. If Q-Tuning benefits partly from seeing less data (early stopping effect), then controlling for total tokens seen (rather than epochs) would be a fairer comparison.

No evaluation on generation quality or human preference. All evaluation is on accuracy-based benchmarks with extractable answers (multiple choice, exact match, or math problem grading). The paper does not evaluate on open-ended generation tasks where quality is subjective (e.g., AlpacaEval, MT-Bench). This is a standard limitation of pruning papers — the available benchmarks favor tasks with unambiguous correctness — but it means the findings may not generalize to the full spectrum of SFT applications, particularly chat and instruction-following where calibration and stylistic quality matter as much as factual accuracy.

Where the Claims Hold Conditionally

The +38% improvement on SmolLM2-1.7B (Section 1, Table 2) holds on the MathInstruct reasoning dataset under 25% samples and 50% tokens. The "average improvement" is across two benchmarks (GSM8K and MATH). On the alignment benchmarks (WizardLM, OpenHermes), the improvements over full data are smaller in percentage terms but still positive (e.g., Q-Tuning achieves 37.74 vs. 35.36 on LLaMA2-7B, a +6.7% relative improvement). The +38% figure should be understood as the most favorable case, not a typical result.

The claim that Q-Tuning "exceeds full-data training" holds consistently on the alignment benchmarks (WizardLM, OpenHermes) at aggressive pruning levels (12.5% samples) but is more mixed at moderate levels (50% samples, 70% tokens), where Q-Tuning's advantage narrows. On reasoning (MathInstruct), Q-Tuning exceeds full-data on LLaMA3-8B and SmolLM2-1.7B but only matches it on Mistral-7B (22.74 vs. 22.58). The claim is generally supported but is not universal — there are configurations where Q-Tuning is competitive with full data rather than strictly superior.

The claim that "joint sample–token pruning" is the key innovation is supported by the baseline comparisons (Tables 1–2), which show that naive combinations of independent sample and token pruners underperform Q-Tuning. However, the paper does not compare against an oracle that coordinates sample and token pruning through a different mechanism (e.g., using gradient-based influence for both levels). Without such a comparison, the paper demonstrates that its specific coordination mechanism works, not that coordination per se is sufficient or that the EU Plane is necessary for coordination.

The claim that Q-Tuning "consistently matches or exceeds full-dataset SFT across benchmarks" for Qwen3-series (Figure 4) is supported visually but lacks numerical tables, making precise verification difficult. The bar charts suggest Q-Tuning at 12.5% samples and 50–70% tokens is competitive with full data across all three model scales, with some benchmarks above and some slightly below the full-data bar. The average (rightmost group in each panel) appears to favor Q-Tuning, but without exact numbers, the magnitude of the advantage is uncertain.

What Would Strengthen the Paper

  • Multiple random seeds for all methods, with standard deviations reported, to establish statistical reliability of the many small per-benchmark differences reported.
  • Ablation of quantile-based vs. fixed absolute thresholds to quantify the benefit of dynamic adaptation.
  • Comparison against a continuous two-dimensional scoring baseline (e.g., a learned classifier on (PPL, Ent) that predicts whether to keep/prune) to test whether the discrete quadrant structure is necessary or whether any reasonable joint scoring would work.
  • Evaluation on open-ended generation benchmarks (AlpacaEval, MT-Bench) to test generalization beyond accuracy-based tasks.
  • Efficiency measurements on larger models to verify that the selection overhead becomes proportionally smaller at scale.
  • A controlled comparison where total tokens seen (not epochs) is held constant between pruned and full-data training, to disentangle the benefit of data selection from the benefit of early stopping.
  • An analysis of quadrant assignment stability across mini-batches and training steps, to clarify whether the EU Plane's categories are stable properties of samples or artifacts of batch composition.

6. Limitations and Trade-offs

Dynamic Difficulty Estimation Cost Is Unaccounted For in the Headline Efficiency Gains

The assumption and its cost. Q-Tuning's EU Plane construction requires a gradient-free forward pass of the current model state on every sample in every mini-batch to compute perplexity and entropy, followed by a bisect search to determine quantile thresholds. This per-batch diagnostic step is what enables dynamic, adaptive pruning boundaries. The paper reports this overhead in Table 6: for LLaMA2-7B on WizardLM, the cumulative selection time across all three epochs ranges from ~43 minutes (12.5% sample ratio) to ~53 minutes (50% sample ratio), compared to 90 minutes for full-data training. At the most aggressive pruning (12.5% samples, 50% tokens), selection overhead consumes roughly 42.84 minutes of a 65-minute total — approximately 66% of the total training time is spent on data selection rather than gradient computation.

The consequence. The headline efficiency gains — e.g., ~28% wall-clock reduction over full-data SFT at 12.5% samples, 50% tokens — are measured after amortizing the selection overhead into the total training time. This is legitimate accounting, but it obscures a fundamental scaling relationship: as the pruning ratio becomes less aggressive, the selection overhead becomes a larger fraction of the total time, while the training FLOPs savings diminish. At 50% samples and 50% tokens, total training time is 80 minutes vs. 90 for full data — an ~11% wall-clock reduction, with ~53 of the 80 minutes spent on selection. The practical value of Q-Tuning is thus concentrated at aggressive pruning levels; at moderate levels, the efficiency argument weakens considerably.

Furthermore, the selection forward pass requires loading the full model and computing logits for every token — a computation that scales with model size. The paper only measures overhead on LLaMA2-7B. For Qwen3-32B (which the paper evaluates in Figure 4), the forward pass cost would be substantially higher in absolute terms, potentially changing the efficiency calculus. The paper does not report efficiency measurements for larger models, nor for the MathInstruct dataset, where different sequence length distributions could affect the per-batch forward pass cost.

What evidence exists. Table 6 is the only efficiency measurement. It covers one model (LLaMA2-7B), one dataset (WizardLM), and three pruning configurations. The paper notes that "the screening overhead is modest relative to the overall budget and is amortized by the savings from skipping backward/optimizer updates on pruned data" (Section 4.3), which is true for the aggressive configurations but becomes less true as the pruning ratio increases.

Mitigation status. The paper acknowledges the overhead explicitly by measuring and reporting it — this is better than ignoring it — but does not explore methods to reduce it. The bisect search itself is fast (~10 iterations, negligible cost), but the forward pass through the full model on every mini-batch is inherently expensive. Potential mitigations not explored include: using a smaller proxy model for the diagnostic forward pass (the paper uses the model being fine-tuned, but a distilled or earlier-checkpoint model might provide adequate PPL/Ent estimates at lower cost); caching PPL/Ent values and only recomputing periodically rather than every batch; or amortizing the selection cost over larger effective batch sizes (the sensitivity analysis in Figure 9 suggests larger batches improve performance, which would also amortize selection cost over more training tokens).

The EU Plane's Quadrant Assignments Are Relative to the Current Mini-Batch, Not Absolute Properties of Samples

The constraint. The EU Plane partitions samples using quantile thresholds computed on the current mini-batch's empirical PPL and Ent distributions. A sample's quadrant assignment depends on two things: (1) its own PPL and Ent values, and (2) the PPL and Ent values of all other samples in that specific mini-batch. The same sample could be classified as Q2 in one batch (if the batch contains many low-PPL samples, making its PPL relatively high) and as Q1 in another batch (if the batch contains even higher-PPL samples, pushing the quantile threshold above its value). This is a direct consequence of the quantile-based design: "high PPL" means "higher than the (1 - α)-quantile of this batch," which is a relative, not absolute, notion.

The consequence. The paper's diagnostic interpretation — that Q1 contains "unreliable or mislabeled data," Q2 contains "valuable misconceptions," Q3 is "redundant knowledge," Q4 is "calibration data" — implies that these are intrinsic properties of the samples. If quadrant assignments are highly unstable across batches and across training steps, this interpretation weakens. A sample that oscillates between Q1 and Q2 depending on its batch-mates cannot be intrinsically "harmful noise" some of the time and "valuable misconception" at other times — at least, not in a way that supports the paper's narrative of four qualitatively distinct data categories.

This instability could also produce inconsistent gradient signals. If a sample is in Q2 (retained, token-pruned) in one batch and Q1 (discarded entirely) in the next, the model sees its tokens in some gradient steps but not others. This is not necessarily harmful — stochasticity in data selection can be beneficial — but it complicates the claim that Q-Tuning is providing a "principled" pruning based on stable data properties.

What evidence exists. The paper provides no analysis of quadrant assignment stability. There is no measurement of how often a sample changes quadrants across batches, across epochs, or as a function of batch size. The training dynamics in Figure 8 track average PPL and Ent over 100 randomly sampled instances, but this shows population-level trends, not per-sample trajectory stability. This is a genuine gap in the evidence: the paper's central diagnostic framework is asserted to reveal stable categories, but this assertion is not tested.

Mitigation status. Not addressed. The paper does not discuss assignment stability or its implications for the diagnostic interpretation. A natural mitigation — if instability proves to be a problem — would be to compute quantile thresholds over a larger sample (e.g., across multiple mini-batches or the full dataset periodically) rather than per-batch, trading some adaptivity for stability. Alternatively, the paper could clarify that the quadrants are operational categories (defining what pruning action to take) rather than ontological claims about the data, which would make instability less concerning.

Hard Problems and Tasks Where the Model's Base Capability Is Near Zero Show Minimal Improvement

The capability bound. Q-Tuning works by removing harmful noise (Q1) and redundant content (Q3) while surgically refining misconceptions (Q2) and preserving calibration signals (Q4). This entire mechanism depends on the model having some signal to work with — there must be a meaningful distribution of PPL and Ent values across the training data, with samples falling into distinguishable quadrants. When the model's base capability is near zero on a task — meaning it assigns uniformly low probability to correct answers and has uniformly high entropy — the EU Plane collapses: all samples become Q1 (high PPL, high Ent), and the bisect search has no Q2/Q4 region to retain.

The consequence. Q-Tuning cannot improve performance on tasks that are fundamentally outside the model's capability range. The paper's results on MATH (Table 2) illustrate this boundary: on LLaMA3-8B, Q-Tuning achieves 5.54 on MATH (vs. 3.02 for full data) — a meaningful but modest absolute gain. On Mistral-7B, Q-Tuning reaches 4.0 (vs. 3.08 full data). On SmolLM2-1.7B, Q-Tuning reaches 3.90 (vs. 2.10 full data). These are improvements, but the absolute performance remains low. The pruning mechanism can denoise the training signal, but it cannot create capability where none exists. For genuinely hard reasoning tasks where the base model has near-zero pass@1, data pruning offers diminishing returns — the problem is insufficient model capacity or pretraining, not noisy training data.

This parallel is explicit in how the paper structures its evaluation: the largest gains are on alignment benchmarks (WizardLM, OpenHermes) where the base model already has non-trivial performance, and gains on MATH are proportionally smaller. The paper does not discuss this capability boundary explicitly, but the data pattern is consistent with it.

What evidence exists. The MATH results in Table 2 show the pattern across all three models: Q-Tuning improves over full-data and over baselines, but absolute MATH accuracy remains low (3.90–5.54%). The GSM8K results show much larger absolute gains (e.g., 36.32 vs. 32.90 full data on LLaMA3-8B) because the base model's GSM8K capability is higher. The paper does not report a difficulty-bin analysis (unlike the reference example, which explicitly partitions problems by the base model's pass@1 rate), so the capability-boundary claim is inferred from the aggregate results rather than directly measured.

Mitigation status. Not addressed. The paper does not discuss the relationship between base model capability and pruning effectiveness, nor does it provide guidance on when Q-Tuning is likely to help versus when pretraining or architecture improvements are needed. This is a practical gap: a practitioner considering Q-Tuning for a new domain needs to know whether their base model's capability is sufficient for pruning to be beneficial, and the paper provides no diagnostic for this.

The Empirical Validation Is Limited to Accuracy-Based Benchmarks with Extractable Answers; Generalization to Open-Ended Generation and Subjective Quality Tasks Is Unverified

The scope constraint. All evaluation in the paper uses benchmarks where correctness is objective and answers are extractable: multiple-choice (ARC-E, ARC-C), extractive QA (SQuAD), short-answer QA (TriviaQA), and math problem solving with numeric answers (GSM8K, MATH). These tasks have the property that a single correct answer exists and can be verified automatically. The paper applies pruning exclusively to the answer portions of training samples (Appendix B.4: "we applied pruning exclusively to the answers"), which means the instruction portions — the prompts that define the task — are always retained in full.

The consequence. This evaluation suite does not cover the full spectrum of SFT applications. Many real-world use cases for instruction tuning involve open-ended generation: dialogue, creative writing, summarization, explanation, and multi-step reasoning with free-text outputs. In these tasks, there is no single "correct" answer, and quality is multi-dimensional (relevance, coherence, factual accuracy, style, safety). The EU Plane's perplexity and entropy metrics are computed against a single ground-truth response — they measure how well the model predicts the specific reference answer, not how good the answer is in an absolute sense. If the training data contains multiple valid responses to the same instruction (a common scenario in crowd-sourced or synthetically generated datasets), a response that is perfectly good but different from the reference would have high perplexity and might be classified as Q1 or Q2 — and thus pruned — even though it represents valuable diversity.

The paper's token pruning case study (Figure 7) provides some qualitative evidence about what gets pruned — boilerplate, formatting, non-answer content — but this analysis is on MathInstruct, which has deterministic answers. In a dialogue dataset, pruning tokens based on perplexity might remove stylistic variations, personality markers, or hedging language that contribute to natural-sounding responses, even if those tokens have high perplexity relative to a specific reference. The paper provides no evidence about whether Q-Tuning preserves or degrades these qualities.

What evidence exists. None directly. The paper's evaluation is exclusively on the five accuracy-based benchmarks plus MATH. Appendix E.2 provides qualitative token-pruning examples, but all are from MathInstruct (math reasoning) and the analysis focuses on whether pruned tokens are "boilerplate" or "gold answer spans," not on generation quality dimensions. The paper cites no evaluation on AlpacaEval, MT-Bench, Chatbot Arena, or any other benchmark that measures open-ended generation quality.

Mitigation status. Not addressed. The paper does not discuss the limitation of its evaluation scope to accuracy-based tasks, nor does it suggest evaluation on generation-quality benchmarks as future work. This is a significant gap for a method that claims to be a general-purpose data pruning solution for supervised fine-tuning, since a large fraction of real-world SFT involves datasets and tasks where answer correctness is not binary.

Baselines Are Evaluated in Default Configurations Without Task-Specific Tuning; the Strongest Competing Methods May Be Underrepresented

The assumption about baselines. The paper constructs baselines by pairing sample-level and token-level pruning methods and evaluating them at the same sample and token keep ratios as Q-Tuning. The sample pruners (Alpagasus, Deita, DS2, LESS) and token pruners (Rho-1, TokenCleaning, FastV, SparseVLM) are used in their published default configurations. The paper does not tune these baselines for the specific datasets, model families, or pruning ratios being tested — they are applied "off-the-shelf."

The consequence. Several of these baselines may be operating far from their optimal configuration. For example, FastV and SparseVLM were designed for vision-language model inference acceleration, not text-only SFT — the paper itself notes that FastV "degrades sharply (e.g., driving LLaMA3-8B average accuracy below 6% in multiple settings)" (Section 4.1). Using these methods as baselines on math reasoning tasks may be testing them in a domain they were never designed for, which inflates Q-Tuning's apparent advantage. Similarly, LESS was designed for targeted instruction tuning where a small set of target examples is available — its default configuration assumes a specific few-shot evaluation setup that may not align with the paper's broad evaluation across five benchmarks.

More critically, several recent methods that explicitly combine multiple data quality criteria are not included. D3 (Zhang et al., 2025) — which the paper cites in its related work (Appendix A.1) — combines diversity, difficulty, and dependability into weighted coresets. This is conceptually closer to Q-Tuning's multi-dimensional approach than the single-criterion baselines included. The paper's claim that "naively combining independently designed sample- and token-level pruners is insufficient" (Section 4.1) is well-supported against the specific baseline pairings tested, but the absence of stronger multi-criterion baselines limits the strength of the claim that Q-Tuning's coordination mechanism is uniquely effective.

The paper's strongest non-random baseline in the alignment experiments is LESS-Random (e.g., 33.69 on LLaMA2-7B at 12.5% samples, 50% tokens, vs. Q-Tuning's 37.74). LESS uses gradient-based influence estimation, which is computationally expensive and may benefit from task-specific target examples — the paper's use of LESS with default target examples may underestimate its potential.

What evidence exists. Table 13 and Table 14 provide the most comprehensive baseline comparisons. The paper's auxiliary comparison against stronger token-level baselines (Table 14, Rho-1 and TokenCleaning) shows that these methods underperform Random-Random in several configurations, which is evidence that they are genuinely challenged in this setting — not just untuned. But the absence of D3, the absence of task-specific tuning for LESS, and the inclusion of vision-language methods (FastV, SparseVLM) on text-only tasks means the baseline suite may not represent the best available alternatives.

Mitigation status. The paper partially acknowledges this by including a broad range of baselines and reporting results at multiple budget levels, which reduces the chance that a single baseline's poor performance is driving the comparison. The fact that Q-Tuning outperforms all baseline pairings in essentially every configuration — including the strong dynamic methods InfoBatch and Entropy — is evidence that its advantage is robust to baseline choice. However, the paper does not discuss which baselines are most appropriate for each setting, nor does it attempt to tune any baseline for fairness. Including a simple baseline that does not appear (e.g., training a classifier to predict sample utility from (PPL, Ent) and using it for selection, which would test whether the EU Plane's quadrant structure is specifically valuable or any two-dimensional scoring would work) would strengthen the comparative claims.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper does not introduce a new model architecture, a new training objective, or a new scale of compute. Its contribution is diagnostic and methodological: it provides a lens—the Error–Uncertainty Plane—through which the heterogeneous utility of training data becomes visible and actionable, and it demonstrates that coordinating sample-level and token-level pruning through that lens produces consistent, often dramatic improvements over both full-data training and existing pruning methods. The significance of this shift is best understood by what it reframes, what it resolves, and what it redirects.

Reframing data pruning from filtering to classification-and-differential-treatment. Before this work, the dominant paradigm in data pruning—whether static or dynamic, sample-level or token-level—was to rank examples or tokens on a single utility axis and keep the top-K. The implicit assumption was that data utility is a continuous, monotonic quantity: some data is more useful than other data, and the task of pruning is to find the best threshold. The EU Plane challenges this assumption at its root. By crossing model error (perplexity) with model uncertainty (entropy), it reveals that data does not array itself along a single "usefulness" spectrum—it falls into qualitatively distinct categories that demand fundamentally different actions: discard entirely (Q1, Q3), refine surgically (Q2), or preserve holistically (Q4). This is a categorical shift in how the field should think about pruning. It is not "how much should we keep?" but "what kind of data is this, and what does that imply for how we should treat it?"

The practical consequence of this reframing is that pruning becomes a design problem rather than a threshold-tuning problem. The question is no longer "what percentile of the loss distribution should we retain?" but "how do we build a system that correctly identifies which samples are noise, which are misconceptions, which are redundant, and which are calibration anchors—and then applies the right treatment to each?" This opens a much richer design space than the one-dimensional paradigm allowed, and Q-Tuning represents one specific—and empirically successful—instantiation of that design philosophy.

Resolving the paradox of why sophisticated pruning often underperforms random sampling. The paper opens by citing the troubling finding from Xia et al. (2024b) that "even sophisticated dynamic pruning heuristics often underperform simple random sampling." The EU Plane provides a coherent explanation for this paradox, and Q-Tuning's results validate that explanation. Random sampling preserves the natural distribution of all four quadrants—including Q1 (harmful noise) and Q3 (redundant knowledge)—in proportion to their prevalence in the dataset. A one-dimensional pruner, by contrast, systematically distorts this distribution. A loss-based pruner will retain mostly high-loss samples, which concentrates Q1 and Q2 while discarding Q3 and Q4—removing the calibration signals and mastered examples that stabilize learning, and amplifying the noise and misconceptions that disrupt it. The pruner is "sophisticated" in its scoring but naive in its treatment: it applies the same action (keep or discard) to all high-scoring samples, unaware that high loss can indicate either harmful noise (discard) or valuable misconception (keep, but token-prune). This mismatch between scoring granularity and treatment granularity is the structural flaw that Q-Tuning addresses, and the EU Plane is the diagnostic that makes the flaw visible.

The resolution of this paradox is valuable beyond Q-Tuning itself. It provides a framework for understanding why prior pruning methods succeeded or failed: methods that implicitly concentrated data in useful quadrants (e.g., those that selected for high-quality, diverse examples, which would tend to favor Q2 and Q4) worked well; methods that concentrated data in harmful quadrants (e.g., those that selected purely for high loss, which would favor Q1 and Q2 without distinguishing them) failed. Future pruning research can use the EU Plane as a diagnostic to characterize not just how much data a method keeps, but which kinds of data it keeps, providing a more mechanistic understanding of pruning behavior.

Redirecting research attention from scoring functions to treatment policies. A significant fraction of prior work on data pruning focused on developing better scoring functions: more accurate influence estimation (LESS), better reference models for excess loss (RHO-LOSS, Rho-1), attention-based token importance (FastV, SparseVLM), and information-theoretic criteria (InfoBatch). The implicit bet was that better scoring would translate to better pruning. Q-Tuning's results suggest a different bet: the treatment policy—what you do with the scores—matters at least as much as the scores themselves. The paper uses simple, off-the-shelf metrics (perplexity and entropy, both available essentially for free from a forward pass) and achieves substantially better results than methods that use more sophisticated scoring (gradient influence, reference-model excess loss, attention patterns). The advantage comes not from better scores but from using the scores to make a more nuanced decision—specifically, using two scores jointly to classify data into categories, and then applying category-specific treatments.

This redirects research attention toward the design space of treatment policies. Given a set of scores (PPL, Ent, gradient norm, influence, attention weight, etc.), how should the pruning system map those scores to actions? Q-Tuning's answer—discrete quadrants with category-specific policies—is one design point. Other designs are possible: continuous policies that smoothly interpolate treatment based on score values, learned policies that optimize the mapping from scores to actions using reinforcement learning or bilevel optimization, or hierarchical policies that make coarse-grained decisions first and refine them later. The EU Plane provides a language for describing and comparing these policies: any pruning method can be characterized by how it redistributes data across the four quadrants, and the paper's quadrant ablation (Tables 4, 15) provides a template for evaluating whether that redistribution is beneficial.

Establishing that pruning can exceed full-data performance by removing actively harmful content. The paper's most striking empirical finding is not that Q-Tuning is competitive with full-data training at reduced cost—many pruning methods make this claim—but that it consistently exceeds full-data training, often by substantial margins, while using a small fraction of the data. This is a qualitatively stronger result than "competitive at lower cost." It implies that the original datasets (WizardLM, OpenHermes, MathInstruct) contain content that is not merely redundant but actively harmful—training on it degrades the final model relative to not training on it at all. Q-Tuning's EU Plane identifies and removes this content, producing a training distribution that is not just smaller but better than the original.

This finding has implications for how the field thinks about dataset construction. The prevailing assumption in SFT has been that more data is better, provided it is "high quality." The EU Plane suggests a more nuanced view: data quality is not a scalar property but a quadrant-dependent property, and a dataset that contains many Q1 samples (noisy or mislabeled) or Q3 samples (redundant) may produce worse models than a carefully pruned subset. This does not mean large datasets are bad—it means large datasets benefit from diagnostic pruning to remove the harmful fractions that inevitably accumulate at scale. The paper's results at 3.125% data retention (Table 3) exceeding full-data performance are a vivid demonstration: the original WizardLM dataset, despite being widely used and considered high-quality, contains enough Q1 and Q3 content that removing 97% of it improves model quality. This is a strong argument for incorporating diagnostic pruning into standard SFT pipelines, not as an optional efficiency optimization but as a quality-improvement step.

Follow-Up Research This Work Enables

Learning a lightweight difficulty estimator to replace the per-batch forward pass. Q-Tuning's primary computational cost is the gradient-free forward pass of the full model on every mini-batch to compute PPL and Ent (Section 4.3, Table 6: ~43–53 minutes cumulative on LLaMA2-7B). A natural extension is to train a small proxy model—perhaps a distilled version of the base model, or a lightweight classifier operating on hidden states from an early layer—to predict (PPL, Ent) coordinates, or directly predict quadrant assignments, without requiring a full forward pass. The paper's finding that predicted difficulty bins perform similarly to oracle bins in the reference example's framework suggests this is plausible: approximate difficulty estimates may be sufficient. A strong follow-up would train a small LSTM or lightweight transformer (e.g., 50M parameters) on (instruction, response) → (PPL, Ent) pairs collected during the first epoch of Q-Tuning, then use that proxy for the remaining epochs, measuring (a) wall-clock speedup vs. full Q-Tuning, (b) accuracy of quadrant assignment (do proxy-predicted quadrants match full-model quadrants?), and (c) downstream benchmark performance. If a 50M-parameter proxy can achieve >90% quadrant agreement with the 7B-parameter model while reducing selection overhead by 10×, Q-Tuning becomes practical for deployment where the selection cost currently dominates.

Combining Q-Tuning with curriculum learning by ordering samples within each quadrant. Q-Tuning currently treats all samples within a quadrant as interchangeable—a Q2 sample from step 1 of training gets the same token-pruning treatment as a Q2 sample from the final epoch. But the difficulty of a sample relative to the model's current state likely matters: a Q2 sample at epoch 1 (when the model has many misconceptions) may be a genuinely hard error to correct, while a Q2 sample at epoch 3 (when most misconceptions have been resolved) may be a residual edge case that benefits from different treatment. A natural extension is to combine EU Plane categorization with curriculum learning: within Q2, order samples by their PPL (lower PPL first, to correct easier misconceptions before harder ones), or within Q4, order by Ent (higher Ent first, to address the most uncertain predictions early). The paper's training dynamics (Figure 8) show that Q-Tuning reduces average PPL and Ent more rapidly than baselines—adding a curriculum within each quadrant could accelerate this further. A strong follow-up would compare: (a) Q-Tuning with random intra-quadrant ordering (the current approach), (b) Q-Tuning with PPL-ascending ordering within Q2, (c) Q-Tuning with Ent-descending ordering within Q4, and (d) both curricula combined, measuring benchmark performance and the rate of PPL/Ent decrease over training.

Extending the EU Plane to three or more dimensions for finer-grained categorization. The paper's two-dimensional EU Plane (PPL × Ent) successfully separates four categories, but the categories are defined by coarse quantile thresholds (above/below the median on each axis). This leaves substantial heterogeneity within each quadrant. For example, within Q2, some samples may have moderately high PPL (just above the threshold) while others have extremely high PPL—these likely represent different types of misconceptions (minor errors vs. fundamental misunderstandings) that could benefit from different token-pruning aggressiveness. Adding a third dimension—such as gradient norm (magnitude of the parameter update the sample would produce), influence (alignment with the direction of improvement on a validation set), or semantic diversity (distance from other retained samples in embedding space)—could split existing quadrants into finer subcategories. A strong follow-up would add gradient norm as a third axis, partitioning each quadrant into "high-impact" and "low-impact" sub-quadrants, and test whether applying more aggressive token pruning to low-impact Q2 samples and preserving high-impact Q2 samples fully (or vice versa) improves over the current uniform Q2 policy. The bilevel optimization framework in Section 2 provides a natural formalism for learning the optimal multi-dimensional treatment policy, though solving it exactly remains challenging.

Stress-testing Q-Tuning on datasets with deliberately introduced noise and label errors. The paper argues that Q1 samples are "harmful noise" and that removing them improves performance, but the evidence for this is correlational: Q1 samples have high PPL and high Ent, and ablating them helps (Table 4). A stronger causal test would construct a controlled experiment: take a clean dataset (e.g., a subset of WizardLM verified to be high-quality), introduce synthetic noise at known rates (e.g., randomly corrupt 10% of response tokens, swap 5% of correct answers with plausible but incorrect alternatives, insert boilerplate text into 20% of responses), and measure (a) how accurately Q-Tuning's EU Plane classifies the corrupted samples as Q1 vs. their original clean versions, (b) whether Q-Tuning's removal of Q1 samples recovers performance to near the clean-dataset baseline, and (c) how Q-Tuning compares to alternative noise-filtering methods (influence-based filtering, perplexity-only filtering) at the same task. If Q-Tuning can accurately identify known-corrupted samples and its removal of them recovers clean-dataset performance, that provides direct evidence for the "harmful noise" interpretation of Q1 and validates the EU Plane's diagnostic capability. If Q-Tuning misclassifies corrupted samples (e.g., places them in Q2 instead of Q1), that would reveal a limitation: the EU Plane's error–uncertainty coordinates may not cleanly separate noise from genuine difficulty.

Evaluating Q-Tuning's effect on model calibration, not just accuracy. The paper's treatment of Q4 (Calibration Data) is based on the claim that high-entropy but correct samples "improve model confidence and robustness" (Section 1) and should be preserved in full. However, the paper evaluates only accuracy, not calibration. A model can have high accuracy but poor calibration—it may assign high confidence to wrong answers and low confidence to right answers. If Q4's role is genuinely about calibration, then preserving Q4 should improve calibration metrics (expected calibration error, reliability diagrams, Brier score) relative to pruning methods that discard or token-prune Q4. A strong follow-up would compute calibration metrics on ARC-E, ARC-C, and TriviaQA (all of which allow measuring confidence via the probability assigned to the chosen answer) for: (a) full-data SFT, (b) Q-Tuning with Q4 preserved fully (the default), (c) Q-Tuning with Q4 token-pruned (the ablated variant from Table 4 that degrades accuracy), and (d) a baseline that discards Q4 entirely (sample-level pruning). If Q-Tuning's preservation of Q4 improves calibration relative to (c) and (d) even when accuracy is similar, that validates the calibration interpretation. If calibration is unchanged, then Q4's value may be about something other than calibration—perhaps about maintaining output diversity or preventing overfitting to specific error modes.

Adapting the EU Plane framework to RLHF and preference optimization. The paper applies Q-Tuning exclusively to SFT, where each training sample is a single instruction–response pair and the loss is cross-entropy against the reference response. In RLHF (reinforcement learning from human feedback) and direct preference optimization (DPO), training data consists of paired preferences (chosen vs. rejected responses), and the loss depends on the relative quality of the pair rather than absolute correctness. The EU Plane's coordinates—PPL and Ent—are computed against a single reference, so they don't directly capture the structure of preference data. However, the conceptual framework—categorizing data by the model's error and uncertainty, and applying category-specific treatment—should extend. For preference data, "error" could be whether the model assigns higher probability to the rejected response than the chosen one, and "uncertainty" could be the entropy of the model's distribution over which response is preferred. Samples where the model confidently prefers the wrong response (analogous to Q2) might benefit from targeted token pruning of the misleading spans in the rejected response; samples where the model is uncertain but correct (analogous to Q4) should be preserved. A strong follow-up would adapt Q-Tuning to DPO training on a standard preference dataset (e.g., Anthropic HH-RLHF or UltraFeedback), defining appropriate PPL/Ent analogs for paired data, and measuring whether quadrant-based pruning improves preference optimization efficiency.

Practical Applications and Downstream Use Cases

Cost-efficient SFT for mid-size organizations and academic labs. The paper's results at extreme data retention levels—Mistral-7B on WizardLM achieving 46.23 average accuracy (exceeding full-data SFT's 45.84) with only 3.125% data retention, reducing training FLOPs to 0.0625× and peak GPU memory from 78% to 27% (Table 6)—make Q-Tuning directly applicable for teams with limited compute budgets. A lab with a single 8× A100 node that previously could only fine-tune a 7B model on a full dataset can, with Q-Tuning, fine-tune an 8B or potentially 14B model in comparable wall-clock time while using dramatically less GPU memory. The ~28% wall-clock reduction at 12.5% samples (65 vs. 90 minutes, Table 6) means faster experiment cycles, enabling more hyperparameter sweeps or more model variants tested within a fixed compute budget. The practical recipe implied by the paper is: (1) run Q-Tuning with default hyperparameters (λ = 0.5, batch size 8, 3 epochs) on the target dataset, (2) measure benchmark performance at several sample/token budget combinations (start with 12.5%/50% and 25%/50%), (3) if performance exceeds or matches full-data SFT, deploy at that budget for production fine-tuning. The method's demonstrated robustness to batch size and λ (Figures 5, 9) means minimal tuning is needed, lowering the barrier to adoption.

Denoising large-scale synthetic datasets before fine-tuning. Many contemporary SFT datasets are generated by prompting strong LLMs (GPT-4, Claude) to produce instruction–response pairs, then filtering heuristically. These synthetic datasets—OpenHermes, WizardLM, and their derivatives—are known to contain hallucinations, formatting inconsistencies, and responses that are stylistically correct but factually wrong. Q-Tuning's EU Plane offers a principled, automated way to identify and remove these problematic samples without manual inspection. The fact that Q-Tuning with 12.5% of OpenHermes data (on Qwen3-8B) achieves 60.19 average vs. 55.45 full data (Tables 10–11)—a nearly 5-point improvement—suggests that OpenHermes contains a substantial fraction of Q1 and Q3 content whose removal improves the training signal. Organizations that generate large synthetic datasets for domain-specific fine-tuning (legal, medical, customer support) can apply Q-Tuning as a post-generation cleaning step: run the base model over the synthetic data to compute PPL and Ent, categorize into quadrants, and retain only Q2 and Q4 samples, with Q2 token-pruned. The result is a smaller, higher-quality dataset that can be shared, versioned, and used for multiple downstream fine-tuning runs without repeatedly paying the diagnostic cost—the EU Plane categorization need only be computed once after dataset generation.

Fine-tuning on edge devices or in memory-constrained environments. The paper's memory measurements (Table 6: peak GPU memory drops from 78% to 27% at 12.5% samples, 50% tokens) indicate that Q-Tuning substantially reduces the memory footprint of SFT. This matters for fine-tuning on consumer GPUs (RTX 3090/4090 with 24GB VRAM), edge devices, or shared clusters where memory is the binding constraint. A practitioner attempting to fine-tune a 7B model on a 24GB GPU might find full-data SFT infeasible without aggressive gradient checkpointing or quantization. Q-Tuning's memory reduction—driven by smaller effective batch sizes (fewer tokens per batch after pruning) and fewer retained optimizer states (since pruned tokens don't contribute to gradients)—could make the same fine-tuning feasible at full precision. The paper doesn't directly measure fine-tuning feasibility on consumer hardware, but the memory numbers in Table 6 (78% → 27% of A100 memory) suggest substantial headroom. A useful operational guideline: at 12.5% samples and 50% tokens, Q-Tuning reduces the effective training tokens per epoch to 6.25% of the original, which should reduce activation memory proportionally (since fewer tokens are processed in the forward and backward passes). This makes Q-Tuning a candidate for the growing "on-device fine-tuning" use case where models are personalized to user data without sending that data to the cloud.

When to Prefer This Method

The paper implicitly articulates a tradeoff between Q-Tuning and both full-data SFT and alternative pruning methods, though it does not provide a formal decision framework. The empirical results support the following decision rule:

  • Prefer Q-Tuning over full-data SFT when training on datasets that are large (billions of tokens) and likely to contain noisy, redundant, or mislabeled content—the paper's results on WizardLM, OpenHermes, and MathInstruct suggest that Q-Tuning's denoising effect improves final model quality when the dataset contains non-trivial Q1 and Q3 content. The signal is whether Q-Tuning at 12.5% samples outperforms full-data training; if it does, the dataset benefits from pruning not just for efficiency but for quality.

  • Prefer Q-Tuning over existing pruning methods (InfoBatch, LESS, Entropy, Rho-1, TokenCleaning) when both sample-level and token-level budgets are constrained (e.g., retaining <25% samples and <70% tokens) and consistency across diverse benchmarks is required—baseline pairings show sharp degradations on specific tasks (Tables 1, 2), while Q-Tuning delivers balanced improvements. If the deployment scenario involves a single, narrow task (e.g., only GSM8K), a task-specific sample pruner might be competitive; but for general-purpose SFT where the fine-tuned model will be evaluated on a range of benchmarks, Q-Tuning's quadrant-based coordination provides more robust performance.

  • Prefer full-data SFT (or milder pruning) when the dataset is small, carefully curated, and known to contain minimal noise (e.g., a hand-labeled dataset of a few thousand high-quality examples), or when fine-tuning a model that has near-zero capability on the target task (analogous to the MATH results in Table 2, where absolute improvements are modest). In these regimes, the diagnostic overhead of Q-Tuning may not be justified, and the risk of discarding valuable data through imperfect quadrant classification is higher.

  • The paper does not articulate a tradeoff against data selection methods that explicitly optimize for diversity or coverage (e.g., D3, DS2), so a direct decision rule against those methods is not supported by the paper's evidence. The comparison against DS2 in Table 13 shows Q-Tuning outperforming it, but the broader class of diversity-aware methods is not systematically evaluated.