Robustness May Be at Odds with Accuracy

Introduction

Deep learning models have achieved impressive performance on a number of challenging benchmarks in computer vision, speech recognition and competitive game playing (Krizhevsky et al., 2012; Graves et al., 2013; Silver et al., 2016, 2017; He et al., 2015). However, it turns out that these models are actually quite brittle. In particular, one can often synthesize small, imperceptible perturbations of the input data and cause the model to make highly-confident but erroneous predictions (Dalvi et al., 2004; Biggio & Roli, 2018; Szegedy et al., 2014).

This problem of so-called adversarial examples has garnered significant attention recently and resulted in a number of approaches both to finding these perturbations, and to training models that are robust to them (Goodfellow et al., 2015; Nguyen et al., 2015; Moosavi-Dezfooli et al., 2016; Carlini & Wagner, 2017b; Sharif et al., 2016; Kurakin et al., 2017; Evtimov et al., 2018; Athalye et al., 2018b). However, building such adversarially robust models has proved to be quite challenging. In particular, many of the proposed robust training methods were subsequently shown to be ineffective (Carlini & Wagner, 2017a; Athalye et al., 2018a; Uesato et al., 2018). Only recently, has there been progress towards models that achieve robustness that can be demonstrated empirically and, in some cases, even formally verified (Madry et al., 2018; Wong & Kolter, 2018; Sinha et al., 2018; Tjeng et al., 2019; Raghunathan et al., 2018; Dvijotham et al., 2018a; Xiao et al., 2019).

The vulnerability of models trained using standard methods to adversarial perturbations makes it clear that the paradigm of adversarially robust learning is different from the classic learning setting. In particular, we already know that robustness comes at a cost. This cost takes the form of computationally expensive training methods (more training time), but also, as shown recently in Schmidt et al. (2018), the potential need for more training data. It is natural then to wonder: Are these the only costs of adversarial robustness? And, if so, once we choose to pay these costs, would it always be preferable to have a robust model instead of a standard one? After all, one might expect that training models to be adversarially robust, albeit more resource-consuming, can only improve performance in the standard classification setting.

In this work, we show, however, that the picture here is much more nuanced: the goals of standard performance and adversarial robustness might be fundamentally at odds. Specifically, even though training models to be adversarially robust can be beneficial in the regime of limited training data, in general, there can be an inherent trade-off between the standard accuracy and adversarially robust accuracy of a model. In fact, we show that this trade-off provably exists even in a fairly simple and natural setting.

At the root of this trade-off is the fact that features learned by the optimal standard and optimal robust classifiers can be fundamentally different and, interestingly, this phenomenon persists even in the limit of infinite data. This goes against the natural expectation that given sufficient data, classic machine learning tools would be sufficient to learn robust models and emphasizes the need for techniques specifically tailored to the adversarially robust learning setting.

Our exploration also uncovers certain unexpected benefits of adversarially robust models. These stem from the fact that the set of perturbations considered in robust training contains perturbations that we would expect humans to be invariant to. Training models to be robust to this set of perturbations thus leads to feature representations that align better with human perception, and could also pave the way towards building models that are easier to understand. For instance, the features learnt by robust models yield clean inter-class interpolations, similar to those found by generative adversarial networks (GANs) (Goodfellow et al., 2014) and other generative models. This hints at the existence of a stronger connection between GANs and adversarial robustness.

On the Price of Adversarial Robustness

Recall that in the canonical classification setting, the primary focus is on maximizing standard accuracy, i.e. the performance on (yet) unseen samples from the underlying distribution. Specifically, the goal is to train models that have low expected loss (also known as population risk):

The existence of adversarial examples largely changed this picture. In particular, there has been a lot of interest in developing models that are resistant to them, or, in other words, models that are adversarially robust. In this context, the goal is to train models with low expected adversarial loss:

Adversarial training.

