Adversarial Examples Are Not Bugs, They Are Features

Introduction

The pervasive brittleness of deep neural networks [Sze+14, Eng+19a, HD19, Ath+18] has attracted significant attention in recent years. Particularly worrisome is the phenomenon of adversarial examples [Big+13, Sze+14], imperceptibly perturbed natural inputs that induce erroneous predictions in state-of-the-art classifiers. Previous work has proposed a variety of explanations for this phenomenon, ranging from theoretical models [Sch+18, BPR18] to arguments based on concentration of measure in high-dimensions [Gil+18, MDM18, Sha+19]. These theories, however, are often unable to fully capture behaviors we observe in practice (we discuss this further in Section 5).

More broadly, previous work in the field tends to view adversarial examples as aberrations arising either from the high dimensional nature of the input space or statistical fluctuations in the training data [Sze+14, GSS15, Gil+18]. From this point of view, it is natural to treat adversarial robustness as a goal that can be disentangled and pursued independently from maximizing accuracy [Mad+18, SHS19, Sug+19], either through improved standard regularization methods [TG16] or pre/post-processing of network inputs/outputs [Ues+18, CW17, He+17].

In this work, we propose a new perspective on the phenomenon of adversarial examples. In contrast to the previous models, we cast adversarial vulnerability as a fundamental consequence of the dominant supervised learning paradigm. Specifically, we claim that:

Adversarial vulnerability is a direct result of our models’ sensitivity to well-generalizing features in the data.

Recall that we usually train classifiers to solely maximize (distributional) accuracy. Consequently, classifiers tend to use any available signal to do so, even those that look incomprehensible to humans. After all, the presence of “a tail” or “ears” is no more natural to a classifier than any other equally predictive feature. In fact, we find that standard ML datasets do admit highly predictive yet imperceptible features. We posit that our models learn to rely on these ‘‘non-robust’’ features, leading to adversarial perturbations that exploit this dependence. It is worth emphasizing that while our findings demonstrate that adversarial vulnerability does arise from non-robust features, they do not preclude the possibility of adversarial vulnerability also arising from other phenomena [TG16, Sch+18]. For example, [Nak19] constructs adversarial examples that do not exploit non-robust features (and hence do not allow one to learn a generalizing model from them). Still, the mere existence of useful non-robust features suffices to establish that without explicitly discouraging models from utilizing these features, adversarial vulnerability will remain an issue.

Our hypothesis also suggests an explanation for adversarial transferability: the phenomenon that adversarial perturbations computed for one model often transfer to other, independently trained models. Since any two models are likely to learn similar non-robust features, perturbations that manipulate such features will apply to both. Finally, this perspective establishes adversarial vulnerability as a human-centric phenomenon, since, from the standard supervised learning point of view, non-robust features can be as important as robust ones. It also suggests that approaches aiming to enhance the interpretability of a given model by enforcing “priors” for its explanation [MV15, OMS17, Smi+17] actually hide features that are “meaningful” and predictive to standard models. As such, producing human-meaningful explanations that remain faithful to underlying models cannot be pursued independently from the training of the models themselves.

To corroborate our theory, we show that it is possible to disentangle robust from non-robust features in standard image classification datasets. Specifically, given any training dataset, we are able to construct:

A “robustified” version for robust classification (Figure 1(a)) The corresponding datasets for CIFAR-10 are publicly available at http://git.io/adv-datasets. . We demonstrate that it is possible to effectively remove non-robust features from a dataset. Concretely, we create a training set (semantically similar to the original) on which standard training yields good robust accuracy on the original, unmodified test set. This finding establishes that adversarial vulnerability is not necessarily tied to the standard training framework, but is also a property of the dataset.

A “non-robust” version for standard classification (Figure 1(b)) 2 . We are also able to construct a training dataset for which the inputs are nearly identical to the originals, but all appear incorrectly labeled. In fact, the inputs in the new training set are associated to their labels only through small adversarial perturbations (and hence utilize only non-robust features). Despite the lack of any predictive human-visible information, training on this dataset yields good accuracy on the original, unmodified test set. This demonstrates that adversarial perturbations can arise from flipping features in the data that are useful for classification of correct inputs (hence not being purely aberrations).

Finally, we present a concrete classification task where the connection between adversarial examples and non-robust features can be studied rigorously. This task consists of separating Gaussian distributions, and is loosely based on the model presented in [Tsi+19], while expanding upon it in a few ways. First, adversarial vulnerability in our setting can be precisely quantified as a difference between the intrinsic data geometry and that of the adversary’s perturbation set. Second, robust training yields a classifier which utilizes a geometry corresponding to a combination of these two. Lastly, the gradients of standard models can be significantly more misaligned with the inter-class direction, capturing a phenomenon that has been observed in practice in more complex scenarios [Tsi+19].

The Robust Features Model

We begin by developing a framework, loosely based on the setting proposed by [Tsi+19], that enables us to rigorously refer to “robust” and “non-robust” features. In particular, we present a set of definitions which allow us to formally describe our setup, theoretical results, and empirical evidence.

We consider binary classification Our framework can be straightforwardly adapted though to the multi-class setting., where input-label pairs $(x,y)\in\mathcal{X}\times\{\pm 1\}$ are sampled from a (data) distribution $\mathcal{D}$; the goal is to learn a classifier $C:\mathcal{X}\rightarrow\{\pm 1\}$ which predicts a label $y$ corresponding to a given input $x$.

We now define the key concepts required for formulating our framework. To this end, we categorize features in the following manner:

$\rho$-useful features: For a given distribution $\mathcal{D}$, we call a feature $f$ $\rho$-useful ($\rho>0$) if it is correlated with the true label in expectation, that is if

We then define $\rho_{\mathcal{D}}(f)$ as the largest $\rho$ for which feature $f$ is $\rho$-useful under distribution $\mathcal{D}$. (Note that if a feature $f$ is negatively correlated with the label, then $-f$ is useful instead.) Crucially, a linear classifier trained on $\rho$-useful features can attain non-trivial generalization performance.

$\gamma$-robustly useful features: Suppose we have a $\rho$-useful feature $f$ ($\rho_{\mathcal{D}}(f)>0$). We refer to $f$ as a robust feature (formally a $\gamma$-robustly useful feature for $\gamma>0$) if, under adversarial perturbation (for some specified set of valid perturbations $\Delta$), $f$ remains $\gamma$-useful. Formally, if we have that

Useful, non-robust features: A useful, non-robust feature is a feature which is $\rho$-useful for some $\rho$ bounded away from zero, but is not a $\gamma$-robust feature for any $\gamma\geq 0$. These features help with classification in the standard setting, but may hinder accuracy in the adversarial setting, as the correlation with the label can be flipped.

