Year: 2020

Abstract:
The impressive performance exhibited by modern machine learning models hinges on the ability to train such models on a very large amounts of labeled data. However, since access to large volumes of labeled data is often limited or expensive, it is desirable to alleviate this bottleneck by carefully curating the training set. Optimal experimental design is a well-established paradigm for selecting data point to be labeled so to maximally inform the learning process. Unfortunately, classical theory on optimal experimental design focuses on selecting examples in order to learn underparameterized (and thus, non-interpolative) models, while modern machine learning models such as deep neural networks are overparameterized, and oftentimes are trained to be interpolative. As such, classical experimental design methods are not applicable in many modern learning setups. Indeed, the predictive performance of underparameterized models tends to be variance dominated, so classical experimental design focuses on variance reduction, while the predictive performance of overparameterized models can also be, as is shown in this paper, bias dominated or of mixed nature. In this paper we propose a design strategy that is well suited for overparameterized regression and interpolation, and we demonstrate the applicability of our method in the context of deep learning by proposing a new algorithm for single shot deep active learning.

heading: 1 INTRODUCTION
text: The impressive performance exhibited by modern machine learning models hinges on the ability to train the aforementioned models on a very large amounts of labeled data. In practice, in many real world scenarios, even when raw data exists aplenty, acquiring labels might prove challenging and/or expensive. This severely limits the ability to deploy machine learning capabilities in real world applications. This bottleneck has been recognized early on, and methods to alleviate it have been suggested. Most relevant for our work is the large body of research on active learning or optimal experimental design, which aims at selecting data point to be labeled so to maximally inform the learning process. Disappointedly, active learning techniques seem to deliver mostly lukewarm benefits in the context of deep learning.
One possible reason why experimental design has so far failed to make an impact in the context of deep learning is that such models are overparameterized, and oftentimes are trained to be interpolative (Zhang et al., 2017), i.e., they are trained so that a perfect fit of the training data is found. This raises a conundrum: the classical perspective on statistical learning theory is that overfitting should be avoided since there is a tradeoff between the fit and complexity of the model. This conundrum is exemplified by the double descent phenomena (Belkin et al., 2019b; Bartlett et al., 2020), namely when fixing the model size and increasing the amount of training data, the predictive performance initially goes down, and then starts to go up, exploding when the amount of training data approaches the model complexity, and then starts to descend again. This runs counter to statistical intuition which says that more data implies better learning. Indeed, when using interpolative models, more data can hurt (Nakkiran et al., 2020a)! This phenomena is exemplified in the curve labeled “Random Selection” in Figure 1. Figure 1 explores the predictive performance of various designs when learning a linear regression model and varying the amount of training data with responses.
The fact that more data can hurt further motivates experimental design in the interpolative regime. Presumably, if data is carefully curated, more data should never hurt. Unfortunately, classical optimal experimental design focuses on the underparameterized (and thus, noninterpolative) case. As such, the theory reported in the literature is often not applicable in the interpolative regime. As our analysis shows (see Section 3), the prediction error of interpolative models can either be bias dominated (the first descent phase, i.e., when training size is very small compared to the number of parameters), variance dominated (near equality of size and parameters) or of mixed nature. However, properly trained underparameterized models tend to have prediction error which is variance dominated, so classical experimental design focuses on variance reduction. As such, naively using
classical optimality criteria, such as V-optimality (the one most relevant for generalization error) or others, in the context of interpolation, tends to produce poor results when prediction error is bias dominated or of mixed nature. This is exemplified in the curve labeled “Classical OED” in Figure 1.
The goal of this paper is to understand these regimes, and to propose an experimental design strategy that is well suited for overparameterized models. Like many recent work that attempt to understand the double descent phenomena by analyzing underdetermined linear regression, we too use a simple linear regression model in our analysis of experimental design in the overparameterized case (however, we also consider kernel ridge regression, not only linear interpolative models). We believe that understanding experimental design in the overparameterized linear regression case is a prelude to designing effective design algorithms for deep learning. Indeed, recent theoretical results showed a deep connection between deep learning and kernel learning via the so-called Neural Tangent Kernel (Jacot et al., 2018; Arora et al., 2019a; Lee et al., 2019). Based on this connection, and as a proof-of-concept, we propose a new algorithm for single shot deep active learning.
Let us now summarize our contributions:
• We analyze the prediction error of learning overparameterized linear models for a given fixed design, revealing three possible regimes that call for different design criteria: bias dominated, variance dominated, and mixed nature. We also reveal an interesting connection between overparameterized experimental design and the column subset selection problem (Boutsidis et al., 2009), transductive experimental design (Yu et al., 2006), and coresets (Sener & Savarese, 2018). We also extend our approach to kernel ridge regression. • We propose a novel greedy algorithm for finding designs for overparameterized linear
models. As exemplified in the curve labeled “Overparameterized OED”, our algorithm is sometimes able to mitigate the double descent phenomena, while still performing better than classical OED (though no formal proof of this fact is provided). • We show how our algorithm can also be applied for kernel ridge regression, and report
experiments which show that when the number of parameters is in a sense infinite, our algorithm is able to find designs that are better than state of the art. • We propose a new algorithm for single shot deep active learning, a scaracly treated problem
so far, and demonstrate its effectiveness on MNIST.
Related Work. The phenomena of benign overfitting and double descent was firstly recognized in DNNs (Zhang et al., 2017), and later discussed and analyzed in the context of linear models (Zhang et al., 2017; Belkin et al., 2018; 2019a;b; Bartlett et al., 2020). Recently there is also a growing interest in the related phenomena of “more data can hurt” (Nakkiran et al., 2020a; Nakkiran, 2019; Nakkiran et al., 2020b; Loog et al., 2019). A complementary work discussed the need to consider zero or negative regularization coefficient for large real life linear models (Kobak et al., 2020).
Experimental design is an well established paradigm in statistics, extensively covered in the literature for the linear case (Pukelsheim, 2006) and the non linear case (Pronzato & Pázman, 2013). The application of it to pool based active learning with batch acquisitions was explored by Yu et al. (2006) for linear models and by Hoi et al. (2006) for logistic regression. It was also proposed in the context of deep learning (Sourati et al., 2018). Another related line of work is recent work by Haber and Horesh on experimental design for ill-posed inverse problems(Haber et al., 2008; 2012; Horesh et al., 2010). Active learning in the context of overparameterized learning was explored by Karzand & Nowak (2020), however their approach differs from ours significantly since it is based on artificially completing the labels using a minimax approach.
I the context of Laplacian regularized Least Squares (LapRLS), which is a generalization of ridge regression, Gu et al. (2012) showed rigorously that Yu et al. (2006) criterion is justified as a bound for both the bias and variance components of the expected error. We farther show that this bound is in some sense tight only if the parameter norm is oneand the noise variance equals the l2 penalty coefficient. In addition we postulate and show experimentally that in the overparameterized case using a bias dominant criterion is preferable. Another case in which the bias term idoes not vanish is when the model is misspecified. For linear and generalized linear models this case has been tackled with reweighing of the loss function.
A popular modern approach for pool based active learning with batch acquisition is coresets (Sener & Savarese, 2018; Geifman & El-Yaniv, 2017; Ash et al., 2019; Pinsler et al., 2019). This approach has been used in the context of active learning for DNNs.

