Title: ENSEMBLE ADVERSARIAL TRAINING: ATTACKS AND DEFENSES

Abstract: Adversarial examples are perturbed inputs designed to fool machine learning models. Adversarial training injects such examples into training data to increase robustness. To scale this technique to large datasets, perturbations are crafted using fast single-step methods that maximize a linear approximation of the model's loss. We show that this form of adversarial training converges to a degenerate global minimum, wherein small curvature artifacts near the data points obfuscate a linear approximation of the loss. The model thus learns to generate weak perturbations, rather than defend against strong ones. As a result, we find that adversarial training remains vulnerable to black-box attacks, where we transfer perturbations computed on undefended models, as well as to a powerful novel single-step attack that escapes the non-smooth vicinity of the input data via a small random step. We further introduce Ensemble Adversarial Training, a technique that augments training data with perturbations transferred from other models. On ImageNet, Ensemble Adversarial Training yields models with strong robustness to black-box attacks. In particular, our most robust model won the first round of the NIPS 2017 competition on Defenses against Adversarial Attacks (Kurakin et al., 2017c).

1. INTRODUCTION:

Machine learning (ML) models are often vulnerable to adversarial examples, maliciously perturbed inputs designed to mislead a model at test time (Biggio et al., 2013; Szegedy et al., 2013; Goodfellow et al., 2014b; Papernot et al., 2016a) . Furthermore, Szegedy et al. (2013) showed that these inputs transfer across models: the same adversarial example is often misclassified by different models, thus enabling simple black-box attacks on deployed models (Papernot et al., 2017; Liu et al., 2017) .

Adversarial training (Szegedy et al., 2013) increases robustness by augmenting training data with adversarial examples. Madry et al. (2017) showed that adversarially trained models can be made robust to white-box attacks (i.e., with knowledge of the model parameters) if the perturbations computed during training closely maximize the model's loss. However, prior attempts at scaling this approach to ImageNet-scale tasks (Deng et al., 2009) have proven unsuccessful (Kurakin et al., 2017b) .

It is thus natural to ask whether it is possible, at scale, to achieve robustness against the class of black-box adversaries Towards this goal, Kurakin et al. (2017b) adversarially trained an Inception v3 model (Szegedy et al., 2016b) on ImageNet using a "single-step" attack based on a linearization of the model's loss (Goodfellow et al., 2014b) . Their trained model is robust to single-step perturbations but remains vulnerable to more costly "multi-step" attacks. Yet, Kurakin et al. (2017b) found that these attacks fail to reliably transfer between models, and thus concluded that the robustness of their model should extend to black-box adversaries. Surprisingly, we show that this is not the case.

We demonstrate, formally and empirically, that adversarial training with single-step methods admits a degenerate global minimum, wherein the model's loss can not be reliably approximated by a linear function. Specifically, we find that the model's decision surface exhibits sharp curvature near the data points, thus degrading attacks based on a single gradient computation. In addition to the model of Kurakin et al. (2017b) , we reveal similar overfitting in an adversarially trained Inception ResNet v2 model (Szegedy et al., 2016a) , and a variety of models trained on MNIST (LeCun et al., 1998) .

We harness this result in two ways. First, we show that adversarially trained models using single-step methods remain vulnerable to simple attacks. For black-box adversaries, we find that perturbations crafted on an undefended model often transfer to an adversarially trained one. We also introduce a simple yet powerful single-step attack that applies a small random perturbation-to escape the nonsmooth vicinity of the data point-before linearizing the model's loss. While seemingly weaker than the Fast Gradient Sign Method of Goodfellow et al. (2014b) , our attack significantly outperforms it for a same perturbation norm, for models trained with or without adversarial training.

Second, we propose Ensemble Adversarial Training, a training methodology that incorporates perturbed inputs transferred from other pre-trained models. Our approach decouples adversarial example generation from the parameters of the trained model, and increases the diversity of perturbations seen during training. We train Inception v3 and Inception ResNet v2 models on ImageNet that exhibit increased robustness to adversarial examples transferred from other holdout models, using various single-step and multi-step attacks (Goodfellow et al., 2014b; Carlini & Wagner, 2017a; Kurakin et al., 2017a; Madry et al., 2017) . We also show that our methods globally reduce the dimensionality of the space of adversarial examples (Tramèr et al., 2017) . Our Inception ResNet v2 model won the first round of the NIPS 2017 competition on Defenses Against Adversarial Attacks (Kurakin et al., 2017c) , where it was evaluated on other competitors' attacks in a black-box setting.1 

2. RELATED WORK:

Various defensive techniques against adversarial examples in deep neural networks have been proposed (Gu & Rigazio, 2014; Luo et al., 2015; Papernot et al., 2016c; Nayebi & Ganguli, 2017; Cisse et al., 2017) and many remain vulnerable to adaptive attackers (Carlini & Wagner, 2017a; b; Baluja & Fischer, 2017) . Adversarial training (Szegedy et al., 2013; Goodfellow et al., 2014b; Kurakin et al., 2017b; Madry et al., 2017) appears to hold the greatest promise for learning robust models. Madry et al. (2017) show that adversarial training on MNIST yields models that are robust to whitebox attacks, if the adversarial examples used in training closely maximize the model's loss. Moreover, recent works by Sinha et al. (2018) , Raghunathan et al. (2018) and Kolter & Wong (2017) even succeed in providing certifiable robustness for small perturbations on MNIST. As we argue in Appendix C, the MNIST dataset is peculiar in that there exists a simple "closed-form" denoising procedure (namely feature binarization) which leads to similarly robust models without adversarial training. This may explain why robustness to white-box attacks is hard to scale to tasks such as Im-ageNet (Kurakin et al., 2017b) . We believe that the existence of a simple robust baseline for MNIST can be useful for understanding some limitations of adversarial training techniques. Szegedy et al. (2013) found that adversarial examples transfer between models, thus enabling blackbox attacks on deployed models. Papernot et al. (2017) showed that black-box attacks could succeed with no access to training data, by exploiting the target model's predictions to extract (Tramèr et al., 2016) a surrogate model. Some prior works have hinted that adversarially trained models may remain vulnerable to black-box attacks: Goodfellow et al. (2014b) found that an adversarial maxout network on MNIST has slightly higher error on transferred examples than on white-box examples. Papernot et al. (2017) further showed that a model trained on small perturbations can be evaded by transferring perturbations of larger magnitude. Our finding that adversarial training degrades the accuracy of linear approximations of the model's loss is as an instance of a gradient-masking phenomenon (Papernot et al., 2016b) , which affects other defensive techniques (Papernot et al., 2016c; Carlini & Wagner, 2017a; Nayebi & Ganguli, 2017; Brendel & Bethge, 2017; Athalye et al., 2018) .

3. THE ADVERSARIAL TRAINING FRAMEWORK:

We consider a classification task with data x ∈ [0, 1] d and labels y true ∈ Z k sampled from a distribution D. We identify a model with an hypothesis h from a space H. On input x, the model outputs class scores h(x) ∈ R k . The loss function used to train the model, e.g., cross-entropy, is L(h(x), y).

3.1. THREAT MODEL:

For some target model h ∈ H and inputs (x, y true ) the adversary's goal is to find an adversarial example x adv such that x adv and x are "close" yet the model misclassifies x adv . We consider the wellstudied class of ∞ bounded adversaries (Goodfellow et al., 2014b; Madry et al., 2017) that, given some budget , output examples x adv where x adv -x ∞ ≤ . As we comment in Appendix C.1, ∞ robustness is of course not an end-goal for secure ML. We use this standard model to showcase limitations of prior adversarial training methods, and evaluate our proposed improvements.

