Language Model-Driven Data Pruning Enables Efficient Active Learning

## Abstract

Abstract Active learning (AL) optimizes data labeling efficiency by selecting the most informative instances for annotation. A key component in this procedure is an acquisition function that guides the selection process and identifies the suitable instances for labeling from the unlabeled pool. However, these acquisition methods suffer from high computational costs with large unlabeled data pools, posing a roadblock to their applicability on large datasets. To address this challenge and bridge this gap, we introduce a novel plug-and-play unlabeled data pruning strategy, ActivePrune , which leverages language models to prune the unlabeled pool. ActivePrune implements a two-stage pruning process: an initial fast evaluation using perplexity scores from an n -gram language model, followed by a high-quality selection using metrics for data quality computed through a quantized LLM. Additionally, to enhance the diversity in the unlabeled pool, we propose a novel perplexity reweighting method that systematically brings forward underrepresented instances for selection in subsequent labeling iterations. Experiments on translation, sentiment analysis, topic classification, and summarization tasks on four diverse datasets and four active learning strategies demonstrate that ActivePrune outperforms existing data pruning methods. Finally, we compare the selection quality ↔ ↔ \leftrightarrow ↔ efficiency tradeoff of the data pruning methods and demonstrate that ActivePrune is computationally more efficient than other LLM score-based pruning methods, and provides up to 74% reduction in the end-to-end time required for active learning.

## 1 Introduction

Active learning (AL) optimizes data labeling efficiency by selecting the most informative instances of an unlabeled dataset for annotation, thereby enhancing model performance with minimal labeled data (Tsvigun et al., ). This plays a crucial role in reducing labeling efforts and the associated costs by strategically choosing examples for annotation. For example, active learning can help medical experts efficiently prioritize which clinical texts should be labeled first, saving up to 30% annotation time while training a model for clinical named entity recognition (Wei et al., ).

The core challenge in active learning is determining which examples from the pool of unlabeled data should be labeled. For this purpose, different acquisition functions, including uncertainty and diversity heuristics, are used to guide the selection process (Zhang et al., ). However, as the size of the unlabeled pool increases, the computational cost and latency of the acquisition functions escalate significantly (Maekawa et al., ; Tsvigun et al., ; ). High acquisition latency leads to several issues: it significantly hinders the interactivity of the AL process by increasing the waiting time of experts, leads to higher computational requirements, and thus causes the overall cost of the labeling procedure to increase (Maekawa et al., ).

In this work, we thus ask the question, “Can we efficiently reduce the size of the unlabeled pool without compromising selection quality in active learning?”. To this end, a few heuristics have been proposed. The simplest and widely used method is random selection (Maekawa et al., ), where random instances from the unlabeled pool are selected before applying the acquisition strategy. A better subsampling method, called unlabeled pool subsampling (Tsvigun et al., ), selectively updates uncertainty scores for a subset of instances. In each AL iteration, a portion of the most uncertain instances from preceding iterations is selected, along with a limited number of instances based on their position in a sorted list by uncertainty. However, this technique cannot be applied reliably in early AL iterations, as the acquisition model is only trained on a small amount of data,
which leads to irregular uncertainty estimates (Tsvigun et al., ). Thus, there is still a need for a generalizable and high-quality data pruning mechanism for reducing the size of the unlabeled pool to enable efficient active learning.

Our approach. Recently, large language models (LLMs) have emerged as promising evaluators of data quality (Kocmi & Federmann, ; Mekala et al., ; Sachdeva et al., ). However, LLM quality scores are expensive to compute (Sachdeva et al., ) and cannot be directly used for pruning the unlabeled pool in the AL pipeline. To bridge this gap, we propose a novel plug-and-play module called ActivePrune, for efficiently pruning the unlabeled pool in AL (Fig. 1). ActivePrune operates by first pruning the entire unlabeled pool through a fast evaluation using perplexity scores from an n-gram language model (KenLM). Subsequently, a high-quality selection for a smaller set from the remaining pool is done through an open-source quantized LLM (with 2B parameters). The remaining unlabeled pool is then passed to the acquisition function of the AL strategy. To increase diversity in the unlabeled pool for subsequent iterations, we propose a novel perplexity reweighting process to systematically prioritize underrepresented instances for selection and then present a theoretical basis for this method. To validate the effectiveness of ActivePrune, we conduct experiments on translation, sentiment analysis, topic classification, and summarization tasks on four diverse datasets and four active learning methods, and demonstrate that our approach outperforms existing unlabeled data selection algorithms across multiple AL strategies. Finally, we compare the selection quality $\leftrightarrow$ efficiency tradeoff of the data pruning methods in AL and demonstrate that ActivePrune performs better than other score-based pruning methods while being 97% computationally more efficient. Moroever, ActivePrune provides up to 74% reduction in the end-to-end AL time, thus enabling efficient active learning.

Implications. Our work provides a high-quality AL-strategy agnostic method of reducing the size of large datasets so that they can be used in active learning. This enables more efficient utilization of computational resources and increases the interactivity of the labeling process, thereby saving the time of labeling experts. Finally, it paves the way for broader applicability of active learning techniques to high-volume, domain-specific datasets.

Figure: Figure 1: Illustration of the proposed ActivePrune framework for data pruning in Active Learning. Perplexity scores are first computed for the entire unlabeled pool through the KenLM 5-gram model, followed by the computation of data quality scores on a subset of examples through a quantized LLM. Then, the data pruning strategy leverages both these scores to prune the unlabeled pool and send it as the input to the AL acquisition function. After each iteration, a reweighting algorithm adjusts the perplexity distribution based on the selected examples to enhance the diversity for the next iteration.
Refer to caption: x1.png

## 2 Related Work

Our work brings together two closely related but distinct (and well-studied) domains of data pruning and active learning. Thus, we provide an overview of the literature on these two areas and then briefly describe the existing approaches of large language models for data quality assessment and pruning.

### 2.1 Active Learning

Active learning (AL) techniques focus on selectively querying unlabeled data that, when labeled, are most beneficial for model training (Ren et al., ). This selective data querying aims to reduce annotation costs while improving model performance. Pool-based active learning methods are primarily uncertainty-based (Zhao et al., ), diversity-based (Hu & Neubig, ; Pendas et al., ), or hybrid (Azeemi et al., ). Despite the improvements in query strategies, the trade-off between high-quality acquisition and computational overhead remains a central issue in AL research. Approaches like Bayesian query strategies offer sophisticated means to quantify uncertainty but at a significant computational and memory cost (Siddhant & Lipton, ). This has led to a continued search for methods that balance informative sample selection with practical constraints on the computation and reduce the waiting time between iterations.

### 2.2 Data Pruning

Data Pruning focuses on the elimination of redundant or less informative samples from the training dataset to reduce computational costs in training (Kothawade et al., ; Killamsetty et al., ; Kothyari et al., ; Azeemi et al., ; Schreiber et al., ; Lee et al., ; Sorscher et al., ), improve model generalization (Paul et al., ; Marion et al., ; Azeemi et al., ; Sachdeva et al., ), or reduce bias and remove harmful content. Different metrics are used in data pruning techniques to assess the informativeness or redundancy of data samples, such as geometry-based (Agarwal et al., ; Sener & Savarese, ), uncertainty-based (Coleman et al., ), margin-based (Park et al., ), gradient-matching metrics (Mirzasoleiman et al., ; Killamsetty et al., ), forgetting scores (Toneva et al., ; Azeemi et al., ), and metrics based on training trajectories (Paul et al., ). Despite their utility, these methods often face challenges regarding their generalizability across different architectures or datasets and may incur non-negligible overheads (Paul et al., ; Bartoldson et al., ). This can be mitigated through self-supervised pruning metrics, which do not require initial training runs (Sorscher et al., ; Azeemi et al., ), or dynamic data pruning methods, which select samples throughout training based on their relevance (Raju et al., ; He et al., ; Qin et al., ). In contrast to the existing methods, our focus in this work is to develop a novel data pruning mechanism that is specifically tailored for active learning.

### 2.3 LLMs for Data Filtering