In our framework, a classifier $C=(F,w,b)$ is comprised of a set of features $F\subseteq\mathcal{F}$, a weight vector $w$, and a scalar bias $b$. For a given input $x$, the classifier predicts the label $y$ as

For convenience, we denote the set of features learned by a classifier $C$ as $F_{C}$.

Training a classifier is performed by minimizing a loss function (via empirical risk minimization (ERM)) that decreases with the correlation between the weighted combination of the features and the label. The simplest example of such a loss is Just as for the other parts of this model, we use this loss for simplicity only—it is straightforward to generalize to more practical loss function such as logistic or hinge loss.

When minimizing classification loss, no distinction exists between robust and non-robust features: the only distinguishing factor of a feature is its $\rho$-usefulness. Furthermore, the classifier will utilize any $\rho$-useful feature in $F$ to decrease the loss of the classifier.

In the presence of an adversary, any useful but non-robust features can be made anti-correlated with the true label, leading to adversarial vulnerability. Therefore, ERM is no longer sufficient to train classifiers that are robust, and we need to explicitly account for the effect of the adversary on the classifier. To do so, we use an adversarial loss function that can discern between robust and non-robust features [Mad+18]:

for an appropriately defined set of perturbations $\Delta$. Since the adversary can exploit non-robust features to degrade classification accuracy, minimizing this adversarial loss (as in adversarial training [GSS15, Mad+18]) can be viewed as explicitly preventing the classifier from learning a useful but non-robust combination of features.

We want to note that even though the framework above enables us to formally describe and predict the outcome of our experiments, it does not necessarily capture the notion of non-robust features exactly as we intuitively might think of them. For instance, in principle, our theoretical framework would allow for useful non-robust features to arise as combinations of useful robust features and useless non-robust features [Goh19a]. These types of constructions, however, are actually precluded by our experimental results (in particular, the classifiers trained in Section 3 would not generalize). This shows that our experimental findings capture a stronger, more fine-grained statement than our formal definitions are able to express. We view bridging this gap as an interesting direction for future work.

Finding Robust (and Non-Robust) Features

The central premise of our proposed framework is that there exist both robust and non-robust features that constitute useful signals for standard classification. We now provide evidence in support of this hypothesis by disentangling these two sets of features.

On one hand, we will construct a “robustified” dataset, consisting of samples that primarily contain robust features. Using such a dataset, we are able to train robust classifiers (with respect to the standard test set) using standard (i.e., non-robust) training. This demonstrates that robustness can arise by removing certain features from the dataset (as, overall, the new dataset contains less information about the original training set). Moreover, it provides evidence that adversarial vulnerability is caused by non-robust features and is not inherently tied to the standard training framework.

On the other hand, we will construct datasets where the input-label association is based purely on non-robust features (and thus the corresponding dataset appears completely mislabeled to humans). We show that this dataset suffices to train a classifier with good performance on the standard test set. This indicates that natural models use non-robust features to make predictions, even in the presence of robust features. These features alone are actually sufficient for non-trivial generalizations performance on natural images, which indicates that they are indeed valuable features, rather than artifacts of finite-sample overfitting.

A conceptual description of these experiments can be found in Figure 1.

Recall that the features a classifier learns to rely on are based purely on how useful these features are for (standard) generalization. Thus, under our conceptual framework, if we can ensure that only robust features are useful, standard training should result in a robust classifier. Unfortunately, we cannot directly manipulate the features of very complex, high-dimensional datasets. Instead, we will leverage a robust model and modify our dataset to contain only the features that are relevant to that model.

In terms of our formal framework (Section 2), given a robust (i.e., adversarially trained [Mad+18]) model $C$ we aim to construct a distribution $\widehat{\mathcal{D}}_{R}$ which satisfies:

where $F_{C}$ again represents the set of features utilized by $C$. Conceptually, we want features used by $C$ to be as useful as they were on the original distribution $\mathcal{D}$ while ensuring that the rest of the features are not useful under $\widehat{\mathcal{D}}_{NR}$.

We will construct a training set for $\widehat{\mathcal{D}}_{R}$ via a one-to-one mapping $x\mapsto x_{r}$ from the original training set for $\mathcal{D}$. In the case of a deep neural network, $F_{C}$ corresponds to exactly the set of activations in the penultimate layer (since these correspond to inputs to a linear classifier). To ensure that features used by the model are equally useful under both training sets, we (approximately) enforce all features in $F_{C}$ to have similar values for both $x$ and $x_{r}$ through the following optimization:

where $x$ is the original input and $g$ is the mapping from $x$ to the representation layer. We optimize this objective using gradient descent in input space We follow [Mad+18] and normalize gradient steps during this optimization. Experimental details are provided in Appendix C..

Since we don’t have access to features outside $F_{C}$, there is no way to ensure that the expectation in (5) is zero for all $f\not\in F_{C}$. To approximate this condition, we choose the starting point of gradient descent for the optimization in (6) to be an input $x_{0}$ which is drawn from $\mathcal{D}$ independently of the label of $x$ (we also explore sampling $x_{0}$ from noise in Appendix D.1). This choice ensures that any feature present in that input will not be useful since they are not correlated with the label in expectation over $x_{0}$. The underlying assumption here is that, when performing the optimization in (6), features that are not being directly optimized (i.e., features outside $F_{C}$) are not affected. We provide pseudocode for the construction in Figure 5 (Appendix C).

Given the new training set for $\widehat{\mathcal{D}}_{R}$ (a few random samples are visualized in Figure 2(a)), we train a classifier using standard (non-robust) training. We then test this classifier on the original test set (i.e. $\mathcal{D}$). The results (Figure 2(b)) indicate that the classifier learned using the new dataset attains good accuracy in both standard and adversarial settings In an attempt to explain the gap in accuracy between the model trained on $\widehat{\mathcal{D}}_{R}$ and the original robust classifier $C$, we test distributional shift, by reporting results on the “robustified” test set in Appendix D.3. In order to gain more confidence in the robustness of the resulting model, we attempt several diverse attacks in Appendix D.2..

As a control, we repeat this methodology using a standard (non-robust) model for $C$ in our construction of the dataset. Sample images from the resulting “non-robust dataset” $\widehat{\mathcal{D}}_{NR}$ are shown in Figure 2(a)—they tend to resemble more the source image of the optimization $x_{0}$ than the target image $x$. We find that training on this dataset leads to good standard accuracy, yet yields almost no robustness (Figure 2(b)). We also verify that this procedure is not simply a matter of encoding the weights of the original model—we get the same results for both $\widehat{\mathcal{D}}_{R}$ and $\widehat{\mathcal{D}}_{NR}$ if we train with different architectures than that of the original models.