We distinguish between white-box adversaries that have access to the target model's parameters (i.e., h), and black-box adversaries with only partial information about the model's inner workings. Formal definitions for these adversaries are in Appendix A. Although security against white-box attacks is the stronger notion (and the one we ideally want ML models to achieve), black-box security is a reasonable and more tractable goal for deployed ML models.

3.2. ADVERSARIAL TRAINING:

Following Madry et al. (2017) , we consider an adversarial variant of standard Empirical Risk Minimization (ERM), where our aim is to minimize the risk over adversarial examples: (Szegedy et al., 2013; Goodfellow et al., 2014b) , which we use in our experiments, trains on both the "clean" examples x and adversarial examples x adv .

EQUATION

We consider three algorithms to generate adversarial examples with bounded ∞ norm. The first two are single-step (i.e., they require a single gradient computation); the third is iterative-it computes multiple gradient updates. We enforce x adv ∈ [0, 1] d by clipping all components of x adv .

Fast Gradient Sign Method (FGSM). This method (Goodfellow et al., 2014b) linearizes the inner maximization problem in (1):

EQUATION

Single-Step Least-Likely Class Method (Step-LL). This variant of FGSM introduced by Kurakin et al. (2017a; b) targets the least-likely class, y LL = arg min{h(x)}:

EQUATION

Although this attack only indirectly tackles the inner maximization in (1), Kurakin et al. (2017b) find it to be the most effective for adversarial training on ImageNet.

Iterative Attack (I-FGSM or Iter-LL). This method iteratively applies the FGSM or Step-LL k times with step-size α ≥ /k and projects each step onto the ∞ ball of norm around x. It uses projected gradient descent to solve the maximization in (1). For fixed , iterative attacks induce higher error rates than single-step attacks, but transfer at lower rates (Kurakin et al., 2017a; b) . • For an input x from D, there is no x adv close to x (in ∞ norm) that induces a high loss. That is,

3.3. A DEGENERATE GLOBAL MINIMUM:

EQUATION

In other words, h * is robust to all ∞ bounded perturbations. • The minimizer h * is a model for which the approximation method underlying the attack (i.e., linearization in our case) poorly fits the model's loss function. That is,

EQUATION

Thus the attack when applied to h * produces samples x adv that are far from optimal.

Note that this second "degenerate" minimum can be more subtle than a simple case of overfitting to samples produced from single-step attacks. Indeed, we show in Section 4.1 that single-step attacks applied to adversarially trained models create "adversarial" examples that are easy to classify even for undefended models. Thus, adversarial training does not simply learn to resist the particular attack used during training, but actually to make that attack perform worse overall. This phenomenon relates to the notion of Reward Hacking (Amodei et al., 2016) wherein an agent maximizes its formal objective function via unintended behavior that fails to captures the designer's true intent.

3.4. ENSEMBLE ADVERSARIAL TRAINING:

The degenerate minimum described in Section 3.3 is attainable because the learned model's parameters influence the quality of both the minimization and maximization in (1). One solution is to use a stronger adversarial example generation process, at a high performance cost (Madry et al., 2017) . Alternatively, Baluja & Fischer (2017) suggest training an adversarial generator model as in the GAN framework (Goodfellow et al., 2014a) . The power of this generator is likely to require careful tuning, to avoid similar degenerate minima (where the generator or classifier overpowers the other).

We propose a conceptually simpler approach to decouple the generation of adversarial examples from the model being trained, while simultaneously drawing an explicit connection with robustness to black-box adversaries. (Mansour et al., 2009; Zhang et al., 2012) .

In Domain Adaptation, a model trained on data sampled from one or more source distributions S 1 , . . . , S k is evaluated on samples x from a different target distribution T .

Let A i be an adversarial distribution obtained by sampling (x, y true ) from D, computing an adversarial example x adv for some model such that x adv -x ∞ ≤ , and outputting (x adv , y true ). In Ensemble Adversarial Training, the source distributions are D (the clean data) and A 1 , . . . , A k (the attacks overs the currently trained model and the static pre-trained models). The target distribution takes the form of an unseen black-box adversary A * . Standard generalization bounds for Domain Adaptation (Mansour et al., 2009; Zhang et al., 2012) Figure 1 : Gradient masking in single-step adversarial training. We plot the loss of model v3 adv on points

x * = x + 1 • g + 2 • g ⊥ ,

where g is the signed gradient and g ⊥ is an orthogonal adversarial direction. Plot (b) is a zoom of (a) near x. The gradient poorly approximates the global loss.

We give a formal statement of this result and of the assumptions on A * in Appendix B. Of course, ideally we would like guarantees against arbitrary future adversaries. For very low-dimensional tasks (e.g., MNIST), stronger guarantees are within reach for specific classes of adversaries (e.g., ∞ bounded perturbations (Madry et al., 2017; Sinha et al., 2018; Raghunathan et al., 2018; Kolter & Wong, 2017) ), yet they also fail to extend to other adversaries not considered at training time (see Appendix C.1 for a discussion). For ImageNet-scale tasks, stronger formal guarantees appear out of reach, and we thus resort to an experimental assessment of the robustness of Ensemble Adversarially Trained models to various non-interactive black-box adversaries in Section 4.2.

4. EXPERIMENTS:

We show the existence of a degenerate minimum, as described in Section 3.3, for the adversarially trained Inception v3 model of Kurakin et al. (2017b) . Their model (denoted v3 adv ) was trained on a Step-LL attack with ≤ 16/256. We also adversarially train an Inception ResNet v2 model (Szegedy et al., 2016a) using the same setup. We denote this model by IRv2 adv . We refer the reader to (Kurakin et al., 2017b) for details on the adversarial training procedure.

We first measure the approximation-ratio of the Step-LL attack for the inner maximization in (1). As we do not know the true maximum, we lower-bound it using an iterative attack. For 1,000 random test points, we find that for a standard Inception v3 model, step-LL gets within 19% of the optimum loss on average. This attack is thus a good candidate for adversarial training. Yet, for the v3 adv model, the approximation ratio drops to 7%, confirming that the learned model is less amenable to linearization. We obtain similar results for Inception ResNet v2 models. The ratio is 17% for a standard model, and 8% for IRv2 adv . Similarly, we look at the cosine similarity between the perturbations given by a single-step and multi-step attack. The more linear the model, the more similar we expect both perturbations to be. The average similarity drops from 0.13 for Inception v3 to 0.02 for v3 adv . This effect is not due to the decision surface of v3 adv being "too flat" near the data points: the average gradient norm is larger for v3 adv (0.17) than for the standard v3 model (0.10).

We visualize this "gradient-masking" effect (Papernot et al., 2016b) by plotting the loss of v3 adv on examples

x * = x + 1 • g + 2 • g ⊥ ,

where g is the signed gradient of model v3 adv and g ⊥ is a signed vector orthogonal to g. Looking forward to Section 4.1, we actually chose g ⊥ to be the signed gradient of another Inception model, from which adversarial examples transfer to v3 adv . Figure 1 shows that the loss is highly curved in the vicinity of the data point x, and that the gradient poorly reflects the global loss landscape. Similar plots for additional data points are in Figure 4 .