Recent works have leveraged large language models (LLMs) for data quality assessment, opening up new dimensions for optimizing training datasets. Techniques focusing on quality-score sampling, as discussed by Maini et al. () and Engstrom et al. (), employ LLMs to evaluate and select high-quality training samples based on various criteria, including perplexity filtering (Marion et al., ; Muennighoff et al., ; Ankner et al., ) and similarity to high-quality data sources (Xie et al., ; Anil et al., ; Javaheripi et al., ). These methods aim to prioritize samples that are representative or have desirable characteristics, thereby enhancing the overall quality of the training dataset. Furthermore, model-based training-run simulators (Guu et al., ) and submodular selection routines (Coleman et al., ) represent newer approaches to assess and select the training data to increase the efficiency of downstream fine-tuning.

## 3 Method

In this section, we introduce ActivePrune, a framework for efficient pruning of the unlabeled pool to enable computationally feasible active learning. ActivePrune has the following key components:

- 1.
A fast, approximate quality evaluation of the entire unlabeled pool using perplexity scores (Section 3.2).
- 2.
A high-quality assessment for a select subset of candidates through a quantized LLM (Section 3.3).
- 3.
A reweighting algorithm that incorporates the labeled instances after each AL iteration to reweight the perplexity distribution and promote the selection of examples from previously underrepresented subpopulations (Section 3.4).

### 3.1 Preliminaries

We follow the standard active learning setup used in previous works (Hu & Neubig, ; Tsvigun et al., ). Consider an unlabeled dataset $\mathcal{U}=\{x_{i}\}_{i=1}^{N}$ and the labeled set $\mathcal{L}$ which is initially empty. In each iteration, the acquisition strategy $\mathcal{Q}$ selects the most informative examples for annotation which are then annotated by human experts $\mathcal{H}(\cdot)$. During the experiments, we simulate this labeling procedure by acquiring the actual labels from the dataset, following the protocol from previous works (Tsvigun et al., ; Hu & Neubig, ; Tsvigun et al., ). The labeled examples are used to train the acquisition model $\mathcal{M}$, added to the labeled dataset $\mathcal{L}$, and excluded from the unlabeled dataset $\mathcal{U}$. The model is then evaluated on an unseen validation set. This process continues until the budget $b$ is exhausted. In each iteration, we construct a filtered unlabeled pool $\mathcal{F}$ using ActivePrune, which is used by the acquisition strategy instead of the complete unlabeled pool $\mathcal{U}$.

### 3.2 Perplexity Calculation

The first step in ActivePrune is to perform a quality evaluation for the complete unlabeled pool $\mathcal{U}$. For this purpose, we first compute the perplexity scores for each example in the unlabeled pool $\mathbf{P}=\{p_{1},p_{2},\ldots,p_{n}\}$. This process must be computationally feasible so that large datasets are processed quickly. Thus, for fast and efficient perplexity calculation, we use the KenLM 5-gram language model (Heafield, ) along with the SentencePiece tokenizer (Kudo & Richardson, ). KenLM enables fast and memory-efficient language model queries through the Probing and Trie data structures, and uses a modified version of Kneser-Ney smoothing. The Probing variant of KenLM achieves a computation speed of 1818 perplexity queries per millisecond (Heafield, ) on the English Gigaword corpus (Parker, Robert et al., ). We use the KenLM trained on the Oscar dataset (Suárez et al., ) derived from CommonCrawl, which contains web-crawl data

Once the perplexity scores are computed, we sort them in an ascending order $\mathbf{P}_{\text{sorted}}=\text{argsort}(\mathbf{P},\text{order}=\text{
ascending})$ and select the bottom $k$ indices having the lowest perplexity scores: $\mathcal{P}_{s}=\{p_{i}\in\mathbf{P}_{\text{sorted}}\ |\ i=1,2,\ldots,k\}$. The examples with the lowest perplexity scores are added to the filtered pool: $\mathcal{F}=\mathcal{F}\cup\mathcal{P}_{s}$. The examples with high perplexity scores are filtered out (based on a pruning percentage p) as they represent highly surprising and potentially noisy examples (Muennighoff et al., ; Marion et al., ; Sachdeva et al., ) and these examples are thus re-evaluated through data quality scores in the next step before they can be selected for labeling.

### 3.3 LLM Data Quality Scores

We compute the data quality scores for the top m high-perplexity examples from the remaining unlabeled pool $x\in\mathcal{U}\setminus\mathcal{P}_{s}$. We adapt the procedure presented in (Sachdeva et al., ) for computing data quality scores through an LLM. Given the task type $\tau$, the data quality score $q(x_{i})$ for each example $x_{i}$ is computed as follows:

Figure: Figure 2: An example prompt for determining the data quality score for a training example on the translation task.
Refer to caption: x2.png

(1) — Construct a prompt $P(x_{i},\tau)$ with example $x_{i}$ and the task type $\tau$. The prompt specifically asks whether $x_{i}$ should be included in the training set for task $\tau$ (Fig. 2) and asks for a response as “yes” or “no”. (2) — Obtain the response $R$ from the LLM, which includes a decision on whether $x_{i}$ is suitable for inclusion in the training set. This decision is represented by tokens such as “yes” or “no”. (3) — Compute the data quality score $q(x_{i})$ for each example $x_{i}$ as the softmax probability of the token “yes” in the LLM’s response, $q(x_{i})$, computed as:

$$ $\text{softmax}(\text{LLM}(P(x_{i},\tau)))_{\text{``yes''}}=\frac{e^{\text{LLM} (P(x_{i},\tau))_{\text{``yes''}}}}{\sum_{j}e^{\text{LLM}(P(x_{i},\tau))_{j}}}$ $$

where $\text{LLM}(P(x_{i},\tau))$ denotes the vector of logits output by the LLM for the prompt $P(x_{i},\tau)$, and $\text{softmax}(\cdot)_{\text{``yes''}}$ indicates the softmax probability corresponding to the token “yes”.

Calculating data quality scores through an LLM over a sizable dataset can be computationally expensive. Therefore, we use a quantized LLM for the computation of data quality scores. Quantization (Dettmers et al., ) significantly reduces the cost of inference by representing weights in limited bits. We use 4-bit quantized LLMs (Dettmers et al., ) which have been shown to match the full 16-bit fine-tuning performance despite using a fraction of memory.

After calculating the data quality scores, we sort them in a descending order $\mathbf{Q}_{\text{sorted}}=\text{argsort}(\mathbf{Q},\text{order}=\text{
descending})$ and select the bottom $k$ indices having the highest data quality scores: $\mathcal{Q}_{s}=\{q_{i}\in\mathbf{Q}_{\text{sorted}}\ |\ i=1,2,\ldots,k\}$. These are then added to the filtered pool as well: $\mathcal{F}=\mathcal{F}\cup\mathcal{P}_{s}$. The final unlabeled pool containing examples selected through perplexity and data quality scores is then passed to the acquisition function which begins the next AL iteration.

### 3.4 Perplexity Reweighting

After each AL iteration, we dynamically adjust the perplexity scores of the unlabeled pool to prioritize diversity in the examples. This adjustment is based on a similarity measure relative to the perplexity scores of the instances most recently added to $\mathcal{L}$. The adjustment factor for an instance $x_{i}$, given the set of newly labeled instances $L\subseteq\mathcal{L}$, is defined as:

$$ $A(x_{i},L)=\frac{1}{|L|}\sum_{l\in L}|P(x_{i})-P(l)|$ (1) $$

This factor measures the average absolute difference in perplexity between $x_{i}$ and the instances in $L$, reflecting the similarity of $x_{i}$ to the instances most recently labeled. We use the adjustment factor to compute new perplexity:

$$ $P_{\text{new}}(x_{i})=P_{old}(x_{i})-{\beta.A(x_{i},L)}=P_{old}(x_{i})-\beta. \frac{1}{|L|}\sum_{l\in L}|P(x_{i})-P(l)|$ (2) $$

The perplexity of the instances in the unlabeled pool which are farther away from the newly labeled instances is decreased after reweighting, thereby increasing their chance of being selected through bottom-k perplexity sampling. $\beta$ is a hyperparameter that controls the sensitivity to the adjustment factor. Higher values of $\beta$ result in a steeper decrease in the perplexity for instances farther away from those recently labeled. Note that perplexity reweighting takes place outside the AL procedure itself and instead within the data pruning step, making it independent of any specific AL strategy. Thus, perplexity reweighting is different from other sample reweighting techniques in AL that are typically designed to increase batch diversity for specific acquisition functions, e.g., BADGE (Ash et al., ).