Overall, our findings corroborate the hypothesis that adversarial examples can arise from (non-robust) features of the data itself. By filtering out non-robust features from the dataset (e.g. by restricting the set of available features to those used by a robust model), one can train a significantly more robust model using standard training.

2 Non-robust features suffice for standard classification

The results of the previous section show that by restricting the dataset to only contain features that are used by a robust model, standard training results in classifiers that are significantly more robust. This suggests that when training on the standard dataset, non-robust features take on a large role in the resulting learned classifier. Here we set out to show that this role is not merely incidental or due to finite-sample overfitting. In particular, we demonstrate that non-robust features alone suffice for standard generalization— i.e., a model trained solely on non-robust features can perform well on the standard test set.

To show this, we construct a dataset where the only features that are useful for classification are non-robust features (or in terms of our formal model from Section 2, all features $f$ that are $\rho$-useful are non-robust). To accomplish this, we modify each input-label pair $(x,y)$ as follows. We select a target class $t$ either (a) uniformly at random among classes (hence features become uncorrelated with the labels) or (b) deterministically according to the source class (e.g. using a fixed permutation of labels). Then, we add a small adversarial perturbation to $x$ in order to ensure it is classified as $t$ by a standard model. Formally:

where $L_{C}$ is the loss under a standard (non-robust) classifier $C$ and $\varepsilon$ is a small constant. The resulting inputs are nearly indistinguishable from the originals (Appendix D Figure 9)—to a human observer, it thus appears that the label $t$ assigned to the modified input is simply incorrect. The resulting input-label pairs $(x_{adv},t)$ make up the new training set (pseudocode in Appendix C Figure 6).

Now, since $\|x_{adv}-x\|$ is small, by definition the robust features of $x_{adv}$ are still correlated with class $y$ (and not $t$) in expectation over the dataset. After all, humans still recognize the original class. On the other hand, since every $x_{adv}$ is strongly classified as $t$ by a standard classifier, it must be that some of the non-robust features are now strongly correlated with $t$ (in expectation).

In the case where $t$ is chosen at random, the robust features are originally uncorrelated with the label $t$ (in expectation), and after the adversarial perturbation can be only slightly correlated (hence being significantly less useful for classification than before) [Goh19] provides an approach to quantifying this “robust feature leakage” and finds that one can obtain a (small) amount of test accuracy by leveraging robust feature leakage on $\widehat{\mathcal{D}}_{rand}$.. Formally, we aim to construct a dataset $\widehat{\mathcal{D}}_{rand}$ where Note that the optimization procedure we describe aims to merely approximate this condition, where we once again use trained models to simulate access to robust and non-robust features. :

In contrast, when $t$ is chosen deterministically based on $y$, the robust features actually point away from the assigned label $t$. In particular, all of the inputs labeled with class $t$ exhibit non-robust features correlated with $t$, but robust features correlated with the original class $y$. Thus, robust features on the original training set provide significant predictive power on the training set, but will actually hurt generalization on the standard test set. Viewing this case again using the formal model, our goal is to construct $\widehat{\mathcal{D}}_{det}$ such that

We find that standard training on these datasets actually generalizes to the original test set, as shown in Table 1). This indicates that non-robust features are indeed useful for classification in the standard setting. Remarkably, even training on $\widehat{\mathcal{D}}_{det}$ (where all the robust features are correlated with the wrong class), results in a well-generalizing classifier. This indicates that non-robust features can be picked up by models during standard training, even in the presence of robust features that are predictive Additional results and analysis (e.g. training curves, generating $\widehat{\mathcal{D}}_{rand}$ and $\widehat{\mathcal{D}}_{det}$ with a robust model, etc.) are in App. D.6 and D.5 We also show that the models trained on $\widehat{\mathcal{D}}_{rand}$ and $\widehat{\mathcal{D}}_{det}$ generalize to CIFAR-10.1 [Rec+19] in Appendix D.7..

3 Transferability can arise from non-robust features

One of the most intriguing properties of adversarial examples is that they transfer across models with different architectures and independently sampled training sets [Sze+14, PMG16, CRP19]. Here, we show that this phenomenon can in fact be viewed as a natural consequence of the existence of non-robust features. Recall that, according to our main thesis, adversarial examples can arise as a result of perturbing well-generalizing, yet brittle features. Given that such features are inherent to the data distribution, different classifiers trained on independent samples from that distribution are likely to utilize similar non-robust features. Consequently, an adversarial example constructed by exploiting the non-robust features learned by one classifier will transfer to any other classifier utilizing these features in a similar manner.

In order to illustrate and corroborate this hypothesis, we train five different architectures on the dataset generated in Section 3.2 (adversarial examples with deterministic labels) for a standard ResNet-50 [He+16]. Our hypothesis would suggest that architectures which learn better from this training set (in terms of performance on the standard test set) are more likely to learn similar non-robust features to the original classifier. Indeed, we find that the test accuracy of each architecture is predictive of how often adversarial examples transfer from the original model to standard classifiers with that architecture (Figure 3). In a similar vein, [Nak19] constructs a set of adversarial perturbations that is explicitly non-transferable and finds that these perturbations cannot be used to learn a good classifier. These findings thus corroborate our hypothesis that adversarial transferability arises when models learn similar brittle features of the underlying dataset.

A Theoretical Framework for Studying (Non)-Robust Features

The experiments from the previous section demonstrate that the conceptual framework of robust and non-robust features is strongly predictive of the empirical behavior of state-of-the-art models on real-world datasets. In order to further strengthen our understanding of the phenomenon, we instantiate the framework in a concrete setting that allows us to theoretically study various properties of the corresponding model. Our model is similar to that of [Tsi+19] in the sense that it contains a dichotomy between robust and non-robust features, but extends upon it in a number of ways:

Robust learning corresponds exactly to learning a combination of these two metrics.

The gradients of adversarially trained models align better with the adversary’s metric.

We study a simple problem of maximum likelihood classification between two Gaussian distributions. In particular, given samples $(x,y)$ sampled from $\mathcal{D}$ according to

our goal is to learn parameters $\Theta=(\bm{\mu},\bm{\Sigma})$ such that

A detailed analysis of this setting is in Appendix E—here we present a high-level overview of the results.

Consider an adversary whose perturbation is determined by the “Lagrangian penalty” form of (12), i.e.