heading: 2 UNDERPARAMETERIZED V-OPTIMAL EXPERIMENTAL DESIGN
text: Consider a noisy linear response model y = xTw + , where ∼ N (0, σ2) and w ∈ Rd and assume we are given with some data points x1, . . . ,xn, for which we obtained independent responses, yi = x T iw + i. Consider the underparameterized case, i.e. n ≥ d, and furthermore assume that the set {x1, . . . ,xn} contains at least d independent vectors. The best linear unbiased estimator ŵ of w according to the Gauss-Markov theorem is given by: ŵ = arg minw ‖Xw − y‖22 = X +y where X ∈ Rn×d is a matrix whose rows are x1, . . . ,xn, y = [y1 . . . yn]T ∈ Rn and X+ is the Moore-Pensrose pseudoinverse of X. It is well known that ŵ −w is a normal random vector with zero mean and covariance matrix σ2M−1, where M = XTX is the Fisher information matrix. This implies that ŷ(x)− y(x) is also a normal variable with zero mean and variance equal to σ2xTM−1x. Assume also that x comes from a distribution ρ. With that we can further define the excess risk R(ŵ) = Ex∼ρ [ (xTw − xTŵ)2 ] and its expectation:
E [R(ŵ)] = Ex∼ρ [Var [y(x)− ŷ(x)]] = Ex∼ρ [ σ2xTM−1x ] = Tr ( σ2M−1Cρ ) (1)
where Cρ is the uncentered second moment matrix of ρ: Cρ := Ex∼ρ [ xxT ] .
Eq. (1) motivates the so-called V-optimal design criterion: select the dataset x1, . . . ,xn so that ϕ(M) := Tr ( M−1Cρ ) is minimized (if we do not have access to Cρ then it is possible to estimate it by drawing samples from ρ). In doing so, we are trying to minimize the expected (with respect to the noise ) average (with respect to the data x) prediction variance, since the risk is composed solely from it (due to the fact that the estimator is unbiased). As we shall see, this is in contrast with the overparameterized case, in which the estimator is biased.
V-optimality is only one instance of various statistical criteria used in experimental design. In general experimental design, the focus is on minimizing a preselected criteria ϕ (M) (Pukelsheim, 2006). For example in D-optimal design, ϕ(M) = det(M−1) and in A-optimal design ϕ(M) = Tr ( M−1 ) . However, since minimizing the V-optimality criterion corresponds to minimizing the risk, it is more appropriate when assessing the predictive performance of machine learning models.

heading: 3 OVERPARAMETERIZED EXPERIMENTAL DESIGN CRITERIA
text: In this section we derive an expression for the risk in the overparameterized case, i.e. like Eq. (1) but also for the case that n ≤ d (our expressions also hold for n > d). This, in turn, leads to an
experimental design criteria analogous to V-optimality, but relevant for overparamterized modeling as well. We design a novel algorithm based on this criteria in subsequent sections.

heading: 3.1 OVERPARAMETERIZED REGRESSION AND INTERPOLATION
text: When n ≥ d there is a natural candidate for ŵ: the best unbiased linear estimator X+y1. However, when d > n there is no longer a unique minimizer of ‖Xw − y‖22 as there is an infinite amount of interpolating w’s, i.e. w’s such that Xw = y (the last statement makes the mild additional assumption that X has full row rank). One natural strategy for dealing with the non-uniqueness is to consider the minimum norm interpolator:
ŵ := arg min ‖w‖22 s.t. Xw = y
It is still the case that ŵ = X+y. Another option for dealing with non-uniqueness of the minimizer is to add a ridge term, i.e., add and additive penalty λ‖w‖22. Let:
ŵλ := arg min ‖Xw − y‖22 + λ‖w‖22 One can show that
ŵλ = X + λ y (2) where for λ ≥ 0 we define X+λ := ( XTX + λId )+ XT (see also Bardow (2008)). Note that Eq. (2) holds both for the overparameterized (d ≥ n) and underparameterized (d < n) case. Proposition 1. The function λ 7→ X+λ is continuous for all λ ≥ 0.
The proof, like all of our proofs, is delegated to the appendix. Thus, we also have that the minimum norm interpolator ŵ is equal to ŵ0, and that λ 7→ ŵλ is continuous. This implies that the various expressions for the expected risk of ŵλ hold also when λ = 0. So, henceforth we analyze the expected risk of ŵλ and the results also apply for ŵ.
3.2 EXPECTED RISK OF ŵλ
The following proposition gives an expression for the expected risk of the regularized estimator ŵλ. Note that it holds both for the overparameterized (d ≥ n) and underparameterized (d < n) case. Proposition 2. We have
E [R(ŵλ)] = ‖C 1/2 ρ ( I−M+λM ) w‖22︸ ︷︷ ︸
bias
+σ2Tr ( CρM +2 λ M )
︸ ︷︷ ︸ variance
where Mλ := XTX + λId = M + λId. The expectation is with respect to the training noise .
The last proposition motivates the following design criterion, which can be viewed as a generalization of classical V-optimality:
ϕλ(M) := ‖C 1/2 ρ ( I−M+λM ) w‖22 + σ2Tr ( CρM +2 λ M ) .
For λ = 0 the expression simplifies to the following expression:
ϕ0 (M) = ‖C 1/2 ρ (I−PM)w‖22 + σ2Tr ( CρM + )
where PM = M+M is the projection on the row space of X. Note that when n ≥ d and X has full column rank, ϕ0(M) reduces to the variance of underparameterized linear regression, so minimizing ϕλ(M) is indeed a generalization of the V-optimality criterion.
Note the bias-variance tradeoff in ϕλ(M). When the bias term is much larger than the variance, something we should expect for small n, then it make sense for the design algorithm to be bias oriented. When the variance is larger, something we should expect for n ≈ d or n ≥ d, then the design algorithm should be variance oriented. It is also possible to have mixed nature in which both bias and variance are of the same order.
1In practice, when n is only mildly bigger than d it is usually better to regularize the problem.