We show similar results for adversarially trained MNIST models in Appendix C.2. On this task, input dropout (Srivastava et al., 2014) mitigates adversarial training's overfitting problem, in some cases. Presumably, the random input mask diversifies the perturbations seen during training (dropout at intermediate layers does not mitigate the overfitting effect). Mishkin et al. (2017) find that input dropout significantly degrades accuracy on ImageNet, so we did not include it in our experiments. 13.6 13.5 9.0 13.0 14.5 IRv2 14.1 14.8 9.9 24.0 10.6 IRv2 adv 10.3 10.5 7.7 10.4 5.8

Top 5

4.1 ATTACKS AGAINST ADVERSARIALLY TRAINED NETWORKS Kurakin et al. (2017b) found their adversarially trained model to be robust to various single-step attacks. They conclude that this robustness should translate to attacks transferred from other models.

As we have shown, the robustness to single-step attacks is actually misleading, as the model has learned to degrade the information contained in the model's gradient. As a consequence, we find that the v3 adv model is substantially more vulnerable to single-step attacks than Kurakin et al. (2017b) predicted, both in a white-box and black-box setting. The same holds for the IRv2 adv model.

In addition to the v3 adv and IRv2 adv models, we consider standard Inception v3, Inception v4 and Inception ResNet v2 models. These models are available in the TensorFlow-Slim library (Abadi et al., 2015) . We describe similar results for a variety of models trained on MNIST in Appendix C.2.

Black-box attacks. Table 1 shows error rates for single-step attacks transferred between models.

We compute perturbations on one model (the source) and transfer them to all others (the targets).

When the source and target are the same, the attack is white-box. Adversarial training greatly increases robustness to white-box single-step attacks, but incurs a higher error rate in a black-box setting. Thus, the robustness gain observed when evaluating defended models in isolation is misleading. Given the ubiquity of this pitfall among proposed defenses against adversarial examples (Carlini & Wagner, 2017a; Brendel & Bethge, 2017; Papernot et al., 2016b) , we advise researchers to always consider both white-box and black-box adversaries when evaluating defensive strategies. Notably, a similar discrepancy between white-box and black-box attacks was recently observed in Buckman et al. (2018) .

Attacks crafted on adversarial models are found to be weaker even against undefended models (i.e., when using v3 adv or IRv2 adv as source, the attack transfers with lower probability). This confirms our intuition from Section 3.3: adversarial training does not just overfit to perturbations that affect standard models, but actively degrades the linear approximation underlying the single-step attack.

A new randomized single-step attack. The loss function visualization in Figure 1 shows that sharp curvature artifacts localized near the data points can mask the true direction of steepest ascent. We thus suggest to prepend single-step attacks by a small random step, in order to "escape" the non-smooth vicinity of the data point before linearizing the model's loss. Our new attack, called R+FGSM (alternatively, R+Step-LL), is defined as follows, for parameters and α (where α < ):

x adv = x + (ε -α) • sign ∇ x J(x , y true ) , where x = x + α • sign(N (0 d , I d )) . (7)

Note that the attack requires a single gradient computation. The R+FGSM is a computationally efficient alternative to iterative methods that have high success rates in a white-box setting. Our attack can be seen as a single-step variant of the general PGD method from (Madry et al., 2017) . We find that the addition of this random step hinders transferability (see Table 9 ). We also tried adversarial training using R+FGSM on MNIST, using a similar approach as (Madry et al., 2017) . We adversarially train a CNN (model A in Table 5 ) for 100 epochs, and attain > 90.0% accuracy on R+FGSM samples. However, training on R+FGSM provides only little robustness to iterative attacks. For the PGD attack of (Madry et al., 2017) with 20 steps, the model attains 18.0% accuracy.

We now evaluate our Ensemble Adversarial Training strategy described in Section 3.4. We recall our intuition: by augmenting training data with adversarial examples crafted from static pre-trained models, we decouple the generation of adversarial examples from the model being trained, so as to avoid the degenerate minimum described in Section 3.3. Moreover, our hope is that robustness to attacks transferred from some fixed set of models will generalize to other black-box adversaries.