where $C\geq\frac{1}{\sigma_{min}(\bm{\Sigma}_{*})}$ is a constant trading off NLL minimization and the adversarial constraint The constraint on $C$ is to ensure the problem is concave.. Then, the adversarial loss $\mathcal{L}_{adv}$ incurred by the non-robustly learned $(\bm{\mu},\bm{\Sigma})$ is given by:

and, for a fixed $\text{tr}(\bm{\Sigma}_{*})=k$ the above is minimized by $\bm{\Sigma}_{*}=\frac{k}{d}\bm{I}$.

In fact, note that such a misalignment corresponds precisely to the existence of non-robust features, as it indicates that “small” changes in the adversary’s metric along certain directions can cause large changes under the data-dependent notion of distance established by the parameters. This is illustrated in Figure 4, where misalignment in the feature-induced metric is responsible for the presence of a non-robust feature in the corresponding classification problem.

Just as in the non-robust case, $\bm{\mu}_{r}=\bm{\mu}^{*}$, i.e. the true mean is learned. For the robust covariance $\bm{\Sigma}_{r}$, there exists an $\varepsilon_{0}>0$, such that for any $\varepsilon\in[0,\varepsilon_{0})$,

Note that in the setting described so far, robustness can be at odds with accuracy since robust training prevents us from learning the most accurate classifier (a similar conclusion is drawn in [Tsi+19]). However, we note that there are very similar settings where non-robust features manifest themselves in the same way, yet a classifier with perfect robustness and accuracy is still attainable. Concretely, consider the distributions pictured in Figure 14 in Appendix D.10. It is straightforward to show that while there are many perfectly accurate classifiers, any standard loss function will learn an accurate yet non-robust classifier. Only when robust training is employed does the classifier learn a perfectly accurate and perfectly robust decision boundary.

Related Work

Several models for explaining adversarial examples have been proposed in prior work, utilizing ideas ranging from finite-sample overfitting to high-dimensional statistical phenomena [Gil+18, FFF18, For+19, TG16, Sha+19, MDM18, Sha+19a, GSS15, BPR18]. The key differentiating aspect of our model is that adversarial perturbations arise as well-generalizing, yet brittle, features, rather than statistical anomalies or effects of poor statistical concentration. In particular, adversarial vulnerability does not stem from using a specific model class or a specific training method, since standard training on the “robustified” data distribution of Section 3.1 leads to robust models. At the same time, as shown in Section 3.2, these non-robust features are sufficient to learn a good standard classifier. We discuss the connection between our model and others in detail in Appendix A. We discuss additional related work in Appendix B.

Conclusion

In this work, we cast the phenomenon of adversarial examples as a natural consequence of the presence of highly predictive but non-robust features in standard ML datasets. We provide support for this hypothesis by explicitly disentangling robust and non-robust features in standard datasets, as well as showing that non-robust features alone are sufficient for good generalization. Finally, we study these phenomena in more detail in a theoretical setting where we can rigorously study adversarial vulnerability, robust training, and gradient alignment.

Our findings prompt us to view adversarial examples as a fundamentally human phenomenon. In particular, we should not be surprised that classifiers exploit highly predictive features that happen to be non-robust under a human-selected notion of similarity, given such features exist in real-world datasets. In the same manner, from the perspective of interpretability, as long as models rely on these non-robust features, we cannot expect to have model explanations that are both human-meaningful and faithful to the models themselves. Overall, attaining models that are robust and interpretable will require explicitly encoding human priors into the training process.

Acknowledgements

We thank Preetum Nakkiran for suggesting the experiment of Appendix D.9 (i.e. replicating Figure 3 but with targeted attacks). We also are grateful to the authors of [Eng+19] (Chris Olah, Dan Hendrycks, Justin Gilmer, Reiichiro Nakano, Preetum Nakkiran, Gabriel Goh, Eric Wallace)—for their insights and efforts replicating, extending, and discussing our experimental results.

Work supported in part by the NSF grants CCF-1553428, CCF-1563880, CNS-1413920, CNS-1815221, IIS-1447786, IIS-1607189, the Microsoft Corporation, the Intel Corporation, the MIT-IBM Watson AI Lab research grant, and an Analog Devices Fellowship.

References

Appendix A Connections to and Disambiguation from Other Models

Here, we describe other models for adversarial examples and how they relate to the model presented in this paper.

An orthogonal line of work [Gil+18, FFF18, MDM18, Sha+19], argues that the high dimensionality of the input space can present fundamental barriers on classifier robustness. At a high level, one can show that, for certain data distributions, any decision boundary will be close to a large fraction of inputs and hence no classifier can be robust against small perturbations. While there might exist such fundamental barriers to robustly classifying standard datasets, this model cannot fully explain the situation observed in practice, where one can train (reasonably) robust classifiers on standard datasets [Mad+18, RSL18, WK18, Xia+19, CRK19].

[Sch+18] propose a theoretical model under which a single sample is sufficient to learn a good, yet non-robust classifier, whereas learning a good robust classifier requires $O(\sqrt{d})$ samples. Under this model, adversarial examples arise due to insufficient information about the true data distribution. However, unless the adversary is strong enough (in which case no robust classifier exists), adversarial inputs cannot be utilized as inputs of the opposite class (as done in our experiments in Section 3.2). We note that our model does not explicitly contradict the main thesis of [Sch+18]. In fact, this thesis can be viewed as a natural consequence of our conceptual framework. In particular, since training models robustly reduces the effective amount of information in the training data (as non-robust features are discarded), more samples should be required to generalize robustly.

[TG16] introduce the “boundary tilting” model for adversarial examples, and suggest that adversarial examples are a product of over-fitting. In particular, the model conjectures that “adversarial examples are possible because the class boundary extends beyond the submanifold of sample data and can be—under certain circumstances—lying close to it.” Consequently, the authors suggest that mitigating adversarial examples may be a matter of regularization and preventing finite-sample overfitting. In contrast, our empirical results in Section 3.2 suggest that adversarial inputs consist of features inherent to the data distribution, since they can encode generalizing information about the target class.

Inspired by this hypothesis and concurrently to our work, [KSJ19] present a simple classification task comprised of two Gaussian distributions in two dimensions. They experimentally show that the decision boundary tends to better align with the vector between the two means for robust models. This is a special case of our theoretical results in Section 4. (Note that this exact statement is not true beyond two dimensions, as discussed in Section 4.)

[FMF16] and [For+19] argue that the adversarial robustness of a classifier can be directly connected to its robustness under (appropriately scaled) random noise. While this constitutes a natural explanation of adversarial vulnerability given the classifier robustness to noise, these works do not attempt to justify the source of the latter.

At the same time, recent work [Lec+19, CRK19, For+19] utilizes random noise during training or testing to construct adversarially robust classifiers. In the context of our framework, we can expect the added noise to disproportionately affect non-robust features and thus hinder the model’s reliance on them.