The most successful approach to building adversarially robust models so far (Madry et al., 2018; Wong & Kolter, 2018; Sinha et al., 2018; Raghunathan et al., 2018) was so-called adversarial training (Goodfellow et al., 2015). Adversarial training is motivated by viewing (2) as a statistical learning question, for which we need to solve the corresponding (adversarial) empirical risk minimization problem:

Though adversarial training is effective, this success comes with certain drawbacks. The most obvious one is an increase in the training time (we need to compute new perturbations each parameter update step). Another one is the potential need for more training data as shown recently in Schmidt et al. (2018). These costs make training more demanding, but is that the whole price of being adversarially robust? In particular, if we are willing to pay these costs: Are robust classifiers better than standard ones in every other aspect? This is the key question that motivates our work.

Adversarial Training as a Form of Data Augmentation.

Our point of start is a popular view of adversarial training as the “ultimate” form of data augmentation. According to this view, the adversarial perturbation set $\Delta$ is seen as the set of invariants that a good model should satisfy (regardless of the adversarial robustness considerations). Thus, finding the worst-case $\delta$ corresponds to augmenting the training data in the “most confusing” and thus also “most helpful” manner. A key implication of this view is that adversarial training should be beneficial for the standard accuracy of a model (Torkamani & Lowd, 2013, 2014; Goodfellow et al., 2015; Miyato et al., 2018).

Surprisingly however, as we include more samples in the training set, this positive effect becomes less significant (Figure 1). In fact, after some point adversarial training actually decreases the standard accuracy. Overall, when training on the entire dataset, we observe a decline in standard accuracy as the strength of the adversary increases (see Figure 7 of Appendix G for a plot of standard accuracy vs. $\varepsilon$). (Note that this still holds if we train on batches that contain natural examples as well, as recommended by Kurakin et al. (2017). See Appendix B for details.) Similar effects were also observed in prior and concurrent work (Kurakin et al., 2017; Madry et al., 2018; Dvijotham et al., 2018b; Wong et al., 2018; Xiao et al., 2019; Su et al., 2018).

The goal of this work is to illustrate and explain the roots of this phenomenon. In particular, we would like to understand:

Why does there seem to be a trade-off between standard and adversarially robust accuracy?

As we will show, this effect is not necessarily an artifact of our adversarial training methods but may in fact be an inevitable consequence of the different goals of adversarial robustness and standard generalization.

1 Adversarial robustness might be incompatible with standard accuracy

As we discussed above, we often observe that employing adversarial training leads to a decrease in a model’s standard accuracy. In what follows, we show that this phenomenon is possibly a manifestation of an inherent tension between standard accuracy and adversarially robust accuracy. In particular, we present a fairly simple theoretical model where this tension provably exists.

Our data model consists of input-label pairs $(x,y)$ sampled from a distribution $\mathcal{D}$ as follows:

where $\mathcal{N}(\mu,\sigma^{2})$ is a normal distribution with mean $\mu$ and variance $\sigma^{2}$, and $p\geq 0.5$. We chose $\eta$ to be large enough so that a simple classifier attains high standard accuracy (>$99\%$) – e.g. $\eta=\Theta(1/\sqrt{d})$ will suffice. The parameter $p$ quantifies how correlated the feature $x_{1}$ is with the label. For the sake of example, we can think of $p$ as being $0.95$. This choice is fairly arbitrary; the trade-off between standard and robust accuracy will be qualitatively similar for any $p<1$.

Standard classification is easy.

Note that samples from $\mathcal{D}$ consist of a single feature that is moderately correlated with the label and $d$ other features that are only very weakly correlated with it. Despite the fact that each one of the latter type of features individually is hardly predictive of the correct label, this distribution turns out to be fairly simple to classify from a standard accuracy perspective. Specifically, a natural (linear) classifier

achieves standard accuracy arbitrarily close to $100\%$, for $d$ large enough. Indeed, observe that

which is $>99\%$ when $\eta\geq 3/\sqrt{d}$.

Adversarially robust classification.

