Adversarial Examples Are Not Bugs, They Are Features

Adversarial examples have attracted significant attention in machine learning, but the reasons for their existence and pervasiveness remain unclear. We demonstrate that adversarial examples can be directly attributed to the presence of non-robust features: features derived from patterns in the data distribution that are highly predictive, yet brittle and incomprehensible to humans. After capturing these features within a theoretical framework, we establish their widespread existence in standard datasets. Finally, we present a simple setting where we can rigorously tie the phenomena we observe in practice to a misalignment between the (human-specified) notion of robustness and the inherent geometry of the data.


Introduction
The pervasive brittleness of deep neural networks [Sze+14; Eng+19; 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+19a]. 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;CW17a;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.
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 purely 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 interpretablity of a given model by enforcing "priors" for its explanation [Erh+09; MV15; OMS17] 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: 1. A "robustified" version for robust classification (Figure 1a) 1 . 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.

2.
A "non-robust" version for standard classification (Figure 1b) 1 . 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.
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 Tsipras et al. [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 Tsipras et al. [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.
Useful, robust, and non-robust features. We now define the key concepts required for formulating our framework. To this end, we categorize features in the following manner: • ρ-useful features: For a given distribution D, we call a feature f ρ-useful (ρ > 0) if it is correlated with the true label in expectation, that is if We then define ρ D ( f ) as the largest ρ for which feature f is ρ-useful under distribution D. (Note that if a feature f is negatively correlated with the label, then − f is useful instead.) Crucially, a linear classifier trained on ρ-useful features can attain non-trivial generalization performance.
• γ-robustly useful features: Suppose we have a ρ-useful feature f (ρ D ( f ) > 0). We refer to f as a robust feature (formally a γ-robustly useful feature for γ > 0) if, under adversarial perturbation (for some specified set of valid perturbations ∆), f remains γ-useful. Formally, if we have that (2) • Useful, non-robust features: A useful, non-robust feature is a feature which is ρ-useful for some ρ bounded away from zero, but is not a γ-robust feature for any γ ≥ 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.
Classification. In our framework, a classifier C = (F, w, b) is comprised of a set of features F ⊆ 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 .
Standard Training. 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 When minimizing classification loss, no distinction exists between robust and non-robust features: the only distinguishing factor of a feature is its ρ-usefulness. Furthermore, the classifier will utilize any ρ-useful feature in F to decrease the loss of the classifier.

Robust training.
In the presence of an adversary, any useful but non-robust features can be made anticorrelated 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 define set of perturbations ∆. 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.

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 nonrobust 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.

Disentangling robust and non-robust features
Recall that 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.  Figure 12.
In terms of our formal framework (Section 2), given a robust (i.e. adversarially trained) model C we aim to construct a distribution 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 D while ensuring that the rest of the features are not useful under D NR . We will construct a training set for D R via a one-to-one mapping x → x r from the original training set for 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 5 . 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 ∈ 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 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 D R (a few random samples are visualized in Figure 2a), we train a classifier using standard (non-robust) training. We then test this classifier on the original test set (i.e. D). The 5 We follow [Mad+18] and normalize gradient steps during this optimization. Experimental details are provided in Appendix C. results ( Figure 2b) indicate that the classifier learned using the new dataset attains good accuracy in both standard and adversarial settings 6 7 .
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" D NR are shown in Figure 2a-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 2b). 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 D R and D NR if we train with different architectures than that of the original models.
Overall, our findings corroborate the hypothesis that adversarial examples 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 robust model using standard training.

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 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 nonrobust features (or in terms of our formal model from Section 2, all features f that are ρ-useful are nonrobust). 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 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 ε 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). Thus, for any choice of t (whether random or deterministic), only non-robust features of the new dataset agree with that new label assignment.
In the case where t is chosen at random, the robust features are (in expectation) uncorrelated with the label t, and are thus not useful for classification. Formally, we aim to construct a dataset D rand where 8 : 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 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 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 1011 .  Table 1: Test accuracy (on D) of classifiers trained on the D, D rand , and D det training sets created using a standard (non-robust) model. For both D rand and D det , only non-robust features correspond to useful features on both the train set and D. These datasets are constructed using adversarial perturbations of x towards a class t (random for D rand and deterministic for D det ); the resulting images are relabeled as t.

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 are the result of perturbing wellgeneralizing, 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). 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 nonrobust 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 Tsipras et al. [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: 1. The adversarial vulnerability can be explicitly expressed as a difference between the inherent data metric and the 2 metric.
2. Robust learning corresponds exactly to learning a combination of these two metrics.
3. The gradients of adversarially trained models align better with the adversary's metric.

Setup.
We study a simple problem of maximum likelihood classification between two Gaussian distributions.
In particular, given samples (x, y) sampled from D according to y u.a.r.
our goal is to learn parameters Θ = (µ, Σ) such that where (x; µ, Σ) represents the Gaussian negative log-likelihood (NLL) function. Intuitively, we find the parameters µ, Σ which maximize the likelihood of the sampled data under the given model. Classification under this model can be accomplished via likelihood test: given an unlabeled sample x, we predict y as In turn, the robust analogue of this problem arises from replacing (x; y · µ, Σ) with the NLL under adversarial perturbation. The resulting robust parameters Θ r can be written as A detailed analysis of this setting is in Appendix E-here we present a high-level overview of the results.
(1) Vulnerability from metric misalignment (non-robust features). Note that in this model, one can rigorously make reference to an inner product (and thus a metric) induced by the features. In particular, one can view the learned parameters of a Gaussian Θ = (µ, Σ) as defining an inner product over the input space given by x, . This in turn induces the Mahalanobis distance, which represents how a change in the input affects the features learned by the classifier. This metric is not necessarily aligned with the metric in which the adversary is constrained, the 2 -norm. Actually, we show that adversarial vulnerability arises exactly as a misalignment of these two metrics.
is a constant trading off NLL minimization and the adversarial constraint 12 . Then, the adversarial loss L adv incurred by the non-robustly learned (µ, Σ) is given by: and, for a fixed tr(Σ * ) = k the above is minimized by Σ * = k d 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.
(2) Robust Learning. The optimal (non-robust) maximum likelihood estimate is Θ = Θ * , and thus the vulnerability for the standard MLE estimate is governed entirely by the true data distribution. The following theorem characterizes the behaviour of the learned parameters in the robust problem. 13 . In fact, we can prove (Section E.3.4) that performing (sub)gradient descent on the inner maximization (also known as adversarial training [GSS15; Mad+18]) yields exactly Θ r . We find that as the perturbation budget ε is increased, the metric induced by the learned features mixes 2 and the metric induced by the features.
Theorem 2 (Robustly Learned Parameters). Just as in the non-robust case, µ r = µ * , i.e. the true mean is learned. For the robust covariance Σ r , there exists an ε 0 > 0, such that for any ε ∈ [0, ε 0 ), where The effect of robust optimization under an 2 -constrained adversary is visualized in Figure 4. As grows, the learned covariance becomes more aligned with identity. For instance, we can see that the classifier learns to be less sensitive in certain directions, despite their usefulness for natural classification.
(3) Gradient Interpretability. Tsipras et al. [Tsi+19] observe that gradients of robust models tend to look more semantically meaningful. It turns out that under our model, this behaviour arises as a natural consequence of Theorem 2. In particular, we show that the resulting robustly learned parameters cause the gradient of the linear classifier and the vector connecting the means of the two distributions to better align (in a worst-case sense) under the 2 inner product. 12 The constraint on C is to ensure the problem is concave. 13 Note: as discussed in Appendix E.3.3, we study a slight relaxation of (12) that approaches exactness exponentially fast as d → ∞ Robust parameters, = 10.0 Figure 4: An empirical demonstration of the effect illustrated by Theorem 2-as the adversarial perturbation budget ε is increased, the learned mean µ remains constant, but the learned covariance "blends" with the identity matrix, effectively adding more and more uncertainty onto the non-robust feature.
Theorem 3 (Gradient alignment). Let f (x) and f r (x) be monotonic classifiers based on the linear separator induced by standard and 2 -robust maximum likelihood classification, respectively. The maximum angle formed between the gradient of the classifier (wrt input) and the vector connecting the classes can be smaller for the robust model: . Figure 4 illustrates this phenomenon in the two-dimensional case. With 2 -bounded adversarial training the gradient direction (perpendicular to the decision boundary) becomes increasingly aligned under the 2 inner product with the vector between the means (µ).

Discussion.
Our theoretical analysis suggests that rather than offering any quantitative classification benefits, a natural way to view the role of robust optimization is as enforcing a prior over the features learned by the classifier. In particular, training with an 2 -bounded adversary prevents the classifier from relying heavily on features which induce a metric dissimilar to the 2 metric. The strength of the adversary then allows for a trade-off between the enforced prior, and the data-dependent features.

Robustness and accuracy.
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+19a; MDM18; Sha+19b; 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 nonrobust 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.
[Pap+17] Nicolas Papernot et al. "Practical black-box attacks against machine learning". In: Asia Conference on Computer and Communications Security. 2017.

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. We note that our model does not explicitly contradict the main thesis of Schmidt et al. [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. Boundary Tilting. Tanay and Griffin [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, Kim, Seo, and Jeon [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.) Test Error in Noise. Fawzi, Moosavi-Dezfooli, and Frossard [FMF16] and Ford et al. [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.
Local Linearity. Goodfellow, Shlens, and Szegedy [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].

Piecewise-linear decision boundaries.
Shamir et al. [Sha+19b] 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.
Theoretical constructions which incidentally exploit non-robust features. Bubeck, Price, and Razenshteyn [BPR18] and Nakkiran [Nak19] 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.

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.

Distillation.
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.
Adversarial Transferabiliy. 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]. Tramer et al. [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.

Universal Adversarial Perturbations Moosavi-Dezfooli et al. [Moo+17]
construct perturbations that can cause misclassification when applied to multiple different inputs. More recently, Jetley, Lord, and Torr [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.
Manipulating dataset features Ding et al. [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. Geirhos et al.
[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.

C.1 Datasets
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
To obtain robust classifiers, we employ the adversarial training methodology proposed in [Mad+18]. Specifically, we train against a projected gradient descent (PGD) adversary constrained in 2 -norm starting from the original image. Following Madry et al.
[Mad+18] we normalize the gradient at each step of PGD to ensure that we move a fixed distance in 2 -norm per step. Unless otherwise specified, we use the values of provided in Table 4 to train/evaluate our models. We used 7 steps of PGD with a step size of ε/5. Adversary CIFAR-10 Restricted Imagenet 2 0.5 3

C.4 Constructing a Robust Dataset
In Section 3.1, we describe a procedure to construct a dataset that contains features relevant only to a given (standard/robust) model. To do so, we optimize the training objective in (6). Unless otherwise specified, we initialize x r as a different randomly chosen sample from the training set. (For the sake of completeness, we also try initializing with a Gaussian noise instead as shown in Table 7.) We then perform normalized gradient descent ( 2 -norm of gradient is fixed to be constant at each step). At each step we clip the input x r to in the [0, 1] range so as to ensure that it is a valid image. Details on the optimization procedure are shown in Table 5. We provide the pseudocode for the construction in Figure 5. GETROBUSTDATASET(D) 1. C R ← ADVERSARIALTRAINING(D) g R ← mapping learned by C R from the input to the representation layer Figure 5: Algorithm to construct a "robust" dataset, by restricting to features used by a robust model.

C.5 Non-robust features suffice for standard classification
To construct the dataset as described in Section 3.2, we use the standard projected gradient descent (PGD) procedure described in [Mad+18] to construct an adversarial example for a given input from the dataset (7). Perturbations are constrained in 2 -norm while each PGD step is normalized to a fixed step size. The details for our PGD setup are described in Table 6. We provide pseudocode in Figure 6. Figure 6: Algorithm to construct a dataset where input-label association is based entirely on non-robust features.

D.1 Detailed evaluation of models trained on "robust" dataset
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 14 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.

Robust Accuracy Model
Accuracy    Figure 7: Robust and non-robust datasets for CIFAR-10 when the process starts from noise (as opposed to random images as in Figure 2a).

D.2 Adversarial evaluation
To verify the robustness of our classifiers trained on the 'robust" dataset, we evaluate them with strong attacks [Car+19]. In particular, we try up to 2500 steps of projected gradient descent (PGD), increasing steps until the accuracy plateaus, and also try the CW-2 loss function [CW17b] with 1000 steps. For each attack we search over step size. We find that over all attacks and step sizes, the accuracy of the model does not drop by more than 2%, and plateaus at 48.27% for both PGD and CW-2 (the value given in Figure 2). We show a plot of accuracy in terms of the number of PGD steps used in Figure 8.

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 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 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 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 D R than on the standard test set containing unseen samples from D).

Dataset Robust Accuracy
Robust training set 77.33% Robust test set 62.49% Standard test set 48.27% Table 8: Performance of model trained on the robust dataset on the robust training and test sets as well as the standard CIFAR-10 test set. We observe that the drop in robust accuracy stems from a combination of generalization gap and distributional shift. The adversary is constrained to ε = 0.25 in 2 -norm.  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 D det and 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 D.

D.4 Classification based on non-robust features
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 D rand or 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.6 Performance of ERM classifiers on relabeled test set
In Table 10), we evaluate the performance of classifiers trained on D det on both the original test set drawn from D, and the test set relabelled using t(y) = (y + 1) mod C. Observe that the classifier trained on 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).  Table 10: Performance of classifiers trained using D det training set constructed using either standard or robust models. The classifiers are evaluated both on the standard test set from D and the test set relabeled using t(y) = (y + 1) mod C. We observe that using a robust model for the construction results in a model that largely predicts the permutation of labels, indicating that the dataset does not have strongly predictive non-robust features.

D.7 Generalization to CIFAR-10.1
Recht et al. [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 D det and D rand achieve 23% and 33% generalization on the CIFAR-10.1 test set, respectively. This demonstrates non-trivial generalization, and actually perform better than (for D det ) or on par with (for D rand ) the linear fit would predict (given their accuracies on the CIFAR-10 test set). Figure 11: Repeating the experiments shown in Figure 2 for the Restricted ImageNet dataset. Sample images from the resulting dataset.  Figure 14: An example where adversarial vulnerability can arise from ERM training on any standard loss function due to non-robust features (the green line shows the ERM-learned decision boundary). There exists, however, a classifier that is both perfectly robust and accurate, resulting from robust training, which forces the classifier to ignore the x 2 feature despite its predictiveness.

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.

E.1 Setup
We consider the setup where a learner receives labeled samples from two distributions, N (µ * , Σ * ), and N (−µ * , Σ * ). The learner's goal is to be able to classify new samples as being drawn from D 1 or D 2 according to a maximum likelihood (MLE) rule.
A simple coupling argument demonstrates that this problem can actually be reduced to learning the parameters µ, Σ of a single Gaussian N (−µ * , Σ * ), and then employing a linear classifier with weight Σ −1 µ. In the standard setting, maximum likelihoods estimation learns the true parameters, µ * and Σ * , and thus the learned classification rule is C(x) = 1{x Σ −1 µ > 0}.
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 + δ, where δ ∈ ∆ is chosen to maximize the loss of the learner. Our goal is to derive the parameters µ, Σ corresponding to an adversarially robust maximum likelihood estimate of the parameters of N (µ * , Σ * ). Note that since we have access to Σ * (indeed, the learner can just run non-robust MLE to get access), we work in the space where Σ * is a diagonal matrix, and we restrict the learned covariance Σ to the set of diagonal matrices.
Notation. We denote the parameters of the sampled Gaussian by µ * ∈ R d , and Σ * ∈ {diag(u)|u ∈ R d }. We use σ min (X) to represent the smallest eigenvalue of a square matrix X, and (·; x) to represent the Gaussian negative log-likelihood for a single sample x. For convenience, we often use v = x − µ, and R = µ * . We also define the operator to represent the vectorization of the diagonal of a matrix. In particular, for a matrix X ∈ R d×d , we have that

E.2 Outline and Key Results
We focus on the case where ∆ = B 2 ( ) for some > 0, i.e. the 2 ball, corresponding to the following minimax problem: 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 → ∞). In particular, we propose studying the following in place of (13): Our goal is to characterize the behavior of the robustly learned covariance Σ in terms of the true covariance matrix Σ * and the perturbation budget ε. 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.
First, we consider a simplified version of (13), in which the adversary solves a maximization with a fixed Lagrangian penalty, rather than a hard 2 constraint. In this setting, we show that the loss contributed by the adversary corresponds to a misalignment between the data metric (the Mahalanobis distance, induced by Σ −1 ), and the 2 metric: Theorem 1 (Adversarial vulnerability from misalignment). Consider an adversary whose perturbation is determined by the "Lagrangian penalty" form of (12), i.e.
where C ≥ 1 σ min (Σ * ) is a constant trading off NLL minimization and the adversarial constraint 15 . Then, the adversarial loss L adv incurred by the non-robustly learned (µ, Σ) is given by: and, for a fixed tr(Σ * ) = k the above is minimized by Σ * = k d I. We then return to studying (14), where we provide upper and lower bounds on the learned robust covariance matrix Σ: Theorem 2 (Robustly Learned Parameters). Just as in the non-robust case, µ r = µ * , i.e. the true mean is learned. For the robust covariance Σ r , there exists an ε 0 > 0, such that for any ε ∈ [0, ε 0 ), where Finally, we show that in the worst case over mean vectors µ * , the gradient of the adversarial robust classifier aligns more with the inter-class vector: Theorem 3 (Gradient alignment). Let f (x) and f r (x) be monotonic classifiers based on the linear separator induced by standard and 2 -robust maximum likelihood classification, respectively. The maximum angle formed between the gradient of the classifier (wrt input) and the vector connecting the classes can be smaller for the robust model:

E.3 Proofs
In the first section, we have shown that the classification between two Gaussian distributions with identical covariance matrices centered at µ * and −µ * 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: Note that in this setting, one can simply find differentiate with respect to both µ and Σ, and obtain closed forms for both (indeed, these closed forms are, unsurprisingly, µ * and Σ * ). Here, we consider the existence of a malicious adversary who is allowed to perturb each sample point x by some δ. The goal of the adversary is to maximize the same loss that the learner is minimizing.

E.3.1 Motivating example: 2 -constrained adversary
We first consider, as a motivating example, an 2 -constrained adversary. That is, the adversary is allowed to perturb each sampled point by δ : δ 2 = ε. In this case, the minimax problem being solved is the following: The following Lemma captures the optimal behaviour of the adversary: 15 The constraint on C is to ensure the problem is concave.
Proof. In this context, we can solve the inner maximization problem with Lagrange multipliers. In the following we write ∆ = B 2 (ε) for brevity, and discard terms not containing δ as well as constant factors freely: Now we can solve (17) using the aforementioned Lagrange multipliers. In particular, note that the maximum of (17) is attained at the boundary of the 2 ball ∆. Thus, we can solve the following system of two equations to find δ, rewriting the norm constraint as 1 2 δ 2 2 = 1 2 ε 2 : For clarity, we write v = x − µ: then, combining the above, we have that our final result for the maximizer of the inner problem, where λ is set according to the norm constraint.
Note then, that by Lemma 1, the optimal perturbation δ * is given by We now proceed to the proof of Theorem 1.
where C ≥ 1 σ min (Σ * ) is a constant trading off NLL minimization and the adversarial constraint 16 . Then, the adversarial loss L adv incurred by the non-robustly learned (µ, Σ) is given by: and, for a fixed tr(Σ * ) = k the above is minimized by Σ * = k d I. 16 The constraint on C is to ensure the problem is concave.
Proof. We begin by expanding the Gaussian negative log-likelihood for the relaxed problem: Recall that we are considering the vulnerability at the MLE parameters µ * and Σ * : This shows the first part of the theorem. It remains to show that for a fixed k = tr(Σ * ), the adversarial risk is minimized by Σ * = k d I: where {σ i } are the eigenvalues of Σ * . Now, we have that ∑ σ i = k by assumption, so by optimality conditions, we have that Σ * minimizes the above if ∇ {σ i } ∝ 1, i.e. if ∇ σ i = ∇ σ j for all i, j. Now, Then, by solving analytically, we find that admits only one real solution, σ i = σ j . Thus, Σ * ∝ I. Scaling to satisfy the trace constraint yields Σ * = k d I, which concludes the proof.

E.3.3 Real objective
Our motivating example (Section E.3.1) demonstrates that the optimal perturbation for the adversary in the a minimax problem, due to the presence of the expectation between the outer minimization and the inner maximization. Motivated by this and (19), we define the following robust problem: where M = M ∈ R d×d : M ij = 0 ∀ i = j, E x∼N (µ * ,Σ * ) Mv 2 2 = 2 .
First, note that this objective is slightly different from that of (15). In the motivating example, δ is constrained to always have ε-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 v, and of ε 2 squared norm in expectation.
Note, however, that via the result of Laurent and Massart [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 → ∞, Mv 2 = ε almost surely, and thus the problem becomes identical to that of (15). We now derive the optimal M for a given (µ, Σ): Lemma 2. Consider the minimax problem described by (20), i.e. Then, the optimal action M * of the inner maximization problem is given by where again λ is set so that M ∈ M.
Proof. We accomplish this in a similar fashion to what was done for δ * , using Lagrange multipliers: where λ is a constant depending on Σ and µ enforcing the expected squared-norm constraint.
Indeed, note that the optimal M for the adversary takes a near-identical form to the optimal δ (19), with the exception that λ 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: Theorem 4 (Danskin's Theorem). Suppose φ(x, z) : R × Z → R is a continuous function of two arguments, where Z ⊂ R m is compact. Define f (x) = max z∈Z φ(x, z). Then, if for every z ∈ Z, φ(x, z) is convex and differentiable in x, and ∂φ ∂x is continuous: The subdifferential of f (x) is given by where conv(·) represents the convex hull operation, and Z 0 is the set of maximizers defined as Z 0 (x) = z : φ(x, z) = max z∈Z φ(x, z) .
In short, given a minimax problem of the form min x max y∈C f (x, y) where C is a compact set, if f (·, y) is convex for all values of y, then rather than compute the gradient of g(x) := max y∈C f (x, y), we can simply find a maximizer y * for the current parameter x; Theorem 4 ensures that ∇ x f (x, y * ) ∈ ∂ x g(x). Note that 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.
Convexity of the outer minimization. Note that even in the standard case (i.e. non-adversarial), the Gaussian negative log-likelihood is not convex with respect to (µ, Σ). 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 T = Σ −1 and m = Σ −1 µ. Under this parameterization, we show that the robust problem is convex for any fixed M. Proof. 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 ∼ N (µ * , Σ * ): i.e. that the log-likelihood is indeed convex with respect to T m , as desired.

E.3.5 Applying Danskin's Theorem
The previous two parts show that we can indeed apply Danskin's theorem to the outer minimization, and in particular that the gradient of f at M = M * is in the subdifferential of the outer minimization problem. We proceed by writing out this gradient explicitly, and then setting it to zero (note that since we have shown f is convex for all choices of perturbation, we can use the fact that a convex function is globally minimized ⇐⇒ its subgradient contains zero). We continue from above, plugging in (21) for M and using (22) to write In the regime ε ∈ [0, ε 0 ), note that λ is inversely proportional to ε (i.e. as ε grows, λ decreases). This allows us to get a qualitative view of (26): as the allowed perturbation value increases, the robust covariance Σ resembles the identity matrix more and more, and thus assigns more and more variance on initially lowvariance features. The √ Σ * 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 Σ in the regime ε ∈ [0, ε 0 ).