[GSS15] suggest that the local linearity of DNNs is largely responsible for the existence of small adversarial perturbations. While this conjecture is supported by the effectiveness of adversarial attacks exploiting local linearity (e.g., FGSM [GSS15]), it is not sufficient to fully characterize the phenomena observed in practice. In particular, there exist adversarial examples that violate the local linearity of the classifier [Mad+18], while classifiers that are less linear do not exhibit greater robustness [ACW18].

[Sha+19a] prove that the geometric structure of the classifier’s decision boundaries can lead to sparse adversarial perturbations. However, this result does not take into account the distance to the decision boundary along these direction or feasibility constraints on the input domain. As a result, it cannot meaningfully distinguish between classifiers that are brittle to small adversarial perturbations and classifiers that are moderately robust.

[BPR18] and [Nak19a] propose theoretical models where the barrier to learning robust classifiers is, respectively, due to computational constraints or model complexity. In order to construct distributions that admit accurate yet non-robust classifiers they (implicitly) utilize the concept of non-robust features. Namely, they add a low-magnitude signal to each input that encodes the true label. This allows a classifier to achieve perfect standard accuracy, but cannot be utilized in an adversarial setting as this signal is susceptible to small adversarial perturbations.

Appendix B Additional Related Work

We describe previously proposed models for the existence of adversarial examples in the previous section. Here we discuss other work that is methodologically or conceptually similar to ours.

The experiments performed in Section 3.1 can be seen as a form of distillation. There is a line of work, known as model distillation [HVD14, Fur+18, BCN06], where the goal is to train a new model to mimic another already trained model. This is typically achieved by adding some regularization terms to the loss in order to encourage the two models to be similar, often replacing training labels with some other target based on the already trained model. While it might be possible to successfully distill a robust model using these methods, our goal was to achieve it by only modifying the training set (leaving the training process unchanged), hence demonstrating that adversarial vulnerability is mainly a property of the dataset. Closer to our work is dataset distillation [Wan+18] which considers the problem of reconstructing a classifier from an alternate dataset much smaller than the original training set. This method aims to produce inputs that directly encode the weights of the already trained model by ensuring that the classifier’s gradient with respect to these inputs approximates the desired weights. (As a result, the inputs constructed do not resemble natural inputs.) This approach is orthogonal to our goal since we are not interested in encoding the particular weights into the dataset but rather in imposing a structure to its features.

In our work, we posit that a potentially natural consequence of the existence of non-robust features is adversarial transferability [Pap+17, Liu+17, PMG16]. A recent line of work has considered this phenomenon from a theoretical perspective, confined to simple models, or unbounded perturbations [CRP19, Zou+18]. [Tra+17] study transferability empirically, by finding adversarial subspaces, (orthogonal vectors whose linear combinations are adversarial perturbations). The authors find that there is a significant overlap in the adversarial subspaces between different models, and identify this as a source of transferability. In our work, we provide a potential reason for this overlap—these directions correspond to non-robust features utilized by models in a similar manner.

[Moo+17] construct perturbations that can cause misclassification when applied to multiple different inputs. More recently, [JLT18] discover input patterns that are meaningless to humans and can induce misclassification, while at the same time being essential for standard classification. These findings can be naturally cast into our framework by considering these patterns as non-robust features, providing further evidence about their pervasiveness.

[Din+19] perform synthetic transformations on the dataset (e.g., image saturation) and study the performance of models on the transformed dataset under standard and robust training. While this can be seen as a method of restricting the features available to the model during training, it is unclear how well these models would perform on the standard test set. [Gei+19] aim to quantify the relative dependence of standard models on shape and texture information of the input. They introduce a version of ImageNet where texture information has been removed and observe an improvement to certain corruptions.

Appendix C Experimental Setup

For our experimental analysis, we use the CIFAR-10 [Kri09] and (restricted) ImageNet [Rus+15] datasets. Attaining robust models for the complete ImageNet dataset is known to be a challenging problem, both due to the hardness of the learning problem itself, as well as the computational complexity. We thus restrict our focus to a subset of the dataset which we denote as restricted ImageNet. To this end, we group together semantically similar classes from ImageNet into 9 super-classes shown in Table 2. We train and evaluate only on examples corresponding to these classes.

C.2 Models

We use the ResNet-50 architecture for our baseline standard and adversarially trained classifiers on CIFAR-10 and restricted ImageNet. For each model, we grid search over three learning rates ($0.1$, $0.01$, $0.05$), two batch sizes ($128$, $256$) including/not including a learning rate drop (a single order of magnitude) and data augmentation. We use the standard training parameters for the remaining parameters. The hyperparameters used for each model are given in Table 3.

C.3 Adversarial training

C.4 Constructing a Robust Dataset

C.5 Non-robust features suffice for standard classification

Appendix D Omitted Experiments and Figures

In Section 3.1, we generate a ‘‘robust’’ training set by restricting the dataset to only contain features relevant to a robust model (robust dataset) or a standard model (non-robust dataset). This is performed by choosing either a random input from the training set or random noise We use 10k steps to construct the dataset from noise, instead to using 1k steps done when the input is a different training set image (cf. Table 5). and then performing the optimization procedure described in (6). The performance of these classifiers along with various baselines is shown in Table 7. We observe that while the robust dataset constructed from noise resembles the original, the corresponding non-robust does not (Figure 7). This also leads to suboptimal performance of classifiers trained on this dataset (only $46\%$ standard accuracy) potentially due to a distributional shift.

D.2 Adversarial evaluation

D.3 Performance of “robust” training and test set

In Section 3.1, we observe that an ERM classifier trained on a “robust” training dataset $\widehat{\mathcal{D}}_{R}$ (obtained by restricting features to those relevant to a robust model) attains non-trivial robustness (cf. Figure 1 and Table 7). In Table 8, we evaluate the adversarial accuracy of the model on the corresponding robust training set (the samples which the classifier was trained on) and test set (unseen samples from $\widehat{\mathcal{D}}_{R}$, based on the test set). We find that the drop in robustness comes from a combination of generalization gap (the robustness on the $\widehat{\mathcal{D}}_{R}$ test set is worse than it is on the robust training set) and distributional shift (the model performs better on the robust test set consisting of unseen samples from $\widehat{\mathcal{D}}_{R}$ than on the standard test set containing unseen samples from $\mathcal{D}$).

D.4 Classification based on non-robust features

Figure 9 shows sample images from $\mathcal{D}$, $\widehat{\mathcal{D}}_{rand}$ and $\widehat{\mathcal{D}}_{det}$ constructed using a standard (non-robust) ERM classifier, and an adversarially trained (robust) classifier.