Note that in our discussion so far, we effectively viewed the average of $x_{2},\ldots,x_{d+1}$ as a single “meta-feature” that is highly correlated with the correct label. For a standard classifier, any feature that is even slightly correlated with the label is useful. As a result, a standard classifier will take advantage (and thus rely on) the weakly correlated features $x_{2},\ldots,x_{d+1}$ (by implicitly pooling information) to achieve almost perfect standard accuracy.

Formally, the probability of the meta-feature correctly predicting $y$ in this setting (4) is

As a result, the simple classifier in (4) that relies solely on these features cannot get adversarial accuracy better than $1\%$.

Intriguingly, this discussion draws a distinction between robust features ($x_{1}$) and non-robust features ($x_{2},\ldots,x_{d+1}$) that arises in the adversarial setting. While the meta-feature is far more predictive of the true label, it is extremely unreliable in the presence of an adversary. Hence, a tension between standard and adversarial accuracy arises. Any classifier that aims for high accuracy (say $>99\%$) will have to heavily rely on non-robust features (the robust feature provides only, say, $95\%$ accuracy). However, since the non-robust features can be arbitrarily manipulated, this classifier will inevitably have low adversarial accuracy. We make this formal in the following theorem proved in Appendix C.

This bound implies that if $p<1$, as standard accuracy approaches $100\%$ ($\delta\to 0$), adversarial accuracy falls to $0\%$. As a concrete example, consider $p=0.95$, for which any classifier with standard accuracy more than $1-\delta$ will have robust accuracy at most $19\delta$Hence, any classifier with standard accuracy $\geq 99\%$ has robust accuracy $\leq 19\%$ and any classifier with standard accuracy $\geq 96\%$ has robust accuracy $\leq 76\%$.. Also it is worth noting that the theorem is tight. If $\delta=1-p$, both the standard and adversarial accuracies are bounded by $p$ which is attained by the classifier that relies solely on the first feature. Additionally, note that compared to the scale of the features $\pm 1$, the value of $\varepsilon$ required to manipulate the standard classifier is very small ($\varepsilon=O(\eta)$, where $\eta=O(1/\sqrt{d})$).

On the (non-)existence of an accurate and robust classifier.

It might be natural to expect that in the regime of infinite data, the Bayes-optimal classifier—the classifier minimizing classification error with full-information about the distribution—is a robust classifier. Note however, that this is not true for the setting we analyze above. Here, the trade-off between standard and adversarial accuracy is an inherent trait of the data distribution itself and not due to having insufficient samples. In this particular classification task, we (implicitly) assumed that there does not exist a classifier that is both robust and very accurate (i.e. $>99$% standard and robust accuracy). Thus, for this task, any classifier that is very accurate (including the Bayes-optimal classifier) will necessarily be non-robust.

This seemingly goes against the common assumption in adversarial ML that such perfectly robust and accurate classifiers for standard datasets exist, e.g., humans. Note, however, that humans can have lower accuracy in certain benchmarks compared to ML models (Karpathy, 2011, 2014; He et al., 2015; Gastaldi, 2017) potentially because ML models rely on brittle features that humans themselves are naturally invariant to. Moreover, even if perfectly accurate and robust classifiers exist for a particular benchmark, state-of-the-art ML models might still rely on such non-robust features of the data to achieve their performance. Hence, training these models robustly will result in them being unable to rely on such features, thus suffering from reduced accuracy.

2 The importance of adversarial training

As we have seen in the distributional model $\mathcal{D}$ (3), a classifier that achieves very high standard accuracy (1) will inevitably have near-zero adversarial accuracy. This is true even when a classifier with reasonable standard and robust accuracy exists. Hence, in an adversarial setting (2), where the goal is to achieve high adversarial accuracy, the training procedure needs to be modified. We now make this phenomenon concrete for linear classifiers trained using the soft-margin SVM loss. Specifically, in Appendix D we prove the following theorem.