We train Inception v3 and Inception ResNet v2 models (Szegedy et al., 2016a) on ImageNet, using the pre-trained models shown in Table 3 Black-box attacks. Ensemble Adversarial Training significantly boosts robustness to all attacks transferred from the holdout models. For the IRv2 adv-ens model, the accuracy loss (compared to IRv2's accuracy on clean data) is 7.4% (top 1) and 3.1% (top 5). We find that the strongest attacks in our test suite (i.e., with highest transfer rates) are the FGSM attacks. Black-box R+Step-LL or iterative attacks are less effective, as they do not transfer with high probability (see Kurakin et al. (2017b) and Table 9 ). Attacking an ensemble of all three holdout models, as in Liu et al. (2017) , did not lead to stronger black-box attacks than when attacking the holdout models individually.

Our results have little variance with respect to the attack parameters (e.g., smaller ) or to the use of other holdout models for black-box attacks (e.g., we obtain similar results by attacking the v3 adv-ens3 and v3 adv-ens4 models with the IRv2 model). We also find that v3 adv-ens3 is not vulnerable to perturbations transferred from v3 adv-ens4 . We obtain similar results on MNIST (see Appendix C.2), thus demonstrating the applicability of our approach to different datasets and model architectures.

The NIPS 2017 competition on adversarial examples. Our Inception ResNet v2 model was included as a baseline defense in the NIPS 2017 competition on Adversarial Examples (Kurakin et al., 2017c) . Participants of the attack track submitted non-interactive black-box attacks that produce adversarial examples with bounded ∞ norm. Models submitted to the defense track were evaluated on all attacks over a subset of the ImageNet test set. The score of a defense was defined as the average accuracy of the model over all adversarial examples produced by all attacks.

Our IRv2 adv-ens model finished 1 st among 70 submissions in the first development round, with a score of 95.3% (the second placed defense scored 89.9%). The test data was intentionally chosen as an "easy" subset of ImageNet. Our model achieved 97.9% accuracy on the clean test data.

After the first round, we released our model publicly, which enabled other users to launch white-box attacks against it. Nevertheless, a majority of the final submissions built upon our released model. The winning submission (team "liaofz" with a score of 95.3%) made use of a novel adversarial The dimensionality of the adversarial cone. For 500 correctly classified points x, and for ∈ {4, 10, 16}, we plot the probability that we find at least k orthogonal vectors r i such that r i ∞ = and x + r i is misclassified. For ≥ 10, model v3 adv shows a bimodal phenomenon: most points x either have 0 adversarial directions or more than 90.

denoising technique. The second placed defense (team "cihangxie" with a score of 92.4%) prepends our IRv2 adv-ens model with random padding and resizing of the input image (Xie et al., 2018) .

It is noteworthy that the defenses that incorporated Ensemble Adversarial Training faired better against the worst-case black-box adversary. Indeed, although very robust on average, the winning defense achieved as low as 11.8% accuracy on some attacks. The best defense under this metric (team "rafaelmm" which randomly perturbed images before feeding them to our IRv2 adv-ens model) achieved at least 53.6% accuracy against all submitted attacks, including the attacks that explicitly targeted our released model in a white-box setting.

Decreasing gradient masking. Ensemble Adversarial Training decreases the magnitude of the gradient masking effect described previously. For the v3 adv-ens3 and v3 adv-ens4 models, we find that the loss incurred on a Step-LL attack gets within respectively 13% and 18% of the optimum loss (we recall that for models v3 and v3 adv , the approximation ratio was respectively 19% and 7%). Similarly, for the IRv2 adv-ens model, the ratio improves from 8% (for IRv2 adv ) to 14%. As expected, not solely training on a white-box single-step attack reduces gradient masking. We also verify that after Ensemble Adversarial Training, a two-step iterative attack outperforms the R+Step-LL attack from Section 4.1, thus providing further evidence that these models have meaningful gradients. Finally, we revisit the "Gradient-Aligned Adversarial Subspace" (GAAS) method of Tramèr et al. (2017) . Their method estimates the size of the space of adversarial examples in the vicinity of a point, by finding a set of orthogonal perturbations of norm that are all adversarial. We note that adversarial perturbations do not technically form a "subspace" (e.g., the 0 vector is not adversarial). Rather, they may form a "cone", the dimension of which varies as we increase . By linearizing the loss function, estimating the dimensionality of this cone reduces to finding vectors r i that are strongly aligned with the model's gradient g = ∇ x L(h(x), y true ). Tramèr et al. (2017) give a method that finds k orthogonal vectors r i that satisfy g r i ≥ • g 2 • 1 √ k (this bound is tight). We extend this result to the ∞ norm, an open question in Tramèr et al. (2017) . In Section E, we give a randomized combinatorial construction (Colbourn, 2010) , that finds k orthogonal vectors r i satisfying

r i ∞ = and E g r i ≥ • g 1 • 1 √ k .

We show that this result is tight as well. For models v3, v3 adv and v3 adv-ens3 , we select 500 correctly classified test points. For each x, we search for a maximal number of orthogonal adversarial perturbations r i with r i ∞ = . We limit our search to k ≤ 100 directions per point. The results are in Figure 2 . For ∈ {4, 10, 16}, we plot the proportion of points that have at least k orthogonal adversarial perturbations. For a fixed , the value of k can be interpreted as the dimension of a "slice" of the cone of adversarial examples near a data point. For the standard Inception v3 model, we find over 50 orthogonal adversarial directions for 30% of the points. The v3 adv model shows a curious bimodal phenomenon for ≥ 10: for most points (≈ 80%), we find no adversarial direction aligned with the gradient, which is consistent with the gradient masking effect. Yet, for most of the remaining points, the adversarial space is very high-dimensional (k ≥ 90). Ensemble Adversarial Training yields a more robust model, with only a small fraction of points near a large adversarial space.

5. CONCLUSION AND FUTURE WORK:

Previous work on adversarial training at scale has produced encouraging results, showing strong robustness to (single-step) adversarial examples (Goodfellow et al., 2014b; Kurakin et al., 2017b ). Yet, these results are misleading, as the adversarially trained models remain vulnerable to simple black-box and white-box attacks. Our results, generic with respect to the application domain, suggest that adversarial training can be improved by decoupling the generation of adversarial examples from the model being trained. Our experiments with Ensemble Adversarial Training show that the robustness attained to attacks from some models transfers to attacks from other models.

We did not consider black-box adversaries that attack a model via other means than by transferring examples from a local model. For instance, generative techniques (Baluja & Fischer, 2017) might provide an avenue for stronger attacks. Yet, a recent work by Xiao et al. (2018) found Ensemble Adversarial Training to be resilient to such attacks on MNIST and CIFAR10, and often attaining higher robustness than models that were adversarially trained on iterative attacks.

Moreover, interactive adversaries (see Appendix A) could try to exploit queries to the target model's prediction function in their attack, as demonstrated in Papernot et al. (2017) . If queries to the target model yield prediction confidences, an adversary can estimate the target's gradient at a given point (e.g., using finite-differences as in Chen et al. (2017) ) and fool the target with our R+FGSM attack. Note that if queries only return the predicted label, the attack does not apply. Exploring the impact of these classes of black-box attacks and evaluating their scalability to complex tasks is an interesting avenue for future work.

A THREAT MODEL: FORMAL DEFINITIONS:

We provide formal definitions for the threat model introduced in Section 3.1. In the following, we explicitly identify the hypothesis space H that a model belongs to as describing the model's architecture. We consider a target model h ∈ H trained over inputs (x, y true ) sampled from a data distribution D. More precisely, we write h ← train(H, X train , Y train , r) , where train is a randomized training procedure that takes in a description of the model architecture H, a training set X train , Y train sampled from D, and randomness r.

Given a set of test inputs X, Y = {(x 1 , y 1 ), . . . , (x m , y m )} from D and a budget > 0, an adversary A produces adversarial examples

X adv = {x adv 1 , . . . , x adv m }, such that x i -x adv i ∞ ≤ for all i ∈ [1, m].

We evaluate success of the attack as the error rate of the target model over X adv :

1 m m i=1 1(arg max h(x adv i ) = y i ) .

We assume A can sample inputs according to the data distribution D. We define three adversaries. Definition 2 (White-Box Adversary). For a target model h ∈ H, a white-box adversary is given access to all elements of the training procedure, that is train (the training algorithm), H (the model architecture), the training data X train , Y train , the randomness r and the parameters h. The adversary can use any attack (e.g., those in Section 3.2) to find adversarial inputs. Attacks based on transferability (Szegedy et al., 2013) fall in this category, wherein the adversary selects a procedure train and model architecture H , trains a local model h over D, and computes adversarial examples on its local model h using white-box attack strategies.

Most importantly, a black-box adversary does not learn the randomness r used to train the target, nor the target's parameters h. The black-box adversaries in our paper are actually slightly stronger than the ones defined above, in that they use the same training data X train , Y train as the target model.

We provide A with the target's training procedure train to capture knowledge of defensive strategies applied at training time, e.g., adversarial training (Szegedy et al., 2013; Goodfellow et al., 2014b) or ensemble adversarial training (see Section 4.2). For ensemble adversarial training, A also knows the architectures of all pre-trained models. In this work, we always mount black-box attacks that train a local model with a different architecture than the target model. We actually find that black-box attacks on adversarially trained models are stronger in this case (see Table 1 ).

The main focus of our paper is on non-interactive black-box adversaries as defined above. For completeness, we also formalize a stronger notion of interactive black-box adversaries that additionally issue prediction queries to the target model (Papernot et al., 2017) . We note that in cases where ML models are deployed as part of a larger system (e.g., a self driving car), an adversary may not have direct access to the model's query interface. Definition 4 (Interactive Black-Box Adversary). For a target model h ∈ H, an interactive blackbox adversary only gets access to train (the target model's training procedure) and H (the model architecture). The adversary issues (adaptive) oracle queries to the target model. That is, for arbitrary inputs x ∈ [0, 1] d , the adversary obtains y = arg max h(x) and uses a local algorithm to craft adversarial examples (given knowledge of H, train, and tuples (x, y)). Papernot et al. (2017) show that such attacks are possible even if the adversary only gets access to a small number of samples from D. Note that if the target model's prediction interface additionally returns class scores h(x), interactive black-box adversaries could use queries to the target model to estimate the model's gradient (e.g., using finite differences) (Chen et al., 2017) , and then apply the attacks in Section 3.2. We further discuss interactive black-box attack strategies in Section 5.

B GENERALIZATION BOUND FOR ENSEMBLE ADVERSARIAL TRAINING:

We provide a formal statement of Theorem 1 in Section 3.4, regarding the generalization guarantees of Ensemble Adversarial Training. For simplicity, we assume that the model is trained solely on adversarial examples computed on the pre-trained models (i.e., we ignore the clean training data and the adversarial examples computed on the model being trained). Our results are easily extended to also consider these data points.

