Title: SELECTION VIA PROXY: EFFICIENT DATA SELECTION FOR DEEP LEARNING

Abstract: Data selection methods, such as active learning and core-set selection, are useful tools for machine learning on large datasets. However, they can be prohibitively expensive to apply in deep learning because they depend on feature representations that need to be learned. In this work, we show that we can greatly improve the computational efficiency by using a small proxy model to perform data selection (e.g., selecting data points to label for active learning). By removing hidden layers from the target model, using smaller architectures, and training for fewer epochs, we create proxies that are an order of magnitude faster to train. Although these small proxy models have higher error rates, we find that they empirically provide useful signals for data selection. We evaluate this "selection via proxy" (SVP) approach on several data selection tasks across five datasets: CIFAR10, CIFAR100, ImageNet, Amazon Review Polarity, and Amazon Review Full. For active learning, applying SVP can give an order of magnitude improvement in data selection runtime (i.e., the time it takes to repeatedly train and select points) without significantly increasing the final error (often within 0.1%). For core-set selection on CIFAR10, proxies that are over 10× faster to train than their larger, more accurate targets can remove up to 50% of the data without harming the final accuracy of the target, leading to a 1.6× end-to-end training time improvement.

1. INTRODUCTION:

Data selection methods, such as active learning and core-set selection, improve the data efficiency of machine learning by identifying the most informative training examples. To quantify informativeness, these methods depend on semantically meaningful features or a trained model to calculate uncertainty. Concretely, active learning selects points to label from a large pool of unlabeled data by repeatedly training a model on a small pool of labeled data and selecting additional examples to label based on the model's uncertainty (e.g., the entropy of predicted class probabilities) or other heuristics (Lewis & Gale, 1994; Rosenberg et al., 2005; Settles, 2011; 2012) . Conversely, core-set selection techniques start with a large labeled or unlabeled dataset and aim to find a small subset that accurately approximates the full dataset by selecting representative examples (Har-Peled & Kushal, 2007; Tsang et al., 2005; Huggins et al., 2016; Campbell & Broderick, 2017; 2018; Sener & Savarese, 2018) .

Unfortunately, classical data selection methods are often prohibitively expensive to apply in deep learning (Shen et al., 2017; Sener & Savarese, 2018; Kirsch et al., 2019) . Deep learning models learn complex internal semantic representations (hidden layers) from raw inputs (e.g., pixels or characters) that enable them to achieve state-of-the-art performance but result in substantial training times. Many core-set selection and active learning techniques require some feature representation before they can accurately identify informative points either to take diversity into account or as part of a trained model to quantify uncertainty. As a result, new deep active learning methods request labels in large batches to avoid retraining the model too many times (Shen et al., 2017; Sener & Savarese, 2018; Kirsch et al., 2019) . However, batch active learning still requires training a full deep model for every batch, which is costly for large models (He et al., 2016b; Jozefowicz et al., 2016; Vaswani et al., 2017) . Similarly, core-set selection applications mitigate the training time of deep learning models by using bespoke combinations of hand-engineered features and simple models (e.g., hidden Markov models) pretrained on auxiliary tasks (Wei et al., 2013; 2014; Tschiatschek et al., 2014; Ni et al., 2015) .

In this paper, we propose selection via proxy (SVP) as a way to make existing data selection methods more computationally efficient for deep learning. SVP uses the feature representation from a separate, less computationally intensive proxy model in place of the representation from the much larger and more accurate target model we aim to train. SVP builds on the idea of heterogeneous uncertainty sampling from Lewis & Catlett (1994) , which showed that an inexpensive classifier (e.g., naïve Bayes) can select points to label for a much more computationally expensive classifier (e.g., decision tree). In our work, we show that small deep learning models can similarly serve as an inexpensive proxy for data selection in deep learning, significantly accelerating both active learning and core-set selection across a range of datasets and selection methods. To create these cheap proxy models, we can scale down deep learning models by removing layers, using smaller model architectures, and training them for fewer epochs. While these scaled-down models achieve significantly lower accuracy than larger models, we surprisingly find that they still provide useful representations to rank and select points. Specifically, we observe high Spearman's and Pearson's correlations between the rankings from small proxy models and the larger, more accurate target models on metrics including uncertainty (Settles, 2012) , forgetting events (Toneva et al., 2019) , and submodular algorithms such as greedy k-centers (Wolf, 2011) . Because these proxy models are quick to train (often 10× faster), we can identify which points to select nearly as well as the larger target model but significantly faster.

We empirically evaluated SVP for active learning and core-set selection on five datasets: CIFAR10, CIFAR100 (Krizhevsky & Hinton, 2009) , ImageNet (Russakovsky et al., 2015) , Amazon Review Polarity, and Amazon Review Full (Zhang et al., 2015) . For active learning, we considered both least confidence uncertainty sampling (Settles, 2012; Shen et al., 2017; Gal et al., 2017) and the greedy k-centers approach from Sener & Savarese (2018) with a variety of proxies. Across all datasets, we found that SVP matches the accuracy of the traditional approach of using the same large model for both selecting points and the final prediction task. Depending on the proxy, SVP yielded up to a 7× speed-up on CIFAR10 and CIFAR100, 41.9× speed-up on Amazon Review Polarity and Full, and 2.9× speed-up on ImageNet in data selection runtime (i.e., the time it takes to repeatedly train and select points). For core-set selection, we tried three methods to identify a subset of points: max entropy uncertainty sampling (Settles, 2012) , greedy k-centers as a submodular approach (Wolf, 2011) , and the recent approach of forgetting events (Toneva et al., 2019) . For each method, we found that smaller proxy models have high Spearman's rank-order correlations with models that are 10× larger and performed as well as these large models at identifying subsets of points to train on that yield high test accuracy. On CIFAR10, SVP applied to forgetting events removed 50% of the data without impacting the accuracy of ResNet164 with pre-activation (He et al., 2016b) , using a 10× faster model than ResNet164 to make the selection. This substitution yielded an end-to-end training time improvement of about 1.6× for ResNet164 (including the time to train and use the proxy). Taken together, these results demonstrate that SVP is a promising, yet simple approach to make data selection methods computationally feasible for deep learning. While we focus on active learning and core-set selection, SVP is widely applicable to methods that depend on learned representations.