This theorem shows that if our focus is on robust models, adversarial training is necessary to achieve non-trivial adversarial accuracy in this setting. Soft-margin SVM classifiers and the constant $0.975$ are chosen for mathematical convenience. Our proofs do not depend on them in a crucial way and can be adapted, in a straightforward manner, to other natural settings, e.g. logistic regression.

An interesting implication of our analysis is that standard training produces classifiers that rely on features that are weakly correlated with the correct label. This will be true for any classifier trained on the same distribution. Hence, the adversarial examples that are created by perturbing each feature in the direction of $-y$ will transfer across classifiers trained on independent samples from the distribution. This constitutes an interesting manifestation of the generally observed phenomenon of transferability (Szegedy et al., 2014) and might hint at its origin.

Empirical examination.

In Section 2.1, we showed that the trade-off between standard accuracy and robustness might be inevitable. To examine how representative our theoretical model is of real-world datasets, we experimentally investigate this issue on MNIST (LeCun, 1998) as it is amenable to linear classifiers. Interestingly, we observe a qualitatively similar behavior. For instance, in Figure 5(b) in Appendix E, we see that the standard classifier assigns weight to even weakly-correlated features. (Note that in settings with finite training data, such brittle features could arise even from noise – see Appendix E.) The robust classifier on the other hand does not assign any weight beyond a certain threshold. Further, we find that it is possible to obtain a robust classifier by directly training a standard model using only features that are relatively well-correlated with the label (without adversarial training). As expected, as more features are incorporated into the training, the standard accuracy is improved at the cost of robustness (see Appendix E Figure 5(c)).

Unexpected benefits of adversarial robustness

In Section 2, we established that robust and standard models might depend on very different sets of features. We demonstrated how this can lead to a decrease in standard accuracy for robust models. In this section, we will argue that the representations learned by robust models can also be beneficial.

As a starting point, we want to investigate which features of the input most strongly affect the prediction of the classifier both for standard and robust models. To this end, we visualize the gradients of the loss with respect to individual features (pixels) of the input in Figure 2. We observe that gradients for adversarially trained networks align well with perceptually relevant features (such as edges) of the input image. In contrast, for standard networks, these gradients have no coherent patterns and appear very noisy to humans. We want to emphasize that no preprocessing was applied to the gradients (other than scaling and clipping for visualization). So far, extraction of human-aligned information from the gradients of standard networks has only been possible with additional sophisticated techniques (Simonyan et al., 2013; Yosinski et al., 2015; Olah et al., 2017).

This observation effectively outlines an approach to train models that align better with human perception by design. By encoding the correct prior into the set of perturbations $\Delta$, adversarial training alone might be sufficient to yield more human-aligned gradients. We believe that this phenomenon warrants an in-depth investigation and we view our experiments as only exploratory.

Adversarial examples exhibit salient data characteristics.

The resulting visualizations are presented in Figure 3 (details in Appendix A). Surprisingly, we can observe that adversarial perturbations for robust models tend to produce salient characteristics of another class. In fact, the corresponding adversarial examples for robust models can often be perceived as samples from that class. This behavior is in stark contrast to standard models, for which adversarial examples appear to humans as noisy variants of the input image.

These findings provide additional evidence that adversarial training does not necessarily lead to gradient obfuscation (Athalye et al., 2018a). Following the gradient changes the image in a meaningful way and (eventually) leads to images of different classes. Hence, the robustness of these models is less likely to stem from having gradients that are ill-suited for first-order methods.

Smooth cross-class interpolations via gradient descent.

By linearly interpolating between the original image and the image produced by PGD we can produce a smooth, “perceptually plausible” interpolation between classes (Figure 4). Such interpolation have thus far been restricted to generative models such as GANs (Goodfellow et al., 2014) and VAEs (Kingma & Welling, 2015), involved manipulation of learned representations (Upchurch et al., 2017), and hand-designed methods (Suwajanakorn et al., 2015; Kemelmacher-Shlizerman, 2016). In fact, we conjecture that the similarity of these inter-class trajectories to GAN interpolations is not a coincidence. We postulate that the saddle point problem that is key in both these approaches may be at the root of this effect. We hope that future research will investigate this connection further and explore how to utilize the loss landscape of robust models as an alternative method to smoothly interpolate between classes.