Let D be the data distribution and A 1 , . . . , A k , A * be adversarial distributions where a sample (x, y) is obtained by sampling (x, y true ) from D, computing an x adv such that x adv -x ∞ ≤ and returning (x adv , y true ). We assume the model is trained on N data points Z train , where N k data points are sampled from each distribution A i , for

1 ≤ i ≤ k. We denote A train = {A 1 , . . . , A k }. At test time, the model is evaluated on adversarial examples from A * .

For a model h ∈ H we define the empirical risk

EQUATION

and the risk over the target distribution (or future adversary)

EQUATION

We further define the average discrepancy distance (Mansour et al., 2009) between distributions A i and A * with respect to a hypothesis space H as

EQUATION

This quantity characterizes how "different" the future adversary is from the train-time adversaries. Intuitively, the distance disc(A train , A * ) is small if the difference in robustness between two models to the target attack A * is somewhat similar to the difference in robustness between these two models to the attacks used for training (e.g., if the static black-box attacks A i induce much higher error on some model h 1 than on another model h 2 , then the same should hold for the target attack A * ). In other words, the ranking of the robustness of models h ∈ H should be similar for the attacks in A train as for A * .

Finally, let R N (H) be the average Rademacher complexity of the distributions A 1 , . . . , A k (Zhang et al., 2012) . Note that R N (H) → 0 as N → ∞. The following theorem is a corollary of Zhang et al. (2012, Theorem 5 .2): Theorem 5. Assume that H is a function class consisting of bounded functions. Then, with probability at least 1 -,

EQUATION

Compared to the standard generalization bound for supervised learning, the generalization bound for Domain Adaptation incorporates the extra term disc H (A train , A * ) to capture the divergence between the target and source distributions. In our context, this means that the model h * learned by Ensemble Adversarial Training has guaranteed generalization bounds with respect to future adversaries that are not "too different" from the ones used during training. Note that A * need not restrict itself to perturbation with bounded ∞ norm for this result to hold.

C EXPERIMENTS ON MNIST:

We re-iterate our ImageNet experiments on MNIST. For this simpler task, Madry et al. (2017) show that training on iterative attacks conveys robustness to white-box attacks with bounded ∞ norm. Our goal is not to attain similarly strong white-box robustness on MNIST, but to show that our observations on limitations of single-step adversarial training, extend to other datasets than ImageNet. The MNIST dataset is a simple baseline for assessing the potential of a defense, but the obtained results do not always generalize to harder tasks. We suggest that this is because achieving robustness to ∞ perturbations admits a simple "closed-form" solution, given the near-binary nature of the data. Indeed, for an average MNIST image, over 80% of the pixels are in {0, 1} and only 6% are in the range [0.2, 0.8]. Thus, for a perturbation with ≤ 0.3, binarized versions of x and x adv can differ in at most 6% of the input dimensions. By binarizing the inputs of a standard CNN trained without adversarial training, we obtain a model that enjoys robustness similar to the model trained by Madry et al. (2017) . Concretely, for a white-box I-FGSM attack, we get at most 11.4% error.

The existence of such a simple robust representation begs the question of why learning a robust model with adversarial training takes so much effort. Finding techniques to improve the performance of adversarial training, even on simple tasks, could provide useful insights for more complex tasks such as ImageNet, where we do not know of a similarly simple "denoising" procedure.

These positive results on MNIST for the ∞ norm also leave open the question of defining a general norm for adversarial examples. Let us motivate the need for such a definition: we find that if we first rotate an MNIST digit by 20°, and then use the I-FGSM, our rounding model and the model from Madry et al. (2017) achieve only 65% accuracy (on "clean" rotated inputs, the error is < 5%).

If we further randomly "flip" 5 pixels per image, the accuracy of both models drops to under 50%. Thus, we successfully evade the model by slightly extending the threat model (see Figure 3 ).

Of course, we could augment the training set with such perturbations (see Engstrom et al. (2017) ).

An open question is whether we can enumerate all types of "adversarial" perturbations. In this work, we focus on the ∞ norm to illustrate our findings on the limitations of single-step adversarial training on ImageNet and MNIST, and to showcase the benefits of our Ensemble Adversarial Training variant. Our approach can easily be extended to consider multiple perturbation metrics. We leave such an evaluation to future work.

C.2 RESULTS:

We repeat experiments from Section 4 on MNIST. We use the architectures in Table 5 . We train a standard model for 6 epochs, and an adversarial model with the FGSM ( = 0.3) for 12 epochs.

During adversarial training, we avoid the label leaking effect described by Kurakin et al. (2017b) by using the model's predicted class arg max h(x) instead of the true label y true in the FGSM,

We first analyze the "degenerate" minimum of adversarial training, described in Section 3.3. For each trained model, we compute the approximation-ratio of the FGSM for the inner maximization problem in equation ( 1). That is, we compare the loss produced by the FGSM with the loss of a If we omit the input dropout (we call this architecture B * ) the single-step attack degrades significantly. We discuss this effect in more detail below. For the fully connected architecture D, we find that the learned model is very close to linear and thus also less prone to the degenerate solution to the min-max problem, as we postulated in Section 3.3.

Attacks. We evaluate our models on black-box attacks crafted on models A,B,C,D (for a fair comparison, we do not use the same pre-trained models for evaluation, but retrain them with different random seeds). In the majority of cases, we find that using a single pre-trained model produces good results, but that the extra diversity of including three pre-trained models can sometimes increase robustness even further. Our experiments confirm our conjecture that robustness to black-box attacks generalizes across models. Indeed, we find that when training with three external models, we attain very good robustness against attacks initiated from models with the same architecture (as evidenced by the average error on our attack suite), but also increased robustness to attacks initiated from the fourth holdout model D TRANSFERABILITY OF RANDOMIZED SINGLE-STEP PERTURBATIONS.

In Section 4.1, we introduced the R+Step-LL attack, an extension of the Step-LL method that prepends the attack with a small random perturbation. In Table 9 , we evaluate the transferability of R+Step-LL adversarial examples on ImageNet. We find that the randomized variant produces perturbations that transfer at a much lower rate (see Table 1 for the deterministic variant). Tramèr et al. (2017) consider the following task for a given model h: for a (correctly classified) point x, find k orthogonal vectors {r 1 , . . . , r k } such that r i 2 ≤ and all the x + r i are adversarial (i.e., arg max h(x + r i ) = y true ). By linearizing the model's loss function, this reduces to finding k orthogonal vectors r i that are maximally aligned with the model's gradient g = ∇ x L(h(x), y true ). We provide an optimal construction for the ∞ norm, based on Regular Hadamard Matrices (Colbourn, 2010) . Given the ∞ constraint, we find orthogonal vectors r i that are maximally aligned with the signed gradient, sign(g). We first prove an analog of (Tramèr et al., 2017, Lemma 1) .

Lemma 6. Let v ∈ {-1, 1} d and α ∈ (0, 1). Suppose there are k orthogonal vectors r 1 , . . .

r n ∈ {-1, 1} d satisfying v r i ≥ α • d. Then α ≤ k -1 2 .

Proof. Let ri = r i r i 2 = r i √ d . Then, we have

EQUATION

from which we obtain α ≤ k -1 2 .

This result bounds the number of orthogonal perturbations we can expect to find, for a given alignment with the signed gradient. As a warm-up consider the following trivial construction of k orthogonal vectors in {-1, 1} d that are "somewhat" aligned with sign(g). We split sign(g) into k "chunks" of size d k and define r i to be the vector that is equal to sign(g) in the i th chunk and zero otherwise. We obtain sign(g) r i = d k , a factor √ k worse than the the bound in Lemma 6.