The following proposition outlines the mechanism by which perplexity reweighting enhances diversity across multiple iterations.

###### Proposition 1 .

Let $\mathcal{U}=\{x_{i}\}_{i=1}^{N}$ be the unlabeled pool and $\mathcal{L}_{t}$ be the labeled set at iteration $t$. Let $S\subseteq\mathcal{U}$ represent an underrepresented subset, containing the instances in $S$ that have perplexity scores significantly different from those in $\mathcal{L}_{t}$. Under the perplexity reweighting procedure, for any $x_{i}\in S$, the probability of selecting $x_{i}$ increases progressively, ensuring its selection within a finite number of iterations.

The detailed proof for this proposition is included in Appendix A, which shows that the perplexity reweighting mechanism prevents the data pruning process from focusing narrowly, as underrepresented instances are systematically brought forward for selection. This is done progressively by reducing the perplexity of such instances over multiple AL iterations, which in turn guarantees that these are selected with high probability within a finite number of AL iterations, thereby promoting diversity in the selected data. In practical scenarios, although the total number of AL iterations may be constrained by the available budget, perplexity-based reweighting still ensures that underrepresented instances are consistently prioritized for selection.

###### Proposition 1 .

## 4 Experimental Setup

### 4.1 Datasets

We evaluate our method on four diverse datasets spanning different tasks and domains, including sentiment analysis, topic classification, translation and abstractive text summarization:

IMDB dataset (Maas et al., ) for binary classification task with movie reviews. It is utilized for assessing sentiment analysis models, consisting of 25,000 reviews for training and an equal number for testing.

AG News dataset (Zhang et al., ) for topic classification task with 4 classes. The dataset includes 120,000 training samples and 7,600 test samples across the categories of World, Sports, Business, and Science/Technology.

IT domain dataset (Koehn & Knowles, ) for En-De machine translation. We use the deduplicated and resplit version (Aharoni & Goldberg, ) containing 223,000 sentence pairs for training and 2,000 pairs for testing.

AESLC dataset (Zhang & Tetreault, ) consisting of email threads for the task of abstractive text summarization. Each instance contains an email and a subject line as the corresponding summary. The training set comprises approximately 14,400 email threads, while the validation and test sets contain around 1960 and 1910 email threads, respectively.

### 4.2 Models

For the abstractive text summarization and machine translation tasks, we utilize the BART model in our experiments (Lewis et al., ) due to its strong performance on these tasks. BART constitutes a transformer encoder-decoder architecture with a bidirectional encoder and an autoregressive decoder. We use the BART-base variant with 139M parameters.

For the topic classification and sentiment analysis tasks, we use the RoBERTa model (Liu et al., ), an encoder-only transformer language model. We use the RoBERTa-base variant containing 125M parameters.

For computing the LLM data quality scores and the LLM perplexity scores, we use the Gemma-2B LLM (Team et al., ), an open-source LLM based on the Gemini research (Team et al., ). Gemma-2B is a decoder-only transformer language model with 18 layers and 2B parameters.

### 4.3 Active Learning Methods

We consider several active learning methods for evaluation.

Random Sampling draws training examples uniformly at random and is considered a competitive baseline in AL (Hu & Neubig, ; Tsvigun et al., ).

Least Confidence (Lewis, ) selects the examples on which the model is least confident.

Coreset (Sener & Savarese, ) samples based on representations extracted from the model’s penultimate layer.

Normalized Sequence Probability (NSP) (Ueffing & Ney, ) is an uncertainty-based strategy designed to measure the uncertainty in a model’s predictions on a specific sequence. It forms the basis for numerous other uncertainty-based active learning (AL) methods.

In-Domain Diversity Sampling (IDDS) (Tsvigun et al., ) aims to choose sentences distinct from those previously annotated to enhance the diversity of the final collection. At the same time, it avoids picking noisier instances that differ significantly from the documents in the in-domain dataset.