Related work

Due to the large body of related work, we will only focus on the most relevant studies here and defer the full discussion to Appendix F. Fawzi et al. (2018b) prove upper bounds on the robustness of classifiers and exhibit a standard vs. robust accuracy trade-off for specific classifier families on a synthetic task. Their setting also (implicitly) utilizes the notion of robust and non-robust features, however these features have small magnitude rather than weak correlation. Ross & Doshi-Velez (2018) propose regularizing the gradient of the classifier with respect to its input. They find that the resulting classifiers have more human-aligned gradients and targeted adversarial examples resemble the target class for digit and character recognition tasks. Finally, there has been recent work proving upper bounds on classifier robustness focusing on the sample complexity of robust learning (Schmidt et al., 2018) or using generative assumptions on the data (Fawzi et al., 2018a).

Conclusions and future directions

In this work, we show that the goal of adversarially robust generalization might fundamentally be at odds with that of standard generalization. Specifically, we identify a trade-off between the standard accuracy and adversarial robustness of a model, that provably manifests even in simple settings. This trade-off stems from intrinsic differences between the feature representations learned by standard and robust models. Our analysis also potentially explains the drop in standard accuracy observed when employing adversarial training in practice. Moreover, it emphasizes the need to develop robust training methods, since robustness is unlikely to arise as a consequence of standard training.

Moreover, we discover that even though adversarial robustness comes at a price, it has some unexpected benefits. Robust models learn meaningful feature representations that align well with salient data characteristics. The root of this phenomenon is that the set of adversarial perturbations encodes some prior for human perception. Thus, classifiers that are robust to these perturbations are also necessarily invariant to input modifications that we expect humans to be invariant to. We demonstrate a striking consequence of this phenomenon: robust models yield clean feature interpolations similar to those obtained from generative models such as GANs (Goodfellow et al., 2014). This emphasizes the possibility of a stronger connection between GANs and adversarial robustness.

Finally, our findings show that the interplay between adversarial robustness and standard classification might be more nuanced that one might expect. This motivates further work to fully undertand the relative costs and benefits of each of these notions.

Acknowledgements

Shibani Santurkar was supported by the National Science Foundation (NSF) under grants IIS-1447786, IIS-1607189, and CCF-1563880, and the Intel Corporation. Dimitris Tsipras was supported in part by the NSF grant CCF-1553428. Aleksander Mądry was supported in part by an Alfred P. Sloan Research Fellowship, a Google Research Award, and the NSF grant CCF-1553428.

References

Appendix A Experimental setup

We perform our experimental analysis on the MNIST (LeCun, 1998), CIFAR-10 (Krizhevsky, 2009) and (restricted) ImageNet (Russakovsky et al., 2015) datasets. For the ImageNet dataset, adversarial training is significantly harder since the classification problem is challenging by itself and standard classifiers are already computationally expensive to train. We thus restrict our focus to a smaller subset of the dataset. We group together a subset of existing, semantically similar ImageNet classes into 8 different super-classes, as shown in Table 1. We train and evaluate only on examples corresponding to these classes.

A.2 Models

MNIST: We use a simple convolutional architecture (Madry et al., 2018)https://github.com/MadryLab/mnist_challenge/.

CIFAR-10: We consider a standard ResNet model (He et al., 2016). It has 4 groups of residual layers with filter sizes (16, 16, 32, 64) and 5 residual units eachhttps://github.com/MadryLab/cifar10_challenge/.

Restricted ImageNet: We use a ResNet-50 (He et al., 2016) architecture using the code from the tensorpack repository (Wu et al., 2016). We do not modify the model architecture, and change the training procedure only by changing the number of examples per “epoch” from 1,280,000 images to 76,800 images.

A.3 Adversarial training

