Data-Efﬁcient Augmentation for Training Neural Networks
Abstract
Data augmentation is essential to achieve state-of-the-art performance in many deep learning applications.
However, the most effective augmentation techniques become computationally prohibitive for even medium-sized datasets.
To address this, we propose a rigorous technique to select subsets of data points that when augmented, closely capture the training dynamics of full data augmentation.
We ﬁrst show that data augmentation, modeled as additive perturbations, improves learning and generalization by relatively enlarging and perturbing the smaller singular values of the network Jacobian, while preserving its prominent directions.
This prevents overﬁtting and enhances learning the harder to learn information.
Then, we propose a framework to iteratively extract small subsets of training data that when augmented, closely capture the alignment of the fully augmented
Jacobian with labels/residuals.
We prove that stochastic gradient descent applied to the augmented subsets found by our approach has similar training dynamics to that of fully augmented data.
Our experiments demonstrate that our method achieves 6.3x speedup on CIFAR10 and 2.2x speedup on SVHN, and outperforms the baselines by up to 10% across various subset sizes.
Similarly, on TinyImageNet and ImageNet, our method beats the baselines by up to 8%, while achieving up to 3.3x speedup across various subset sizes.
Finally, training on and augmenting 50% subsets using our method on a version of CIFAR10 corrupted with label noise even outperforms using the full dataset.
Introduction
Standard (weak) data augmentation transforms the training examples with e.g. rotations or crops for images, and trains on the transformed examples in place of the original training data.
While weak augmentation is effective and computationally inexpensive, strong data augmentation (in addition to weak augmentation) is a key component in achieving nearly all state-of-the-art results in deep learning applications [35].
However, strong data augmentation techniques often increase the training time by orders of magnitude.
First, they often have a very expensive pipeline to ﬁnd or generate more complex transformations that best improves generalization [5, 15, 22, 40].
Second, appending transformed examples to the training data is often much more effective than training on the (strongly or weakly) transformed examples in-place of the original data.
For example, appending one transformed example to the training data is often much more effective than training on two transformed examples in place of every original training data, while both strategies have the same computational cost ( c.f. Appendix
D.6).
Hence, to obtain the state-of-the-art performance, multiple augmented examples are added for every single data point and to each training iteration [14, 40].
In this case, even if producing transformations are cheap, such methods increases the size of the training data by orders of magnitude.
As a result, state-of-the-art data augmentation techniques become computationally prohibitive for even medium-sized real-world problems.
For example, the state-of-the-art augmentation of [40], which appends every example with its highest-loss transformations, increases the training time of
ResNet20 on CIFAR10 by 13x on an Nvidia A40 GPU ( c.f.
Sec. 6).
To make state-of-the-art data augmentation more efﬁcient and scalable, an effective approach is to carefully select a small subset of the training data such that augmenting only the subset provides similar training dynamics to that of full data augmentation.
If such a subset can be quickly found, it would directly lead to a signiﬁcant reduction in storage and training costs.
First, while standard in-place augmentation can be applied to the entire data, the strong and expensive transformations can be only produced for the examples in the subset.
Besides, only the transformed elements of the subset can be appended to the training data.
Finally, when the data is larger than the training budget, one can train on random subsets (with standard in-place augmentation) and augment coresets (by strong augmentation and/or appending transformations) to achieve a superior performance.
Despite the efﬁciency and scalability that it can provide, this direction has remained largely unexplored.
Existing studies are limited to fully training a network and subsampling data points based on their loss or inﬂuence, for augmentation in subsequent training runs [20].
However, this method is prohibitive for large datasets, provides a marginal improvement over augmenting random subsets, and does not provide any theoretical guarantee for the performance of the network trained on the augmented subsets.
Besides, when the data contains mislabeled examples, augmentation methods that select examples with maximum loss, and append their transformed versions to the data, degrade the performance by selecting and appending several noisy labels.
A major challenge in ﬁnding the most effective data points for augmentation is to theoretically understand how data augmentation affects the optimization and generalization of neural networks.
Existing theoretical results are mainly limited to simple linear classiﬁers and analyze data augmentation as enlarging the span of the training data [40], providing a regularization effect [4, 9, 37, 40], enlarging the margin of a linear classiﬁer [32], or having a variance reduction effect [6].
However, such tools do not provide insights on the effect of data augmentation on training deep neural networks.
Here, we study the effect of label invariant data augmentation on training dynamics of overparameterized neural networks.
Theoretically, we model data augmentation by bounded additive perturbations [32], and analyze its effect on neural network Jacobian matrix containing all its ﬁrst-order partial derivatives [1].
We show that label invariant additive data augmentation proportionally enlarges but more importantly perturbs the singular values of the Jacobian, particularly the smaller ones, while maintaining prominent directions of the Jacobian.
In doing so, data augmentation regularizes training by adding bounded but varying perturbations to the gradients.
In addition, it speeds up learning harder to learn information.
Thus, it prevents overﬁtting and improves generalization.
Empirically, we show that the same effect can be observed for various strong augmentations, e.g., AutoAugment [7], CutOut [10], and AugMix [14].
Next, we develop a rigorous method to iteratively ﬁnd small weighted subsets (coresets) that when augmented, closely capture the alignment between the Jacobian of the full augmented data with the label/residual vector.
We show that the most effective subsets for data augmentation are the set of examples that when data is mapped to the gradient space, have the most centrally located gradients.
This problem can be formulated as maximizing a submodular function.
The subsets can be efﬁciently extracted using a fast greedy algorithm which operates on small dimensional gradient proxies, with only a small additional cost.
We prove that augmenting the coresets guarantees similar training dynamics to that of full data augmentation.
We also show that augmenting our coresets achieve a superior accuracy in presence of noisy labeled examples.
We demonstrate the effectiveness of our approach applied to CIFAR10 (ResNet20, WideResNet28-10), CIFAR10-IB (ResNet32), SVHN (ResNet32), noisy-CIFAR10 (ResNet20), Caltech (ResNet18, ResNet50), TinyImageNet (ResNet50), and ImageNet (ResNet50) compared to random and max-loss baselines [20].
We show the effectiveness of our approach (in presence of standard augmentation) in the following cases:
• When producing augmentations is expensive and/or they are appended to the training data:
We show that for the state-of-the-art augmentation method of [40] applied to CIFAR10/ResNet20 it is 3.43x faster to train on the whole dataset and only augment our coresets of size 30%, compared to training and augmenting the whole dataset.
At the same time, we achieve 75% of the accuracy improvement of training on and augmenting the full data with the method of [40], outperforming both max-loss and random baselines by up to 10%.
• When data is larger than the training budget: We show that we can achieve 71.99% test accuracy on ResNet50/ImageNet when training on and augmenting only 30% subsets forepochs.
Compared to AutoAugment [7], despite using only 30% subsets, we achieve 92.8% of the original reported accuracy while boasting 5x speedup in the training time.
Similarly, on Caltech256/ResNet18, training on and augmenting 10% coresets with AutoAugment yields 65.4% accuracy, improving over random 10% subsets by 5.8% and over only weak augmentation by 17.4%.
• When data contains mislabeled examples: We show that training on and strongly augmenting 50% subsets using our method on CIFAR10 with 50% noisy labels achieves 76.20% test accuracy.
Notably, this yields a superior performance to training on and strongly augmenting the full data.
Additional Related Work
Strong data augmentation methods achieve state-of-the-art performance by ﬁnding the set of transformations for every example that best improves the performance.
Methods like AutoAugment [7],
RandAugment [8], and Faster RandAugment [8] search over a (possibly large) space of transformations to ﬁnd sequences of transformations that best improve generalization [7, 8, 24, 40].
Other techniques involve a very expensive pipeline for generating the transformations.
For example, some use Generative Adversarial Networks to directly learn new transformations [2, 24, 27, 33].
Strong augmentations like Smart Augmentation [22], Neural Style Transfer-based [15], and GAN-based augmentations [5] require an expensive forward pass through a deep network for input transformations.
For example, [15] increases training time by 2.8x for training ResNet18 on Caltech256.
Similarly, [40] generates multiple augmentations for each training example, and selects the ones with the highest loss.
Strong data augmentation methods either replace the original example by its transformed version, or append the generated transformations to the training data.
Crucially, appending the training data with transformations is much more effective in improving the generalization performance.
Hence, the most effective data augmentation methods such as that of [40] and AugMix [14] append the transformed examples to the training data.
In Appendix D.6, we show that even for cheaper strong augmentation methods such as AutoAugment [7], while replacing the original training examples with transformations may decrease the performance, appending the augmentations signiﬁcantly improves the performance.
Appending the training data with augmentations, however, increase the training time by orders of magnitude.
For example, AugMix [14] that outperforms AutoAugment increases the training time by at least 3x by appending extra augmented examples, and [40] increases training time by 13x due to appending and forwarding additional augmented examples through the model.
Problem Formulation
We begin by formally describing the problem of learning from augmented data.
Consider a dataset
D train =
( X train , y train ) , where X train = ( x 1 , · · · , x n
) ∈ R d × n is the set of n normalized data points x i ∈ [0 , 1] d , from the index set V , and y train =
( y 1 , · · · , y n ) ∈ { y ∈ { ν 1 , ν 2 , · · · , ν C }} with { ν j } Cj =1 ∈ [0 , 1] .
The additive perturbation model.
Following [32] we model data augmentation as an arbitrary bounded additive perturbation (cid:15) , with (cid:107) (cid:15) (cid:107)≤ (cid:15) 0 .
For a given (cid:15) 0 and the set of all possible transformations A , we study the transformations selected from S ⊆
A satisfying
[Equation]
While the additive perturbation model cannot represent all augmentations, most real-world augmentations are bounded to preserve the regularities of natural images (e.g. AutoAugment [7] ﬁnds that adegree rotation is optimal for CIFAR10).
Thus, under local smoothness of images, additive perturbation can model bounded transformations such as small rotations, crops, shearing, and pixel-wise transformations like sharpening, blurring, color distortions, structured adversarial perturbation [24].
As such, we see the effects of additive augmentation on the singular spectrum holds even under real-world augmentation settings ( c.f. Fig.
3 in the Appendix).
However, this model is indeed limited when applied to augmentations that cannot be reduced to perturbations, such as horizontal/vertical ﬂips and large translations.
We extend our theoretical analysis to augmentations modeled as arbitrary linear transforms (e.g. as mentioned, horizontal ﬂips) in B.5.
The set of augmentations at iteration t generating r augmented examples per data point can be speciﬁed, with abuse of notation, as D taug = { (cid:83) ri =
( T ti ( X train ) , y train ) } , where |D taug | = rn and
T ti ( X train ) transforms all the training data points with the set of transformations T ti ⊂ S at iteration t .
We denote X taug = { (cid:83) ri =1 T ti ( X train ) } and y taug = { (cid:83) ri =1 y train } .
Training on the augmented data.
Let f ( W , x ) be an arbitrary neural network with m vectorized (trainable) parameters W ∈ R m .
We assume that the network is trained using (stochastic) gradient descent with learning rate η to minimize the squared loss L over the original and augmented training examples D t = {D train ∪ D taug } with associated index set V t , at every iteration t .
I.e.,
[Equation]
The gradient update at iteration t is given by
[Equation]
[Equation]
) where X t = { X train ∪ X taug } and y t = { y train ∪ y taug } are the set of original and augmented examples and their labels, J ( W , X ) ∈ R n × m is the Jacobian matrix associated with f , and r t
= f
( W t , X ) − y is the residual.
We further assume that J is smooth with Lipschitz constant L .
I.e., (cid:107)J ( W , x i ) −J ( W , x j ) (cid:107)≤
L (cid:107) x
i − x j (cid:107) ∀ x i , x j ∈ X .
Thus, for any transformation T j ∈ S , we have (cid:107)J ( W , x i ) −
J ( W , T j ( x i ))
(cid:107)≤ L(cid:15) 0 .
Finally, denoting J = J ( W , X train ) and ˜ J
= J ( W ,T j ( X train )) ,we get ˜ J
= J + E , where E is the perturbation matrix with (cid:107) E (cid:107) 2 ≤(cid:107)
E (cid:107) F ≤√ nL(cid:15) 0 .
Data Augmentation Improves Learning
In this section, we analyze the effect of data augmentation on training dynamics of neural networks, and show that data augmentation can provably prevent overﬁtting.
To do so, we leverage the recent results that characterize the training dynamics based on properties of neural network Jacobian and the corresponding Neural Tangent Kernel (NTK) [16] deﬁned as Θ = J ( W , X ) J
( W , X ) T .
Formally: r t =
[Equation] [Equation]
(4) where Θ = U Λ U T
= (cid:80) i =
λ i u
i
u
Ti is the eigendecomposition of the NTK [1].
Although the constant NTK assumption holds only in the inﬁnite width limit, [21] found close empirical agreement between the NTK dynamics and the true dynamics for wide but practical networks, such as wide
ResNet architectures [41].
Eq.
(4) shows that the training dynamics depend on the alignment of the
NTK with the residual vector at every iteration t .
Next, we prove that for small perturbations (cid:15) 0 , data augmentation prevents overﬁtting and improves generalization by proportionally enlarging and perturbing smaller eigenvalues of the NTK relatively more, while preserving its prominent directions.
4.1 Effect of Augmentation on Eigenvalues of the NTK
We ﬁrst investigate the effect of data augmentation on the singular values of the Jacobian, and use this result to bound the change in the eigenvalues of the NTK.
To characterize the effect of data augmentation on singular values of the perturbed Jacobian ˜ J , we rely on Weyl’s theorem [39] stating that under bounded perturbations E , no singular value can move more than the norm of the perturbations.
Formally, | ˜ σ i − σ i |≤ (cid:107) E (cid:107) 2 , where ˜ σ i and σ i are the singular values of the perturbed and original Jacobian respectively.
Crucially, data augmentation affects larger and smaller singular values differently.
Let P be orthogonal projection onto the column space of J T , and
P ⊥ =
I − P be the projection onto its orthogonal complement subspace.
Then, the singular values of the perturbed
[Figure]
Jacobian ˜ J T are ˜
[Equation]
2 i , where | µ i |≤ (cid:107) P E (cid:107) 2 , and σ min ( P ⊥ E
[Equation]
≤ ζ i ≤ (cid:107) P ⊥ E (cid:107) 2 , σ min the smallest singular value of J T [36].
Since the eigenvalues of the projection matrix P are either 0 or 1, as the number of dimensions m grows, for bounded perturbations we get that on average µ 2 i
= O (1) and ζ 2 i
= O ( m ) .
Thus, the second term dominates and increase of small singular values under perturbation is proportional to √ m .
However, for larger singular values, ﬁrst term dominates and hence ˜
σ i − σ i ∼ = µ i .
Thus in general, small singular values can become proportionally larger, while larger singular values remain relatively unchanged.
The following Lemma characterizes the expected change to the eignvalues of the NTK.
Lemma 4.1.
Data augmentation as additive perturbations bounded by small (cid:15) 0 results in the following expected change to the eigenvalues of the NTK:
[Equation] [Equation]
where p i := P ( ˜ σ i − σ i < 0) is the probability that σ i decreases as a result of data augmentation, and is smaller for smaller singular values.
The proof can be found in Appendix A.1.
Next, we discuss the effect of data augmentation on singular vectors of the Jacobian and show that it mainly affects the non-prominent directions of the Jacobian spectrum, but to a smaller extent compared to the singular values.
4.2 Effect of Augmentation on Eigenvectors of the NTK
Here, we focus on characterizing the effect of data augmentation on the eigenspace of the NTK.
Let the singular subspace decomposition of the Jacobian be J = U Σ V T .
Then for the NTK, we have Θ =
J J T =
U Σ V T V Σ U T =
U Σ 2 U T (since V T V = I ).
Hence, the perturbation of the eigenspace of the NTK is the same as perturbation of the left singular subspace of the Jacobian J .
Suppose σ i are singular values of the Jacobian.
Let the perturbed Jacobian be ˜
J = J + E , and denote the eigengap γ
= min { σ i − σ i
+1 :
i = 1 , · · · , r } where σ r +1 := 0 .
Assuming γ 0 ≥ 2 (cid:107) E (cid:107) 2 , a combination of Wedin’s theorem [38] and Mirsky’s inequality [26] implies
[Equation]
This result provides an upper-bound on the change of every left singular vectors of the Jacobian.
However as we discuss below, data augmentation affects larger and smaller singular directions differently.
To see the effect of data augmentation on every singular vectors of the Jacobian, let the subspace decomposition of Jacobian be J = U Σ V T
=
U s Σ s V
Ts + U n Σ n V Tn , where U s associated with nonzero singular values, spans the column space of J , which is also called the signal subspace, and U n , associated with zero singular values ( Σ n = 0 ), spans the orthogonal space of U s , which is also called the noise subspace.
Similarly, let the subspace decomposition of the perturbed Jacobian be ˜ J
=
˜
U ˜ Σ
˜ V T = ˜
U s ˜ Σ s ˜ V T s + ˜ U n ˜ Σ n ˜ V T n , and ˜ U s =
U s + ∆ U s , where ∆ U s is the perturbation of the singular vectors that span the signal subspace.
Then the following general ﬁrst-order expression for the perturbation of the orthogonal subspace due to perturbations of the
Jacobian characterize the change of the singular directions:
∆ U s =
U n U Tn EV s Σ − 1 s [23].
We see that singular vectors associated to larger singular values are more robust to data augmentation, compared to others.
Note that in general singular vectors are more robust than singular values.
Fig.
1 shows the effect of perturbations with (cid:15)
= 8 , 16 on singular values and singular vectors of the
Jacobian matrix for a 1 hidden layer MLP trained on MNIST, and ResNet20 trained on CIFAR10.
As calculating the entire Jacobian spectrum is computationally prohibitive, data is subsampled fromclasses.
We report the effect of other real-world augmentation techniques, such as random crops, ﬂips, rotations and Autoaugment [7] - which includes translations, contrast, and brightness transforms - in
Appendix C. We observe that data augmentation increases smaller singular values relatively more.
On the other hand, it affects prominent singular vectors of the Jacobian to a smaller extent.
4.3 Augmentation Improves Training & Generalization
Recent studies have revealed that the Jacobian matrix of common neural networks is low rank.
That is there are a number of large singular values and the rest of the singular values are small.
Based on this, the Jacobian spectrum can be divided into information and nuisance spaces [31].
Information space is a lower dimensional space associated with the prominent singular value/vectors of the Jacobian.
Nuisance space is a high dimensional space corresponding to smaller singular value/vectors of the
Jacobian.
While learning over information space is fast and generalizes well, learning over nuisance space is slow and results in overﬁtting [31].
Importantly, recent theoretical studies connected the generalization performance to small singular values (of the information space)
Our results show that label-preserving additive perturbations relatively enlarge the smaller singular values of the Jacobian in a stochastic way and with a high probability.
This beneﬁts generalization in 2 ways.
First, this stochastic behavior prevents overﬁtting along any particular singular direction in the nuisance space , as stochastic perturbation of the smallest singular values results in a stochastic noise to be added to the gradient at every training iteration.
This prevents overﬁtting (thus a larger training loss as shown in Appendix D.5), and improves generalization [8, 9].
Theorem B.1 in the Appendix characterizes the expected training dynamics resulted by data augmentation.
Second, additive perturbations improve the generalization by enlarging the smaller (useful) singular values that lie in the information space , while preserving eigenvectors.
Hence, it enhances learning along these (harder to learn) components.
The following Lemma captures the improvement in the generalization performance, as a result of data augmentation.
Lemma 4.2.
Assume gradient descent with learning rate η is applied to train a neural network with constant NTK and Lipschitz constant L , on data points augmented with additive perturbations bounded by (cid:15) 0 as deﬁned in Sec.
Let σ min be the minimum singular value of Jacobian J associated with training data X train .
With probability 1 − δ , generalization error of the network trained with gradient descent on augmented data X aug enjoys the following bound:
[Equation]
The proof can be found in Appendix A.2.
Effective Subsets for Data Augmentation
Here, we focus on identifying subsets of data that when augmented similarly improve generalization and prevent overﬁtting.
To do so, our key idea is to ﬁnd subsets of data points that when augmented, closely capture the alignment of the NTK (or equivalently the Jacobian) corresponding to the full augmented data with the residual vector, J ( W t , X taug ) T r taug .
If such subsets can be found, augmenting only the subsets will change the NTK and its alignment with the residual in a similar way as that of full data augmentation, and will result in similar improved training dynamics.
However, generating the full set of transformations X taug is often very expensive, particularly for strong augmentations and large datasets.
Hence, generating the transformations, and then extracting the subsets may not provide a considerable overall speedup.
In the following, we show that weighted subsets (coresets) S that closely estimate the alignment of the
Jacobian associated to the original data with the residual vector J T ( W t , X train ) r train can closely estimate the alignment of the Jacobian of the full augmented data and
the corresponding residual
J T ( W t , X taug ) r taug .
Thus, the most effective subsets for augmentation can be directly found from the training data.
Formally, subsets S t ∗ weighted by γ tS that capture the alignment of the full Jacobian
Require: The dataset D = { ( x i , y i ) } ni =1 , number of iterations T .
Ensure: Output model parameters W T .
1: for t = 1 , · · · , T do 2:
X taug = ∅ .
3: for c ∈ { 1 , · · · , C } do 4:
S tc = ∅ , [ G S tc ] i. =
c 1 1 ∀ i .
5: while (cid:107) G S tc (cid:107) F ≥ ξ do (cid:46) Extract a coreset from class c by solving Eq.
S tc = { S tc ∪ arg max s ∈ V \ S tc ( (cid:107) G S tc (cid:107) F −(cid:107) G { S tc ∪{ s }} (cid:107) F ) } 7: end while 8: γ j = (cid:80) i ∈
V c I [ j =arg min j (cid:48) ∈ S (cid:107)J T ( W t , x i ) r
i −J T ( W t , x j (cid:48) )
r j (cid:48) (cid:107) ]
(cid:46)
Coreset weights 9:
X taug = { X aug ∪ {∪ ri =1 T ti ( X S tc ) }} (cid:46) Augment the coreset 10: ρ tj = γ tj /r 11: end for 12:
Update the parameters W t using weighted gradient descent on X taug or { X train ∪ X taug } .
13: end for with the residual by an error of at most ξ can be found by solving the following optimization problem:
[Equation]
Solving the above optimization problem is NP-hard.
However, as we discuss in the Appendix A.5, a near optimal subset can be found by minimizing the Frobenius norm of a matrix G S , in which the i th row contains the euclidean distance between data point i and its closest element in the subset S , in the gradient space.
Formally, [ G S ] i. =
min j (cid:48) ∈ S (cid:107)J T ( W t , x i ) r i − J T ( W t , x j (cid:48) )
r j (cid:48) (cid:107) .
When S = ∅ , [ G S ] i. = c 1 1 , where c 1 is a big constant.
Intuitively, such subsets contain the set of medoids of the dataset in the gradient space.
Medoids of a dataset are deﬁned as the most centrally located elements in the dataset [18].
The weight of every element j ∈ S is the number of data points closest to it in the gradient space, i.e., γ
[Equation]
=
[Equation]
The set of medoids can be found by solving the following submodular 3 cover problem:
[Equation]
The classical greedy algorithm provides a logarithmic approximation for the above submodular maximization problem, i.e., | S |≤ (1 + ln ( n )) .
It starts with the empty set S 0 = ∅ , and at each iteration τ , it selects the training example s ∈ V \ S τ − 1 that maximizes the marginal gain, i.e.,
S
[Equation]
=
[Equation]
s
[Equation] [Equation]
G S
[Equation]
1 (cid:107) F −(cid:107) G { S
[Equation]
− 1 ∪{ s }} (cid:107) F ) } .
The O ( nk ) computational complexity of the greedy algorithm can be reduced to O ( n ) using randomized methods [28] and further improved using lazy evaluation [25] and distributed implementations [30].
The rows of the matrix G can be efﬁciently upper-bounded using the gradient of the loss w.r.t.
the input to the last layer of the network, which has been shown to capture the variation of the gradient norms closely [17].
The above upper-bound is only marginally more expensive than calculating the value of the loss.
Hence the subset can be found efﬁciently.
Better approximations can be obtained by considering earlier layers in addition to the last two, at the expense of greater computational cost.
At every iteration t during training, we select a coreset from every class c ∈
[ C ] separately, and apply the set of transformations { T ti } ri =1 only to the elements of the coresets, i.e., X taug = {∪ ri =1 T ti ( X S t ) } .
We divide the weight of every element j in the coreset equally among its transformations, i.e. the ﬁnal weight ρ tj = γ tj /r if j ∈ S t .
We apply the gradient descent updates in Eq.
(3) to the weighted
Jacobian matrix of X t = X taug or X t
=
{ X train ∪ X taug } (viewing ρ t as ρ t ∈ R n ) as follows:
[Equation]
The pseudocode is illustrated in Alg. 1.
The following Lemma upper bounds the difference between the alignment of the Jacobian and residual for augmented coreset vs. full augmented data.
[Table]
Lemma 5.1.
Let S be a coreset that captures the alignment of the full data NTK with residual with an error of at most ξ as in Eq. 8.
Augmenting the coreset with perturbations bounded by (cid:15) 0 ≤ n 32 √ L captures the alignment of the fully augmented data with the residual by an error of at most
[Equation]
5.1 Coreset vs. Max-loss
Data Augmentation
In the initial phase of training the NTK goes through rapid changes.
This determines the ﬁnal basin of convergence and network’s ﬁnal performance [11].
Regularizing deep networks by weight decay or data augmentation mainly affects this initial phase and matters little afterwards [12].
Crucially, augmenting coresets that closely capture the alignment of the NTK with the residual during this initial phase results in less overﬁtting and improved generalization performance.
On the other hand, augmenting points with maximum loss early in training decreases the alignment between the NTK and the label vector and impedes learning and convergence.
After this initial phase when the network has good prediction performance, the gradients for majority of data points become small.
Here, the alignment is mainly captured by the elements with the maximum loss.
Thus, as training proceeds, the intersection between the elements of the coresets and examples with maximum loss increases.
We visualize this pattern in Appendix D.11.
The following Theorem characterizes the training dynamics of training on the full data and the augmented coresets, using our additive perturbation model.
Theorem 5.2.
Let L i be β -smooth, L be λ -smooth and satisfy the α -PL condition, that is for α > 0 , (cid:107)∇L ( W ) (cid:107) 2 ≥ α L ( W ) for all weights W .
Let f be Lipschitz in X with constant L (cid:48) , and ¯
L = max { L, L (cid:48) } .
Let G 0 be the gradient at initializaion, σ max the maximum singular value of the coreset Jacobian at initialization.
Choosing (cid:15) 0 ≤ 1 σ max √ ¯ Ln and running SGD on full data with augmented coreset using constant step size η = αλβ , result in the following bound:
[Equation]
The proof can be found in Appendix A.4.
Theorem 5.2 shows that training on full data and augmented coresets converges to a close neighborhood of the optimal solution, with the same rate as that of training on the fully augmented data.
The size of the neighborhood depends on the error of the coreset ξ in Eq.
(8), and the error in capturing the alignment of the full augmented data with the residual derived in Lemma 5.1.
The ﬁrst term decrease as the size of the coreset grows, and the second term depends on the network structure.
We also analyze convergence of training only on the augmented coresets, and augmentations modelled as arbitrary linear transformations using a linear model [40] in Appendix B.5.
Experiments
Setup and baselines.
We extensively evaluate the performance of our approach in three different settings.
Firstly, we consider training only on coresets and their augmentations.
Secondly, we investigate the effect of adding augmented coresets to the full training data.
Finally, we consider adding augmented coresets to random subsets.
We compare our coresets with max-loss and random subsets as baselines.
For all methods, we select a new augmentation subset every R epochs.
We note that the original max-loss method [20] selects points using a fully trained model, hence it can only
[Table] [Table]
[Table]
select one subset throughout training.
To maximize fairness, we modify our max-loss baseline to select a new subset at every subset selection step.
For all experiments, standard weak augmentations (random crop and horizontal ﬂips) are always performed on both the original and strongly augmented data.
6.1 Training on Coresets and their Augmentations
First, we evaluate the effectiveness of our approach for training on the coresets and their augmentations.
Our main goal here is to compare the performance of training on and augmenting coresets vs. random and max-loss subsets.
Tab. 1 shows the test accuracy for training ResNet20 and Wide-ResNet on CIFAR10 when we only train on small augmented coresets of size 0 .
1% to 1% selected at every epoch ( R = 1 ), and training ResNet18 on Caltech256 using coresets of size 5% to 50% with R = 5 .
We see that the augmented coresets outperform augmented random subsets by a large margin, particularly when the size of the subset is small.
On Caltech256/ResNet18, training on and augmenting 10% coresets yields 65.4% accuracy, improving over random by 5.8%, and over only weak augmentation by 17.4%.
This clearly shows the effectiveness of augmenting the coresets.
Note that for CIFAR experiments, training on the augmented max-loss points did not even converge in absence of full data.
Generalization across augmentation techniques.
We note that our coresets are not dependent on the type of data augmentation.
To conﬁrm this, we show the superior generalization performance of our method in Tab. 2 for training ResNet18 with R = 5 on coresets vs. random subsets of Caltech256, augmented with CutOut [10], AugMix [14], and noise perturbations (color jitter, gaussian blur).
For example, on 30% subsets, we obtain 28.2%, 29.3%, 20.2% relative improvement over augmenting random subsets when using CutOut, AugMix, and noise perturbation augmentations, respectively.
6.2 Training on Full Data and Augmented Coresets
Next, we study the effectiveness of our method for training on full data and augmented coresets.
Tab. 4 demonstrates the percentage of accuracy improvement resulted by augmenting subsets of size 5%, 10%, and 30% selected from our method vs. max-loss and random subsets, over that of full data augmentation.
We observe that augmenting coresets effectively improves generalization, and outperforms augmenting random and max-loss subsets across different models and datasets.
For example, on 30% subsets, we obtain 13.1% and 2.3% relative improvement over random and max-loss on average.
We also report results on TinyImageNet/ResNet50 ( R =15 ) in Tab. 3, where we show that augmenting coresets outperforms max-loss and random baselines, e.g. by achieving 3.7% and 4.4% relative improvement over 30% max-loss and random subsets, respectively.
Training speedup.
In Fig.
2, we measure the improvement in training time in the case of training on full data and augmenting subsets of various sizes.
While our method yields similar or slightly lower speedup to the max-loss and random baselines, our resulting accuracy outperforms the baselines on average.
For example, for SVHN/Resnet32 using 30% coresets, we sacriﬁce 11% of the relative speedup to obtain an additional 24 .
8% of the relative gain in accuracy from full data augmentation, compared to random baseline.
Notably, we get 3.43x speedup for training on full data and augmenting
[Table]
[Figure]
Augmenting noisy labeled data.
Next, we evaluate the robustness of our coresets to label noise.
Tab. 5 shows the result of augmenting coresets vs. max-loss and random subsets of different sizes selected from CIFAR10 with 50% label noise on ResNet20.
Notably, our method not only outperforms max-loss and random baselines, but also achieves superior performance over full data augmentation.
6.3 Training on Random Data and Augmented Coresets
Finally, we evaluate the performance of our method for training on random subsets and augmenting coresets, applicable when data is larger than the training budget.
We report results on TinyImageNet and ImageNet on ResNet50 (90 epochs, R = 15 ).
Tab. 6 shows the results of training on random subsets, and augmenting random subsets and coresets of the same size.
We see that our results hold for large-scale datasets, where we obtain 7 . 9% , 4 .
9% , and 5 .
3% relative improvement over random baseline with 10% , 20% , 30% subset sizes respectively on TinyImageNet, and 7 . 6% , 2 .
3% , and 1 .
3% relative improvement over random baseline with 10% , 30% , and 50% subset sizes on
ImageNet.
Notably, compared to AutoAugment, despite using only 30% subsets, we achieve 71.99% test accuracy, which is 92.8% of the original reported accuracy, while boasting 5x speedup in training.
[Table]
Conclusion
We showed that data augmentation improves training and generalization by relatively enlarging and perturbing the smaller singular values of the neural network Jacobian while preserving its prominent directions.
Then, we proposed a framework to iteratively extract small coresets of training data that when augmented, closely capture the alignment of the fully augmented Jacobian with the label/residual vector.
We showed the effectiveness of augmenting coresets in providing a superior generalization performance when added to the full data or random subsets, in presence of noisy labels, or as a standalone subset.
Under local smoothness of images, our additive perturbation can be applied to model many bounded transformations such as small rotations, crops, shearing, and pixel-wise transformations like sharpening, blurring, color distortions, structured adversarial perturbation [24].
However, the additive perturbation model is indeed limited when applied to augmentations that cannot be reduced to perturbations, such as horizontal/vertical ﬂips and large translations.
Further theoretical analysis of complex data augmentations is indeed an interesting direction for future work.
Acknowledgements
This research was supported in part by the National Science Foundation CAREER Award 2146492, and the UCLA-Amazon Science Hub for Humanity and AI.
Checklist
For all authors... (a) Do the main claims made in the abstract and introduction accurately reﬂect the paper’s contributions and scope?
[Yes] (b) Did you describe the limitations of your work?
[Yes] (c) Did you discuss any potential negative societal impacts of your work?
[N/A] (d) Have you read the ethics review guidelines and ensured that your paper conforms to them?
[Yes] 2.
If you are including theoretical results... (a) Did you state the full set of assumptions of all theoretical results?
[Yes] (b) Did you include complete proofs of all theoretical results?
[Yes] 3.
If you ran experiments... (a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)?
[Yes] In Supp Mat.
(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)?
[Yes] (c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)?
[Yes] (d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)?
[Yes] 4.
If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... (a) If your work uses existing assets, did you cite the creators?
[N/A] (b) Did you mention the license of the assets?
[N/A] (c) Did you include any new assets either in the supplemental material or as a URL?
[Yes] (d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating?
[N/A] (e) Did you discuss whether the data you are using/curating contains personally identiﬁable information or offensive content?
[N/A] 5.
If you used crowdsourcing or conducted research with human subjects... (a) Did you include the full text of instructions given to participants and screenshots, if applicable?
[N/A] (b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable?
[N/A] (c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation?
[N/A]
Supplementary Material:
Data-Efﬁcient Augmentation for Training Neural Networks
A Proof of Main Results A.1 Proof for Lemma 4.
Proof.
Let δ i :=
˜ σ i − σ i , where P ( δ i < 0)
=
p i .
Assuming uniform probability between −(cid:107) E (cid:107) to 0 , and between 0 to (cid:107) E (cid:107) , we have pdf ρ i ( x ) for δ i :
ρ i ( x ) =
  p i (cid:107) E (cid:107) , if − (cid:107) E (
cid:107)≤ x <1 − p
i (cid:107) E (cid:107) , 0 ≤ x
[Equation]
(cid:107) E (cid:107) 0 , otherwise (12)
Taking expectation,
[Equation]
(13) =
[Equation]
(cid:90)
[Equation]
(cid:107)
[Equation]
(cid:107)
[Equation]
(cid:107)
[Equation]
(cid:90) (cid:107) E (cid:107) x
1 − p
[Equation]
(cid:107)
[Equation]
(cid:107) dx (14)
[Equation]
(cid:107) p
[Equation] [Equation]
p i
[Equation]
(cid:107)
[Equation]
(cid:107) (15) = (
[Equation]
p
[Equation]
(cid:107)
[Equation]
(cid:107) (16)
We also have
[Equation] [Equation]
(cid:107)
[Equation]
(cid:107)
[Equation]
(cid:90) (cid:107)
[Equation]
(cid:107)
[Equation]
p
[Equation]
(cid:107) E (cid:107) dx
[Equation]
Thus
[Equation]
we have
[Equation]
A.2 Proof of Corollary 4.
Under the assumptions of Theorem 5.1 of [1], i.e. where the minimum eigenvalue of the NTK is λ min ( J J T ) ≥ λ 0 for a constant λ 0 > 0 , and training data X of size n sampled i.i.d.
from distribution D and 1-Lipschitz loss L , we have that with probability δ/ 3 , training the over-parameterized neural network with gradient descent for t ≥ Ω (cid:16) 1 nλ 0 log nδ (cid:17) iterations results in the following population loss L D (generalization error)
[Equation]
with high probability of at least 1 − δ over random initialization and training samples.
Hence, using λ min , σ min to denote minimum eigen and singular value respectively of the NTK corresponding to full data, we get
[Equation]
For augmented dataset X aug , we have ˜ σ i ≤ σ i + √ nL(cid:15) 0 , hence the improvement in the generalization error is at most
[Equation]
Combining these two results, we obtain Corollary 4.2.
A.3 Proof of Lemma 5.
Proof.
[Equation]
Applying deﬁnition of coresets
[Equation]
we obtain
[Equation]
A.4 Proof of Theorem
[Equation]
Proof.
In this proof, as shorthand notation
[Equation]
we use X f and X train interchangeably.
We further use
X c to represent the coreset selected from the full data, and X c aug to represent the augmented coreset.
By Theorem 1 of [ 3 ] , under the α -PL assumption for L and interpolation assumption (i
[Equation]
e. for every sequence W 1 , W 2 , . . .
such that lim t →∞ L ( W t , X ) = 0 , we have that the loss for each data point lim t →∞ L ( W t , x i ) = 0 ), the convergence of SGD with constant step size is given by
[Equation]
Using Jensen’s inequality, we have
[Equation] [Equation]
A.5 Finding Subsets
Let S be a subset of training data points.
Furthermore, assume that there is a mapping π w,S : V → S that for every W assigns every data point i ∈ V to its closest element j ∈ S ,
i
[Equation]
e. j = π w,S ( i ) =
arg max j (cid:48)
∈ S s ij (cid:48)
( W ) , where s ij ( W ) =
C − (cid:107)J T ( W t , x i ) r i − J T ( W t , x j ) r j (cid:107) is the similarity between gradients of i and j , and
C ≥ max ij s ij ( W ) is a constant.
Consider a matrix G π w,S ∈
R n × m , in which every row i contains gradient of π w ( i ) , i.e., [ G π w,S ] i. =
J T ( W t , x π w,S ( i ) )
r π w,S ( i ) .
The Frobenius norm of the matrix G π w provides an upper-bound on the error of the weighted subset S in capturing the alignment of the residuals of the full training data with the Jacobian matrix.
Formally,
[Equation] [Equation]
where the weight vector γ S t ∈ R | S | contains the number of elements that are mapped to every element j ∈ S by mapping π w,S , i.e. γ j = (cid:80) i ∈ V (cid:49) [ π w,S ( i )
=
j ] .
Hence, the set of training points that closely estimate the projection of the residuals of the full training data on the Jacobian spectrum can be obtained by ﬁnding a subset S that minimizes the Frobenius norm of matrix G π w,S .
B Additional Theoretical Results B.1 Convergence analysis for training on augmented full data
Theorem B.1.
Gradient descent with learning rate η applied to a neural network with constant NTK and Lipschitz constant L , and data points D aug augmented with r additive perturbations bounded by (cid:15) 0 results in the following training dynamics:
[Equation]
56) where E with (cid:107) E (cid:107)≤ √ nL(cid:15) 0 is the perturbation to the Jacobian, and p i :=
P ( ˜ σ i − σ i < 0) is the probability that σ i decreases as a result of data augmentation.
B.2 Proof of Theorem B.
Using Jensen’s inequality, we have
[Equation]
B.3 Convergence analysis for training on the coreset and its augmentation
Theorem B.2.
Let L i be β -smooth, L be λ -smooth and satisfy the α -PL condition, that is for α > 0 , (cid:107)∇L ( W , X ) (cid:107) 2 ≥ α L ( W , X ) for all weights W .
Let ξ upper-bound the normed difference in gradients between the weighted coreset and full dataset.
Assume that the network f ( W , X ) is
Lipschitz in W , X with Lipschitz constant L and L’ respectively, and ¯ L = max { L, L (cid:48) } .
Let Gthe gradient over the full dataset at initialization, σ max the maximum Jacobian singular value at initialization.
Choosing perturbation bound (cid:15) 0 ≤ 1 σ max √ ¯ Ln where σ max is the maximum singular value of the coreset Jacobian and n is the size of the original dataset, running SGD on the coreset and its augmentation using constant step size η
= α λβ , we get the following convergence bound:
[Equation]
where X c + c aug represents the dataset containing the (weighted) coreset and its augmentation.
Proof.
As in the proof for Theorem 5.2, we begin with the following inequality
[Equation]
Thus
[Equation]
we can write
[Equation]
The rest of the proof is similar to that of Theorem 5 . 2 .
B.4 Lemma for eigenvalues of coreset
The following Lemma characterizes the sum of eigenvalues of the NTK associated with the coreset.
Lemma B.3.
Let ξ be an upper bound of the normed difference in gradient of the weighted coreset and the original dataset, i.e. for full data X and its corresponding coreset X S with weights γ S , and respective residuals r , r S , we have the bound (cid:107)J T ( W t , X ) r t − γ S J T ( W t , X S ) r tS (cid:107)≤ ξ .
Let { λ i } ki =1 be the eigenvalues of the NTK associated with the coreset.
Then we have that
[Equation]
Proof.
Let singular values of coreset Jacobian be σ i .
Let J T ( W t , X ) r t = γ S J T ( W t , X S ) r tS + ξ S where (cid:107) ξ S (cid:107)≤ ξ .
Taking Frobenius norm, we get
[Equation]
[Equation] [Equation]
i
[Equation]
We can make the following observations: For overparameterized networks, with bounded activation functions and labels, e
[Equation]
g. softmax and one-hot encoding, the norm of the residual vector is bounded, and the gradient norm is likely to be much larger than residual, especially when dimension of gradient is large.
In this case, the Jacobian matrix associated with small weighted coresets found by solving
Eq.
(9), have large singular values.
B.5 Augmentation as Linear Transformation: Linear Model Analysis
We introduce a simpliﬁed linear model to extend our theoretical analysis to augmentations modelled as linear transformation matrices F applied to the original training data.
These augmentations are also originally studied by [40].
In this section, we speciﬁcally study the effect of these augmentations using a linear model when applied to coresets.
Lemma B.4 (Augmented coreset gradient bounds: Linear) .
Let f be a simple linear model with weights W ∈ R d × C where f ( W , x i )
=
W T x i , trained on mean squared loss function L .
Let
F ∈ R d × d be a common linear augmentation matrix with norm (cid:107) F (cid:107) with augmentation x
aug i given by F x i .
Let coreset be of size k and full dataset be of size n .
Further assume that the predicted label of x i and its augmentation F x i are sufﬁciently close, i.e. there exists ω such that W T ( F x i )
[Equation]
ω ∀ i .
Let ξ upper-bound the normed difference in gradients between the weighted coreset and full dataset.
Then, the normed difference between the gradient of the augmented full data and augmented coreset is given by
[Equation]
for some (small) constant ξ .
Proof.
By our assumption, we can begin with,
[Equation] [Equation]
Furthermore, by [29], we know that sum of the coreset weights γ s j is given by (cid:80) k
=1 j =1 γ s j ≤ n .
Hence,
[Equation]
Corollary B.5.
In the simpliﬁed linear case above, the difference in gradients of the full training data with its augmentations ( ∇L ( W , X f + aug ) ) and gradients of the coreset with its augmentations ( ∇L ( W , X c + c aug ) ) can be bounded by
[Equation]
Proof.
Applying Eq.
(77) and Lemma B
[Equation] [Equation]
we obtain
[Equation]
Theorem B.6 (Convergence of linear model) .
Let f be a linear model with weights W and augmentation be represented by the common linear transformation F .
Let L i be β -smooth, L be λ -smooth and satisfy the α -PL condition, that is for α > 0 , (cid:107)∇L ( W , X ) (cid:107) 2 ≥ α L ( W , X ) for all weights
W .
Let ξ upper-bound the normed difference in gradients between the weighted coreset and full dataset and ω bound W T ( F x i )
=
W T x
i
+ z
i , (cid:107) z i (cid:107)≤ ω ∀ i .
Let G (cid:48) 0 be the gradient over the full dataset and its augmentations at initialization.
Then, running SGD on the size k coreset with its augmentation using constant step size η = αλβ , we get the following convergence bound:
[Equation]
Proof.
From [ 3 ] , we have
[Equation]
Using Jensen’s inequality, we have
[Equation]
where the last inequality follows from applying Corollary B.5.
C Singular spectrum analysis C.1 Experiment details
We generate singular spectrum plots for both MNIST and CIFAR10 datasets in Figures 1 and 3.
Due to the computational infeasbility of computing the network Jacobian for the full datasets in deep network settings, we instead construct and use a reduced version of these datasets by uniformly select 900 images from the ﬁrst 3 classes.
For our experiments on MNIST, we pretrain a MLP model with hidden layer for 15 epochs.
For our experiments on CIFAR10, we pretrain a ResNet20 model forepochs.
We then compute the singular spectrums for augmented and non-augmented data based on these pretrained networks.
Since it is difﬁcult to perform a one-to-one matching of singular values produced from augmented and non-augmented datasets, we instead bin our singular values into 30 separate and uniformly distributed bins each containing the same number of singular values.
To measure perturbation to singular values resulted from augmentation, we compute the mean difference between each bin.
On the other hand, to measure perturbation to singular vectors, we compute mean subspace angle between the singular subspace spanned by singular vectors in each bin.
C.2 Real-world strong augmentations
We study the effects of real-world, unbounded augmentations on the singular spectrum of the network
Jacobian.
In particular, in additional to the plots in the main paper, we show the effect of strong augmentations through (1) random rotation (up to 30 ◦ and AutoAugment [7] for MNIST and (2) random horizontal ﬂips/random crops and AutoAugment for CIFAR10.
The policies implemented by
AutoAugment include translations, shearing, as well as contrast and brightness transforms.
We study the effects of these augmentations on the singular spectrum in Figure 3.
Despite these augmentations being unbounded transformations, we note that the results of our theory still holds.
In particular, it can be observed that data augmentation increases smaller singular values relatively more with a higher probability.
On the other hand, data augmentation affects the prominent singular vectors of the Jacobian to a smaller extent, and preserves the prominent directions.
As such, our argument empirically extends to real-world, unbounded label-invariant transformations characteristic of strong augmentations.
D Experiment Setup and Additional Experiments D.1 Experiment setup
For all experiments, we train using SGD with 0.9 momentum and learning rate decay.
For experiments on CIFAR10 and variants/ResNet20, we train for 200 epochs, for Caltech256 (ImageNet pretrained)/
ResNet18, we trained for 40 epochs starting at learning rate 0 .
001 and batch size 64.
We also report results for Caltech256 without ImageNet pretraining in Sec.
D.8, where we train for 400 epochs to ensure convergence with a starting learning rate of 0 .
05 and batch size 64.
For experiments on
ImageNet/ResNet50 and TinyImageNet/ResNet50, we use the standard 90 epoch learning schedule starting at learning rate of 0.1 and batch size 64.
Data and augmentation.
We apply our method to training ResNet20 and Wide-ResNet-28-10 on
CIFAR10, and ResNet32 on CIFAR10-IMB (Long-Tailed CIFAR10 with Imbalance factor offollowing [19]) and SVHN datasets.
We train Caltech256 [13] on ImageNet-pretrained ResNet18, and include experiments with random initialization in Appendix D. TinyImageNet and ImageNet are trained on with ResNet50.
We use [40] for CIFAR10/SVHN, and AutoAugment [7] for Caltech256,
TinyImageNet, and ImageNet as the strong augmentation method.
Note that we append strong augmentations rather than apply them in-place, which we show to be more effective in Appendix D.
All results are averaged over 5 runs using an Nvidia A40 GPU.
D.2 Experiment setup
For all experiments, we train using SGD with 0.9 momentum and learning rate decay.
We also set weight decay as For experiments on CIFAR10 and variants/ResNet20, we train for 200 epochs, for
Caltech256 (ImageNet pretrained)/ ResNet18, we trained for 40 epochs starting at learning rate 0 .and
batch size 64.
We also report results for Caltech256 without ImageNet pretraining in Sec.
D.8, where we train for 400 epochs to ensure convergence with a starting learning rate of 0 .
05 and batch size 64.
For experiments on ImageNet/ResNet50 and TinyImageNet/ResNet50, we use the standard 90 epoch learning schedule starting at learning rate of 0.1 and batch size 64.
Data and augmentation.
We apply our method to training ResNet20 and Wide-ResNet-28-10 on
CIFAR10, and ResNet32 on CIFAR10-IMB (Long-Tailed CIFAR10 with Imbalance factor offollowing [19]) and SVHN datasets.
We train Caltech256 [13] on ImageNet-pretrained ResNet18,
[Figure]
and include experiments with random initialization in Appendix D. TinyImageNet and ImageNet are trained on with ResNet50.
We use [40] for CIFAR10/SVHN, and AutoAugment [7] for Caltech256,
TinyImageNet
[Figure]
and ImageNet as the strong augmentation method.
Note that we append strong augmentations rather than apply them in-place, which we show to be more effective in Appendix D.
All results are averaged over 5 runs using an Nvidia A40 GPU.
D.3 Full Results for Table
This section contains full experiment results including standard deviations and the full augmentation benchmark for Table 4 .
Augmenting coresets of size 10% achieves 51% of the improvement obtained from augmentation of the full data and further enjoys a 6x speedup in training time on CIFAR10.
This speedup becomes more signiﬁcant when using strong augmentation techniques which are mostly computationally demanding, especially when applied to the entire dataset.
[Table]
D.4 Supplementary results for Tab.
[Table]
D.5 Training dynamics vs generalization
Figure 4 demonstrates the relationship between training loss and validation accuracy resulted from data augmentation.
While training loss of augmented datasets do not decrease as quickly as nonaugmented datasets, generalization performance (
) improves.
D.6 Augmentations applied through appending vs in-place
Our experiments on Caltech256/ResNet18/AutoAugment ( R =5 ) show that even for cheaper strong augmentation methods (AutoAugment), while in-place augmentation may decrease the performance, appending Random (R) and Coresets (C) augmentations (Append) outperforms in-place augmentation of 2x data points (In-place 2x) for various subset sizes.
[Table]
D.7 Speed-up measurements
We measure the improvement in training time in the case of training on full data and augmenting subsets of various sizes.
While our method yields similar or slightly lower speed-up to the max-loss policy and random approach respectively, our resulting accuracy outperforms these two approaches.
We show this in Fig.
D.7.
For example, for SVHN/Resnet32 using 30% coresets, we sacriﬁce 11% of the speed-up to obtain an additional 24 .
8% of the gain in accuracy from full data augmentation when compared to a random subset of the same size.
We show the speed-up obtained for our method and various subset sizes in Tab. 10, and provide wall-clock times for our method in Tab. D.7.
R20), SVHN + ResNet32 (SVHN/R32).
Dataset
Full Aug.
Ours
Max loss.
Random.
[Figure]
C10 / R 1 x 7 .
93 x 6 .
31 x 4 .
46 x 4 .
27 x 3 .
41 x 3 .
43 x 3 .
48 x 4 .
03 x
SVHN / R 1 x
[Figure]
35 x
[Figure]
x 3 .
40 x 2 .
80 x 2 .
49 x 2 .
18 x 2 .
21 x
[Figure]
43 x
[Figure]
be found in parallel ( threads) different classes and selection happens every
=
Hence, the numbers divide by
[Table]
As Caltech256 contains many classes and higher resolution images, training on smaller subset without pretraining has a low accuracy.
Thus, many works (e.g. Achille et al., 2020) ﬁnetune from ImageNet pretrained initialization.
However, we show that our results still hold even when training form scratch.
We demonstrate our results in Tab.
12, where we train Caltech256 on ResNet50 without pretraining for 400 epochs, and with R = 40 , where our method consistently outperfoms random subsets for multiple subset sizes ( 5% , 10% , 30% , 50% ).
[Table]
D.9 Training on full data and augmenting small subsets re-selected every epoch
We apply our proposed method to select a new subset for augmentation every epoch (i.e. using
R = 1 ) and compare our results with other approaches using accuracy and percentage of data not selected (NS).
We see that while the max-loss policy selects a small fraction of data points over and over and random uniformly selects all the data points, our approach successfully ﬁnds the smallest subset of data points that are the most crucial for data augmentation.
Hence, it can achieve a superior accuracy than max-loss policy, while augmenting only slightly more examples.
This conﬁrms the data-efﬁciency of our approach.
This is especially evident when using coresets of size 0 .
Furthermore, despite the random baseline using a signiﬁcantly larger percentage of data, it is outperformed by our approach in both data-efﬁciency and accuracy.
We emphasize that results in this table is different from that of Table 7 , as default augmentations on the full training data are performed once every R = 1 epochs instead of every R = 20 epochs.
Since selecting subsets at every epoch can be computationally expensive, we only perform these experiments on small coresets and hence still enjoy good speedups compared to full data augmentation.
This shows that our approach is still effective at very small subset sizes, hence can be computationally efﬁcient even when subsets are re-selected every epoch.
[Table]
D.10 Additional visualizations for training on coresets and its augmentations - Measuring training dynamics over time
We include additional visualizations in Figure 6 for training on coresets and its augmentations as supplementary plots to Figure 9(c) and Table 1.
We plot metrics obtained during each point (epoch)
[Figure]
of the training process based on percentage of data selected/used and test accuracy achieved.
All metrics are averaged over 5 runs and obtained using R = 1 .
These plots demonstrate that coreset augmentation approaches outperform random augmentation baselines throughout the training process.
Furthermore, they show that augmentation of coresets result in a larger increase in test accuracy compared to augmentation of randomly selected training examples, especially for small subset sizes
D.11 Intersection of max-loss policy and coresets
Figure 9( a ) depicts the increase in intersection between max-loss subsets and coresets over time.
In addition, we also aggregate 30% subsets selected every R = 20 epochs using both approaches over the entire training process to compute intersection between the top N selected data points.
Our plots
[Figure]
in Figure 7 suggest that a similar pattern holds in this setting.
We also qualitatively visualize this in
Figure 8.