**Table 1: Comparison of unlabeled pool pruning methods for Active Learning. For each dataset, we run experiments on two active learning methods across five pool pruning strategies and evaluate the performance on the validation set. Five active learning iterations are done and 1% of the dataset is selected for labeling in each iteration. For each strategy, we do three runs with different seeds and report the mean evaluation score, with the standard error of the mean given in the subscript. The bold values represent top-performing results compared to other data pruning strategies on a specific task and AL method.**
| Dataset | Evaluation | AL | Data Pruning | AL Iteration |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| (Task) | Metric | Method | Strategy | 1 | 2 | 3 | 4 | 5 |
| IT Domain<br>(Translation) | SacreBLEU | IDDS | No Pruning | 25.43±0.0 | 25.22±0.0 | 24.98±0.0 | 25.12±0.0 | 25.20±0.0 |
| Random | 25.38±0.1 | 24.95±0.1 | 24.82±0.1 | 24.96±0.1 | 25.00±0.1 |  |  |  |
| ASK-LLM | 25.25±0.1 | 25.08±0.1 | 24.87±0.1 | 24.96±0.1 | 25.06±0.1 |  |  |  |
| Perplexity | 25.63±0.1 | 24.81±0.1 | 24.78±0.1 | 24.79±0.1 | 24.72±0.1 |  |  |  |
| UPS | 25.21±0.1 | 24.42±0.1 | 24.32±0.1 | 24.41±0.1 | 24.22±0.1 |  |  |  |
|  | ActivePrune | 27.01±0.1 | 27.39±0.1 | 27.80±0.1 | 28.40±0.1 | 28.97±0.1 |  |  |
| NSP | No Pruning | 27.89±0.0 | 28.61±0.0 | 29.42±0.0 | 30.10±0.0 | 30.57±0.0 |  |  |
| Random | 27.94±0.0 | 28.95±0.1 | 29.51±0.4 | 29.87±0.2 | 30.09±0.2 |  |  |  |
| ASK-LLM | 28.07±0.1 | 29.39±0.1 | 29.59±0.2 | 30.13±0.1 | 30.46±0.1 |  |  |  |
| Perplexity | 27.86±0.1 | 29.07±0.1 | 29.53±0.3 | 30.15±0.2 | 30.53±0.2 |  |  |  |
|  |  | UPS | 27.82±0.1 | 29.02±0.2 | 29.69±0.0 | 30.33±0.1 | 30.49±0.1 |  |
|  |  |  | ActivePrune | 28.70±0.0 | 29.85±0.2 | 30.52±0.1 | 30.76±0.2 | 30.97±0.1 |
| AESLC<br>(Summarization) | ROUGE-L | IDDS | No Pruning | 29.14±0.0 | 29.66±0.0 | 28.91±0.0 | 30.10±0.0 | 29.30±0.0 |
| Random | 28.03±0.4 | 29.02±0.1 | 28.31±0.2 | 29.25±0.2 | 29.96±0.1 |  |  |  |
| ASK-LLM | 28.15±0.4 | 28.99±0.3 | 28.86±0.2 | 29.54±0.5 | 29.00±0.1 |  |  |  |
| Perplexity | 28.54±0.4 | 29.13±0.3 | 29.68±0.2 | 29.15±0.3 | 29.93±0.3 |  |  |  |
| UPS | 28.34±0.4 | 28.71±0.4 | 29.46±0.5 | 29.13±0.0 | 30.14±0.4 |  |  |  |
|  | ActivePrune | 28.76±0.2 | 30.08±0.2 | 29.94±0.1 | 30.41±0.2 | 30.85±0.2 |  |  |
| NSP | No Pruning | 28.78±0.0 | 29.10±0.0 | 29.79±0.0 | 29.97±0.0 | 30.47±0.0 |  |  |
| Random | 28.03±0.4 | 28.69±0.3 | 28.62±0.4 | 29.81±0.3 | 29.53±0.2 |  |  |  |
| ASK-LLM | 27.62±0.4 | 28.72±1.0 | 29.26±0.6 | 29.25±0.6 | 30.07±0.3 |  |  |  |
| Perplexity | 27.96±0.4 | 28.44±0.2 | 29.02±0.4 | 29.46±0.2 | 29.53±0.1 |  |  |  |
|  |  | UPS | 28.02±0.4 | 29.04±0.1 | 29.69±0.4 | 29.41±0.6 | 29.80±0.1 |  |
|  |  |  | ActivePrune | 28.04±0.1 | 29.46±0.1 | 29.89±0.4 | 30.29±0.2 | 30.34±0.2 |
| IMDB<br>(Classification) | F1-Score | Coreset | No Pruning | 91.90±0.0 | 92.36±0.0 | 92.32±0.0 | 92.68±0.0 | 93.01±0.0 |
| Random | 91.35±0.1 | 92.11±0.3 | 92.40±0.1 | 92.83±0.1 | 92.99±0.1 |  |  |  |
| ASK-LLM | 91.25±0.5 | 91.81±0.7 | 92.00±1.0 | 92.09±0.9 | 91.64±0.2 |  |  |  |
| Perplexity | 91.41±0.1 | 92.16±0.0 | 92.31±0.1 | 92.66±0.1 | 92.91±0.0 |  |  |  |
| UPS | 87.28±0.7 | 91.89±0.2 | 92.40±0.0 | 92.83±0.1 | 93.03±0.1 |  |  |  |
|  | ActivePrune | 91.67±0.1 | 92.20±0.1 | 92.60±0.4 | 92.84±0.1 | 93.15±0.1 |  |  |
| LC | No Pruning | 91.68±0.0 | 92.10±0.0 | 92.92±0.0 | 92.46±0.0 | 92.98±0.0 |  |  |
| Random | 92.03±0.1 | 92.07±0.1 | 92.19±0.1 | 92.68±0.0 | 92.53±0.1 |  |  |  |
| ASK-LLM | 90.13±0.2 | 90.26±0.9 | 88.30±0.4 | 90.15±0.2 | 90.33±0.1 |  |  |  |
| Perplexity | 91.71±0.1 | 92.08±0.1 | 92.18±0.2 | 92.74±0.1 | 92.79±0.0 |  |  |  |
|  |  | UPS | 89.87±0.1 | 91.71±0.1 | 92.29±0.2 | 92.71±0.1 | 92.79±0.0 |  |
|  |  |  | ActivePrune | 92.37±0.0 | 92.46±0.1 | 92.76±0.0 | 93.16±0.1 | 93.11±0.1 |
| AG News<br>(Classification) | F1-Score | Coreset | No Pruning | 92.36±0.0 | 92.91±0.0 | 93.50±0.0 | 93.80±0.0 | 94.05±0.0 |
| Random | 92.04±0.2 | 93.30±0.1 | 94.00±0.1 | 94.10±0.1 | 94.06±0.1 |  |  |  |
| ASK-LLM | 91.71±0.2 | 92.45±0.2 | 93.18±0.2 | 93.65±0.2 | 93.83±0.1 |  |  |  |
| Perplexity | 92.64±0.2 | 93.24±0.2 | 93.41±0.1 | 93.59±0.2 | 93.93±0.1 |  |  |  |
| UPS | 92.29±0.2 | 92.96±0.1 | 93.70±0.1 | 94.07±0.1 | 94.04±0.1 |  |  |  |
|  | ActivePrune | 92.40±0.2 | 93.55±0.1 | 94.13±0.1 | 94.33±0.1 | 94.22±0.1 |  |  |
| LC | No Pruning | 92.58±0.0 | 93.40±0.0 | 93.98±0.0 | 93.98±0.0 | 94.40±0.0 |  |  |
| Random | 91.85±0.1 | 92.75±0.1 | 93.53±0.1 | 93.91±0.1 | 94.08±0.1 |  |  |  |
| ASK-LLM | 91.20±0.1 | 92.43±0.1 | 93.33±0.1 | 93.72±0.1 | 93.86±0.1 |  |  |  |
| Perplexity | 92.54±0.1 | 93.15±0.1 | 93.45±0.1 | 93.56±0.1 | 93.85±0.1 |  |  |  |
|  |  | UPS | 92.46±0.1 | 93.07±0.1 | 93.34±0.1 | 93.85±0.1 | 93.92±0.1 |  |
|  |  |  | ActivePrune | 91.69±0.1 | 92.98±0.1 | 93.89±0.1 | 93.93±0.1 | 94.30±0.1 |

### 4.4 Baselines

We compare our method with different unlabeled pool subsampling and data pruning strategies. (1) Random Selection selects examples randomly from the unlabeled pool which are then passed to the active learning method. (2) ASK-LLM selects the top-k examples with the highest quality scores assigned by an LLM (Sachdeva et al., ). (3) Perplexity picks examples with the lowest perplexity scores (computed through an LLM) in an attempt to exclude noisy examples and label noise (Laurençon et al., ). (4) UPS (Unlabeled pool subsampling) prefers the instances with the highest uncertainty scores from the unlabeled pool and selectively updates those in each AL iteration (Tsvigun et al., ).

### 4.5 Training Settings

For the translation task on the IT domain dataset, we use the BART-base variant (with 139 million parameters) trained on the WMT14 En-De out-of-domain parallel corpora, following the setup in previous works (Dou et al., ; Hu & Neubig, ). SacreBLEU score is used for the evaluation on the test set of the IT domain dataset. For abstractive text summarization on the AESLC dataset, we follow the setup used in Tsvigun et al. () and train the BART-base model. ROUGE-L score is used for the evaluation on the test set of AESLC. For binary sentiment classification on the IMDB dataset and topic classification on the AG News dataset, we follow the protocol from Tsvigun et al. () and fine-tune the RoBERTa-base model. F1-score is used for the evaluation of the model on the test set of IMDB and AG News datasets.