A.4 Adversarial examples for large ε𝜀\varepsilon

The images we generated for Figure 3 were allowed a much larger perturbation from the original sample in order to produce visible changes to the images. These values are listed in Table 3.

Since these levels of perturbations would allow to truly change the class of the image, training against such strong adversaries would be impossible. Still, we observe that smaller values of $\varepsilon$ suffice to ensure that the models rely on the most robust features.

Appendix B Mixing natural and adversarial examples in each batch

In order to make sure that the standard accuracy drop in Figure 7 is not an artifact of only training on adversarial examples, we experimented with including unperturbed examples in each training batch, following the recommendation of (Kurakin et al., 2017). We found that while this slightly improves the standard accuracy of the classifier, it usually decreases robust accuracy by a roughly proportional amount, see Table 4.

Appendix C Proof of Theorem 2.1

The main idea of the proof is that an adversary with $\varepsilon=2\eta$ is able to change the distribution of features $x_{2},\ldots,x_{d+1}$ to reflect a label of $-y$ instead of $y$ by subtracting $\varepsilon y$ from each variable. Hence any information that is used from these features to achieve better standard accuracy can be used by the adversary to reduce adversarial accuracy. We define $G_{+}$ to be the distribution of $x_{2},\ldots,x_{d+1}$ when $y=+1$ and $G_{-}$ to be that distribution when $y=-1$. We will consider the setting where $\varepsilon=2\eta$ and fix the adversary that replaces $x_{i}$ by $x_{i}-y\varepsilon$ for each $i\geq 2$. This adversary is able to change $G_{+}$ to $G_{-}$ in the adversarial setting and vice-versa.

Consider any classifier $f(x)$ that maps an input $x$ to a class in $\{-1,+1\}$. Let us fix the probability that this classifier predicts class $+1$ for some fixed value of $x_{1}$ and distribution of $x_{2},\ldots,x_{d+1}$. Concretely, we define $p_{ij}$ to be the probability of predicting $+1$ given that the first feature has sign $i$ and the rest of the features are distributed according to $G_{j}$. Formally,

Using these definitions, we can express the standard accuracy of the classifier as

Similarly, we can express the accuracy of this classifier against the adversary that replaces $G_{+}$ with $G_{-}$ (and vice-versa) as

For convenience we will define $a=1-p_{++}+p_{--}$ and $b=1-p_{-+}+p_{+-}$. Then we can rewrite

We are assuming that the standard accuracy of the classifier is at least $1-\delta$ for some small $\delta$. This implies that

Since $p_{ij}$ are probabilities, we can guarantee that $a\geq 0$. Moreover, since $p\geq 0.5$, we have $p/(1-p)\geq 1$. We use these to upper bound the adversarial accuracy by

Appendix D Proof of Theorem 2.2

We consider the problem of fitting the distribution $\mathcal{D}$ of (3) by using a standard soft-margin SVM classifier. Specifically, this can be formulated as:

First we will argue that, due to symmetry, the optimal solution will assign equal weight to all the features $x_{i}$ for $i=2,\ldots,d+1$.

Consider an optimal solution $w^{*}$ to the optimization problem (5). Then,

Assume that $\exists\,i,j\in\{2,...,d+1\}$ such that $w^{*}_{i}\neq w^{*}_{j}$. Since the distribution of $x_{i}$ and $x_{j}$ are identical, we can swap the value of $w_{i}$ and $w_{j}$, to get an alternative set of parameters $\hat{w}$ that has the same loss function value ($\hat{w}_{j}=w_{i}$, $\hat{w}_{i}=w_{j}$, $\hat{w}_{k}=w_{k}$ for $k\neq i,j$).

Moreover, since the margin term of the loss is convex in $w$, using Jensen’s inequality, we get that averaging $w^{*}$ and $\hat{w}$ will not increase the value of that margin term. Note, however, that $\lVert\frac{w^{*}+\hat{w}}{2}\rVert_{2}<\lVert w^{*}\rVert_{2}$, hence the regularization loss is strictly smaller for the average point. This contradicts the optimality of $w^{*}$. ∎