We now provide a construction that meets this upper bound. We make use of Regular Hadamard Matrices of order k (Colbourn, 2010). These are square matrices H k such that: (1) all entries of H k are in {-1, 1} k ; (2) the rows of H k are mutually orthogonal; (3) All row sums are equal to √ k.

The order of a Regular Hadamard Matrix is of the form 4u 2 for an integer u. We use known constructions for k ∈ {4, 16, 36, 64, 100}.

Lemma 7. Let g ∈ R d and k be an integer for which a Regular Hadamard Matrix of order k exists.

Then, there is a randomized construction of k orthogonal vectors r 1 , . . . r n ∈ {-1, 1} d , such that sign(g)

r i = d • k -1 /2 . Moreover, E[g r i ] = k -1 /2 • g 1 .

Proof. We construct k orthogonal vectors r 1 , . . . , r k ∈ {-1, 1} d , where r i is obtained by repeating the i th row of H k d /k times (for simplicity, we assume that k divides d. Otherwise we pad r i with zeros). We then multiply each r i component-wise with sign(g). By construction, the k vectors r i ∈ {-1, 1} d are mutually orthogonal, and we have sign(g)

r i = d k • √ k = d • k -1 /2

, which is tight according to Lemma 6.

As the weight of the gradient g may not be uniformly distributed among its d components, we apply our construction to a random permutation of the signed gradient. We then obtain

EQUATION

)

It can be shown that the bound in Lemma 7 can be attained if and only if the r i are constructed from the rows of a Regular Hadamard Matrix (Colbourn, 2010) . For general integers k for which no such matrix exists, other combinatorial designs may be useful for achieving looser bounds.

F ILLUSTRATIONS OF GRADIENT MASKING IN ADVERSARIAL TRAINING:

In Section 3.3, we show that adversarial training introduces spurious curvature artifacts in the model's loss function around data points. As a result, one-shot attack strategies based on first-order approximations of the model loss produce perturbations that are non-adversarial. In Figures 4 and 5 we show further illustrations of this phenomenon for the Inception v3 adv model trained on ImageNet by Kurakin et al. (2017b) as well as for the model A adv we trained on MNIST. 

:

We publicly released our model after the first round, and it could thereafter be targeted using white-box attacks. Nevertheless, a majority of the top submissions in the final round, e.g.(Xie et al.,

2018) built upon our released model.

We thank Arjun Bhagoji, Bo Li and Dawn Song for this observation.

Figures and Tables:

in for small 1 , 2 .

Figure2: The dimensionality of the adversarial cone. For 500 correctly classified points x, and for ∈ {4, 10, 16}, we plot the probability that we find at least k orthogonal vectors r i such that r i ∞ = and x + r i is misclassified. For ≥ 10, model v3 adv shows a bimodal phenomenon: most points x either have 0 adversarial directions or more than 90.