In each AL iteration, the acquisition model is trained for 5 epochs, with a learning rate of 2e-5, weight decay of 0.028, and a batch size of 16. Gradient clipping was set at 0.28, and a warmup steps factor of 0.1 was applied to the learning rate scheduler. For the 4-bit quantization of the Gemma-2B model, we use the CUDA implementation provided by bitsandbytes (^1^11[https://github.com/TimDettmers/bitsandbytes](https://github.com/TimDettmers/bitsandbytes)).

At the start of each iteration, the data pruning strategy selects 25% of the dataset (thus pruning away 75% of the dataset), which is then passed to the AL strategy. 1% of the dataset is selected by the AL strategy, added to the labeled pool (i.e., emulating the labeling process), and then used for training the acquisition model, mirroring the protocol presented in Tsvigun et al. (). $\beta$ (perplexity reweighting sensitivity) is set to 0.1 after tuning through validation set. We evaluate the acquisition model on the unseen test dataset after each AL iteration.

## 5 Experiments

### 5.1 Results

We compare ActivePrune with the other four data pruning strategies in Table 1. For each combination of the dataset, AL strategy, and data pruning method, we do three runs with different seeds and report the mean evaluation metric along with the standard error. Across all datasets, ActivePrune performs better than other strategies in the final AL iteration with statistically significant differences. On the IT domain dataset with IDDS strategy, ActivePrune shows the highest SacreBLEU consistently over 5 AL iterations, with an increase of 15.61% (25.06 to 28.97) after the final iteration compared to the runner-up baseline (ASK-LLM). For the NSP strategy, ActivePrune shows an increase of 1.44% SacreBLEU over Perplexity (30.53 to 30.97) to 2.92% over Random (30.09 to 30.97). For the AESLC dataset, the difference in ROUGE-L score between ActivePrune and other strategies goes up to 6.37%. In certain configurations, the performance of ActivePrune even exceeds the no pruning baseline. For instance, our method achieves a SacreBLEU score of 30.97 on the IT domain dataset with NSP strategy, compared to 30.57 SacreBLEU without pruning. We hypothesize that this performance increase results from the selective removal of noisy examples from the entire unlabeled pool.

For the AG News and IMDB classification tasks, ActivePrune demonstrates the highest F1-score across most AL iterations for both Coreset and Least Confidence strategies. Note that the relative performance of other strategies varies between datasets, pointing towards differences in the data distribution. For example, ASK-LLM does not perform better than Perplexity and UPS on IMDB dataset. However, ActivePrune is able to perform consistently well, indicating the robustness of this strategy to different domains and distribution shifts.

### 5.2 Computational Cost Comparison

Comparison with other pruning methods. We now compare the computational efficiency of ActivePrune with other unlabeled data pruning methods (Random, UPS, ASK-LLM, Perplexity) under the same hardware and software configuration (Table 2). We conduct this analysis on the IT domain dataset, as it is the largest dataset (with 223,000 training instances) on which we conducted our experiments. We focus on the time taken (s) for unlabeled data selection, the acquisition and training time, and the overall end-to-end time for the complete AL procedure for 5 iterations. ActivePrune is 97.5% more efficient in pruning the unlabeled pool compared to Perplexity and by 97.6% compared to ASK-LLM. Specifically, the pruning time decreased from 34,550s for Perplexity and 36,010s for ASK-LLM to just 840s for ActivePrune. Note that the high computational cost of ASK-LLM and Perplexity pruning baseline is primarily due to a full LLM inference on the entire unlabeled pool, in contrast to ActivePrune which adopts a two-stage pruning process: the usage of KenLM in the first stage and the quantized LLM inference for a limited number of examples in the second stage.

The increase in efficiency is mirrored in the total time as well, with ActivePrune showing a decrease of 44.1% and 45.2% in the active learning time compared to Perplexity and ASK-LLM, respectively. Despite being computationally more efficient, ActivePrune demonstrates a higher SacreBLEU score on the test set.

Enabling efficient active learning. The end-to-end AL procedure without data pruning on the NSP strategy and the complete IT domain dataset requires 166,275s. In contrast, ActivePrune takes 42,240s (Table 2), which is a 74.5% decrease in the time required for Active Learning. This highlights the benefits of incorporating data pruning in the AL procedure and demonstrates that it enables efficient active learning.

**Table 2: Performance and wall clock time (seconds) comparison of the end-to-end active learning procedure for five iterations across different unlabeled pool pruning methods. The NSP strategy was used on the IT domain dataset on a single A6000 GPU server.**
|  | Random | UPS | Perplexity | ASK-LLM | ActivePrune (Ours) |
| --- | --- | --- | --- | --- | --- |
| SacreBLEU | 30.09 | 30.49 | 30.53 | 30.46 | 30.97 |
| Unlabeled pool pruning (s) | 12 | 20 | 34,550 | 36,010 | 840 |
| Acquisition and training time (s) | 41,400 | 41,400 | 41,400 | 41,400 | 41,400 |
| Total time (s) | 41,412 | 41,420 | 75,950 | 77,410 | 42,240 |

Figure: Figure 3: Trade-off between quality and efficiency across various data pruning strategies on the IT domain dataset with the NSP acquisition method. The perplexity method in the figure reflects the perplexity scores computed through the LLM (Gemma-2B) and not the perplexity scores from KenLM (which is a component of ActivePrune only).
Refer to caption: x3.png

Selection quality $\leftrightarrow$ efficiency tradeoff. We present the tradeoff between selection quality and efficiency for AL data pruning strategies in Fig. 3. The shaded regions indicate efficiency categories with light gray representing cost-effective methods, light blue for high-quality methods that require more time, and light green marking preferred region. Our method emerges as a notably efficient strategy, with a SacreBLEU score of 30.97 and requiring significantly less time than more expensive metrics. Thus, ActivePrune optimizes the Pareto frontier of the example selection quality and the required computational resources for pruning the unlabeled pool in AL.

### 5.3 Examining the selection

To understand the sentence selection preference in ActivePrune during AL iterations, it is important to find out how the quality of the selected instances differs from other data pruning methods. We plot LLM data quality vs. perplexity scores and analyze the unlabeled instances selected in ten iterations for annotation by each unlabeled pool pruning strategy (Random, UPS, ActivePrune, Perplexity, ASK-LLM) on the IMDB dataset. Figure 4 shows that Random and UPS strategies do not prioritize instances having a high data quality score or a high perplexity score (i.e., orange instances). A few examples of such instances are presented in Appendix C. Conversely, ActivePrune, Perplexity, and ASK-LLM select the instances having high scores, in addition to prototypical examples (blue examples). ActivePrune has the additional benefit of being significantly more efficient than the other score-based strategies (Section 5.2).

Figure: Figure 4: Distribution of Perplexity vs LLM data quality scores across samples selected through different pruning methods for the IMDB dataset. Each subplot represents sentences selected through the Active Learning (AL) procedure across 10 iterations, with each iteration involving the selection 1% of the dataset. Examples with orange color indicate examples with a high LLM quality score or a high perplexity score. The color gradient indicates the sequence of iterations, where the darkest shade denotes the first iteration and progressively lighter shades denote subsequent iterations, up to the lightest shade for the tenth iteration. Subplots are organized by sampling strategy.
Refer to caption: x4.png

### 5.4 Ablation Experiments

We conduct ablation experiments to demonstrate the importance of different components and algorithmic choices in ActivePrune. These experiments are conducted on the AESLC summarization dataset with the IDDS AL strategy.

Analyzing different components. We analyze the impact of three key components in ActivePrune: Perplexity, LLM Score, and Reweighting (Table 3). The configuration which includes only Perplexity and Reweighting achieves a ROUGE-L score of 30.05. However, this combination alone does not fully exploit the potential of ActivePrune. Next, we assess the effect of incorporating the LLM Score without reweighting, resulting in a ROUGE-L score of 30.34. This significant improvement suggests that the LLM Score plays a crucial role in enhancing the model’s performance.

**Table 3: Ablation of different components in ActivePrune.**
| Component | ROUGE-L |  |  |
| --- | --- | --- | --- |
| Perplexity | LLM Score | Reweighting |  |
| ✓ |  | ✓ | 30.05 |
| ✓ | ✓ |  | 30.34 |
|  | ✓ |  | 29.00 |
| ✓ | ✓ | ✓ | 30.85 |

Further, excluding Perplexity while retaining the LLM Score yields a ROUGE-L score of 29.00. This configuration does not perform better than scenario where both the Perplexity and LLM scores are utilized together, highlighting the importance of using Perplexity as well for example selection. Finally, the full ActivePrune algorithm, which integrates Perplexity, LLM Score, and Reweighting, achieves the highest ROUGE-L score of 30.85. This result confirms that each component in ActivePrune contributes uniquely to the algorithm’s overall effectiveness.

## 6 Conclusion

In this work, we introduced ActivePrune, a novel plug-and-play method for enabling efficient active learning through data pruning using language models. Our approach follows a two-stage pruning process: a fast evaluation using perplexity scores from an n-gram language model, and a high-quality selection using quantized LLM. Additionally, we introduce a perplexity reweighting method that increases the diversity of the selected example for subsequent active learning iterations. Our experiments with diverse datasets across translation, sentiment analysis, topic classification, and summarization tasks demonstrate that ActivePrune effectively reduces the size of the unlabeled pool without compromising the selection quality of examples. Moreover, ActivePrune enables more efficient utilization of resources during active learning by reducing the computational cost associated with large unlabeled pools. This also increases the interactivity of the labeling process thereby saving the valuable time of labeling experts. Future work includes the application of ActivePrune on larger datasets to demonstrate its utility in enabling efficient active learning at scale.

Limitations. The implications of pruning the unlabeled pool on the privacy and fairness of the final trained models were not explored in this study. Data pruning may lead to disproportionate pruning of different subpopulations in the dataset, potentially leading to the insufficient representation of specific groups. To address these issues, it is essential to thoroughly evaluate explainability and fairness for models that undergo active learning after a data pruning procedure.

## Appendix A Proof of Proposition 1

###### Proof.

Let $\mathcal{U}=\{x_{i}\}_{i=1}^{N}$ denote the unlabeled pool, and let $P_{t}(x_{i})$ be the perplexity score of instance $x_{i}$ at iteration $t$. The labeled set at iteration $t$ is $\mathcal{L}_{t}$, with newly labeled instances $L_{t}\subseteq\mathcal{L}_{t}$. The adjustment factor for $x_{i}$ is defined as:

$$ $A_{t}(x_{i})=\frac{1}{|L_{t}|}\sum_{l\in L_{t}}|P_{t}(x_{i})-P_{t}(l)|.$ $$

The reweighted perplexity is updated according to:

$$ $P_{t+1}(x_{i})=P_{t}(x_{i})-\beta\cdot A_{t}(x_{i}),$ (3) $$

where $\beta>0$ is a hyperparameter controlling the adjustment magnitude. The probability of selecting $x_{i}$ at iteration $t$ is proportional to:

$$ $\pi_{t}(x_{i})=\frac{w_{t}(x_{i})}{\sum_{x_{j}\in\mathcal{U}}w_{t}(x_{j})},$ $$

with $w_{t}(x_{i})=f(P_{t}(x_{i}))$, and $f$ is a monotonically decreasing function since lower perplexity implies higher selection priority.

Let $S\subseteq\mathcal{U}$ represent an underrepresented subset, meaning the instances in $S$ have perplexity scores significantly different from those in $\mathcal{L}_{t}$, and these are not selected through the LLM quality scoring as well. Our goal is to show that for any $x_{i}\in S$, the sampling probability $\pi_{t}(x_{i})$ increases over iterations, ensuring eventual selection.

Since $x_{i}\in S$ is underrepresented, there exists a constant $\delta>0$ such that:

$$ $|P_{t}(x_{i})-P_{t}(l)|\geq\delta,\quad\forall l\in\mathcal{L}_{t}.$ $$

Similarly, for instances $x_{j}\notin S$, which are similar to labeled instances, there exists a constant $\epsilon\geq 0$ (typically small) such that:

$$ $|P_{t}(x_{j})-P_{t}(l)|\leq\epsilon,\quad\forall l\in\mathcal{L}_{t}.$ $$

Under the assumption that underrepresented instances are sufficiently different from labeled instances compared to other instances, we have $\delta>\epsilon$.

Therefore, the adjustment factor for $x_{i}\in S$ satisfies:

$$ $A_{t}(x_{i})=\frac{1}{|L_{t}|}\sum_{l\in L_{t}}|P_{t}(x_{i})-P_{t}(l)|\geq\delta.$ (4) $$

Similarly, for $x_{j}\notin S$, the adjustment factor satisfies:

$$ $A_{t}(x_{j})=\frac{1}{|L_{t}|}\sum_{l\in L_{t}}|P_{t}(x_{j})-P_{t}(l)|\leq\epsilon.$ (5) $$

Substituting equation 4 into equation 3, we obtain for $x_{i}\in S$:

$$ $P_{t+1}(x_{i})\leq P_{t}(x_{i})-\beta\delta.$ $$

Similarly, for $x_{j}\notin S$, substituting equation 5 into equation 3, we have:

$$ $P_{t+1}(x_{j})\geq P_{t}(x_{j})-\beta\epsilon.$ $$

Now, consider the difference in perplexity between $x_{i}\in S$ and $x_{j}\notin S$:

$$ $\displaystyle P_{t+1}(x_{i})-P_{t+1}(x_{j})$ $\displaystyle=\left(P_{t}(x_{i})-\beta A_{t}(x_{i})\right)-\left(P_{t}(x_{j})- \beta A_{t}(x_{j})\right)$ $\displaystyle=\left(P_{t}(x_{i})-P_{t}(x_{j})\right)-\beta\left(A_{t}(x_{i})-A _{t}(x_{j})\right).$ $$

Since $A_{t}(x_{i})-A_{t}(x_{j})\geq\delta-\epsilon$, we have:

$$ $P_{t+1}(x_{i})-P_{t+1}(x_{j})\leq\left(P_{t}(x_{i})-P_{t}(x_{j})\right)-\beta \left(\delta-\epsilon\right).$ (6) $$

Define $\Delta=\beta\left(\delta-\epsilon\right)>0$, since $\delta>\epsilon$ and $\beta>0$.

Thus, the perplexity gap decreases by at least $\Delta$ per iteration:

$$ $P_{t+1}(x_{i})-P_{t+1}(x_{j})\leq\left(P_{t}(x_{i})-P_{t}(x_{j})\right)-\Delta.$ (7) $$

Let $D_{0}=P_{0}(x_{i})-P_{0}(x_{j})$. The number of iterations required for $x_{i}$ to have a perplexity less than or equal to that of $x_{j}$ is:

$$ $T_{ij}=\left\lceil\frac{D_{0}}{\Delta}\right\rceil.$ (8) $$

Since there are a finite number of instances $x_{j}\notin S$, we can define:

$$ $T^{*}=\max_{x_{j}\notin S}T_{ij}.$ (9) $$

At iteration $T^{*}$, for all $x_{j}\notin S$, we have:

$$ $P_{T^{*}}(x_{i})\leq P_{T^{*}}(x_{j}).$ $$

Moreover, since the perplexity of $x_{i}$ decreases by at least $\beta\delta$ per iteration, from equation 4 and equation 3, the perplexity of $x_{i}$ after $T^{*}$ iterations satisfies: $P_{T^{*}}(x_{i})\leq P_{0}(x_{i})-\beta\delta T^{*}.$
Similarly, for $x_{j}\notin S$, their perplexity satisfies:$P_{T^{*}}(x_{j})\geq P_{0}(x_{j})-\beta\epsilon T^{*}.$ Thus, after $T^{*}$ iterations, $x_{i}\in S$ will have a perplexity not greater than any $x_{j}\notin S$.

An instance $x_{i}$ will be selected when its perplexity score ranks among the lowest $k$ in the unlabeled pool:

$$ $P_{t}(x_{i})\leq P^{(k)}_{t},$ (10) $$

where $P^{(k)}_{t}$ is the $k$-th lowest perplexity score at iteration $t$. Since after $T^{*}$ iterations, $x_{i}$ has a perplexity lower than or equal to that of all $x_{j}\notin S$, and there are only a finite number of instances with perplexity less than or equal to $P_{T^{*}}(x_{i})$, $x_{i}$ will eventually satisfy the selection condition equation 10.

Therefore, underrepresented instances $x_{i}\in S$ have larger adjustment factors, leading to a significant decrease in their reweighted perplexity scores over iterations. The perplexity gap between $x_{i}$ and other instances decreases at a rate of $\Delta=\beta(\delta-\epsilon)>0$, resulting in $x_{i}$ eventually ranking among the lowest perplexity scores and being selected.

∎

###### Proof.

## Appendix B Implementation Details

### B.1 Algorithm

We have extended the ALToolbox(^2^22[https://github.com/AIRI-Institute/al_toolbox](https://github.com/AIRI-Institute/al_toolbox)) Python package (Tsvigun et al., ) to include functionality for ActivePrune. This enables compatibility with any dataset(^3^33[https://huggingface.co/datasets](https://huggingface.co/datasets)) and model(^4^44[https://huggingface.co/models](https://huggingface.co/models)) that is accessible on HuggingFace (Wolf et al., ). The ActivePrune procedure is presented in Algorithm 1. The ALToolbox repository is available under the MIT license. We release the code with the MIT license too and submit it as part of the supplementary material.

Figure: Algorithm 1 ActivePrune

### B.2 Resources

We utilized 48GB NVIDIA A6000 GPUs to conduct all our experiments on the cloud. Over the course of the project, from the initial trials to achieving the final results, the experiments used a total of approximately 3210 GPU hours.

### B.3 Models

**Table 4: Summary of models used in the experiments, including their parameter count, architecture, use cases, and licenses.**
| Model | Parameters | Architecture | Task | License |
| --- | --- | --- | --- | --- |
| BART (Lewis et al., ) | 406M | Encoder-Decoder | ATS, NMT | MIT |
| RoBERTa-base (Liu et al., ) | 125M | Encoder-only | Classification | MIT |
| Gemma-2B (Team et al., ) | 2B | Decoder-only | LLM data quality scoring | Apache 2.0 |

### B.4 Data Statistics

**Table 5: The datasets used for experiments, their respective tasks, the number of training, validation, and test samples, and their licenses.**
| Dataset | Task | Training | Validation | Test | License |
| --- | --- | --- | --- | --- | --- |
| IMDB | Sentiment Analysis | 25,000 | N/A | 25,000 | Non-commercial use only |
| AG News | Topic Classification | 120,000 | N/A | 7,600 | Non-commercial use only |
| IT Domain | Machine Translation (En-De) | 223,000 | 2,000 | 2,000 | Creative Commons CC0 |
| AESLC | Abstractive Text Summarization | 14,400 | 1,960 | 1,910 | CC BY-NC-SA 4.0 |

## Appendix C Qualitative comparison

We present a qualitative comparison of perplexity and LLM data quality scores for the IT domain En-De translation dataset. Table 6 contains examples with high percentiles of perplexity scores, representing the examples with the lowest values of perplexity. Table 7 shows examples with a high percentile of LLM scores, representing the examples with the highest values of data quality scores.

**Table 6: A selection of translation examples from the IT dataset with high perplexity percentiles and varying LLM quality percentiles.**
| Perplexity Percentile | LLM score Percentile | Text (English) | Translation (German) |
| --- | --- | --- | --- |
| 99.86 | 94.47 | With this option you can turn the & kmix; main window content by 90 degrees. Sliders, texts and everything else (if applicable) is rotated. There are some exclusions to this rule, most notably the menubar, the mixer selector (if shown at all), the panning slider and the multiple-choice selectors. | Mit dieser Einstellung können Sie den Inhalt des & kmix;-Hauptfensters um 90 Grad drehen / Schieberegler, Texte und vieles mehr wird gedreht. Davon ausgeschlossen sind & eg; die Menüleiste, die Mixerauswahl (wenn vorhanden), der Rechts-Links-Abgleich und die Mehrfachauswahlen. |
| 99.71 | 88.45 | One is used for text completion in the Location Toolbar text entry box. To clear this right click on the text entry box and select Clear History. | Einer wird für die Vervollständigung von Einträgen im Eingabefeld der Adressleiste benutzt. Um diese Einträge zu löschen, klicken Sie mit der rechten Maustaste auf das Texteingabefeld und wählen Alles löschen aus. |
| 99.84 | 79.84 | Build a temporary sandbox and download/install the necessary packages and debug symbols in there; without this option it assumes that the necessary packages and debug symbols are already installed in the system. The argument points to the packaging system configuration base directory; if you specify "system", it will use the system configuration files, but will then only be able to retrace crashes that happened on the currently running release. | Erstellt eine temporäre Sandbox, lädt die benötigten Pakete und Symbole zur Fehlerdiagnose herunter und installiert diese in die Sandbox; ohne diese Option wird davon ausgegangen, dass die benötigten Pakete und Symbole zur Fehlerdiagnose bereits im System installiert sind.Der Parameter verweist auf das Stammverzeichnis des Paketsystemkonfigurationsverzeichnisses; wenn Sie »system« angeben werden die Systemkonfigurationsdateien verwendet, allerdings sind Sie dann nur in der Lage Abstürze in der aktuell laufenden Veröffentlichung zurück zu verfolgen. |
| 99.73 | 72.93 | Color-blindness simulation | Simulation für Farbenblindheit |
| 99.67 | 69.30 | akonadictl found and usable | akonadictl gefunden und benutzbar |
| 99.93 | 25.23 | _Add Bookmark… | Lesezeichen _hinzufügen … |
| 99.96 | 10.50 | File ’%1 ’not found! | Datei‚ %1‘ kann nicht gefunden werden. |
| 99.91 | 6.77 | & Audio Alarm Template | & Audio-Erinnerungsvorlage@action |
| 99.86 | 3.69 | Local Scope | Lokaler Gültigkeitsbereich |
| 99.88 | 1.24 | Auto Next | Automatisch zum nächsten |

**Table 7: A selection of translation examples from the IT dataset with high LLM quality scores and varying perplexity scores.**
| Perplexity Percentile | LLM score Percentile | Text (English) | Translation (German) |
| --- | --- | --- | --- |
| 96.53 | 99.80 | The ’Zoom to 100%’ command resizes the video area to the original video size of the current file. | ‚Äû Zoomfaktor 100 %‚Äú zeigt das Video in Originalgröße an. |
| 82.54 | 99.98 | Mark this check box to convert the URLs referencing other ODF files to PDF files with the same name. | Aktivieren Sie diese Option, um URLs, die von anderen ODF-Dateien auf PDF-Dateien verweisen, mit dem gleichen Namen zu konvertieren. |
| 65.46 | 99.69 | Designed to be the successor of the MP3 format, AAC generally achieves better sound quality than MP3 at many bit rates. | Wird als Nachfolger des MP3-Formats angesehen. AAC erreicht generell bessere Klangqualität als MP3 bei niedrigeren Bitraten. |
| 51.42 | 99.65 | To get a list of all Kanji with a certain number of strokes, enter that number in the text-entry in the toolbar as "S:4". | Um eine Liste aller Kanji mit einer bestimmten Anzahl von Strichen zu bekommen, geben Sie diese Anzahl in das Texteingabefeld in der Werkzeugleiste als S:4 ein. |
| 36.20 | 99.64 | Remove the selected widget, returns the index of the removed widget or -1 if no such widget was found. | Entfernt das ausgewählte Bedienelement, gibt den Index des entfernten Bedienelements zurück oder -1, falls kein Bedienelement gefunden wurde. |
| 33.61 | 99.60 | SEEK-END - Set position to end-of-file plus offset. (To move to a position before the end-of-file, you need to pass a negative value in offset.) | SEEK-END - Setzt die Position ans Ende der Datei plus offset. (Um zu einer Position vor EOF zu gelangen, übergeben Sie in offset einen negativen Wert.) |
| 27.69 | 99.91 | Error reading the keyboard layout; the default number keypad will be created instead. You can choose another keyboard layout in the preferences dialog. | Fehler beim Lesen der Tastaturbelegung! Stattdessen wird das normale Nummernfeld erzeugt. Sie können eine andere Tastaturbelegung im Dialog‚Äû Einstellungen‚Äú wählen. |
| 15.20 | 99.86 | Use –filter=’exclude. rsync-filter ’filter rule | Benutze die –filter=‚Äö exclude .rsync-filter‚Äò Filterregel |
| 13.82 | 99.59 | Cut off after specified number. Use -1 for infinite number of entries. | Nach angegebener Anzahl abschneiden. -1 bedeutet unbegrenzt. |
| 2.41 | 99.75 | Only reuses an instance with the specified PID (Process ID). Used with the –use option. | kate; benutzt eine existierende Instanz nur dann, wenn diese die angegebene PID (Process ID) hat. Diese Option wird zusammen mit der Option –use benutzt. |

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 5
presentation: 2
questions: 1. In line 219 should the expression for $\mathcal{F}$ be $\mathcal{F} \cup \mathcal{Q}_s$ ? 

2. In Section 3 the authors call out the key components of ActivePrune. These seem to also be the main contributions of the paper and should be clearly called out earlier in the paper, preferably in Section 1.

3. In line 182, the line ends without a period '.' and should be included.

4. The authors perform only 5 rounds of AL for each task. Is this a common practice or has been decided based on some factors ? This would highly increase readability.
soundness: 3
strengths: 1.  The proposed ActivePrune framework is a novel, efficient two-stage pruning process that claims a significant reduction in computational costs in active learning without compromising data selection quality.

2.  The paper introduces a unique perplexity reweighting technique that systematically prioritizes underrepresented instances, promoting diversity in the selection pool across iterations.

3. The re-weighting algorithm based on the already selected samples in previous iterations in very unique to ActivePrune and is a very good way to enforce diversity.
summary: The main contribution of the paper is the introduction of ActivePrune, a novel data pruning strategy that enhances the efficiency of active learning. ActivePrune uses a two-stage pruning process: (1) a fast evaluation using perplexity scores from an n-gram language model, followed by (2) a high-quality selection using data quality scores computed with a quantized large language model (LLM). Additionally, ActivePrune employs a novel perplexity reweighting technique to improve diversity by prioritizing underrepresented instances in the dataset.
weaknesses: 1. The authors should clearly include the definitions of $\mathcal{L}$, $\mathcal{F}$, L etc. which seems to be used interchangeably in the document. eg. In line 226, is L here same as $\mathcal{L}$ introduced in line 161 ?

2. ActivePrune uses 2 LLMs in its pipeline but continues to enjoy 97% higher efficiency over 'Random' sampling techniques. This is misleading. Can this be a function of large compute resources used in the paper ?

3. Authors claim the use of a 'high-quality' LLM to score examples. LLMs have been shown in recent literature to demonstrate hallucinations and spurious correlations which have a high probability to impact the quality of predictions. The authors should provide additional analysis on this to establish the impact of the paper. This impact is even more necessary since the paper claims to have used a quantized language model (line 213) in their pipeline.

4. In lines 184 the authors mention the selection bottom $k$ instances. Since the list is sorted in ascending order, the top-k examples should have the lowest perplexity. This is also observed in line 217 where the authors mention the selection of bottom k indices, which for a list sorted in descending order should be the top-k elements.

5. The gain in performance for datasets other than IT Domain seem to be very marginal. In some cases such as the classification task in AG News dataset, the change in F1 score over random is very incremental which weakens the contribution of ActivePrune.

---

confidence: 3
contribution: 2
initial_rating: 3
presentation: 2
questions: Are the selected high perplexity examples actually good for training?

Does the competitiveness for speed go away when the baselines also use quantized LLM?
soundness: 3
strengths: The writing is easy to follow an understand. All 3 stages of the methods are clearly stated and it is very easy to understand their mechanisms. 

The diversity claim through perplexity is explained clearly with proofs.

Leveraging LLM is a good way to improve the quality selected examples.

The problem is non trivial as data size can greatly affect the training process.
summary: This paper introduces ActivePrune a Data Pruning method for Active Learning. The method comes in 3 parts: a perplexity filter, a LLM model for quality selection, and perplexity reweighting for diversity. First, the perplexity filter reduces the unlabeled pool to top k examples. Second, the quantized LLM chooses quality examples by being prompted a yes or no questions. Lastly, the perplexity reweight formula  updates the perplexity scores in light of new data to increases diversity. The reweighting formula is also the main novelty of the paper. The authors claim that this method can speed up the training process and also improves task performances.
weaknesses: A contradictory stance on the perplexity score: examples with the lowest perplexity scores are chosen to improve quality but then examples with high initial perplexity are then chosen also. The perplexity reweighting method does not target quality examples but only diversify the perplexity of the chosen examples. 

Unclear why the perplexity - LLM pipeline is needed: Sachdeva et al., 2024 stated that the usage of LLM instead of perplexity to select quality data is because LLM is superior. The author has not justify their decision to use both methods in contrary to Sachdeva et al., 2024 

Unjustified usage of perplexity for diversity: Based on figure 4, the selected high perplexity examples are low quality examples. 

Figure 4 seems to suggests the Ask-LLM would be a better candidate as the chosen samples have higher quality and the mass of the selection examples are more spread out on the perplexity tail end compare to ActivePrune. 

The speed up baseline is unreasonable: ActivePrune uses both perplexity and LLM but the speed up is 100x compare to methods that only use LLM or perplexity.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: - How does the method impact model generalisation in out-of-distribution settings? CounterAL and ALVIN show that many AL methods struggle with OOD generalisation, does this method address that?
- The authors claim that the method promotes underrepresented instances but do not demonstrate that empirically. Metrics such as those defined in Ein-Dor et al. (2020) could help assess the types of instances chosen. Furthermore, if the proposed method indeed identifies underrepresented instances, this could also enhance the method’s effectiveness in OOD settings, as mentioned above.
- It would have been interesting to see how the proposed method performs when combined with state-of-the-art AL methods, such as CAL.
- How does the method perform when used to train other model architectures, such as BERT?
soundness: 3
strengths: - The paper is well-written, and the method is clearly explained.
- The proposed idea is straightforward and appears to be computationally faster than similar state-of-the-art LLM-based methods.
- The method works in both classification and text generation tasks.
summary: The authors propose a data pruning method for active learning (AL) settings that discards instances from the unlabeled pool using a quantized large language model (LLM). Experiments across four datasets from machine translation, summarization, and classification demonstrate that the proposed method outperforms several baselines and is computationally faster than other LLM-based pruning methods.
weaknesses: - The related work section is missing several active learning works (please see below).
- Improvements seem marginal.
- Metrics like BLEU and ROUGE do not fully capture output quality in text generation experiments. The authors should consider using a wider range of metrics to provide a more comprehensive evaluation.
- Evaluation uses a limited number of datasets.

### Missing References
1. Xun Deng, Wenjie Wang, Fuli Feng, Hanwang Zhang, Xiangnan He, and Yong Liao. 2023. Counterfactual Active Learning for Out-of-Distribution Generalization. 
2. Katerina Margatina, Giorgos Vernikos, Loïc Barrault, and Nikolaos Aletras. 2021. Active Learning by Acquiring Contrastive Examples.
3. Michelle Yuan, Hsuan-Tien Lin, and Jordan Boyd-Graber. 2020. Cold-start Active Learning through Self-supervised Language Modeling. 
4. Shujian Zhang, Chengyue Gong, Xingchao Liu, Pengcheng He, Weizhu Chen, and Mingyuan Zhou. 2022. ALLSH: Active Learning Guided by Local Sensitivity and Hardness. 
5. Michalis Korakakis, Andreas Vlachos, and Adrian Weller. 2024. ALVIN: Active Learning Via INterpolation.
6. Liat Ein-Dor, Alon Halfon, Ariel Gera, Eyal Shnarch, Lena Dankin, Leshem Choshen, Marina Danilevsky, Ranit Aharonov, Yoav Katz, and Noam Slonim. 2020. Active learning for BERT: An empirical study.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: Please refer to the comments above. Here are some additional questions and comments:
- Q1) Section 3.3: Could you clarify why you chose a prompt-based approach to evaluate perplexity instead of directly assessing it based on the LLM's logits for the sequence?
- Q2) Section 4.2: Why do you select only one model per task? Would it be possible to evaluate multiple models on the same task?
- Q3) Have you considered using in-context learning in addition to training models on the selected examples for active learning?
- Q4) Section 3.2: I recommend moving some details from this paragraph to another section, as they are not directly related to the proposed method.
soundness: 2
strengths: The strengths of the paper are presented below:

- S1) The problem studied is interesting, as it is computationally challenging to evaluate the LLM's uncertainty on a large pool of examples.

- S2) Experiments conducted on the large IT dataset show that ActivePrune is more efficient than other existing uncertainty-based methods.

- S3) The paper is clearly organized and easy to follow. Additionally, Section 3.4 provides a solution for addressing underrepresented instances during pool pruning.
summary: The paper introduces ActivePrune, a method designed to enhance the efficiency of active learning techniques in NLP. In active learning, instances from an unlabeled pool are selected for labeling, which can be challenging when the pool is large. ActivePrune addresses this issue through pruning: it utilizes perplexity scoring and LLM filtering to reduce the initial pool to a more manageable size. Subsequently, active learning algorithms are applied to this refined pool. Experiments conducted on four NLP tasks demonstrate that ActivePrune is more efficient than existing methods.
weaknesses: The weaknesses of the paper are presented below:

- W1) **Evaluation**: The experimental evaluation lacks depth. For instance, ActivePrune compares itself to other costly LLM-based pruning techniques but does not include comparisons with lightweight methods, such as k-means clustering or coreset selection. These experiments are essential to assess the effectiveness of the approach. 
- W2) **Soundness**: ActivePrune achieves improved efficiency through the use of an n-gram model for perplexity scoring and a quantized 2B LLM for filtering. However, such a solution is not sophisticated and lack robustness. For example, in domain-specific datasets, such as medical or finance, or in complex tasks, such as math reasoning, these models might be limited. It is suggested that authors evaluate their approach in more challenging tasks. 
- W3) Furthermore, the approach does not account for the downstream LLM. For example, it may prune the same instances regardless of whether a medical or finance LLM is used, omitting to consider their respective knowledge of the task.

Meta-review: This work introduces ActivePrune, a plug-and-play strategy for pruning large unlabeled data pools in active learning. Using a two-stage process—initial pruning with n-gram perplexity scores and fine-grained selection with quantized LLM metrics—it reduces computational costs while maintaining high-quality instance selection. A novel perplexity reweighting method further enhances diversity, and experiments across multiple tasks show that ActivePrune outperforms existing pruning methods.

The reviewers have raised a number of issues including the evaluation and baseline comparisons, and a few other issues. Though these have been addressed to some extent in the rebuttal, I would encourage the authors to address all the reviewer's criticisms carefully in the next version and resubmit.

Decision: Reject