heading: 3.3 PRACTICAL CRITERION
text: As is, ϕλ is problematic as an experimental design criterion since it depends both on w and on Cρ. We discuss how to handle an unknown Cρ in Subsection 3.5. Here we discuss how to handle an unknown w. Note that obviously w is unknown: it is exactly what we want to approximate! If we have a good guess w̃ for the true value of w, then we can replace w with w̃ in ϕλ. However, in many cases, such an approximation is not available. Instead, we suggest to replace the bias component with an upper bound: ‖C1/2ρ ( I−M+λM ) w‖22 ≤ ‖w‖22 · ‖C 1/2 ρ ( I−M+λM ) ‖2F .
Let us now define a new design criterion which has an additional parameter t ≥ 0:
ϕ̄λ,t(M) = ‖C 1/2 ρ ( I−M+λM ) ‖2F︸ ︷︷ ︸
bias bound (divided by ‖w‖22)
+ tTr ( CρM + λ 2 M )
︸ ︷︷ ︸ variance (divided by ‖w‖22) .
The parameter t captures an a-priori assumption on the tradeoff between bias and variance: if we have t = σ2/‖w‖22, then ϕλ(M) ≤ ‖w‖22 · ϕ̄λ,t(M) . Thus, minimizing ϕ̄λ,t(M) corresponds to minimizing an upper bound of ϕλ, if t is set correctly.
Another interpretation of ϕ̄λ,t(M) is as follows. If we assume that w ∼ N (0, γ2Id), then
Ew [ϕλ(M)] = γ2‖C 1/2 ρ ( I−M+λM ) ‖2F + σ2Tr ( CρM +2 λ M )
so if we set t = σ2/γ2 then γ2ϕ̄λ,t(M) = Ew [ϕλ(M)], so minimizing ϕ̄λ,t(M) corresponds to minimizing the expected expected risk if t is set correctly. Again, the parameter t captures an a-priori assumption on the tradeoff between bias and variance. Remark 1. One alternative strategy for dealing with the fact that w is unknown is to consider a sequential setup where batches are acquired incrementally based on increasingly refined approximations of w. Such a strategy falls under the heading of Sequential Experimental Design. In this paper, we focus on single shot experimental design, i.e. examples are chosen to be labeled once. We leave sequential experimental design to future research. Although, we decided to focus on the single shot scenario for simplicity, the single shot scenario actually captures important real-life scenarios.

heading: 3.4 COMPARISON TO OTHER GENERALIZED V-OPTIMALITY CRITERIA
text: Consider the case of λ = 0. Note that we can write: ϕ̄0,t(M) = ‖C 1/2 ρ (I−PM) ‖2F +tTr ( CρM + ) .
Recall that the classical V-optimal experimental design criterion is Tr ( CρM −1), which is only applicable if n ≥ d (otherwise, M is not invertible). Indeed, if n ≥ d and M is invertible, then PM = Id and ϕ̄0,t(M) is equal to Tr ( CρM
−1) up to a constant factor. However, M is not invertible if n < d and the expression Tr ( CρM
−1) does not make sense. One naive generalization of classical V-optimality for n < d would be to simply replace the inverse with pseudoinverse, i.e. Tr ( CρM + ) . This corresponds to minimizing only the variance term, i.e. taking t → ∞. This is consistent with classical experimental design which focuses on variance reduction, and is appropriate when the risk is variance dominated.
Another generalization of V-optimality can be obtained by replacing M with its regularized (and invertible) version Mµ = M+µId for some chosen µ > 0, obtaining Tr ( CρM −1 µ ) . This is exactly the strategy employed in transductive experimental design (Yu et al., 2006), and it also emerges in a Bayesian setup (Chaloner & Verdinelli, 1995). One can try to eliminate the parameter µ by taking the limit of the minimizers when µ→ 0. The following proposition shows that this is actually equivalent to taking t = 0. Proposition 3. For a compact domain Ω ⊂ Rd×d of symmetric positive semidefinite matrices:
lim µ→0 argmin M∈Ω
Tr ( CρM −1 µ ) ⊆ argmin
M∈Ω Tr (Cρ (I−PM)) .
We see that the aforementioned generalizations of V-optimality correspond to either disregarding the bias term (t =∞) or disregarding the variance term (t = 0). However, using ϕ̄0,t(M) allows much better control over the bias-variance tradeoff (see Figure 1.)
Let us consider now the case of λ > 0. We now show that the regularized criteria Tr ( CρM −1 µ ) used in transductive experimental design (See Proposition 3) when µ = λ corresponds to also using t = λ.
Proposition 4. For any matrix space Ω, λ > 0: argminX∈Ω Tr ( CρM −1 λ ) = argminX∈Ω ϕ̄λ,λ(M)
So, transductive experimental design corresponds to a specific choice of bias-variance tradeoff. Another interesting relation with transductive experimental design is given by next proposition which is a small modification of Theorem 1 due to Gu et al. (2012) .
Proposition 5. For any λ > 0 and t ≥ 0: ϕ̄λ,t(M) ≤ (λ+ t)Tr ( CρM −1 λ ) In the absence of a decent model of the noise, which is a typical situation in machine learning, Prop. 5 suggests the to perhaps minimize only Tr ( CρM −1 λ ) without need to set t. However, this approach may be suboptimal in the overparameterized regime. This approach implicitly considers t = λ (see Prop. 4) which in a bias dominated regime can put too much emphasis on minimizing the variance. A sequential approach for experimental design can lead to better modeling of the noise, thereby assisting in dynamically setting t during acquisition-learning cycles. However, in a single shot regime, noise estimation is difficult. Arguably, there exists better values for t than using a default rule-of-thumb t = λ. In particular, we conjecture that t = 0 is a better rule-of-thumb then t = λ for severely overparameterized regimes as it suppresses the potential damage of choosing a too large λ and it is reasonale also if λ is small (since anyway we are in a bias dominated regime), so we can focus on minimizing the bias only. In the experiment section we show an experiment that supports this assumption. Notice that t =∞ corresponds to minimizing the variance, while t = 0 corresponds to minimizing the bias.
3.5 APPROXIMATING Cρ
Our criteria so far depended on Cρ. Oftentimes Cρ is unknown. However, it can be approximated using unlabeled data. Suppose we have m unlabeled points (i.e. drawn form ρ), and suppose we write them as the rows of V ∈ Rm×d. Then E [ m−1VTV ] = Cρ. Thus, we can write
mϕλ(M) ≈ ψλ(M) := ‖V ( Id −M+λM ) w‖22 + σ2Tr ( VM+ 2 λ MV T ) , λ ≥ 0.
and use ψλ(M) instead of ϕλ(M). For minimum norm interpolation we have ψ0(M) = ‖V (Id −PM)w‖22 + σ2Tr ( VM+VT ) .
Again, let us turn this into a practical design criteria by introducing an additional parameter t:
ψ̄λ,t(M) := ‖V ( Id −M+λM ) ‖2F + tTr ( VM+ 2 λ MV T ) . (3)