Since every optimal solution will assign equal weight to all $x_{i}$ for $k\geq 2$, we can replace these features by their sum (and divide by $\sqrt{d}$ for convenience). We will define

which, by the properties of the normal distribution, is distributed as

By assigning a weight of $v$ to that combined feature the optimal solutions can be parametrized as

where the regularization term of the loss is $\lambda(w_{1}^{2}+v^{2})/2$.

Recall that our chosen value of $\eta$ is $4/\sqrt{d}$, which implies that the contribution of $vz$ is distributed normally with mean $4yv$ and variance $v^{2}$. By the concentration of the normal distribution, the probability of $vz$ being larger than $v$ is large. We will use this fact to show that the optimal classifier will assign on $v$ at least as much weight as it assigns on $w_{1}$.

Consider the optimal solution $(w_{1}^{*},v^{*})$ of the problem (5). Then

Assume for the sake of contradiction that $v^{*}<1/\sqrt{2}$. Then, with probability at least $1-p$, the first feature predicts the wrong label and without enough weight, the remaining features cannot compensate for it. Concretely,

We will now show that a solution that assigns zero weight on the first feature ($v=1$ and $w_{1}=0$), achieves a better margin loss.

Hence, as long as $p\leq 0.975$, this solution has a smaller margin loss than the original solution. Since both solutions have the same norm, the solution that assigns weight only on $v$ is better than the original solution $(w_{1}^{*},v^{*})$, contradicting its optimality. ∎

We have established that the learned classifier will assign more weight to $v$ than $w_{1}$. Since $z$ will be at least $y$ with large probability, we will show that the behavior of the classifier depends entirely on $z$.

The standard accuracy of the soft-margin SVM learned for problem (5) is at least $99\%$.

By Lemma D.2, the classifier predicts the sign of $w_{1}x_{1}+vz$ where $vz\sim\mathcal{N}(4yv,v^{2})$ and $v\geq 1/\sqrt{2}$. Hence with probability at least $99\%$, $vzy>1/\sqrt{2}\geq w_{1}$ and thus the predicted class is $y$ (the correct class) independent of $x_{1}$. ∎

We can utilize the same argument to show that an adversary that changes the distribution of $z$ has essentially full control over the classifier prediction.

Observe that the adversary can shift each feature $x_{i}$ towards $y$ by $2\eta$. This will cause $z$ to be distributed as

Therefore with probability at least $99\%$, $vyz<-y\leq-w_{1}$ and the predicted class will be $-y$ (wrong class) independent of $x_{1}$. ∎

It remains to show that adversarial training for this classification task with $\varepsilon>2\eta$ will results in a classifier that has relies solely on the first feature.

Minimizing the adversarial variant of the loss (5) results in a classifier that assigns weight to features $x_{i}$ for $i\geq 2$.

The optimization problem that adversarial training solves is

Consider any optimal solution $w$ for which $w_{i}>0$ for some $i>2$. The contribution of terms depending on $w_{i}$ to $1-yw^{\top}x+\varepsilon\|w\|_{1}$ is a normally-distributed random variable with mean $2\eta-\varepsilon\leq 0$. Since the mean is non-positive, setting $w_{i}$ to zero can only decrease the margin term of the loss. At the same time, setting $w_{i}$ to zero strictly decreases the regularization term, contradicting the optimality of $w$. ∎

Clearly, such a classifier will have standard and adversarial accuracy of $p$ against any $\varepsilon<1$ since such a value of $\varepsilon$ is not sufficient to change the sign of the first feature. This concludes the proof of the theorem.

Appendix E Robustness-accuracy trade-off: An empirical examination

Our theoretical analysis shows that there is an inherent tension between standard accuracy and adversarial robustness. At the core of this trade-off is the concept of robust and non-robust features. We now investigate whether this notion arises experimentally by studying a dataset that is amenable to linear classifiers, MNIST (LeCun, 1998) (details in Appendix A).