2. METHODS:

In this section, we describe SVP and show how it can be incorporated into active learning and core-set selection. Figure 1 shows an overview of SVP: in active learning, we retrain a proxy model A P k in place of the target model A T k after each batch is selected, and in core-set selection, we train the proxy A P

[n] rather than the target A T

[n] over all the data to learn a feature representation and select points.

2.1. ACTIVE LEARNING:

Pool-based active learning starts with a large pool of unlabeled data U = {x i } i∈ [n] where [n] = {1, . . . , n}. Each example is from the space X with an unknown label from the label space Y and is sampled i.i.d. over the space Z = X × Y as (x i , y i ) ∼ p Z . Initially, methods label a small pool of points s 0 = {s 0 j ∈ [n]} j∈[m] chosen uniformly at random. Given U , a loss function , and the labels {y s 0 j } j∈ [m] for the initial random subset, the goal of active learning is to select up to a budget of b In active learning, we followed the same iterative procedure of training and selecting points to label as traditional approaches but replaced the target model with a cheaper-to-compute proxy model. For core-set selection, we learned a feature representation over the data using a proxy model and used it to select points to train a larger, more accurate model. In both cases, we found the proxy and target model have high rank-order correlation, leading to similar selections and downstream results.

points s = s 0 ∪ {s j ∈ [n] \ s 0 } j∈[b-m] to label that produces a model A s with low error. Traditional Approach (a) Active Learning Select Subset (! " ∪ ! $ ) Initial Subset (! " ) Train Target (%" & ) Train Target (%'($ & ) Select Subset (… ∪ ! ' ) Train Target (%' & ) … Data Selection Select Subset (! " ∪ ! $ ) Initial Subset (! " ) Select Subset (… ∪ ! ' ) Train Target (%' & ) … Data Selection

Baseline. In this paper, we apply SVP to least confidence uncertainty sampling (Settles, 2012; Shen et al., 2017; Gal et al., 2017) and the recent greedy k-centers approach from Sener & Savarese (2018) . Like recent work for deep active learning (Shen et al., 2017; Sener & Savarese, 2018; Kirsch et al., 2019) , we consider a batch setting with K rounds where we select b K points in every round. Following Gal et al. (2017) ; Sener & Savarese (2018) ; Kirsch et al. (2019) , we reinitialize the target model and retrain on all of the labeled data from the previous k rounds to avoid any correlation between selections (Frankle & Carbin, 2018; Kirsch et al., 2019) . We denote this trained model as A T s 0 ∪...∪s k or just A T k for simplicity. Then using A T k , we either calculate the model's confidence as:

f confidence (x; A T k ) = 1 -max ŷ P (ŷ|x; A T k )

and select the examples with the lowest confidence or extract a feature representation from the model's final hidden layer and compute the distance between examples (i.e., ∆(x i , x j ; A T k )) to select points according to the greedy k-centers method from Wolf (2011) ; Sener & Savarese (2018) (Algorithm 1). The same model is trained on the final b labeled points to yield the final model, A T K , which is then tested on a held-out set to evaluate error and quantify the quality of the selected data.

Although other selection approaches exist, least confidence uncertainty sampling and greedy k-centers cover the spectrum of uncertainty-based and representativeness-based approaches for deep active learning. Other uncertainty metrics such as entropy or margin were highly correlated with confidence when using the same trained model (i.e., above a 0.96 Spearman's correlation in our experiments on CIFAR). Query-by-committee (Seung et al., 1992 ) can be prohibitively expensive in deep learning, where training a single model is already costly. BALD (Houlsby et al., 2011) has seen success in deep learning (Gal et al., 2017; Shen et al., 2017) but is restricted to Bayesian neural networks or networks with dropout (Srivastava et al., 2014) as an approximation (Gal & Ghahramani, 2016) . prev_acc i = acc i 10:

Gradient update classifier on B 11: return forgetting_events 2.2 CORE-SET SELECTION Core-set selection can be broadly defined as techniques that find a subset of data points that maintain a similar level of quality (e.g., generalization error of a trained model or minimum enclosing ball) as the full dataset. Specifically, we start with a labeled dataset L = {x i , y i } i∈[n] sampled i.i.d. from Z with p Z and want to find a subset of m ≤ n points s = {s j ∈ [n]} j∈[m] that achieves comparable quality to the full dataset:

min s:|s|=m E x,y∼p Z [ (x, y; A s )] -E x,y∼p Z (x, y; A [n] )

Baseline. To find s for a given budget m, we implement three core-set selection techniques: greedy kcenters (Wolf, 2011; Sener & Savarese, 2018) , forgetting events (Toneva et al., 2019) , and max entropy uncertainty sampling (Lewis & Gale, 1994; Settles, 2012) . Greedy k-centers is described above and in Algorithm 1. Forgetting events are defined as the number of times an example is incorrectly classified after having been correctly classified earlier during training a model, as described in Algorithm 2. To select points, we follow the same procedure as Toneva et al. (2019) : we keep the points with the m highest number of forgetting events. Points that are never correctly classified are treated as having an infinite number of forgetting events. Similarly, we rank examples based on the entropy from a trained target A T

[n] as:

f entropy (x; A T [n] ) = - ŷ P (ŷ|x; A T [n] ) log P (ŷ|x; A T [n] )

and keep the m examples with the highest entropy. To evaluate core-set quality, we compare the performance of training the large target model on the selected subset A T s to training the target model on the entire dataset A T

[n] by measuring error on a held-out test set.

2.3. APPLYING SELECTION VIA PROXY:

In general, SVP can be applied by replacing the models used to compute data selection metrics such as uncertainty with proxy models. In this paper, we applied SVP to the active learning and core-set selection methods described in Sections 2.1 and 2.2 as follows:

• For active learning, we replaced the model trained at each batch (A T k ) with a proxy (A P k ), but then trained the same final model A T K once the budget b was reached. • For core-set selection, we used a proxy A P

[n] instead of A T

[n] to compute metrics and select s.

We explored two main methods to create our proxy models:

Scaling down. For deep models with many layers, reducing the dimension or the number of hidden layers is an easy way to trade-off accuracy to reduce training time. For example, deep ResNet models come in a variety of depths (He et al., 2016b; a) and widths (Zagoruyko & Komodakis, 2016) that represent many points on the accuracy and training time curve. As shown in Figure 4a in the Appendix, a ResNet20 model achieves a top-1 error of 7.6% on CIFAR10 in 26 minutes, while a larger ResNet164 model takes 4 hours and reduces error by 2.5%. Similar results have been shown for many other tasks, including neural machine translation (Vaswani et al., 2017 ), text classification (Conneau et al., 2016) , and recommendation (He et al., 2017) . Looking across architectures gives even more options to reduce computational complexity. We exploit the limitless model architectures in deep learning to trade-off between accuracy and complexity to scale down to a proxy that can be trained quickly but still provides a good approximation of the target's decision boundary.

Training for fewer epochs. Similarly, a significant amount of training is spent on a relatively small reduction in error. While training ResNet20, almost half of the training time (i.e., 12 minutes out of 26 minutes) is spent on a 1.4% improvement in test error, as shown in Figure 4a in the Appendix.

Based on this observation, we also explored training proxy models for a smaller number of epochs to get good approximations of the decision boundary of the target model even faster.

3. RESULTS:

We applied SVP to data selection methods from active learning and core-set selection on five datasets. After a brief description of the datasets and models in Section 3.1, Section 3.2 evaluates SVP's impact on active learning and shows that across labeling budgets SVP achieved similar or higher accuracy and up to a 41.9× improvement in data selection runtime (i.e., the time it takes to repeatedly train and select points). Next, we applied SVP to the core-set selection problem (Section 3.3). For all selection methods, the target model performed nearly as well as or better with SVP than the oracle that trained the target model on all of the data before selecting examples. On CIFAR10, a small proxy model trained for 50 epochs instead of 181 epochs took only 7 minutes compared to the 4 hours for training the target model for all 181 epochs, making SVP feasible for end-to-end training time speed-ups. Finally, Section 3.4 illustrates why proxy models performed so well by evaluating how varying models and methods rank examples.

3.1. EXPERIMENTAL SETUP:

Datasets. We focused on classification as a well-studied task in the active learning literature (see Section A.1 for more detail). Our experiments included three image classification datasets: CIFAR10, CIFAR100 (Krizhevsky & Hinton, 2009) , and ImageNet (Russakovsky et al., 2015) ; and two text classification datasets: Amazon Review Polarity and Full (Zhang & LeCun, 2015; Zhang et al., 2015) . CIFAR10 is a coarse-grained classification task over 10 classes, and CIFAR100 is a fine-grained task with 100 classes. Both datasets contain 50,000 images for training and 10,000 images for testing. ImageNet has 1.28 million training images and 50,000 validation images that belong to 1 of 1,000 classes. Amazon Review Polarity has 3.6 million reviews split evenly between positive and negative ratings with an additional 400,000 reviews for testing. Amazon Review Full has 3 million reviews split evenly between the 5 stars with an additional 650,000 reviews for testing.

Models. For CIFAR10 and CIFAR100, we used ResNet164 with pre-activation from He et al. (2016b) as our large target model. The smaller, proxy models are also ResNet architectures with preactivation, but they use pairs of 3 × 3 convolutional layers as their residual unit rather than bottlenecks.

For ImageNet, we used the original ResNet architecture from He et al. (2016a) implemented in PyTorch1 (Paszke et al., 2017) with ResNet50 as the target and ResNet18 as the proxy. For Amazon Review Polarity and Amazon Review Full, we used VDCNN (Conneau et al., 2017) and fastText (Joulin et al., 2016) with VDCNN29 as the target and fastText and VDCNN9 as proxies. In general, we followed the same training procedure as the original papers (more details in Section A.2).

We explored the impact of SVP on two active learning techniques: least confidence uncertainty sampling and the greedy k-centers approach from Sener & Savarese (2018) . Starting with an initial random subset of 2% of the data, we selected 8% of the remaining unlabeled data for the first round and 10% for subsequent rounds until the labeled data reached the budget b and retrained the models from scratch between rounds as described in Section 2.1. Across datasets, SVP sped up data selection without significantly impacting the final predictive performance of the target.

CIFAR10 and CIFAR100. For least confidence uncertainty sampling and greedy k-centers, SVP sped-up data selection by up to 7× and 3.8× respectively without impacting data efficiency (see Tables 1 and 3 ) despite the proxy achieving substantially higher top-1 error than the target ResNet164 model (see Figure 6 in the Appendix). The speed-ups for least confidence were a direct reflection of the difference in training time between the proxy in the target models. As shown in Figures 4 and 5 in the Appendix, ResNet20 was about 8× faster to train than ResNet164, taking 30 minutes to train rather than 4 hours. Larger budgets required more rounds of selection and, in turn, more training, which led to larger speed-ups as training became a more significant fraction of the total time. Training for fewer epochs provided a significant error reduction compared to random sampling but was not as good as training for the full schedule (see Table 4 in the Appendix). For greedy k-centers, the speed-ups increased more slowly because executing the selection algorithm added more overhead.

ImageNet. For least confidence uncertainty sampling, SVP sped-up data selection by up to 1.6× (Table 1 ) despite ResNet18's higher error compared to ResNet50 (Figure 6g in the Appendix).

Training for fewer epochs increased the speed-up to 2.9× without increasing the error rate of ResNet50 (Table 4 ). Greedy k-centers was too slow on ImageNet due to the quadratic complexity of Algorithm 1.

Table 1 : SVP performance on active learning. Average (± 1 std.) data selection speed-ups from 3 runs of active learning using least confidence uncertainty sampling with varying proxies and labeling budgets on four datasets. Bold speed-ups indicate settings that either achieve lower error or are within 1 std. of the mean top-1 error for the baseline approach of using the same model for selection and the final predictions. Across datasets, SVP sped up selection without significantly increasing the error of the final target. Additional results and details are in Table 3 . Amazon Review Polarity and Amazon Review Full. On Amazon Review Polarity, SVP with a fastText proxy for VDCNN29 led to up to a relative error reduction of 14% over random sampling for large budgets (Table 3 ), while being up to 41.9× faster at data selection than the baseline approach (Table 1 ). Despite fastText's architectural simplicity compared to VDCNN29 and higher error (Figure 6e ), the calculated confidences signaled which examples would be the most informative. For all budgets, VDCNN9 was within 0.1% top-1 error of VDCNN29, giving a consistent 1.8× speed-up. On Amazon Review Full, neither the baseline least confidence uncertainty sampling approach nor the application of SVP outperformed random sampling (see Table 3 in the Appendix), so the data selection speed-ups were uninteresting even though they were similar to Amazon Review Polarity. For both datasets, greedy k-centers was too slow as mentioned above in the ImageNet experiments.

EQUATION

3.3. CORE-SET SELECTION:

CIFAR10 and CIFAR100. For all methods on both CIFAR10 and CIFAR100, SVP proxy models performed as well as or better than an oracle where ResNet164 itself is used as the core-set selection model, as shown in Figure 2 (and Figure 7 in the Appendix). Using forgetting events on CIFAR10, SVP with ResNet20 as the proxy removed 50% of the data without a significant increase in error from ResNet164. 11a and 12a in the Appendix). On CIFAR100, partial training did not work as well for proxies at large subset sizes because the ranking took longer to stabilize and were less correlated (Figure 11b and Figure 12b in the Appendix). On small 30% subsets with forgetting events, partial training improved accuracy on CIFAR100.

ImageNet. Neither the baseline approach nor SVP was able to remove a significant percentage of the data without increasing the final error of ResNet50, as shown in Table 5 in the Appendix. However, the selected subsets from both ResNet18 and ResNet50 outperformed random sampling with up to a 1% drop in top-1 error using forgetting events. Note, due to the quadratic computational complexity of Algorithm 1, we were unable to run greedy k-centers in a reasonable amount of time. Amazon Review Polarity and Amazon Review Full. On Amazon Review Polarity, we were able to remove 20% of the dataset with only a 0.1% increase in VDCNN29's top-1 error using fastText as the proxy (see Table 5 ). In comparison to VDCNN29, which took 16 hours and 40 minutes to train over the entire dataset on a Titan V GPU, fastText was two orders of magnitude faster, taking less than 10 minutes on a CPU to train over the same data and compute output probabilities. This difference allowed us to train VDCNN29 to nearly the same error in 13 and a half hours. However, on Amazon Review Full, both the baseline approach and SVP failed to outperform random sampling. Similar to ImageNet, we were unable to run greedy k-centers in a reasonable amount of time, and additionally, Facebook's fastText implementation2 did not allow us to compute forgetting events.

3.4. RANKING CORRELATION BETWEEN MODELS:

Models with fewer layers. Figure 3 (and Figure 9 in the appendix) shows the Spearman's rankorder correlation between ResNets of varying depth for three selection methods on CIFAR10 (and CIFAR100). For greedy k-centers, we started with 1,000 randomly selected points and ranked the remaining points based on the order they are added to set s in Algorithm 1. Across models, there was a positive correlation similar to the correlation between runs of the same model. For forgetting events and entropy, we ranked points in descending order based on the number of forgetting events and the entropy of the output predictions from the trained model, respectively. Both metrics had comparable positive correlations between different models and different runs of the same model. We also looked at the Pearson correlation coefficient for the number of forgetting events and entropy in Figure 15 in the Appendix and found a similar positive correlation. The consistent positive correlation between varying depths illustrates why small models are good proxies for larger models in data selection.

Models with different architectures. We further investigated different model architectures by calculating the Spearman's correlation between pretrained ImageNet models and found that correlations were high across a wide range of models (Figure 8 in the Appendix). For example, MobileNet V2's (Sandler et al., 2018) entropy-based rankings were highly correlated to ResNet50 (on par with ResNet18), even though the model had far fewer parameters (3.5M vs. 25.6M). In concert with our fastText and VDCNN results, the high correlations between different model architectures suggest that SVP might be widely applicable. While there are likely limits to how different architectures can be, there is a wide range of trade-offs between accuracy and computational complexity, even within a narrow spectrum of models.

4. RELATED WORK:

Active learning. There are examples in the active learning literature that address the computational efficiency of active learning methods by using one model to select points for a different, more expensive model. For instance, Lewis & Catlett (1994) proposed heterogeneous uncertainty sampling and used a Naïve Bayes classifier to select points to label for a more expensive decision tree target model. Tomanek et al. (2007) uses a committee-based active learning algorithm for an NLP task and notes that the set of selected points are "reusable" across different models (maximum entropy, conditional random field, naive Bayes). In our work, we showed that this can be generalized to deep learning by either using smaller models or fewer training epochs, where it can significantly reduce the running time of uncertainty-based (Settles, 2012; Shen et al., 2017; Gal et al., 2017) and recent representativeness-based (Sener & Savarese, 2018 ) methods.

Core-set selection. Core-set selection attempts to find a representative subset of points to speed up learning or clustering; such as k-means and k-medians (Har-Peled & Kushal, 2007) , SVM (Tsang et al., 2005) , Bayesian logistic regression (Huggins et al., 2016) , and Bayesian inference (Campbell & Broderick, 2017; 2018) . However, these examples generally require ready-to-use features as input, and do not directly apply to deep neural networks unless a feature representation is first learned, which usually requires training the full target model itself. There is also a body of work on data summarization based on submodular maximization (Wei et al., 2013; 2014; Tschiatschek et al., 2014; Ni et al., 2015) , but these techniques depend on a combination of hand-engineered features and simple models (e.g., hidden Markov models and Gaussian mixture models) pretrained on auxiliary tasks. In comparison, our work demonstrated that we can use the feature representations of smaller, faster-to-train proxy models as an effective way to select core-sets for deep learning tasks.

Recently, Toneva et al. (2019) showed that a large number of "unforgettable" examples that are rarely incorrectly classified once learned (i.e., 30% on CIFAR10) could be omitted without impacting generalization, which can be viewed as a core-set selection method. They also provide initial evidence that forgetting events are transferable across models and throughout training by using the forgetting events from ResNet18 to select a subset for WideResNet (Zagoruyko & Komodakis, 2016) and by computing the Spearman's correlation of forgetting events during training compared to their final values. In our work, we evaluated a similar idea of using proxy models to approximate various properties of a large model, and showed that proxy models closely match the rankings of large models in the entropy, greedy k-centers, and example forgetting metrics.

5. CONCLUSION:

In this work, we introduced selection via proxy (SVP) to improve the computational efficiency of active learning and core-set selection in deep learning by substituting a cheaper proxy model's representation for an expensive model's during data selection. Applied to least confidence uncertainty sampling and Sener & Savarese (2018)'s greedy k-centers approach, SVP achieved up to a 41.9× and 3.8× improvement in runtime respectively with no significant increase in error (often within 0.1%).

For core-set selection, we found that SVP can remove up to 50% of the data from CIFAR10 in 10× less time than it takes to train the target model, achieving a 1.6× speed-up in end-to-end training.

A APPENDIX A.1 CHOICE OF DATASETS:

For our experimental evaluation in Section 3, we focused on classification because it is a widely studied task in active learning (Lewis & Gale, 1994; Lewis & Catlett, 1994; Settles, 2012; Sener & Savarese, 2018; Kirsch et al., 2019; Mussmann & Liang, 2018; Gal et al., 2017; Houlsby et al., 2011) . While there are a few bespoke solutions for machine translation (Peris & Casacuberta, 2018) and named entity recognition (Shen et al., 2017) , we wanted to compare against the broader body of active learning research. Many popular active learning methods like uncertainty sampling (e.g., entropy, least confidence, and max-margin) assume a single categorical probability distribution for each example, which makes it hard to adapt to other domains. Instead of tackling open challenges for active learning like machine translation, we applied SVP to many classification datasets; however, the simplicity of SVP means that the core ideas of this paper can be applied more broadly in future work.

Specifically, we performed experiments on three image classification datasets: CIFAR10, CI-FAR100 (Krizhevsky & Hinton, 2009) , and ImageNet (Russakovsky et al., 2015) ; and two text classification datasets: Amazon Review Polarity and Full (Zhang & LeCun, 2015; Zhang et al., 2015) . While multiple tasks on roughly the same data distribution may seem redundant, the data efficiency of active learning depends on error (Mussmann & Liang, 2018) . We included both CIFAR10 (low-error) and CIFAR100 (high-error) to demonstrate that our approach performs as well as standard active learning at different points on the error and data efficiency curve. The same rationale is also valid for Amazon Review Polarity (low-error) and Full (high-error). However, the Amazon Review dataset adds a medium (text) and a much larger scale (3.6M and 3M examples, respectively). Adding ImageNet further allows us to investigate scale in the number of examples, but also the number of classes and the dimension of the input. To the best of our knowledge, we are the first active learning paper to present results on the full ImageNet classification task.

A.2 IMPLEMENTATION DETAILS CIFAR10 and CIFAR100. We used ResNet164 with pre-activation from He et al. (2016b) as our large target model for both CIFAR10 and CIFAR100. Note that as originally proposed in He et al. (2016a) , the smaller, proxy models are also ResNet architectures with pre-activation, but they use pairs of 3 × 3 convolutional layers as their residual unit rather than bottlenecks and achieve lower accuracy as shown in Figure 4 . As with He et al. (2016b) , the ResNets we used were much narrower when applied to CIFAR rather than ImageNet (256 filters rather than 2048 in the final layer of the last bottleneck) and have fewer sections, which means far fewer weights despite the increased depth. For example, ResNet50 on ImageNet has ~25M weights while ResNet164 on CIFAR has ~1.7M (see Table 2 ). More recent networks such as Wide Residual Networks (Zagoruyko & Komodakis, 2016) , ResNeXt (Xie et al., 2017) , and DenseNets (Huang et al., 2017) use models with more than 25M parameters on CIFAR10, making ResNet164 relatively small in comparison. Core-set selection experiments used a single Nvidia P100 GPU, while the active learning experiments used a Titan V GPU. We followed the same training procedure, initialization, and hyperparameters as He et al. (2016b) with the exception of weight decay, which was set to 0.0005 and decreased the model's validation error in all conditions.

ImageNet. we used the original ResNet architecture from He et al. (2016a) implemented in Py-Torch3 (Paszke et al., 2017) with ResNet50 as the target and ResNet18 as the proxy. For training, we used a custom machine with 4 Nvidia Titan V GPUs and followed Nvidia's optimized implementation4 with a larger batch size, appropriately scaled learning rate (Goyal et al., 2017) , a 5-epoch warm-up period, and mixed precision training (Micikevicius et al., 2017) with the apex5 library. For active learning, we used the same batch size of 768 images for both ResNet18 and ResNet50 for simplicity, which was the maximum batch size that could fit into memory for ResNet50. However, ResNet18 with a batch size of 768 underutilized the GPU and yielded a lower speed-up. With separate batch sizes for ResNet18 and ResNet50, we would have seen speed-ups closer to 2.7×. Amazon Review Polarity (2-classes) and Full (5-classes). For Amazon Review Polarity and Amazon Review Full, we used VDCNN (Conneau et al., 2017) and fastText (Joulin et al., 2016) with VDCNN29 as the target and fastText and VDCNN9 as proxies. For Amazon Review Polarity, core-set selection experiments used a single Nvidia P100 GPU, while the active learning experiments used a Nvidia Titan V GPU to train VDCNN models. For Amazon Review Full, core-set selection and active learning experiments both used a Nvidia Titan V GPU. In all settings, we used the same training procedure from Conneau et al. (2017) for VDCNN9 and VDCNN29. For fastText, we used Facebook's implementation6 and followed the same training procedure from Joulin et al. (2016) . Figure 6 : Quality of proxies compared to target models. Average (± 1 std.) top-1 error from 3 runs of active learning with varying proxies, selection methods, and budgets on five classification datasets. Dotted lines show the top-1 error of the proxy models, while solid lines show the top-1 error of the target models. CIFAR10 and CIFAR100 experiments used varying depths of pre-activation ResNet (R) models as proxies and ResNet164 (R164) as the target model (e.g., R20-R164 is ResNet20 selecting for ResNet164). ImageNet used ResNet18 (R18) as the proxy and ResNet50 (R50) as the target. Amazon Review Polarity and Amazon Review Full used VDCNN9 (V9) and fastText (FT) as proxies and VDCNN29 (V29) as the target. Across datasets, proxies, methods, and budgets, smaller proxies had higher top-1 error than the target model, but selecting points that were nearly as good as the points selected by the target that did not harm the final target model's predictive performance.

Table 3 : SVP performance on active learning. Average (± 1 std.) top-1 error and data selection speed-ups from 3 runs of active learning with varying proxies, methods, and labeling budgets on five datasets. Bold speed-ups indicate settings that either achieve lower error or are within 1 std. of the mean top-1 error for the baseline approach of using the same model for selection and the final predictions. Across datasets and methods, SVP sped up selection without significantly increasing the error of the final target. Correlations are high across a wide range of model architectures (Xie et al., 2017; He et al., 2016a; Sandler et al., 2018; Huang et al., 2017; Szegedy et al., 2015; Simonyan & Zisserman, 2014; Iandola et al., 2016; Krizhevsky et al., 2012) . For example, MobileNet entropy-based rankings were highly correlated to ResNet50, even though the model had far fewer parameters (3.5M vs. 25.6M).

In concert with our fastText and VDCNN results from Section 3.2, the high correlations between different model architectures suggest that SVP might be widely applicable. Rankings are calculated with forgetting events (top) and entropy (bottom). Notably, the ranking from forgetting events is much more stable because the model's uncertainty is effectively averaged throughout training rather than a single snapshot at the end like entropy. For t-SNE plots of the entire training run, please see http://bit.ly/svp-cifar10-tsne-entropy and http: //bit.ly/svp-cifar10-tsne-forget for entropy and forgetting events respectively.

:

https://pytorch.org/docs/stable/torchvision/models.html

https://github.com/facebookresearch/fastText

Code available at https://github.com/stanford-futuredata/selection-via-proxy

https://pytorch.org/docs/stable/torchvision/models.html

https://github.com/NVIDIA/DeepLearningExamples

https://github.com/NVIDIA/apex/tree/master/examples/imagenet

https://github.com/facebookresearch/fastText

Figures and Tables:

Figure1: SVP applied to active learning (left) and core-set selection (right). In active learning, we followed the same iterative procedure of training and selecting points to label as traditional approaches but replaced the target model with a cheaper-to-compute proxy model. For core-set selection, we learned a feature representation over the data using a proxy model and used it to select points to train a larger, more accurate model. In both cases, we found the proxy and target model have high rank-order correlation, leading to similar selections and downstream results.

Figure2: SVP performance on core-set selection. Average (± 1 std.) top-1 error of ResNet164 over 5 runs of core-set selection with different selection methods, proxies, and subset sizes on CIFAR10. We found subsets using forgetting events (left), entropy (middle), and greedy k-centers (right) from a proxy model trained over the entire dataset. Across datasets and selection methods, SVP performed as well as an oracle baseline but significantly faster (speed-ups in parentheses).

Figure 4: Top-1 test error on CIFAR10 for varying model sizes (left) and over the course of training a single model (right), demonstrating a large amount of time is spent on small changes in accuracy.

Figure 5: Top-1 test error on CIFAR100 for varying model sizes (left) and over the course of training a single model (right), demonstrating a large amount of time is spent on small changes in accuracy.

Figure 8: Comparing selection across model architectures on ImageNet. Spearman's correlation between max entropy rankings from PyTorch (Paszke et al., 2017) pretrained models on ImageNet.Correlations are high across a wide range of model architectures(Xie et al., 2017; He et al., 2016a;Sandler et al., 2018;Huang et al., 2017;Szegedy et al., 2015;Simonyan & Zisserman, 2014;Iandola et al., 2016;Krizhevsky et al., 2012). For example, MobileNet entropy-based rankings were highly correlated to ResNet50, even though the model had far fewer parameters (3.5M vs. 25.6M). In concert with our fastText and VDCNN results from Section 3.2, the high correlations between different model architectures suggest that SVP might be widely applicable.

Figure9: Comparing selection across model sizes and methods on CIFAR100. Average Spearman's correlation between different runs of ResNet (R) models and a varying depths. We computed rankings based on forgetting events (left), entropy (middle), and greedy k-centers (right). We saw a similarly high correlation across model architectures (off-diagonal) as between runs of the same architecture (on-diagonal), suggesting that small models are good proxies for data selection.

Figure 11: Average (± 1 std.) Spearman's rank-order correlation with ResNet164 during 5 training runs of varying ResNet architectures on CIFAR10 (left) and CIFAR100 (right), where rankings were based on forgetting events.

Figure 12: Average (± 1 std.) Spearman's rank-order correlation with ResNet164 during 5 training runs of varying ResNet architectures on CIFAR10 (left) and CIFAR100 (right), where rankings were based on entropy.

Figure 13: Average (± 1 std.) Spearman's rank-order correlation between epochs during 5 training runs of varying ResNet architectures on CIFAR10 (left) and CIFAR100 (right), where rankings were based on forgetting events.

Figure 14: Average (± 1 std.) Spearman's rank-order correlation between epochs during 5 training runs of varying ResNet architectures on CIFAR10 (left) and CIFAR100 (right), where rankings were based on entropy.

Figure 15: Pearson correlation coefficient between different runs of ResNet (R) with pre-activation and a varying number of layers on CIFAR10 (top) and CIFAR100 (bottom).For each combination, we compute the average from 20 pairs of runs. For each run, we compute rankings based on the number of forgetting events (left), and entropy of the final model (right). Generally, we see a similarly high correlation across model architectures (off-diagonal) as between runs of the same architecture (on-diagonal), providing further evidence that small models are good proxies for data selection.

Figure 16: 2D t-SNE plots from the final hidden layer of a fully trained ResNet164 model on CIFAR10 and a 30% subset selected (black). The top row uses another run of ResNet164 to select the subset and the bottom row uses ResNet20. Rankings are computed using forgetting events (left), entropy (middle), and greedy k-centers (right).

Figure17: 2D t-SNE plots from the final hidden layer of a fully trained ResNet164 model on CIFAR10 and a 30% subset selected (black) with ResNet20 trained after a varying number of epochs. Rankings are calculated with forgetting events (top) and entropy (bottom). Notably, the ranking from forgetting events is much more stable because the model's uncertainty is effectively averaged throughout training rather than a single snapshot at the end like entropy. For t-SNE plots of the entire training run, please see http://bit.ly/svp-cifar10-tsne-entropy and http: //bit.ly/svp-cifar10-tsne-forget for entropy and forgetting events respectively.

= arg max i∈[n]\s min j∈s ∆ x i , x j ; A T

Table content: <table><tr><td/><td>Algorithm 2 FORGETTING EVENTS</td></tr><tr><td>Algorithm 1 GREEDY K-CENTERS</td><td>(TONEVA ET AL., 2019)</td></tr><tr><td>(WOLF, 2011; SENER &amp; SAVARESE, 2018)</td><td>1: Initialize prev_acc i = 0, i ∈ [n]</td></tr><tr><td>Input: data x i , existing pool s 0 , trained model A T 0 , and a budget b 1: Initialize s = s 0 2: repeat 3: u 0 4: s = s ∪ {u} 5: until |s| = b + |s 0 | 6: return s \ s 0</td><td>2: Initialize forgetting_events i = 0, i ∈ [n] 3: while training is not done do 4: Sample mini-batch B from L 5: for example i ∈ B do 6: Compute acc i 7: if prev_acc i &gt; acc i then 8: forgetting_events i += 1 9:</td></tr></table>

The entire process of training ResNet20 on all the data, selecting which examples to keep, and training ResNet164 on the subset only took 2 hours and 20 minutes (see Table6in the Appendix), which was a 1.6× speed-up compared to training ResNet164 over all of the data. If we stopped training ResNet56 early and removed 50% of the data based on forgetting events from the first 50 epochs, SVP achieved an end-to-end training time speed-up of 1.8× with only a slightly higher top-1 error from ResNet164 (5.4% vs. 5.1%) as shown in Table7in the Appendix. In general, training the proxy for fewer epochs also maintained the accuracy of the target model on CIFAR10 because the ranking quickly converged (Figure

Table content: <table/>

Number of parameters in each model.

Table content: <table><tr><td>Dataset</td><td>Model</td><td>Number of Parameters (millions)</td></tr><tr><td>CIFAR10</td><td>ResNet164</td><td>1.7</td></tr><tr><td/><td>ResNet110</td><td>1.73</td></tr><tr><td/><td>ResNet56</td><td>0.86</td></tr><tr><td/><td>ResNet20</td><td>0.27</td></tr><tr><td/><td>ResNet14</td><td>0.18</td></tr><tr><td/><td>ResNet8</td><td>0.08</td></tr><tr><td>CIFAR100</td><td>ResNet164</td><td>1.73</td></tr><tr><td/><td>ResNet110</td><td>1.74</td></tr><tr><td/><td>ResNet56</td><td>0.86</td></tr><tr><td/><td>ResNet20</td><td>0.28</td></tr><tr><td/><td>ResNet14</td><td>0.18</td></tr><tr><td/><td>ResNet8</td><td>0.08</td></tr><tr><td>ImageNet</td><td>ResNet50</td><td>25.56</td></tr><tr><td/><td>ResNet18</td><td>11.69</td></tr><tr><td colspan="2">Amazon Review Polarity VDCNN29</td><td>16.64</td></tr><tr><td/><td>VDCNN9</td><td>14.17</td></tr><tr><td>Amazon Review Full</td><td>VDCNN29</td><td>16.64</td></tr><tr><td/><td>VDCNN9</td><td>14.18</td></tr></table>

Performance of training for fewer epochs on active learning. Average (± 1 std.) top-1 error and data selection speed-ups from 3 runs of active learning with varying proxies trained for a varying number of epochs on CIFAR10, CIFAR100, and ImageNet. Bold speed-ups indicate settings that either achieve lower error or are within 1 std. of the mean top-1 error for the baseline approach of using the same model for selection and the final predictions. Training for fewer epochs can provide a significant improvement over random sampling but is not quite as good as training for the full schedule.

Table content: <table><tr><td>1.8×</td></tr><tr><td>1.8×</td></tr><tr><td>1.9×</td></tr><tr><td>1.9×</td></tr></table>

Average (± 1 std.) top-1 error and runtime in minutes from 5 runs of core-set selection with varying proxies, selection methods, and subset sizes on CIFAR10 and CIFAR100.

Table content: <table><tr><td/><td>70%</td><td/></tr><tr><td>Total Runtime in Minutes</td><td>30% 50%</td><td/></tr><tr><td>Data Selection Runtime in Minutes</td><td>30% 50% 70%</td><td/></tr><tr><td/><td>70%</td><td/></tr><tr><td>Top-1 Error of ResNet164 (%)</td><td>30% 50%</td><td/></tr><tr><td/><td>Subset Size</td><td>Method Selection Model</td><td>Facility Location ResNet164 (Baseline)</td></tr><tr><td/><td/><td>Dataset</td><td>CIFAR10</td></tr></table>

Average top-1 error (± 1 std.) and runtime in minutes from 5 runs of core-set selection with varying selection methods calculated from ResNet20 models trained for a varying number of epochs on CIFAR10 and CIFAR100.

Table content: <table><tr><td>Top-1 Error of ResNet164 (%) Data Selection Runtime in Minutes Total Runtime in Minutes</td><td>30% 50% 70% 30% 50% 70% 30% 50% 70%</td><td/><td/><td>39.6 ± 0.43 30.1 ± 0.12 25.4 ± 0.39 220 ± 6.4 220 ± 6.4 220 ± 6.4 297 ± 7.3 340 ± 7.3 380 ± 7.1</td><td>46.5 ± 0.74 29.7 ± 0.45 24.2 ± 0.21 24 ± 0.6 25 ± 0.7 25 ± 0.7 105 ± 1.7 148 ± 2.6 193 ± 3.6</td><td>46.5 ± 0.52 29.7 ± 0.36 24.1 ± 0.48 14 ± 0.4 14 ± 0.3 14 ± 0.3 91 ± 0.5 135 ± 0.7 176 ± 1.5</td><td>43.3 ± 1.83 30.0 ± 0.77 24.7 ± 0.41 7 ± 0.2 7 ± 0.2 8 ± 0.2 85 ± 0.1 128 ± 1.3 170 ± 1.6</td></tr><tr><td/><td>Subset Size</td><td>Method Selection Model Epochs</td><td>Forgetting Events ResNet164 (Baseline) 181</td><td>Entropy ResNet164 (Baseline) 181</td><td>ResNet20 181</td><td>100</td><td>50</td></tr><tr><td/><td/><td>Dataset</td><td>CIFAR10</td><td/><td/><td/></tr></table>

Peer review (iclr2020):
This paper presents a method to speed up the data selection in active learning and core-set learning. The authors present a simple idea: instead of using the full model to select data points, they use a smaller model with fewer layers, potentially trained for fewer iterations. The authors show that this simple approach is able to speed up the data selection portion of both processes significantly with minimal loss in performance, and also results in significant speedup of the entire pipeline (data selection + training). This paper is timely and important -- there has been a lot of emphasis lately on the environmental costs of training deep learning models (e.g., Strubell et al., ACL 2019; Schwartz et al., 2019 arxiv:1907.10597). This paper shows that simple, almost trivial techniques can lead to significant runtime benefits for active learning and core-set learning. The authors present an extensive set of experiments that validate their hypothesis, and the paper is overall clearly written. Comments: 1. The correlation values in Figure 3 are quite diverse. It seemed *forgetting events* is much more correlated that the other two approaches. 2. Why do the authors think that SVP and their baselines failed to outperform random sampling on Amazon Review Full (towards the end of 3.3)? 3. Table 1 is very hard to interpret. I would advise the authors to look for a more succinct way to present their main findings. While this might seem contradictory, Figure 2, which is more reader-friendly, is also hard to interpret without the runtime values (nobody said visualization is easy!). 4. One thing that*s missing from this paper is training the smaller networks end-to-end. What would be the effect of using the proxy network as the main network as well? this is likely to lead to very significant runtime savings, and I wonder at what costs. Minor: 1. Towards the end of 3.2: I disagree that significant speedups are *uninteresting* if they lead to small reductions in performance.