heading: 4 POOL-BASED OVERPARAMETERIZED EXPERIMENTAL DESIGN
text: In the previous section we defined design criteria ϕ̄λ,t and ψ̄λ,t that are appropriate for overparameterized linear regression. While one can envision a situation in which such we are free to choose X so to minimize the design criteria, in much more realistic pool-based active learning we assume that we are given in advance a large pool of unlabeled data x1, . . . ,xm. The training set is chosen to be a subset of the pool. This subset is then labeled, and learning performed. The goal of pool-based experimental design algorithms is to chose the subset to be labeled.
We formalize the pool-based setup as follows. Recall that to approximate Cρ we assumed we have a pool of unlabeled data written as the rows of V ∈ Rm×d. We assume that V serves also as the pool of samples from which X is selected. For a matrix A and index sets S ⊆ [n], T ⊆ [d], let AS,T be the matrix obtained by restricting to the rows whose index is in S and the columns whose index is in T . If : appears instead of an index set, that denotes the full index set corresponding to that dimension. Our goal is to select a subset S of cardinality n such that ψ̄λ,t(VTS,:VS,:) is minimized (i.e., setting X = VS,:). Formally, we pose following problem:
Problem 1. (Pool-based Overparameterized V-Optimal Design) Given a pool of unlabeled examples V ∈ Rm×d, a regularization parameter λ ≥ 0, a bias-variance tradeoff parameter t ≥ 0, and a design size n, find a minimizer of
min S⊆[m], |S|=n
ψ̄λ,t(V T S,:VS,:).
Problem 1 is a generalization of the Column Subset Selection Problem (CSSP) (Boutsidis et al., 2009). In the CSSP, we are given matrix U ∈ Rd×m and target number of columns n, and our goal is to select a subset T which is a minimizer of
min T ⊆[m], |T |=n
‖(Id −U:,TU+:,T )U‖2F
When λ = 0 and t = 0, Problem 1 reduces to the CSSP for U = VT. The λ = t = 0 case is also somewhat related to the coreset approach for active learning Sener & Savarese (2018); Pinsler et al. (2019); Ash et al. (2019); Geifman & El-Yaniv (2017). See Appendix B.

heading: 5 OPTIMIZATION ALGORITHM
text: In this section we propose an algorithm for overparameterized experimental design. Our algorithm is based on greedy minimization of a kernalized version of ψ̄λ,t(VTS,:VS,:). Thus, before presenting our algorithm, we show how to handle feature spaces defined by a kernel.
Kernelization. If |S| ≤ d and VS,: has full row rank we have (VS,:)+λ = VTS,: ( VS,:V T S,: + λI|S| )−1 which allows us to write
ψ̄λ,t(V T S,:VS,:) = Tr ( V [ I− 2VTS,: ( VS,:V T S,: + λI|S| )−1 VS,: ] VT )
+Tr ( VVTS,: ( VS,:V T S,: + λI|S| )−1 VS,:V T S,: ( VS,:V T S,: + λI|S| )−1 VS,:V T )
+tTr ( VVTS,: ( VS,:V T S,: + λI|S| )−2 VS,:V T )
Let now K := VVT ∈ Rm×m. Then VS,:VTS,: = KS,S and VV T S,: = K:,S . Since Tr (K) is constant, minimizing ψ̄λ,t(VTS,:VS,:) is equivalent to minimizing
Jλ,t(S) := Tr ( K:,S [( KS,S + λI|S| )−1 (−2I|S| + KS,S (KS,S + λI|S|)−1)+ t (KS,S + λI|S|)−2]KT:,S) . (4)
For λ = 0 we have a simpler form: J0,t(S) = Tr ( K:,S [ −K−1S,S + tK −2 S,S ] KT:,S ) .
Interestingly, when λ = 0 and t = 0, minimizing J0,0(S) is equivalent to maximizing the trace of the Nystrom approximation of K. Another case for which Eq. (4) simplifies is t = λ (this equation was already derived in Yu et al. (2006)):
Jλ,λ(S) = Tr ( −K:,S ( KS,S + λI|S| )−1 KT:,S ) .
Eq. (4) allows us, via the kernel trick, to perform experimental design for learning of nonlinear models defined using high dimensional feature maps. Denote our unlabeled pool of data by z1, . . . , zm ∈ RD, and that we are using a feature map φ : Rd → H whereH is some Hilbert space (e.g.,H = Rd), i.e. the regression function is y(z) = 〈φ(z),w〉H. We can then envision the pool of data to be defined by xj = φ(zj), j = 1, . . . ,m. If we assume we have a kernel function k : RD × RD → RD such that k(x, z) = 〈φ(x), φ(z)〉H then Jλ,t(S) can be computed without actually forming x1, . . . ,xm since entries in K can be computed via k. IfH is the Reproducing Kernel Hilbert Space of k then this is exactly the setting that corresponds to kernel ridge regression (possibly with a zero ridge term).
Greedy Algorithm. We now propose our algorithm for overparameterized experimental design, which is based on greedy minimization of Jλ,t(S). Greedy algorithms have already been shown to be effective for classical experimental design (Yu et al., 2006; Avron & Boutsidis, 2013; Chamon & Ribeiro, 2017), and it is reasonable to assume this carries on to the overparameterized case.
Our greedy algorithm proceeds as follows. We start with S(0) = ∅, and proceed in iteration. At iteration j, given selected samples S(j−1) ⊂ [m] the greedy algorithm finds the index i(j) ∈ [m]− S(j−1) that minimizes Jλ,t ( S(j−1) ∪ {i(j)} ) . We set S(j) ← S(j−1) ∪ {i(j)}. We continue iterating until S(j) reaches its target size and/or Jλ,t(S) is small enough.
The cost of iteration j in a naive implementation isO ( (m− j) ( mj2 + j3 )) . Through careful matrix
algebra, the cost of iteration j can be reduced to O((m− j)(mj + j2)) = O(m2j) (since j ≤ m). The cost of finding a design of size n is then O(m2(n2 +D)) assuming the entire kernel matrix K is formed at the start and a single evaluation of k takes O(D). Details are delegated to Appendix C.