This calculation suggests that in the adversarial setting, there is an implicit threshold on feature correlations imposed by the threat model (the perturbation allowed to the adversary). While standard models may utilize all features with non-zero correlations, a robust model cannot rely on features with correlation below this threshold. In Figure 5(b), we visualize the correlation of each pixel (feature) in the MNIST dataset along with the learned weights of the standard and robust classifiers. As expected, we see that the standard classifier assigns weights even to weakly-correlated pixels so as to maximize prediction confidence. On the other hand, the robust classifier does not assign any weight below a certain correlation threshold which is dictated by the adversary’s strength ($\varepsilon$) (Figures 5(a, b))

Interestingly, the standard model assigns non-zero weight even to very weakly correlated pixels (Figure 5(a)). In settings with finite training data, such non-robust features could arise from noise. (For instance, in $N$ tosses of an unbiased coin, the expected imbalance between heads and tails is $O(\sqrt{N})$ with high probability.) A standard classifier would try to take advantage of even this “hallucinated” information by assigning non-zero weights to these features.

The analysis above highlights an interesting trade-off between the predictive power of a feature and its vulnerability to adversarial perturbations. This brings forth the question – Could we use these insights to train robust classifiers with standard methods (i.e. without performing adversarial training)? As a first step, we train a (standard) linear classifier on MNIST utilizing input features (pixels) that lie above a given correlation threshold (see Figure 5(c)). As expected, as more non robust features are incorporated in training, the standard accuracy increases at the cost of robustness. Further, we observe that a standard classifier trained in this manner using few robust features attains better robustness than even adversarial training. This results suggest a more direct (and potentially better) method of training robust networks in certain settings.

Appendix F Additional related work

Fawzi et al. (2016) derive parameter-dependent bounds on the robustness of any fixed classifier, while Wang et al. (2018) analyze the adversarial robustness of nearest neighbor classifiers. Our results focus on the statistical setting itself and provide lower bounds for all classifiers learned in this setting.

Schmidt et al. (2018) study the generalization aspect of adversarially robustness. They show that the number of samples needed to achieve adversarially robust generalization is polynomially larger in the dimension than the number of samples needed to ensure standard generalization. However, in the limit of infinite data, one can learn classifiers that are both robust and accurate and thus the trade-off we study does not manifest.

Gilmer et al. (2018) demonstrate a setting where even a small amount of standard error implies that most points provably have a misclassified point close to them. In this setting, achieving perfect standard accuracy (easily achieved by a simple classifier) is sufficient to achieve perfect adversarial robustness. In contrast, our work focuses on a setting where adversarial training (provably) matters and there exists a trade-off between standard and adversarial accuracy.

Xu & Mannor (2012) explore the connection between robustness and generalization, showing that, in a certain sense, robustness can imply generalization. This direction is orthogonal to our, since we work in the limit of infinite data, optimizing the distributional loss directly.

Fawzi et al. (2018a) prove lower bounds on the robustness of any classifier based on certain generative assumptions. Since these bounds apply to all classifiers, independent of architecture and training procedure, they fail to capture the situation we face in practice where robust optimization can significantly improve the adversarial robustness of standard classifiers (Madry et al., 2018; Wong & Kolter, 2018; Raghunathan et al., 2018; Sinha et al., 2018).

A recent work (Bubeck et al., 2018) turns out to (implicitly) rely on the distinction between robust and non-robust features in constructing a distribution for which adversarial robustness is hard from a different, computational point of view.

Goodfellow et al. (2015) observed that adversarial training results in feature weights that depend on fewer input features (similar to Figure 5(a)). Additionally, it has been observed that for naturally trained RBF classifiers on MNIST, targeted adversarial attacks resemble images of the target class (Goodfellow, 2015).

Su et al. (2018) empirically observe a similar trade-off between the accuracy and robustness of standard models across different deep architectures on ImageNet.

Appendix G Omitted figures