In Table 9, we repeat the experiments in Table 1 based on datasets constructed using a robust model. Note that using a robust model to generate the $\widehat{\mathcal{D}}_{det}$ and $\widehat{\mathcal{D}}_{rand}$ datasets will not result in non-robust features that are strongly predictive of $t$ (since the prediction of the classifier will not change). Thus, training a model on these datasets leads to poor accuracy on the standard test set from $\mathcal{D}$.

Observe from Figure 10 that models trained on datasets derived from the robust model show a decline in test accuracy as training progresses. In Table 9, the accuracy numbers reported correspond to the last iteration, and not the best performance. This is because we have no way to cross-validate in a meaningful way as the validation set itself comes from $\widehat{\mathcal{D}}_{rand}$ or $\widehat{\mathcal{D}}_{det}$, and not from the true data distribution $D$. Thus, validation accuracy will not be predictive of the true test accuracy, and thus will not help determine when to early stop.

D.5 Accuracy curves

D.6 Performance of ERM classifiers on relabeled test set

In Table 10), we evaluate the performance of classifiers trained on $\widehat{\mathcal{D}}_{det}$ on both the original test set drawn from $\mathcal{D}$, and the test set relabelled using $t(y)=(y+1)\mod C$. Observe that the classifier trained on $\widehat{\mathcal{D}}_{det}$ constructed using a robust model actually ends up learning permuted labels based on robust features (indicated by high test accuracy on the relabelled test set).

D.7 Generalization to CIFAR-10.1

[Rec+19] have constructed an unseen but distribution-shifted test set for CIFAR-10. They show that for many previously proposed models, accuracy on the CIFAR-10.1 test set can be predicted as a linear function of performance on the CIFAR-10 test set.

As a sanity check (and a safeguard against any potential adaptive overfitting to the test set via hyperparameters, historical test set reuse, etc.) we note that the classifiers trained on $\widehat{\mathcal{D}}_{det}$ and $\widehat{\mathcal{D}}_{rand}$ achieve $44\%$ and $55\%$ generalization on the CIFAR-10.1 test set, respectively. This demonstrates non-trivial generalization, and actually perform better than the linear fit would predict (given their accuracies on the CIFAR-10 test set).

D.8 Omitted Results for Restricted ImageNet

D.9 Targeted Transferability

D.10 Robustness vs. Accuracy

Appendix E Gaussian MLE under Adversarial Perturbation

In this section, we develop a framework for studying non-robust features by studying the problem of maximum likelihood classification between two Gaussian distributions. We first recall the setup of the problem, then present the main theorems from Section 4. First we build the techniques necessary for their proofs.

We consider the setup where a learner receives labeled samples from two distributions, $\mathcal{N}(\bm{\bm{\mu}}_{*},\bm{\bm{\Sigma}}_{*})$, and $\mathcal{N}(-\bm{\bm{\mu}}_{*},\bm{\bm{\Sigma}}_{*})$. The learner’s goal is to be able to classify new samples as being drawn from $\mathcal{D}_{1}$ or $\mathcal{D}_{2}$ according to a maximum likelihood (MLE) rule.

In this work, we consider the problem of adversarially robust maximum likelihood estimation. In particular, rather than simply being asked to classify samples, the learner will be asked to classify adversarially perturbed samples $x+\delta$, where $\delta\in\Delta$ is chosen to maximize the loss of the learner. Our goal is to derive the parameters $\bm{\bm{\mu}},\bm{\bm{\Sigma}}$ corresponding to an adversarially robust maximum likelihood estimate of the parameters of $\mathcal{N}(\bm{\bm{\mu}}_{*},\bm{\bm{\Sigma}}_{*})$. Note that since we have access to $\bm{\bm{\Sigma}}_{*}$ (indeed, the learner can just run non-robust MLE to get access), we work in the space where $\bm{\bm{\Sigma}}^{*}$ is a diagonal matrix, and we restrict the learned covariance $\bm{\bm{\Sigma}}$ to the set of diagonal matrices.

E.2 Outline and Key Results

We first derive the optimal adversarial perturbation for this setting (Section E.3.1), and prove Theorem 1 (Section E.3.2). We then propose an alternate problem, in which the adversary picks a linear operator to be applied to a fixed vector, rather than picking a specific perturbation vector (Section E.3.3). We argue via Gaussian concentration that the alternate problem is indeed reflective of the original model (and in particular, the two become equivalent as $d\rightarrow\infty$). In particular, we propose studying the following in place of (13):

Our goal is to characterize the behavior of the robustly learned covariance $\bm{\bm{\Sigma}}$ in terms of the true covariance matrix $\bm{\bm{\Sigma}}_{*}$ and the perturbation budget $\varepsilon$. The proof is through Danskin’s Theorem, which allows us to use any maximizer of the inner problem $M^{*}$ in computing the subgradient of the inner minimization. After showing the applicability of Danskin’s Theorem (Section E.3.4) and then applying it (Section E.3.5) to prove our main results (Section E.3.7). Our three main results, which we prove in the following section, are presented below.

We then return to studying (14), where we provide upper and lower bounds on the learned robust covariance matrix $\bm{\bm{\Sigma}}$: See 2

Finally, we show that in the worst case over mean vectors $\bm{\mu}_{*}$, the gradient of the adversarial robust classifier aligns more with the inter-class vector: See 3

E.3 Proofs

In the first section, we have shown that the classification between two Gaussian distributions with identical covariance matrices centered at $\bm{\bm{\mu}}^{*}$ and $-\bm{\bm{\mu}}^{*}$ can in fact be reduced to learning the parameters of a single one of these distributions.

Thus, in the standard setting, our goal is to solve the following problem:

The following Lemma captures the optimal behaviour of the adversary:

In the minimax problem captured in (15) (and earlier in (13)), the optimal adversarial perturbation $\delta^{*}$ is given by

where $\bm{v}=x-\bm{\bm{\mu}}$, and $\lambda$ is set such that $\|\delta^{*}\|_{2}=\varepsilon$.

In this context, we can solve the inner maximization problem with Lagrange multipliers. In the following we write $\Delta=\mathcal{B}_{2}(\varepsilon)$ for brevity, and discard terms not containing $\delta$ as well as constant factors freely:

For clarity, we write $\bm{v}=x-\bm{\bm{\mu}}$: then, combining the above, we have that

our final result for the maximizer of the inner problem, where $\lambda$ is set according to the norm constraint. ∎

E.3.2 Variant with Fixed Lagrangian (Theorem 1)