heading: 6 SINGLE SHOT DEEP ACTIVE LEARNING
text: There are few ways in which our proposed experimental design algorithm can be used in the context of deep learning. For example, one can consider a sequential setting where current labeled data are used to create a linear approximation via the Fisher information matrix at the point of minimum loss (Sourati et al., 2018). However, such a strategy falls under the heading of Sequential Experimental Design, and, as we previously stated, in this paper we focus on single shot active learning, i.e. no labeled data is given neither before acquisition nor during acquisition (Yang & Loog, 2019).
In order to design an algorithm for deep active learning, we leverage a recent breakthrough in theoretical analysis of deep learning - the Neural Tangent Kernel (NTK) (Jacot et al., 2018; Lee et al., 2019; Arora et al., 2019a). A rigorous exposition of the NTK is beyond the scope of this paper, but a short and heuristic explanation is sufficient for our needs.
Consider a DNN, and suppose the weights of the various layers can be represented in a vector θ ∈ Rd. Given a specific θ, let fθ(·) denote the function instantiated by that network when the weights are set to θ. The crucial observation is that when the network is wide (width in convolutional layers refers to the number of output channels) enough, we use a quadratic loss function (i.e., l(fθ(x), y) = 1/2(fθ(x)− y)2), and the initial weights θ0 are initialized randomly in a standard way, then when training the DNN using gradient descent, the vector of parameters θ stays almost fixed. Thus, when we consider θ1,θ2, . . . formed by training, a first-order Taylor approximation is:
fθk(x) ≈ fθ0(x) +∇θfθ0(x)T(θk − θ0) Informally speaking, the approximation becomes an equality in the infinite width limit. The Taylor approximation implies that if we further assume that θ0 is such that fθ0(x) = 0, the learned prediction function of the DNN is well approximated by the solution of a kernel regression problem with the (Finite) Neural Tangent Kernel, defined as
kf,θ0(x, z) := ∇θfθ0(x)T∇θfθ0(z) We remark that there are few simple tricks to fulfill the requirement that fθ0(x) = 0.
It has also been shown that under certain initialization distribution, when the width goes to infinity, the NTK kf,θ0 converges in probability to a deterministic kernel kf - the infinite NTK. Thus, in a sense, instead of training a DNN on a finite width network, we can take the width to infinity and solve a kernel regression problem instead.
Although, it is unclear whether the infinite NTK can be an effective alternative to DNNs in the context of inference, one can postulate that it can be used for deep active learning. That is, in order to select examples to be labeled, use an experimental design algorithm for kernel learning applied to the corresponding NTK. Specifically, for single shot deep active learning, we propose to apply the algorithm presented in the previous section to the infinite NTK. In the next section we present preliminary experiments with this algorithm. We leave theoretical analysis to future research.

heading: 7 EMPIRICAL EVALUATION
text: Transductive vs ψ̄λ,0 Criterion (i.e., variance-oriented vs. bias-oriented designs) ψ̄λ,0 and ψ̄λ,λ are simplified version of ψ̄λ,t criterion. Our conjecture is that in the overparameterized regime ψ̄λ,0 is preferable, at least for relatively large λ. Table 1. empirically supports our conjecture. In this experiment, we performed an experimental design task on 112 classification datasets from UCI database (similar to the list that was used by Arora et al. (2019b) ). Learning is performed using kernel ridge regression with standard RBF kernel. We tried different values of λ and checked which criterion brings to a smaller classification error on a test set when selecting 50 samples. Each entry in Table 1 counts how many times ψ̄λ,λ , won ψ̄λ,0 won or the error was the same. We consider an equal error when the difference is less the 5%.
Deep Active Learning Here we report preliminary experiments with the proposed algorithm for single shot deep active learning (Section 6). Additional experiments are reported in the appendix. We used the MNIST dataset, and used the square loss for training. As for the network architecture, we used a version of LeNet5 (LeCun et al., 1998) that is widen by a factor of 8. we refer to this network as “Wide-LeNet5”.
The setup is as follows. We use Google’s open source neural tangents library (Novak et al., 2020) to compute Gram matrix of the infinite NTK using 59,940 training samples (we did not use the full 60,000 training samples due to batching related technical issues). We then used the algorithm proposed in Section 5 to incrementally select greedy designs of up to 800 samples, where we set the parameters to λ = t = 0. We now trained the original neural network with different design sizes, each design with five different random initial parameters. Learning was conducted using SGD, with fixed learning rate of 0.1, batch size of 128, and no weight decay. Instead of counting epochs, we simply capped the number of SGD iterations to be equivalent to 20 epochs of the full trainning set. We computed the accuracy of the model predictions on 9963 test-set samples (again, due to technical issues related to batching).
Figure 2 report the mean and standard deviation (over the parameters initialization) of the final accuracy. We see a consistent advantage in terms of accuracy for designs selected via our algorithm, though as expected the advantage shrinks as the training size increase. Notice, that comparing the accuracy of our design with 400 training samples, random selection required as many as 600 for Wide-LeNet5 to achieve the same accuracy!
Two remarks are in order. First, to prevent overfitting and reduce computational load, at each iteration of the greedy algorithm we computed the score for only on a subset of 2000 samples from the pool. Second, to keep the experiment simple we refrained from using tricks that ensure fθ0 = 0.