White-box access to the internal model weights corresponds to a very strong adversarial model. We thus also consider the following relaxed and arguably more realistic notion of a black-box adversary. Definition 3 (Non-Interactive Black-Box Adversary). For a target model h ∈ H, a non-interactive black-box adversary only gets access to train (the target model's training procedure) and H (the model architecture). The adversary can sample from the data distribution D, and uses a local algorithm to craft adversarial examples X adv .

Figure 3: Adversarial Examples on MNIST. (top) clean examples. (middle) inputs are rotated by 20°and 5 random pixels are flipped. (bottom) The I-FGSM with = 0.3 is applied.

Tramèr et al. (2017) left a construction for the ∞ norm as an open problem.

in of the loss for small 1 , 2 .

Figure 4: Additional illustrations of the local curvature artifacts introduced by adversarial training on ImageNet. We plot the loss of model v3 adv on samples of the form x* = x + 1 • g + 2 • g ⊥ ,where g is the signed gradient of v3 adv and g ⊥ is an orthogonal adversarial direction, obtained from an Inception v4 model. The right-side plots are zoomed in versions of the left-side plots.

yield the following result. Theorem 1 (informal). Let h * ∈ H be a model learned with Ensemble Adversarial Training and static black-box adversaries A 1 , . . . , A k . Then, if h * is robust against the black-box adversaries A 1 , . . . A k used at training time, then h * has bounded error on attacks from a future black-box adversary A * , if A * is not "much stronger", on average, than the static adversaries A 1 , . . . , A k .

Table content: <table/>

Error rates (in %) of adversarial examples transferred between models. We use Step-LL with = 16 /256 for 10,000 random test inputs. Diagonal elements represent a white-box attack. The best attack for each target appears in bold. Similar results for MNIST models appear in Table7.

Table content: <table><tr><td/><td/><td/><td>Source</td><td/><td/><td/><td/><td>Source</td></tr><tr><td>Target</td><td>v4</td><td colspan="3">v3 v3 adv IRv2 IRv2 adv</td><td>Target</td><td>v4</td><td colspan="2">v3 v3 adv IRv2 IRv2 adv</td></tr><tr><td>v4</td><td colspan="2">60.2 39.2</td><td>31.1 36.6</td><td>30.9</td><td>v4</td><td colspan="2">31.0 14.9</td><td>10.2 13.6</td><td>9.9</td></tr><tr><td>v3</td><td colspan="2">43.8 69.6</td><td>36.4 42.1</td><td>35.1</td><td>v3</td><td colspan="2">18.7 42.7</td><td>13.0 17.8</td><td>12.8</td></tr><tr><td>v3 adv</td><td colspan="3">36.3 35.6 $ $ 26.6 35.2</td><td>35.9</td><td>v3 adv</td><td/><td/></tr><tr><td>IRv2</td><td colspan="2">38.0 38.0</td><td>30.8 50.7</td><td>31.9</td><td/><td/><td/></tr><tr><td colspan="3">IRv2 adv 31.0 30.3</td><td>25.7 30.6</td><td>$ $ 21.4</td><td/><td/><td/></tr><tr><td/><td/><td colspan="2">Top 1</td><td/><td/><td/><td/></tr></table>



Table content: <table/>

Error rates (in %) for Step-LL, R+Step-LL and a two-step Iter-LL on ImageNet. We use = 16 /256, α = /2 on 10,000 random test inputs. R+FGSM results on MNIST are in Table7.

Table content: <table><tr><td/><td>v4</td><td colspan="3">v3 v3 adv IRv2 IRv2 adv</td><td>v4</td><td colspan="2">v3 v3 adv IRv2 IRv2 adv</td></tr><tr><td>Step-LL</td><td colspan="2">60.2 69.6</td><td>26.6 50.7</td><td>21.4</td><td colspan="2">31.0 42.7</td><td>9.0 24.0</td><td>5.8</td></tr><tr><td>R+Step-LL</td><td colspan="2">70.5 80.0</td><td>64.8 56.3</td><td>37.5</td><td colspan="2">42.8 57.1</td><td>37.1 29.3</td><td>15.0</td></tr><tr><td>Iter-LL(2)</td><td colspan="3">78.5 86.3 $ $ 58.3 69.9</td><td>41.6</td><td colspan="3">56.2 70.2 ¨29.6 45.4</td><td>16.5</td></tr><tr><td/><td/><td/><td>Top 1</td><td/><td/><td/><td>Top 5</td></tr></table>

Models used for Ensemble Adversarial Training on ImageNet. The ResNets(He et al., 2016) use either 50 or 101 layers. IncRes stands for Inception ResNet(Szegedy et al., 2016a).

Table content: <table><tr><td>Trained Model</td><td>Pre-trained Models</td><td>Holdout Models</td></tr><tr><td>Inception v3 (v3 adv-ens3 )</td><td>Inception v3, ResNet v2 (50)</td><td>Inception v4</td></tr><tr><td colspan="2">Inception v3 (v3 adv-ens4 ) Inception v3, ResNet v2 (50), IncRes v2</td><td>ResNet v1 (50)</td></tr><tr><td>IncRes v2 (IRv2 adv-ens )</td><td>Inception v3, IncRes v2</td><td>ResNet v2 (101)</td></tr></table>

th batch requires a forward-backward pass to compute adversarial gradients. We use synchronous distributed training on 50 machines, with minibatches of size 16 (we did not pre-compute gradients, and thus lower the batch size to fit all models in memory). Half of the examples in a minibatch are replaced by Step-LL examples. As inKurakin et al. (2017b), we use RMSProp with a learning rate of 0.045, decayed by a factor of 0.94 every two epochs.To evaluate how robustness to black-box attacks generalizes across models, we transfer various attacks crafted on three different holdout models (see Table3), as well as on an ensemble of these models (as inLiu et al. (2017)). We use the Step-LL, R+Step-LL, FGSM, I-FGSM and the PGD attack fromMadry et al. (2017) using the hinge-loss function fromCarlini & Wagner (2017a). Our results are in Table4. For each model, we report the worst-case error rate over all black-box attacks transfered from each of the holdout models (20 attacks in total). Results for MNIST are in Table8.

Table content: <table/>

Error rates (in %) for Ensemble Adversarial Training on ImageNet. Error rates on clean data are computed over the full test set. For 10,000 random test set inputs, and = 16 /256, we report error rates on white-box Step-LL and the worst-case error over a series of black-box attacks (Step-LL, R+Step-LL, FGSM, I-FGSM, PGD) transferred from the holdout models in Table3. For both architectures, we mark methods tied for best in bold (based on 95% confidence). For both architectures, the models trained with Ensemble Adversarial Training are slightly less accurate on clean data, compared to standard adversarial training. Our models are also more vulnerable to white-box single-step attacks, as they were only partially trained on such perturbations. Note that for v3 adv-ens4 , the proportion of white-box Step-LL samples seen during training is 1 /4 (instead of 1 /3 for model v3 adv-ens3 ). The negative impact on the robustness to white-box attacks is large, for only a minor gain in robustness to transferred samples. Thus it appears that while increasing the diversity of adversarial examples seen during training can provide some marginal improvement, the main benefit of Ensemble Adversarial Training is in decoupling the attacks from the model being trained, which was the goal we stated in Section 3.4.

Table content: <table><tr><td/><td/><td>Top 1</td><td/><td/><td>Top 5</td><td/></tr><tr><td>Model</td><td colspan="6">Clean Step-LL Max. Black-Box Clean Step-LL Max. Black-Box</td></tr><tr><td>v3</td><td>22.0</td><td>69.6</td><td>51.2</td><td>6.1</td><td>42.7</td><td>24.5</td></tr><tr><td>v3 adv</td><td>22.0</td><td>26.6</td><td>40.8</td><td>6.1</td><td>9.0</td><td>17.4</td></tr><tr><td>v3 adv-ens3</td><td>23.6</td><td>30.0</td><td>34.0</td><td>7.6</td><td>10.1</td><td>11.2</td></tr><tr><td>v3 adv-ens4</td><td>24.2</td><td>43.3</td><td>33.4</td><td>7.8</td><td>19.4</td><td>10.7</td></tr><tr><td>IRv2</td><td>19.6</td><td>50.7</td><td>44.4</td><td>4.8</td><td>24.0</td><td>17.8</td></tr><tr><td>IRv2 adv</td><td>19.8</td><td>21.4</td><td>34.5</td><td>4.9</td><td>5.8</td><td>11.7</td></tr><tr><td>IRv2 adv-ens</td><td>20.2</td><td>26.0</td><td>27.0</td><td>5.1</td><td>7.6</td><td>7.9</td></tr><tr><td colspan="2">White-box attacks.</td><td/><td/><td/><td/><td/></tr></table>

Neural network architectures used in this work for the MNIST dataset.

Table content: <table><tr><td>Conv: convo-</td></tr></table>

Approximation ratio between optimal loss and loss induced by single-step attack on MNIST. Architecture B' is the same as B without the input dropout layer. The results appear in Table6. As we can see, for all model architectures, adversarial training degraded the quality of a linear approximation to the model's loss.We find that input dropout(Srivastava et al., 2014) (i.e., randomly dropping a fraction of input features during training) as used in architecture B limits this unwarranted effect of adversarial training. 2

Table content: <table><tr><td>A</td><td>A adv</td><td>B</td><td>B adv</td><td>B  *</td><td>B  *  adv</td><td>C</td><td>C adv</td><td>D</td><td>D adv</td></tr><tr><td colspan="2">17% 0%</td><td colspan="2">25% 8%</td><td colspan="2">23% 1%</td><td colspan="2">25% 0%</td><td colspan="2">49% 16%</td></tr><tr><td colspan="2">strong iterative attack.</td><td/><td/><td/><td/><td/><td/><td/><td/></tr></table>

Table 7 compares error rates of undefended and adversarially trained models on whitebox and black-box attacks, as in Section 4.1. Again, model B presents an anomaly. For all other models, we corroborate our findings on ImageNet for adversarial training: (1) black-box attacks trump white-box single-step attacks; (2) white-box single-step attacks are significantly stronger if prepended by a random step. For model B adv , the opposite holds true. We believe this is because input dropout increases diversity of attack samples similarly to Ensemble Adversarial Training. White-box and black-box attacks against standard and adversarially trained models. For each model, the strongest single-step white-box and black box attacks are marked in bold.While training with input dropout helps avoid the degradation of the single-step attack, it also significantly delays convergence of the model. Indeed, model B adv retains relatively high error on white-box FGSM examples. Adversarial training with input dropout can be seen as comparable to training with a randomized single-step attack, as discussed in Section 4.1.The positive effect of input dropout is architecture and dataset specific: Adding an input dropout layer to models A, C and D confers only marginal benefit, and is outperformed by Ensemble Adversarial Training, discussed below. Moreover,Mishkin et al. (2017) find that input dropout significantly degrades accuracy on ImageNet. We thus did not incorporate it into our models on ImageNet.

Table content: <table><tr><td/><td colspan="2">white-box</td><td/><td/><td>black-box</td><td/><td/></tr><tr><td/><td colspan="7">FGSM R+FGSM FGSM A FGSM B FGSM B* FGSM C FGSM D</td></tr><tr><td>A</td><td>64.7</td><td>69.7</td><td>-</td><td>61.5</td><td>53.2</td><td>46.8</td><td>41.5</td></tr><tr><td>A adv</td><td>2.2</td><td>14.8</td><td>6.6</td><td>10.7</td><td>8.8</td><td>6.5</td><td>8.3</td></tr><tr><td>B</td><td>85.0</td><td>86.0</td><td>45.7</td><td>-</td><td>69.9</td><td>59.9</td><td>85.9</td></tr><tr><td>B adv</td><td>11.6</td><td>11.1</td><td>6.4</td><td>8.9</td><td>8.5</td><td>4.9</td><td>6.1</td></tr><tr><td>B  *  B  *  adv</td><td>75.7 4.3</td><td>74.1 40.6</td><td>44.3 16.1</td><td>72.8 14.7</td><td>-15.0</td><td>46.0 17.9</td><td>62.6 9.1</td></tr><tr><td>C</td><td>81.8</td><td>81.8</td><td>40.2</td><td>55.8</td><td>49.5</td><td>-</td><td>59.4</td></tr><tr><td>C adv</td><td>3.7</td><td>17.1</td><td>9.8</td><td>29.3</td><td>21.5</td><td>11.9</td><td>21.9</td></tr><tr><td>D</td><td>92.4</td><td>95.4</td><td>61.3</td><td>74.1</td><td>68.9</td><td>65.1</td><td>-</td></tr><tr><td>D adv</td><td>25.5</td><td>47.5</td><td>32.1</td><td>30.5</td><td>29.3</td><td>28.2</td><td>21.8</td></tr><tr><td colspan="8">Ensemble Adversarial Training. To evaluate Ensemble Adversarial Training 3.4, we train two</td></tr><tr><td colspan="8">models per architecture. The first, denoted [A-D] adv-ens , uses a single pre-trained model of the same</td></tr><tr><td>type (i.</td><td/><td/><td/><td/><td/><td/><td/></tr></table>

Ensemble Adversarial Training on MNIST. For black-box robustness, we report the maximum and average error rate over a suite of 12 attacks, comprised of the FGSM, I-FGSM and PGD(Madry et al., 2017) attacks applied to models A,B,C and D. We use = 16 in all cases. For each model architecture, we mark the models tied for best (at a 95% confidence level) in bold.The attacks we consider are the FGSM, I-FGSM and the PGD attack fromMadry et al. (2017) with the loss function fromCarlini & Wagner (2017a)), all with = 0.3. The results appear in Table8. For each model, we report the worst-case and average-case error rate over all black-box attacks.Ensemble Adversarial Training significantly increases robustness to black-box attacks, except for architecture B, which we previously found to not suffer from the same overfitting phenomenon that affects the other adversarially trained networks. Nevertheless, model B adv-ens achieves slightly better robustness to white-box and black-box attacks than B adv .

Table content: <table><tr><td/><td colspan="4">Clean FGSM Max. Black Box Avg. Black Box</td></tr><tr><td>A adv</td><td>0.8</td><td>2.2</td><td>10.8</td><td>7.7</td></tr><tr><td>A adv-ens</td><td>0.8</td><td>7.0</td><td>6.6</td><td>5.2</td></tr><tr><td>A adv-ens3</td><td>0.7</td><td>5.4</td><td>6.5</td><td>4.3</td></tr><tr><td>B adv</td><td>0.8</td><td>11.6</td><td>8.9</td><td>5.5</td></tr><tr><td>B adv-ens</td><td>0.7</td><td>10.5</td><td>6.8</td><td>5.3</td></tr><tr><td>B adv-ens3</td><td>0.8</td><td>14.0</td><td>8.8</td><td>5.1</td></tr><tr><td>C adv</td><td>1.0</td><td>3.7</td><td>29.3</td><td>18.7</td></tr><tr><td>C adv-ens</td><td>1.3</td><td>1.9</td><td>17.2</td><td>10.7</td></tr><tr><td>C adv-ens3</td><td>1.4</td><td>3.6</td><td>14.5</td><td>8.4</td></tr><tr><td>D adv</td><td>2.6</td><td>25.5</td><td>32.5</td><td>23.5</td></tr><tr><td>D adv-ens</td><td>2.6</td><td>21.5</td><td>38.6</td><td>28.0</td></tr><tr><td>D adv-ens3</td><td>2.6</td><td>29.4</td><td>29.8</td><td>15.6</td></tr></table>

Error rates (in %) of randomized single-step attacks transferred between models on ImageNet. We use R+Step-LL with = 16/256, α = /2 for 10,000 random test set samples. The white-box attack always outperforms black-box attacks.E GRADIENT ALIGNED ADVERSARIAL SUBSPACES FOR THE ∞ NORM

Table content: <table><tr><td/><td/><td/><td>Source</td><td/><td/><td/><td/><td>Source</td></tr><tr><td>Target</td><td>v4</td><td colspan="3">v3 v3 adv IRv2 IRv2 adv</td><td>Target</td><td>v4</td><td colspan="3">v3 v3 adv IRv2 IRv2 adv</td></tr><tr><td>v4</td><td colspan="2">70.5 37.2</td><td>23.2 34.0</td><td>24.6</td><td>v4</td><td colspan="2">42.8 14.3</td><td colspan="2">6.3 11.9</td><td>6.9</td></tr><tr><td>v3</td><td colspan="2">42.6 80.0</td><td>26.7 38.5</td><td>27.6</td><td>v3</td><td colspan="2">18.0 57.1</td><td colspan="2">8.0 15.6</td><td>8.6</td></tr><tr><td>v3 adv</td><td colspan="2">31.4 30.7</td><td>64.8 30.4</td><td>34.0</td><td>v3 adv</td><td colspan="2">10.7 10.4</td><td colspan="2">37.1 10.1</td><td>12.9</td></tr><tr><td>IRv2</td><td colspan="2">36.2 35.7</td><td>23.0 56.3</td><td>24.6</td><td>IRv2</td><td colspan="2">12.8 13.6</td><td colspan="2">6.1 29.3</td><td>7.0</td></tr><tr><td colspan="3">IRv2 adv 26.8 26.3</td><td>25.2 26.9</td><td>37.5</td><td>IRv2 adv</td><td>8.0</td><td>8.0</td><td>7.7</td><td>8.3</td><td>15.0</td></tr><tr><td/><td/><td colspan="2">Top 1</td><td/><td/><td/><td colspan="2">Top 5</td></tr></table>

Peer review (iclr2018):
 The paper proposes a modification to adversarial training. Instead of alternating between clean and examples generated on-the-fly by the fast gradient sign during training, the model training is performed by alternating clean examples and adversarial examples generated from pre-trained models. The motivation behind this change is that one-step method to generate adversarial examples fail at generating good adversarial examples when applied to models trained in the adversarial setting. In contrast, one-step methods applied to models trained only on natural data generate adversarial examples that transfer reasonably well, even on models trained with usual adversarial training. The authors also propose a slight modification to the fast gradient sign method, in which an adversarial example is created using a random perturbation and the current model*s gradient, which seems to work better than the fast gradient sign method. Experiments with inception models on ImageNet show increased robustness both against "black-box" attacks using held-out models not used in ensemble adversarial training. One advantage of the method is that it is extremely simple. It uses pre-trained models that are readily available, and gains robustness against several well-known adversaries widely considered in the state of the art. The experiments are carried out on ImageNet and are seriously conducted. On the negative side, there is a significant loss in accuracy, and the models are more vulnerable to white-box attacks than using standard adversarial training. As the authors discuss in the conclusion, this leaves open the question as to whether the models are indeed more robust, or whether it is an artifact of the static black-box attack schemes that are considered in the paper, which measures how much a single model is robust to adversarial examples for other models that were trained independently. For instance, there are no experiments against what is called adaptive black-box adversaries; one could also imagine finding adversarial examples that are trained to fool all models in a predefined collection of models. In the end, while the work presented in the paper found its use in the recent NIPS competition on defending against adversarial examples, it is still unclear whether this kind of defence would make a difference in critical applications.