S ELECTION VIA P ROXY : E FFICIENT D ATA S ELECTION FOR D EEP L EARNING
A BSTRACT
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 efﬁciency 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 ﬁnd that they empirically provide useful signals for data selection.
We evaluate this “selection via proxy” (SVP) approach on several data selection tasks across ﬁve 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 signiﬁcantly increasing the ﬁnal 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 ﬁnal accuracy of the target, leading to a 1 . 6 × end-to-end training time improvement.
I NTRODUCTION
Data selection methods, such as active learning and core-set selection, improve the data efﬁciency 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 (Settles, 2011; 2012; Lewis & Gale, 1994).
Conversely, core-set selection techniques start with a large labeled or unlabeled dataset and aim to ﬁnd 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 efﬁcient 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 classiﬁer (e.g., naïve Bayes) can select points to label for a much more computationally expensive classiﬁer (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, signiﬁcantly 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 signiﬁcantly lower accuracy than larger models, we surprisingly ﬁnd that they still provide useful representations to rank and select points. Speciﬁcally, 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 signiﬁcantly faster.
We empirically evaluated SVP for active learning and core-set selection on ﬁve 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 conﬁdence 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 ﬁnal 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.
M ETHODS
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 Pk in place of the target model
A Tk 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. A CTIVE L EARNING
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 (cid:96) , 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 points s = s 0 ∪ { s j ∈ [ n ] \ s 0 } j ∈ [ b − m ] to label that produces a model A s with low error. [Figure]
Baseline.
In this paper, we apply SVP to least conﬁdence 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 bK points in every round.
Following Gal et al.
; 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 Ts 0 ∪ ... ∪ s k or just A Tk for simplicity.
Then using A Tk , we either calculate the model’s conﬁdence as:
[Equation]
and select the examples with the lowest conﬁdence or extract a feature representation from the model’s ﬁnal hidden layer and compute the distance between examples (i.e., ∆( x i , x j ; A Tk ) ) 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 ﬁnal b labeled points to yield the ﬁnal model, A TK , 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 conﬁdence 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 conﬁdence 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).
(W OLF , 2011; S ENER & S AVARESE , 2018)
2. C ORE -S ET S ELECTION
Core-set selection can be broadly deﬁned as techniques that ﬁnd 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.
Speciﬁcally, 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 ﬁnd 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
[ (cid:96) ( x , y ; A s )] − E x ,y ∼ p Z (cid:2) (cid:96) ( x , y ; A [ n ] ) (cid:3)
Baseline.
To ﬁnd 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 deﬁned as the number of times an example is incorrectly classiﬁed after having been correctly classiﬁed 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 classiﬁed are treated as having an inﬁnite number of forgetting events.
Similarly, we rank examples based on the entropy from a trained target A T [ n ] as:
[Equation]
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 Ts to training the target model on the entire dataset A T [ n ] by measuring error on a held-out test set.
2. A PPLYING S ELECTION V IA P ROXY
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 Tk ) with a proxy ( A Pk ), but then trained the same ﬁnal model
A TK 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 classiﬁcation (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 signiﬁcant 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.
R ESULTS
We applied SVP to data selection methods from active learning and core-set selection on ﬁve 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. E XPERIMENTAL S ETUP
Datasets.
We focused on classiﬁcation as a well-studied task in the active learning literature (see Section A.1 for more detail).
Our experiments included three image classiﬁcation datasets: CIFAR10, CIFAR100 (Krizhevsky & Hinton, 2009), and ImageNet (Russakovsky et al., 2015); and two text classiﬁcation datasets: Amazon Review Polarity and Full (Zhang & LeCun, 2015; Zhang et al., 2015).
CIFAR10 is a coarse-grained classiﬁcation task over 10 classes, and CIFAR100 is a ﬁne-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, 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
PyTorch 1 (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).
3. A CTIVE L EARNING
We explored the impact of SVP on two active learning techniques: least conﬁdence 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 ﬁrst 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 signiﬁcantly impacting the ﬁnal predictive performance of the target.
CIFAR10 and CIFAR100.
For least conﬁdence uncertainty sampling and greedy k-centers, SVP sped-up data selection by up to 7 × and 3 . 8 × respectively without impacting data efﬁciency (see
Tables 1 and 3) despite the proxy achieving substantially higher top-1 error than the target ResNet model (see Figure 6 in the Appendix).
The speed-ups for least conﬁdence were a direct reﬂection of the difference in training time between the proxy in the target models.
As shown in Figuresand 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 signiﬁcant fraction of the total time.
Training for fewer epochs provided a signiﬁcant 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 conﬁdence 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.
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
[Table]
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 conﬁdences 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 conﬁdence 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.
3. C ORE -S ET S ELECTION
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 signiﬁcant increase in error from ResNet164.
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 Table 6 in 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 ﬁrst 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 Table 7 in the Appendix.
In general, training the proxy for fewer epochs also maintained the accuracy of the target model on CIFAR because the ranking quickly converged (Figure 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 signiﬁcant percentage of the data without increasing the ﬁnal 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
[Figure] [Figure]
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 implementation 2 did not allow us to compute forgetting events.
3. R ANKING C ORRELATION B ETWEEN M ODELS
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 coefﬁcient 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.
R ELATED W ORK
Active learning.
There are examples in the active learning literature that address the computational efﬁciency 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 classiﬁer 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 ﬁeld, 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 signiﬁcantly 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 ﬁnd 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 ﬁrst 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 classiﬁed 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 ﬁnal 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.
C ONCLUSION
In this work, we introduced selection via proxy (SVP) to improve the computational efﬁciency 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 conﬁdence 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 signiﬁcant 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, [Table] A CKNOWLEDGMENTS This research was supported in part by afﬁliate members and other supporters of the Stanford
DAWN project—Ant Financial, Facebook, Google, Infosys, NEC, and VMware—as well as Toyota Research Institute, Northrop Grumman, Amazon Web Services, Cisco, and the NSF under CAREER grant CNS-1651570. Jure Leskovec is a Chan Zuckerberg Biohub investigator. We also gratefully acknowledge the support of DARPA under Nos.
FA865018C7880 (ASED), N660011924033 (MCS);
ARO under Nos.
W911NF-16-1-0342 (MURI), W911NF-16-1-0171 (DURIP); NSF under Nos.
OAC1835598 (CINES), OAC-1934578 (HDR), DGE-1656518 (GRFP), DGE-114747 (GRFP); SNSF under Nos.
P2EZP2_172187; Stanford Data Science Initiative, Wu Tsai Neurosciences Institute, Chan Zuckerberg Biohub, JD.com, Amazon, Boeing, Docomo, Huawei, Hitachi, Observe, Siemens, UST Global. The U.S. Government is authorized to reproduce and distribute reprints for Governmental purposes notwithstanding any copyright notation thereon.
Any opinions, ﬁndings, and conclusions or recommendations expressed in this material are those of the authors and do not necessarily reﬂect the views, policies, or endorsements, either expressed or implied, of SNSF, NSF, DARPA, NIH, ARO, or the U.S. Government.
A A PPENDIX A. C HOICE OF DATASETS
For our experimental evaluation in Section 3, we focused on classiﬁcation 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 conﬁdence, 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 classiﬁcation datasets; however, the simplicity of SVP means that the core ideas of this paper can be applied more broadly in future work.
Speciﬁcally, we performed experiments on three image classiﬁcation datasets: CIFAR10, CIFAR100 (Krizhevsky & Hinton, 2009), and ImageNet (Russakovsky et al., 2015); and two text classiﬁcation 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 efﬁciency 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 efﬁciency 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 ﬁrst active learning paper to present results on the full ImageNet classiﬁcation task.
A. I MPLEMENTATION 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 ﬁlters rather than 2048 in the ﬁnal 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 PyTorch 3 (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 implementation 4 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 apex 5 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 ﬁt 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 × .
[Table]
Amazon Review Polarity (2-classes) and Full (5-classes).
For Amazon Review Polarity and Amazon Review Full [Table] 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 implementation 6 and followed the same training procedure from Joulin et al.
A. M OTIVATION FOR C REATING P ROXIES
[Figure]
[Table]
[Figure] [Figure]
[Figure]
A. A DDITIONAL A CTIVE L EARNING R ESULTS
[Figure]
T a b l e 3 :
S V P p
e r f o r m a n ce o n a c t
i v e l e a r n i n g .
A v e r a g e ( ± 1 s t d . )
t ope rr o r a nd d a t
a s e l ec ti on s p ee d - up s fr o mr un s o f
ac ti v e l ea r n i ng w it h v a r
y
i ng p r ox i e s , m e t hod s , a nd l a b e li
ng budg e t s on ﬁ v e d a t a s e t s .
B o l d s p ee d - up s i nd
i ca t e s e tti ng s t h a t e it
h
e r
ac
h
i e v e l o w e r e rr o r
o
r
a r e w it h
i ns t d .
o f t
h e m ea n t op - 1 e rr o r f o r t
h e b a s e li n e a pp r o ac h
o f u s i
ng t h e s a m e m od e l f o
r s e l ec ti on a nd t
h e ﬁ n a l p r
e
d i c ti on s .
A c r o ss d a t a s e t s a nd m e t hod s ,
S V P s p e d up s e l ec ti on w it hou t
s i
gn
i ﬁ ca n tl y i n c r ea s i
ng t h e e r r o r o f t
h e ﬁ n a l t
a r g e t .
T o p1 E rr o r o f T a r g e t M o d e l ( % )
D a t a
S e l ec t i o n
Sp ee
d - up
B ud g e t ( b / n ) 10 % 20 % 30 % 40 % 5 0 % 1 0 % 20 % 3 0 % 4 0 % 50 %
D a t a s e t
M e t h o d
S e l ec t i o n
M o d e l
C
I F
A
R
R a ndo m20 .± 0 .
12 .± 0 .
10 .± 0 .
8 .± 0 .
7 .± 0 .
L e a s t
R e s N e t
( B a s e li n e ) 18 .± 0 .
10 .± 0 .
7 .± 0 .
6 .± 0 .
5 .± 0 .
× 1 .
[-× 1 . 
-]
× 1 .
[Table] [Table]
C on ﬁ d e n ce
R e s N e t18 .± 0 .
10 .± 0 .
7 .± 0 .
5 .± 0 .
5 .± 0 .
1 . 8 × 1 . 9 × 1 . 9 × 1 .
[Table]
R e s N e t18 .± 0 .
10 .± 0 .
7 .± 0 .
6 .± 0 .
5 .± 0 .
6 × 2 .
9 × 3 .
× 3 .
1 × 3 .
[Table]
R e s N e t18 .
[Table]
[Table]
[Table]
dy
[Table]
[Table]
[Table]
ndo
[Table]
L e a s t
R e s N e t
( B a s e li n e ) 61 .± 1 .
42 .± 0 .
33 .± 0 .
29 .± 0 .
26 .± 0 .
× 1 .
× 1 . 
 × 1 . {+
 × 1 . 
+}
×
C on ﬁ d e n ce
R e s N e t60 .± 0 .
42 .± 0 .
34 .± 0 .
29 .± 0 .
27 .± 0 .
5 × 1 . 6 × 1 . 6 × 1 . 6 × 1 . 6 ×
R e s N e t61 .± 0 .
42 .± 0 .
33 .± 0 .
29 .± 0 .
26 .± 0 .
4 × 2 .
7 × 3 .
× 2 .
9 × 3 . 1 ×
R e s N e t62 .±
41 .± 0 .
33 .± 0 .
29 .± 0 .
26 .± 0 .
× 5 . 8 × 6 . 6 × 7 .
× 7 . 2 ×
G r ee dy
R e s N e t
( B a s e li n e ) 60 .± 1 .
42 .± 0 .
34 .± 0 .
30 .± 0 .
27 .± 0 .
× 1 . 
 × 1 .
× {+1 . 
 × 1 . 
+}
× k - C e n t e r s
R e s N e t59 .±
[Table]
T a b l e 4 : P er f
o r m a n ce o f t r a i n i n g f o r f e
w
er
e p o c h s o n a c t
i v e l e a r n i n g .
A v e r a g e ( ±s t d . )
t op1 e rr o r a nd d a t a s e l ec ti on s p ee dup s fr o m 3 r un s o f ac ti v e l ea r n i
ng w it h v a r
y
i ng p r ox i e s t
r
a
i n e d f o r a v a r y
i ng nu m b e r o f e po c h s on
C
I F
A R 10 ,
C
I F
A R 100 , a nd
I m a g e N e t .
B o l d s p ee d - up s i nd
i ca t e s e tti ng s t h a t e it
h
e r
ac
h
i e v e l o w e r e rr o r
o
r
a r e w it h
i n 1 s t d .
o f t
h e m ea n t op - 1 e rr o r f o r t
h e b a s e li n e a pp r o ac h
o f u s i
ng t h e s a m e m od e l f o
r s e l ec ti on a nd t
h e ﬁ n a l p r
e
d i c ti on s .
T r a i n i ng f o r f
e w e r e po
c h s ca n p r ov i d e a s i
gn
i ﬁ ca n t i m p r
ov e m e n t ov e r r a ndo m s a m p li
ng bu t i s no t qu it e a s good a s t r a i n i ng f o r t h e f u
ll s c h e du l e .
T o pE rr
o r o f T a r g e t
M o d e l [Table]
t
[Table]
n
[Table]
e t
[Table]
/ n )
[Table]
D a t a s e t
M e t h o d
S e l ec t i o n
M o d e l
E p o c h s
C
I F
A
R
R a ndo m
[Table]
[-a s e li n e ) 
 [Table] R e s N e t118 .-]L
[Table]
A. A DDITIONAL C ORE -S ET S ELECTION R ESULTS
[Figure]
[Table]
T a b l e 6 : A v e r a g e ( ±s t d . )
t op1 e rr o r a nd r un ti m e i n m i nu t e s f r o m 5 r un s o f c o r es e t s e l ec ti on w it h v a r
y
i ng p r ox i e s , s e l ec ti on m e t hod s , a nd s ub s e t
s i ze s on
C
I F
A R a nd
C
I F
A R 100 .
T o pE rr
o r o f
R e s N e t
D a t a
S e l ec t i o n
R un t i m e i n
M i nu t e s
T o t a l
R un t i m e i n
M i nu t e s
Sub s e t
S i ze 30 % 50 % 70 % 30 % 50 % 70 % 30 % 50 % 70 %
D a t a s e t
M e t h o d
S e l ec t i o n M o d e l
C
I F
A
R
F ac ilit y
L o ca ti on
R e s N e t
( B a s e li n e ) 8 .± 0 .6 .± 0 .5 .± 0 . ± 48 . ± 91 . ± 42 . ± 47 .
± 94 . ± 41 .
R e s N e t9 .±
.6 .±
.5 .±
.27 ± 1 .28 ± 1 .30 ± 2 . ± 1 .
[Table]
± 2 . ± 1 .
[Table]
R e s N e {+t9 .± 
+}
{+.6 .± 
+}
.5 .±
.63 ± 4 .63 ± 4 .63 ± 4 . ± 4 . ± 4 .
[Table]
C
I F
A
R
F ac i lit y L o ca ti on
R e s N e t
( B a s e li n e ) 40 .±
.29 .± {+
 .24 .±+} 0 . ±
[Table]
±
[Table]
[Table]
[Table]
[Table]
[Table]
R e s N e t35 .±
.28 .± {+
+}
{+.24 .± 
+}
{+.27 ± 
 .28 ± 1 .30 ± 1 .+}
[Table] [Table]
[Table]
R e s N e t40 .±
.29 .± {+
+}
{+.24 .± 
 .64 ± 1 .66 ± 1 .67 ± 2 .+}
± 1 .
[Table]
R e s N e t42 {+.± 
+}
.29 .± 0 .24 .± 0 .
± 3 . ± 3 .
± 3 . ± 7 . ± 8 .
[Table]
[Table]
F o r g e tti ng
E v e n t s
R e s N e t
( B a s e li n e ) 36 .±
.27 .± {+
 .23 .±+} 0 .
[Table]
e
[Table]
T a b l e 7 :
A v e r a g e t op1 e rr o r
( ±s t d . )
a nd r un ti m e i n m i nu t e s fr o m 5 r un s o f c o r e - s e t s e l ec
[Table]
on w
[Table]
h v a r y
[Table]
ng
[Table]
on
[Table]
t r a i n e d f o r a v a r y
i
ng nu m b e r
o f e po c h s on C I F
A R 10 a nd C I F A R
[Table]
s
[Table]
D a t a s e t
[Table]
e t
[Table]
o d
S e l
[Table]
t i o n M o d e l E p o c
[Table]
s C I F
A
R F o r g e tti ng
E v e n t s R e s N e t
[Table]
A. A DDITIONAL C ORRELATION R ESULTS
[Table]
MobileNet
[Table]
GoogleNet (
[Table]
VGG-11 w/ BatchNorm (132.9M)
VGG-13 w/ BatchNorm (133.1M)
VGG-16 w/ BatchNorm (138.4M)
VGG-19 w/ BatchNorm (143.7M)
[Table]
1.0 (1.2M)
SqueezeNet 1.1 (1.2M)
AlexNet (
[Table]
1M
[Table]
[Figure]
Zisserman
For example, MobileNet V2’s 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.
[Figure]
[Figure] [Figure]
[Figure] [Figure]
[Figure] [Figure]
[Figure] [Figure]