heading: A PROOFS
text: A.1 PROOF OF PROPOSITION 1
Proof. We prove the case of d ≥ n (for X ∈ Rn×d). The proof for d < n is similar. It is enough to show that limλ→0 X+λ =X +. For a scalar γ let
γ+ := { γ−1 γ 6= 0 0 γ = 0
Let X = UΣVT be the SVD of X with
Σ =  σ1 0 · · · 0. . . ... ... σd 0 · · · 0  ∈ Rd×n where σ1, . . . , σd are the singular values of X. We have X+ = VΣ+UT where we have
Σ+ =  σ+1 . . . σ+d 0 · · · 0 ...
... 0 · · · 0  On the other hand, simple matrix algebra shows that
X+λ = V  (σ21 + λ) +σ1 . . . (σ2d + λ) +σd 0 · · · 0 ...
... 0 · · · 0
 UT (5)
Now clearly for i = 1, . . . , d, lim λ→0+ (σ2i + λ) +σi = σ + i
So the limit of the diagonal matrix in Eq. (5) when λ→ 0+ is Σ+. Since matrix product is a linear, and thus continuous function, the proposition follows.
A.2 PROOF OF PROPOSITION 2
Proof. Let us write
:=  1... n  so
y = Xw + .
Thus, ŵλ = X + λy = X + λXw + X + λ = M + λMw + X + λ
and xTw − xTŵλ = xT(Id −M+λM)w + xTX + λ
For brevity we denote Pλ⊥X = Id −M + λM. Note that this is not really a projection, but rather (informally) a “soft projection”. So:
(xTw − xTŵλ)2 = wTPλ⊥X(xxT)P λ ⊥Xw + w TPλ⊥X(xx T)X+λ + T(X+λ) T(xxT)X+λ
Finally, E [R(ŵλ)] = Ex, [( xTw − xTŵλ )2] = E [ Ex [( xTw − xTŵλ
)2 | ]] = E [ Ex [ wTPλ⊥X(xx T)Pλ⊥Xw + w TPλ⊥X(xx T)X+λ + T(X+λ) T(xxT)X+λ | ]]
= E [ wTPλ⊥XCρP λ ⊥Xw + w TPλ⊥XCρX + λ + T(X+λ) TCρX + λ ]
= wTPλ⊥XCρP λ ⊥Xw + σ 2Tr ( (X+λ) TCρX + λ ) = ‖C1/2ρ P λ ⊥Xw‖22 + σ2Tr ( CρX + λ(X + λ)
T) = ‖C1/2ρ ( I−M+λM ) w‖22 + σ2Tr ( CρM +2 λ M )
A.3 PROOF OF PROPOSITION 3
Before proving Proposition 3 we need the following definition and theorem.
Definition 1. For a family of sets {Aλ}λ∈R, A ⊂ Rd we write limλ→λ̄Aλ = A if w ∈ A if and only if there exists sequence λn → λ and a sequence wn → w where wn ∈ Aλn for sufficiently large n.
Theorem 1. (A restricted version of Theorem 1.17 in Rockafellar & Wets (2009)) Consider f : Ω×Ψ→ R where Ω ⊆ Rd and Ψ ⊆ R are compact and f is continuous. Then
lim λ→λ̄ argmin w f (w, λ) ⊆ argmin w
f ( w, λ̄ ) .
Proof. Suppose w̄ ∈ limλ→λ̄ argminw f (w, λ). The implies that there exits λn → λ̄ such that wn ∈ argminw f (w, λn) and wn → w̄. From the continuity of f we have that f (wn, λn) → f ( w̄, λ̄ ) . Now suppose for the sake of contradiction that w̄ /∈ argminw f ( w, λ̄ ) . So there is u
such that f(u, λ̄) < f ( w̄, λ̄ ) . From the continuity of f in λ there is n0 such that for all n > n0
f(u, λn) < f ( w̄, λ̄ ) . Then from the continuity of f in w, and wn → w̄, for sufficiently large n, f (wn, λn) > f(u, λn), which contradicts wn ∈ argminw f (w, λn).
We are now ready to prove Proposition 3.
Proof. Consider the function f(M, µ) = Tr ( CρM −1 µ ) f(M, µ) = { Tr ( µCρ(M + µI) −1) µ > 0 Tr (Cρ (I−M+M)) µ = 0
defined over Ω × R≥0 where R≥0 denotes the set of non-negative real numbers. Note that this function is well-defined since Ω is a set of positive semidefinite matrices.
We now show that f is continuous. For µ > 0 it is clearly continuous for every M, so we focus on the case that µ = 0 for an arbitrary M. Consider a sequence R>0 3 µn → 0 (where R>0 is the set of positive reals) and Ω 3Mn →M. Since Ω is compact, M ∈ Ω. Let us write a spectral decomposition of Mn (recall that Ω is a set of symmetric matrices)
Mn = UnΛnU T n
where Λn is diagonal with non-negative diagonal elements (recall that Ω is a set of positive definite matrices). Let M = UΛUT be a spectral decomposition of M. Without loss of generality we may assume that Un → U and Λn → Λ. Now note that
(Mn + µnI) −1Mn = Un(Λn + µnI) −1ΛnU T n
One can easily show that (Λn +µnI)−1Λn → sign(Λ) where sign is taken entry wise, which implies that (Mn + µnI)−1Mn → U sign(Λ)UTsince matrix multiplication is continuous. Next, note that M+M = UΛ+ΛUT = U sign(Λ)UT so (Mn + µnI)−1Mn → M+M. The Woodbury formula implies that
µnCρ(Mn + µnI) −1 = Cρ ( I− (Mn + µnI)−1Mn ) so the continuity of the trace operator implies that
Tr ( µnCρ(Mn + µnI) −1) = Tr (Cρ (I− (Mn + µnI)−1Mn))→ Tr (Cρ (I−M+M)) which shows that f is continuous.
Theorem 1 now implies the claim since for µ > 0 we have
argmin M∈Ω
Tr ( CρM −1 µ ) = argmin M∈Ω Tr ( µCρM −1 µ ) .
A.4 PROOF OF PROPOSITION 4 Proof. Let A = ( I− (M + λId)−1M )2 +λ(M+λId)
−2M , so ϕ̄λ,λ(M) = Tr (CρA). We now have for λ > 0:
A = ( I− (M + λId)−1(M + λId) + λ(M + λId)−1 )2 + λ(M + λId) −2M
= λ2 (M + λId) −2 + λ(M + λId) −2M = λ(M + λId) −2 (M + λId) = λ (M + λI) −1
so:
Tr (CρA) = λTr ( Cρ (M + λI) −1 ) .
Since λ > 0 it doesn’t affect the minimizer.

heading: B RELATION TO CORESETS
text: The idea in the coreset approach for active learning is to find an S such that
C(S) = ∣∣∣∣∣ 1m m∑ i=1 l(xi, yi | S)− 1 |S| ∑ i∈S l(xi, yi | S) ∣∣∣∣∣
is minimized. In the above l(x, y | S) is a loss function, and the conditioning on S denotes that the parameters of the loss function are the ones obtained when training only using indices selected in S. For linear regression the conditioning on S is not relevant (since the parameters do not affect the loss). The motivation for minimizing C(S) is that the expected test loss can be broken to the generalization loss on the entire dataset (which is fixed), the training loss (which is 0 in the presence of overparameterization) and the coreset loss.
One popular approach to active learning using coresets is to find a coverset. A δ-coverset of a set of points A is a set of points B such that for every x ∈ A there exists a y ∈ B such that ‖x− y‖2 ≤ δ (other metrics can be used as well). Sener and Savarese Sener & Savarese (2018) showed that under suitable Lipschitz and boundness conditions, if {xi}i∈S is a δ-coverset of {xi}i∈[m] then
C(S) ≤ O(δ +m−1/2) which motivates finding a S that minimizes δS , where δS denotes the minimal δ for which {xi}i∈S is a δ-coverset of {xi}i∈[m].
Since for a x in the training set (which is a row of V) ‖x(Id − PM)‖22, for M = V T S,:VS,: is the minimal distance from x to the span of {xi}i∈S , and as such is always smaller than the distance between x and it’s closest point in {xi}i∈S , it is easy to show that
n−1ψ̄0,0(V T S,:VS,:) ≤ δ2S .
Thus, minimizing δS can be viewed as minimizing an upper bound on the bias term when λ = 0.
Under the setup of the experiment in Section 7 we tried to replace our design with k-centers algorithm, which often used as approximated solution for the problem of finding S that minimizes δS . How ever the result we got were much worse then random design, probably due to the problem of outliers. We did not try more sophisticated versions of the k-center algorithm that tackle the problem of outliers.

heading: C DETAILS ON THE ALGORITHM
text: We discuss the case of λ = 0. The case of λ > 0 requires some more careful matrix algebra, so we omit the details.
Let us define Aj := K −1 S(j),S(j) , Bj := K T :,S(j)K:,S(j)
and note that Jλ,t(S(j)) = −Tr ( Bj(Aj − tA2j ) ) . We also denote by Ãj and B̃j the matrices obtained from Aj and Bj (respectively) by adding a zero row and column.
Our goal is to efficiently compute Jλ,t(S(j−1) ∪ {i}) for any i ∈ [m]− S(j−1) so find i(j) and form S(j). We assume that at the start of iteration j we already have in memory Aj−1 and Bj−1. We show later how to efficiently update Aj and Bj once we have found i(j). For brevity, let us denote
S(j)i := S (j−1) ∪ {i}, Aji := K−1S(j)i ,S(j)i , Bji := K T :,S(j)i K :,S(j)i
Let us also define
Cj−1 := B̃j−1Ãj−1, Dj−1 := B̃j−1Ã 2 j−1, Ej−1 := Ã 2 j−1
Again, we assume that at the start of iteration j we already have in memory Cj−1, Dj−1 and Ej−1, and show how to efficiently update these.
Let
Wji :=
[ 0j−1 K T :,S(j−1)K:,i
KT:,iK:,S(j−1) K T :,iK:,i ] and note that
Bji = B̃j−1 + Wji.
Also important is the fact that Wji has rank 2 and that finding the factors takes O(mj) discounting the cost of computing columns of K. Next, let us denote
rji = 1
(Kii −KTS(j),iAj−1KS(j),i)
and
Qji := rji ·
[ Aj−1KS(j),iK T S(j),iA −1 j−1 −Aj−1KS(j),i
−KTS(j),iAj−1 1 ] A well known identity regarding Schur complement implies that
Aji = Ãj−1 + Qji
Also important is the fact that Qji has rank 2 and that finding the factors takes O(j 2) discounting the cost of computing entries of K.
So Jλ,t(S(j)i ) = −Tr ( Bji(Aji − tA2ji) ) = −Tr ( (B̃j−1 + Wji)(Ãj−1 + Qji − t(Ãj−1 + Qji)2)
) = −Tr ( (B̃j−1 + Wji)(Ãj−1 + Qji)− t(B̃j−1 + Wji)(Ã 2 j−1 + Q 2 ji + Ãj−1Qji + QjiÃj−1
) = −Tr ( Cj−1 + B̃j−1Qji + Wji(Ãj−1 + Qji)
) +tTr ( Dj−1 + B̃j(Ãj−1Qji + QjiÃj−1 + Q 2 ji) )
+Tr ( Wi(Ej−1 + Q 2 ji + Ãj−1Qji + QjiÃj−1 ) Now, Cj−1 is already in memory so Tr (Cj−1) can be computed in O(j), Qji has rank 2 and B̃j−1 is in memory so Tr ( B̃j−1Qji ) can be compute in O(j2), and Wji has rank 2 and Ãj−1 is in
memory so Tr ( Wi(Ãj−1 + Qji) ) can be computed in O(j2). Using a similar rationale, all the
other terms of Jλ,t(S(j)i ) can also be computed in O(j) or O(j2), and overall Jλ,t(S (j) i ) can be computed in O(j2). Thus, scanning for i(j) takes O((m− j)j2).
Once i(j) has been identified, we set S(j) = S(j) i(j)
, Aj = Aji(j) = Ãj−1 +Qji(j) and Bj = Bji(j) = B̃j−1 + Wji(j) . The last two can be computed in O(j2) once we form Qi(j) and Wi(j) . Computing the factors of these matrices takes O(mj). As for updating Cj−1, we have
Cj = C̃j−1 + B̃j−1Qji(j) + Wji(j)Ãj−1 + Wji(j)Qji(j)
where C̃j−1 is obtained from Cj−1 be adding a zero row and column. Since Cj−1 is in memory and both Qji(j) and Wi(j) have rank O(1), we can compute Cj is O(j
2). Similar reasoning can be used to show that Dj and Ej can also be computed in O(j2).
Overall, the cost of iteration j is O((m − j)(mj + j2)) = O(m2j) (since j ≤ m). The cost of finding a design of size n is O(m2(n2 +D)) assuming the entire kernel matrix K is formed at the start and a single evaluation of k takes O(D).

heading: D EXPERIMENTAL PARAMETERS EXPLORATION AND COMPARISON TO TRANSDUCTIVE EXPERIMENTAL DESIGN
text: In this subsection we report a set of experiments on a kernel ridge regression setup (though in one experiment we set the ridge term to 0, so we are using interpolation). We use the MNIST handwriting dataset (LeCun et al., 2010), where the regression target response was computed by applying one-hot function on the labels 0-9. Nevertheless, we still measure the MSE, and do not use the learnt models as classifiers. We use the RBF kernel k(x, z) = exp(−γ‖x− z‖22) with parameter γ = 1/784. From the dataset, we used the standard test set of 10000 images and selected randomly another 10000 images from the rest of the 60000 images as a pool. We used our proposed greedy algorithm to select a training set of sizes 1 to 100. We use two values of λ: λ = 0 (interpolation), and λ = 0.752. The optimal λ according to cross validation was the smallest we checked so we just used λ = 0. However, in some cases having a λ > 0 is desirable from a computational perspective, e.g. it caps the condition
number of the kernel matrix, making the linear system easier to solve. Furthermore, in real world scenarios, oftentimes we do not have any data before we start to acquire labels, and if we do, it is not always distributed as in the test data, so computing the optimal λ can be a challenging.
Results are reported in Figure 3. The left panel show the results for λ = 0. We report results for t = 0 and t = 0.5. The choice of t = 0 worked better. Kernel models with the RBF kernel are highly overparameterized (the hypothesis space is infinite dimensional), so we expect the MSE to be bias dominated, in which case a small t (or t = 0) might work best. Recall that the option of λ = t = 0 is equivalent to the Column Subset Selection Problem, is the limit case of transductive experimental design (Yu et al., 2006), and can be related to the coreset approach (specifically Sener & Savarese (2018)).
The case of λ = 0.752 is reported in the right panel of Figure 3. We tried t = 0 and t = λ = 0.752. Here too, using a purely bias oriented objective (i.e., t = 0) worked better. Note that this is in contrast with classical OED which use variance oriented objectives. The choice of t = λ worked well, but not optimally. In general, in the reported experiments, and other experiments conducted but not reported, it seems that the choice of t = λ, which is, as we have shown in this paper, equivalent to transductive experimental design, usually works well, but is not optimal.

heading: E EXPERIMENTAL SETUP FOR RESULT REPORTED IN FIGURE 1
text: First, w ∈ R100 was sampled randomly from N (0, I) . Then a pool (the set from which we later choose the design) of 500 samples and a test set of 100 samples were randomly generated according to x ∼ N (0,Σ), ∼ N (0, σ2I) and y = xTw + , where Σ ∈ R100×100 is diagonal with Σii = exp(−2.5i/100), and σ = 0.2. We then created three incremental designs (training sets) of size 120 according to three different methods:
• Random design - at each iteration we randomly choose the next training sample from the remaining pool. • Classical OED (variance oriented) - at each iteration we choose the next training sample
from the remaining pool with a greedy step that minimizes the variance term in Eq. (3). • Overparameterized OED - at each iteration we chose the next training sample from the
remaining pool with a greedy step that minimizes Eq. (3), with λ = 0 and t = σ2 .
With the addition of each new training sample we computed the new MSE achieved on the test set with minimum norm linear regression.

heading: F EXPERIMENT: SINGLE SHOT ACTIVE LEARNING FOR NARROW NETWORKS
text: In Figure 4 we compare the result of our method on LeNet5 with the result of our method on Wide-LeNet5. We see that while the result on
the wide version are generally better, both for random designs and our design, our method brings a consistent advantage over random design. In both the narrow and the wide versions it requires about 600 training samples for the random design to achieve the accuracy achieved using our algorithm with only 400 training samples!
The parameters used by our algorithm to select the design are λ = t = 0. For the network training we used SGD with batch size 128, leaning rate 0.1 and no regularization. The SGD number iterations is equivalent to 20 epochs of the full trainning set.

heading: G SEQUENTIAL VS SINGLE SHOT ACTIVE LEARNING
text: While in this work focus on the single shot active learning, an interesting question is how does it compare to sequential active learning. In sequential active learning we alternate between a model improving step and a step of new labels acquisition,. This obviously gives an advantage to sequential active learning over single shot active learning, as the latter is a restricted instance of the former.
As we still do not have a sequential version of our algorithm to compare with, we chose to experimentally compare our single shot algorithm with the classical method of uncertainty sampling (Bartlett et al., 2020). This method has proved to be relatively efficient for neural networks (Gal et al., 2017). Uncertainty sampling based active learning requires computing the uncertainty of the updated model regarding each sample in the pool. As such, this approach is sequential by nature.
Usually uncertainty sampling is derived in connection to the cross entropy since in that case the network output after the softmax layer can be interpreted as a probability estimation of y = i given x, which we symbolize as pi(x). The uncertainty score (in one common version) is then given by
1−max i∈[L] pi(x).
Because we use the square lose, we need to make some adaptation for the way of pi(x) is computed. Considering the fact that the square loss is an outcome of a maximum likelihood model that given x assumes y ∼ N (f(x), IL), it make sense to use
pi(x) = (2π) −L2 e− 1 2‖yi−f(x)‖ 2 2 ,
where yi is the onehot vector of i.
Figure 5. shows a comparison between the accuracy achieved with our single shot algorithm and the sequential active learning on MNIST with LeNet5. The acquisitions batch size of the sequential active learning were set to 100. Our algorithm ran with λ = t = 0. For the network training we used SGD with batch size 128, leaning rate 0.1 and no l2 regularization. The SGD number iterations is equivalent to 20 epochs of the full train set.
Initially, our selection procedure shows a clear advantage. However, once the training set grows large enough, the benefit of a sequential setup starts to kick-in, the sequential algorithm starts to show superior results. This experiment motivates further development of sequential version of our algorithm.

Review summaries:
In this paper, the authors develop a data selection scheme aimed to minimize a notion of Bayes excess risk for overparametrized linear models. The excess Bayes risk is the expected squared error between the prediction and the target. The authors note that solutions such as V-optimality exist for the underparametrized cases (linear regression), and offer extensions to ridge regression. After the development of a greedy schemes and a tentative extension to deep learning models, the authors show that their selection scheme can outperform random selection on MNIST with a specific model.