To simplify the analysis of Theorem 1, we consider a version of (15) with a fixed Lagrangian penalty, rather than a norm constraint:

Note then, that by Lemma 1, the optimal perturbation $\delta^{*}$ is given by

We now proceed to the proof of Theorem 1. See 1

We begin by expanding the Gaussian negative log-likelihood for the relaxed problem:

Recall that we are considering the vulnerability at the MLE parameters $\bm{\mu}^{*}$ and $\bm{\Sigma}^{*}$:

This shows the first part of the theorem. It remains to show that for a fixed $k=\text{tr}(\bm{\Sigma}_{*})$, the adversarial risk is minimized by $\bm{\Sigma}_{*}=\frac{k}{d}\bm{I}$:

where $\{\sigma_{i}\}$ are the eigenvalues of $\bm{\Sigma}_{*}$. Now, we have that $\sum\sigma_{i}=k$ by assumption, so by optimality conditions, we have that $\bm{\Sigma}_{*}$ minimizes the above if $\nabla_{\{\sigma_{i}\}}\propto\vec{1}$, i.e. if $\nabla_{\sigma_{i}}=\nabla_{\sigma_{j}}$ for all $i,j$. Now,

Then, by solving analytically, we find that

admits only one real solution, $\sigma_{i}=\sigma_{j}$. Thus, $\bm{\Sigma}_{*}\propto\bm{I}$. Scaling to satisfy the trace constraint yields $\bm{\Sigma}_{*}=\frac{k}{d}\bm{I}$, which concludes the proof. ∎

E.3.3 Real objective

First, note that this objective is slightly different from that of (15). In the motivating example, $\delta$ is constrained to always have $\varepsilon$-norm, and thus is normalizer on a per-sample basis inside of the expectation. In contrast, here the classifier is concerned with being robust to perturbations that are linear in $\bm{v}$, and of $\varepsilon^{2}$ squared norm in expectation.

Note, however, that via the result of [LM00] showing strong concentration for the norms of Gaussian random variables, in high dimensions this bound on expectation has a corresponding high-probability bound on the norm. In particular, this implies that as $d\rightarrow\infty$, $\|M\bm{v}\|_{2}=\varepsilon$ almost surely, and thus the problem becomes identical to that of (15). We now derive the optimal $M$ for a given $(\bm{\mu},\bm{\Sigma})$:

Consider the minimax problem described by (20), i.e.

Then, the optimal action $M^{*}$ of the inner maximization problem is given by

where again $\lambda$ is set so that $M\in\mathcal{M}$.

We accomplish this in a similar fashion to what was done for $\delta^{*}$, using Lagrange multipliers:

where $\lambda$ is a constant depending on $\bm{\bm{\Sigma}}$ and $\bm{\bm{\mu}}$ enforcing the expected squared-norm constraint. ∎

Indeed, note that the optimal $M$ for the adversary takes a near-identical form to the optimal $\delta$ (19), with the exception that $\lambda$ is not sample-dependent but rather varies only with the parameters.

E.3.4 Danskin’s Theorem

The main tool in proving our key results is Danskin’s Theorem [Dan67], a powerful theorem from minimax optimization which contains the following key result:

The subdifferential of $f(x)$ is given by

In short, given a minimax problem of the form $\min_{x}\max_{y\in C}f(x,y)$ where $C$ is a compact set, if $f(\cdot,y)$ is convex for all values of $y$, then rather than compute the gradient of $g(x):=\max_{y\in C}f(x,y)$, we can simply find a maximizer $y^{*}$ for the current parameter $x$; Theorem 4 ensures that $\nabla_{x}f(x,y^{*})\in\partial_{x}g(x)$. Note that $\mathcal{M}$ is trivially compact (by the Heine-Borel theorem), and differentiability/continuity follow rather straightforwardly from our reparameterization (c.f. (22)), and so it remains to show that the outer minimization is convex for any fixed $M$.

Note that even in the standard case (i.e. non-adversarial), the Gaussian negative log-likelihood is not convex with respect to $(\bm{\bm{\mu}},\bm{\bm{\Sigma}})$. Thus, rather than proving convexity of this function directly, we employ the parameterization used by [Das+19]: in particular, we write the problem in terms of $\bm{T}=\bm{\bm{\Sigma}}^{-1}$ and $\bm{m}=\bm{\bm{\Sigma}}^{-1}\bm{\bm{\mu}}$. Under this parameterization, we show that the robust problem is convex for any fixed $M$.

Under the aforementioned parameterization of $\bm{T}=\bm{\bm{\Sigma}}^{-1}$ and $\bm{m}=\bm{\bm{\Sigma}}^{-1}\bm{\bm{\mu}}$, the following “Gaussian robust negative log-likelihood” is convex:

To prove this, we show that the likelihood is convex even with respect to a single sample $x$; the result follows, since a convex combination of convex functions remains convex. We begin by looking at the likelihood of a single sample $x\sim\mathcal{N}(\bm{\bm{\mu}}_{*},\bm{\bm{\Sigma}}_{*})$:

In terms of the aforementioned $\bm{T}$ and $\bm{m}$, and for convenience defining $A=(I+M)^{2}$:

From here, following an identical argument to [Das+19] Equation (3.7), we find that

i.e. that the log-likelihood is indeed convex with respect to $\begin{bmatrix}{\bm{T}}\\ {\bm{m}}\end{bmatrix}$, as desired. ∎

E.3.5 Applying Danskin’s Theorem

Using this fact, we derive an implicit expression for the robust covariance matrix $\bm{\bm{\Sigma}}$. Note that for the sake of brevity, we now use $M$ to denote the optimal adversarial perturbation (previously defined as $M^{*}$ in (21)). This implicit formulation forms the foundation of the bounds given by our main results.

The minimax problem discussed throughout this work admits the following (implicit) form of solution:

where $\lambda$ is such that $M\in\mathcal{M}$, and is thus dependent on $\bm{\bm{\Sigma}}$.

Rewriting (23) in the standard parameterization (with respect to $\bm{\bm{\mu}},\bm{\bm{\Sigma}}$) and re-expanding $A=(I+M)^{2}$ yields:

Now, note that the equations involving $\bm{\bm{\mu}}$ and $\bm{\bm{\Sigma}}$ are completely independent, and thus can be solved separately. In terms of $\bm{\bm{\mu}}$, the relevant system of equations is $A\bm{\bm{\mu}}-A\bm{\bm{\mu}}_{*}=0$, where multiplying by the inverse $A$ gives that

Now, in the same way, we set out to find $\bm{\bm{\Sigma}}$ by solving the relevant system of equations:

Now, we make use of the Woodbury Matrix Identity in order to write $(I+M)$ as

We now apply the quadratic formula to get an implicit expression for $\bm{\bm{\Sigma}}$ (implicit since technically $\lambda$ depends on $\bm{\bm{\Sigma}}$):

E.3.6 Bounding λ\lambda

Now, consider $\varepsilon^{2}$ as a function of $\lambda$. Observe that for $\lambda\geq\frac{1}{\sigma_{min}(\bm{\bm{\Sigma}})}$, we have that $M$ must be positive semi-definite, and thus $\varepsilon^{2}$ decays smoothly from $\infty$ (at $\lambda=\frac{1}{\sigma_{min}})$ to zero (at $\lambda=\infty$). Similarly, for $\lambda\leq\frac{1}{\sigma_{max}(\bm{\bm{\Sigma}})}$, $\varepsilon$ decays smoothly as $\lambda$ decreases. Note, however, that such values of $\lambda$ would necessarily make $M$ negative semi-definite, which would actually help the log-likelihood. Thus, we can exclude this case; in particular, for the remainder of the proofs, we can assume $\lambda\geq\frac{1}{\sigma_{max}(\bm{\bm{\Sigma}})}$.

Also observe that the zeros of $\varepsilon$ in terms of $\lambda$ are only at $\lambda=\pm\infty$. Using this, we can show that there exists some $\varepsilon_{0}$ for which, for all $\varepsilon<\varepsilon_{0}$, the only corresponding possible valid value of $\lambda$ is where $\lambda\geq\frac{1}{\sigma_{min}}$. This idea is formalized in the following Lemma.

For every $\bm{\bm{\Sigma}}_{*}$, there exists some $\varepsilon_{0}>0$ for which, for all $\varepsilon\in[0,\varepsilon_{0})$ the only admissible value of $\lambda$ is such that $\lambda\geq\frac{1}{\sigma_{min}(\bm{\bm{\Sigma}})}$, and thus such that $M$ is positive semi-definite.

We prove the existence of such an $\varepsilon_{0}$ by lower bounding $\varepsilon$ (in terms of $\lambda$) for any finite $\lambda>0$ that does not make $M$ PSD. Providing such a lower bound shows that for small enough $\varepsilon$ (in particular, less than this lower bound), the only corresponding values of $\lambda$ are as desired in the statement Since our only goal is existence, we lose many factors from the analysis that would give a tighter bound on $\varepsilon_{0}$..

In particular, if $M$ is not PSD, then there must exist at least one index $k$ such that $\lambda\bm{\bm{\Sigma}}_{kk}<1$, and thus $(\lambda\bm{\bm{\Sigma}}_{kk}-1)^{2}\leq 1$ for all $\lambda>0$. We can thus lower bound (27) as:

By contradiction, it follows that for any $\varepsilon<\sigma_{min}(\bm{\bm{\Sigma}}_{*})^{2}$, the only admissible $\lambda$ is such that $M$ is PSD, i.e. according to the statement of the Lemma. ∎

In the regime $\varepsilon\in[0,\varepsilon_{0})$, note that $\lambda$ is inversely proportional to $\varepsilon$ (i.e. as $\varepsilon$ grows, $\lambda$ decreases). This allows us to get a qualitative view of (26): as the allowed perturbation value increases, the robust covariance $\bm{\bm{\Sigma}}$ resembles the identity matrix more and more, and thus assigns more and more variance on initially low-variance features. The $\sqrt{\bm{\Sigma}_{*}}$ term indicates that the robust model also adds uncertainty proportional to the square root of the initial variance—thus, low-variance features will have (relatively) more uncertainty in the robust case. Indeed, our main result actually follows as a (somewhat loose) formalization of this intuition.

E.3.7 Proof of main theorems

First, we give a proof of Theorem 2, providing lower and upper bounds on the learned robust covariance $\bm{\bm{\Sigma}}$ in the regime $\varepsilon\in[0,\varepsilon_{0})$.

We have already shown that $\bm{\mu}=\bm{\mu}_{*}$ in the robust case (c.f. (24)). We choose $\varepsilon_{0}$ to be as described, i.e. the largest $\varepsilon$ for which the set $\{\lambda:\text{tr}(\bm{\bm{\Sigma}}_{*}^{2}M)=\varepsilon,\lambda\geq 1/\sigma_{\max}(\bm{\bm{\Sigma}})\}$ has only one element $\lambda$ (which, as we argued, must not be less than $1/\sigma_{min}(\bm{\bm{\Sigma}})$). We have argued that such an $\varepsilon_{0}$ must exist.

We prove the result by combining our early derivation (in particular, (25) and (26)) with upper and lower bound on $\lambda$, which we can compute based on properties of the trace operator. We begin by deriving a lower bound on $\lambda$. By linear algebraic manipulation (given in Appendix E.3.8), we get the following bound:

Now, we can use (25) in order to remove the dependency of $\lambda$ on $\bm{\bm{\Sigma}}$:

Note that we can simplify this bound significantly by writing $\varepsilon=d\cdot\sigma_{min}(\bm{\bm{\Sigma}}_{*})\varepsilon^{\prime}\leq\text{tr}(\bm{\bm{\Sigma}}_{*})\varepsilon^{\prime}$, which does not affect the result (beyond rescaling the valid regime $(0,\varepsilon_{0})$), and gives:

Next, we follow a similar methodology (Appendix E.3.8) in order to upper bound $\lambda$:

Note that by (25) and positive semi-definiteness of $M$, it must be that $\sigma_{min}(\bm{\bm{\Sigma}})\geq\sigma_{min}(\bm{\bm{\Sigma}}_{*})$. Thus, we can simplify the previous expression, also substituting $\varepsilon=d\cdot\sigma_{min}(\bm{\bm{\Sigma}}_{*})\varepsilon^{\prime}$:

These bounds can be straightforwardly combined with Lemma 4, which concludes the proof. ∎

Using this theorem, we can now show Theorem 3: See 3

To prove this, we make use of the following Lemmas:

For two positive definite matrices $A$ and $B$ with $\kappa(A)>\kappa(B)$, we have that $\kappa(A+B)\leq\max\{\kappa(A),\kappa(B)\}$.

which is false by assumption. This concludes the proof. ∎

For a positive definite matrix $A$ and $k>0$, we have that

For a positive definite matrix $A\succ 0$ with condition number $\kappa$, we have that

These two results can be combined to prove the theorem. First, we show that $\kappa(\bm{\Sigma})\leq\kappa(\bm{\Sigma}_{*})$:

Finally, note that (30) is a strictly decreasing function in $\kappa$, and as such, we have shown the theorem. ∎

E.3.8 Bounds for λ\lambda