Perceptual Adversarial Robustness: Defense Against Unseen Threat Models

Introduction

Many modern machine learning algorithms are susceptible to adversarial examples: carefully crafted inputs designed to fool models into giving incorrect outputs (Biggio et al., 2013; Szegedy et al., 2014; Kurakin et al., 2016a; Xie et al., 2017). Much research has focused on increasing classifiers’ robustness against adversarial attacks (Goodfellow et al., 2015; Madry et al., 2018; Zhang et al., 2019a). However, existing adversarial defenses for image classifiers generally consider simple threat models. An adversarial threat model defines a set of perturbations that may be made to an image in order to produce an adversarial example. Common threat models include $L_{2}$ and $L_{\infty}$ threat models, which constrain adversarial examples to be close to the original image in $L_{2}$ or $L_{\infty}$ distances. Some work has proposed additional threat models which allow spatial perturbations (Engstrom et al., 2017; Wong et al., 2019; Xiao et al., 2018), recoloring (Hosseini and Poovendran, 2018; Laidlaw and Feizi, 2019; Bhattad et al., 2019), and other modifications (Song et al., 2018; Zeng et al., 2019) of an image.

There are multiple issues with these unrealistically constrained adversarial threat models. First, hardening against one threat model assumes that an adversary will only attempt attacks within that threat model. Although a classifier may be trained to be robust against $L_{\infty}$ attacks, for instance, an attacker could easily generate a spatial attack to fool the classifier. One possible solution is to train against multiple threat models simultaneously (Jordan et al., 2019; Laidlaw and Feizi, 2019; Maini et al., 2019; Tramer and Boneh, 2019). However, this generally results in a lower robustness against any one of the threat models when compared to hardening against that threat model alone. Furthermore, not all possible threat models may be known at training time, and adversarial defenses do not usually generalize well to unforeseen threat models (Kang et al., 2019).

The ideal solution to these drawbacks would be a defense that is robust against a wide, unconstrained threat model. We differentiate between two such threat models. The unrestricted adversarial threat model (Brown et al., 2018) encompasses any adversarial example that is labeled as one class by a classifier but a different class by humans. On the other hand, we define the perceptual adversarial threat model as including all perturbations of natural images that are imperceptible to a human. Most existing narrow threat models such as $L_{2}$, $L_{\infty}$, etc. are near subsets of the perceptual threat model (Figure 2). Some other threat models, such as adversarial patch attacks (Brown et al., 2018), may perceptibly alter an image without changing its true class and as such are contained in the unrestricted adversarial threat model. In this work, we focus on the perceptual threat model.

The perceptual threat model can be formalized given the true perceptual distance $d^{*}(\mathbf{x}_{1},\mathbf{x}_{2})$ between images $\mathbf{x}_{1}$ and $\mathbf{x}_{2}$, defined as how different two images appear to humans. For some threshold $\epsilon^{*}$, which we call the perceptibility threshold, images $\mathbf{x}$ and $\mathbf{x}^{\prime}$ are indistinguishable from one another as long as $d^{*}(\mathbf{x},\mathbf{x}^{\prime})\leq\epsilon^{*}$. Note that in general $\epsilon^{*}$ may depend on the specific input. Then, the perceptual threat model for a natural input $\mathbf{x}$ includes all adversarial examples $\widetilde{\mathbf{x}}$ which cause misclassification but are imperceptibly different from $\mathbf{x}$, i.e. $d^{*}(\mathbf{x},\widetilde{\mathbf{x}})\leq\epsilon^{*}$.

The true perceptual distance $d^{*}(\cdot,\cdot)$, however, cannot be easily computed or optimized against. To solve this issue, we propose to use a neural perceptual distance, an approximation of the true perceptual distance between images using neural networks. Fortunately, there have been many surrogate perceptual distances proposed in the computer vision literature such as SSIM (Wang et al., 2004). Recently, Zhang et al. (2018) discovered that comparing the internal activations of a convolutional neural network when two different images are passed through provides a measure, Learned Perceptual Image Patch Similarity (LPIPS), that correlates well with human perception. We propose to use the LPIPS distance $d(\cdot,\cdot)$ in place of the true perceptual distance $d^{*}(\cdot,\cdot)$ to formalize the neural perceptual threat model (NPTM).

We present adversarial attacks and defenses for the proposed NPTM. Generating adversarial examples bounded by the neural perceptual distance is difficult compared to generating $L_{p}$ adversarial examples because of the complexity and non-convexness of the constraint. However, we develop two attacks for the NPTM, Perceptual Projected Gradient Descent (PPGD) and Lagrangian Perceptual Attack (LPA) (see Section 4 for details). We find that LPA is by far the strongest adversarial attack at a given level of perceptibility (see Figure 4), reducing the most robust classifier studied to only 2.4% accuracy on ImageNet-100 (a subset of ImageNet) while remaining imperceptible. LPA also finds adversarial examples outside of any of the other threat models studied (see Figure 2). Thus, even if a model is robust to many narrow threat models ($L_{p}$, spatial, etc.), LPA can still cause serious errors.

In addition to these attacks, which are suitable for evaluation of a classifier against the NPTM, we also develop Fast-LPA, a more efficient version of LPA that we use in Perceptual Adversarial Training (PAT). Remarkably, using PAT to train a neural network classifier produces a single model with high robustness against a variety of imperceptible perturbations, including $L_{\infty}$, $L_{2}$, spatial, recoloring, and JPEG attacks, on CIFAR-10 and ImageNet-100 (Tables 2 and 3). For example, PAT on ImageNet-100 gives 32.5% accuracy against the union of these five attacks, whereas $L_{\infty}$ and $L_{2}$ adversarial training give 0.5% and 12.3% accuracy, respectively (Table 1). PAT achieves more than double the accuracy against this union of five threat models despite not explicitly training against any of them. Thus, it generalizes well to unseen threat models.

Does the LPIPS distance accurately reflect human perception when it is used to evaluate adversarial examples? We performed a study on Amazon Mechanical Turk (AMT) to determine how perceptible 7 different types of adversarial perturbations such as $L_{\infty}$, $L_{2}$, spatial, and recoloring attacks are at multiple threat-specific bounds. We find that LPIPS correlates well with human judgements across all the different adversarial perturbation types we examine. This indicates that the NPTM closely matches the true perceptual threat model and reinforces the utility of our perceptual attacks to measure adversarial robustness against an expansive threat model. Furthermore, this study allows calibration of a variety of attack bounds to a single perceptibility metric. We have released our dataset of adversarial examples along with the annotations made by participants for further studyCode and data can be downloaded at https://github.com/cassidylaidlaw/perceptual-advex..

Related Work

Adversarial robustness Adversarial robustness has been studied extensively for $L_{2}$ or $L_{\infty}$ threat models (Goodfellow et al., 2015; Carlini and Wagner, 2017; Madry et al., 2018) and non-$L_{p}$ threat models such as spatial perturbations (Engstrom et al., 2017; Xiao et al., 2018; Wong et al., 2019), recoloring of an image (Hosseini and Poovendran, 2018; Laidlaw and Feizi, 2019; Bhattad et al., 2019), and perturbations in the frequency domain (Kang et al., 2019). The most popular known adversarial defense for these threat models is adversarial training Kurakin et al. (2016b); Madry et al. (2018); Zhang et al. (2019a) where a neural network is trained to minimize the worst-case loss in a region around the input. Recent evaluation methodologies such as Unforeseen Attack Robustness (UAR) (Kang et al., 2019) and the Unrestricted Adversarial Examples challenge (Brown et al., 2018) have raised the problem of finding an adversarial defense which gives good robustness under more general threat models. Sharif et al. (2018) conduct a perceptual study showing that $L_{p}$ threat models are a poor approximation of the perceptual threat model. Dunn et al. (2020) and Xu et al. (2020) have developed adversarial attacks that manipulate higher-level, semantic features. Jin and Rinard (2020) train with a manifold regularization term, which gives some robustness to unseen perturbation types. Stutz et al. (2020) also propose a method which gives robustness against unseen perturbation types, but requires rejecting (abstaining on) some inputs.

Perceptual similarity Two basic similarity measures for images are the $L_{2}$ distance and the Peak Signal-to-Noise Ratio (PSNR). However, these similarity measures disagree with human vision on perturbations such as blurring and spatial transformations, which has motivated others including SSIM (Wang et al., 2004), MS-SSIM (Wang et al., 2003), CW-SSIM (Sampat et al., 2009), HDR-VDP-2 (Mantiuk et al., 2011) and LPIPS (Zhang et al., 2018). MAD competition (Wang and Simoncelli, 2008) uses a constrained optimization technique related to our attacks to evaluate perceptual measures.

Perceptual adversarial robustness Although LPIPS was previously proposed, it has mostly been used for development and evaluation of generative models (Huang et al., 2018; Karras et al., 2019). Jordan et al. (2019) first explored quantifying adversarial distortions with LPIPS distance. However, to the best of our knowledge, we are the first to apply a more accurate perceptual distance to the problem of improving adversarial robustness. As we show, adversarial defenses based on $L_{2}$ or $L_{\infty}$ attacks are unable to generalize to a more diverse threat model. Our method, PAT, is the first adversarial training method we know of that can generalize to unforeseen threat models without rejecting inputs.

Neural Perceptual Threat Model (NPTM)

Since the true perceptual distance between images cannot be efficiently computed, we use approximations of it based on neural networks, i.e. neural perceptual distances. In this paper, we focus on the LPIPS distance (Zhang et al., 2018) while we note that other neural perceptual distances can also be used in our attacks and defenses.

In the original LPIPS implementation, Zhang et al. (2018) learn weights to apply to the normalized activations based on a dataset of human perceptual judgements. However, they find that LPIPS is a good surrogate for human vision even without the additional learned weights; this is the version we use since it avoids the need to collect such a dataset.

Now let $f:\mathcal{X}\rightarrow\mathcal{Y}$ be a classifier which maps inputs $\mathbf{x}\in\mathcal{X}$ to labels $f(\mathbf{x})\in\mathcal{Y}$. $f(\cdot)$ could be the same as $g(\cdot)$, or it could be a different network; we experiment with both. For a given natural input $\mathbf{x}$ with the true label $y$, a neural perceptual adversarial example with a perceptibility bound $\epsilon$ is an input $\widetilde{\mathbf{x}}\in\mathcal{X}$ such that $\widetilde{\mathbf{x}}$ must be perceptually similar to $\mathbf{x}$ but cause $f$ to misclassify:

Perceptual Adversarial Attacks

We propose attack methods which attempt to find an adversarial example with small perceptual distortion. Developing adversarial attacks that utilize the proposed neural perceptual threat model is more difficult than that of standard $L_{p}$ threat models, because the LPIPS distance constraint is more complex than $L_{p}$ constraints. In general, we find an adversarial example that satisfies (2) by maximizing a loss function $\mathcal{L}$ within the LPIPS bound. The loss function we use is similar to the margin loss from Carlini and Wagner (2017), defined as

where $z_{i}(\mathbf{x})$ is the $i$-th logit output of the classifier $f(\cdot)$. This gives the constrained optimization

Note that in this attack problem, the classifier network $f(\cdot)$ and the LPIPS network $g(\cdot)$ are fixed. These two networks could be identical, in which case the same network that is being attacked is used to calculate the LPIPS distance that bounds the attack; we call this a self-bounded attack. If a different network is used to calculate the LPIPS bound, we call it an externally-bounded attack.

Based on this formulation, we propose two perceptual attack methods, Perceptual Projected Gradient Descent (PPGD) and Lagrangian Perceptual Attack (LPA). See Figures 3 and 7 for sample results.

Perceptual Projected Gradient Descent (PPGD) The first of our two attacks is analogous to the PGD (Madry et al., 2018) attacks used for $L_{p}$ threat models. In general, these attacks consist of iteratively performing two steps on the current adversarial example candidate: (a) taking a step of a certain size under the given distance that maximizes a first-order approximation of the misclassification loss, and (b) projecting back onto the feasible set of the threat model.

Identifying the ideal first-order step is easy in $L_{2}$ and $L_{\infty}$ threat models; it is the gradient of the loss function and the sign of the gradient, respectively. However, computing this step is not straightforward with the LPIPS distance, because the distance metric itself is defined by a neural network. Following (3), we desire to find a step $\delta$ to maximize $\mathcal{L}(f(\mathbf{x}+\delta),y)$ such that $d(\mathbf{x}+\delta,\mathbf{x})=\|\phi(\mathbf{x}+\delta)-\phi(\mathbf{x})\|_{2}\leq\eta$, where $\eta$ is the step size. Let $\hat{f}(\mathbf{x}):=\mathcal{L}(f(\mathbf{x}),y)$ for an input $\mathbf{x}\in\mathcal{X}$. Let $J$ be the Jacobian of $\phi(\cdot)$ at $\mathbf{x}$ and $\nabla\hat{f}$ be the gradient of $\hat{f}(\cdot)$ at $\mathbf{x}$. Then, we can approximate (3) using a first-order Taylor’s approximation of $\phi$ and $\hat{f}$ as follows:

We show that this constrained optimization can be solved in a closed form:

Let $J^{+}$ denote the pseudoinverse of $J$. Then the solution to (4) is given by

See Appendix A.1 for the proof. This solution is still difficult to efficiently compute, since calculating $J^{+}$ and inverting $J^{\top}J$ are computationally expensive. Thus, we approximately solve for $\delta^{*}$ using the conjugate gradient method; see Appendix A.1 for details.

Perceptual PGD consists of repeatedly finding first-order optimal $\delta^{*}$ to add to the current adversarial example $\widetilde{\mathbf{x}}$ for a number of steps. Following each step, if the current adversarial example $\widetilde{\mathbf{x}}$ is outside the LPIPS bound, we project $\widetilde{\mathbf{x}}$ back onto the threat model such that $d(\widetilde{\mathbf{x}},\mathbf{x})\leq\epsilon$. The exact projection is again difficult due to the non-convexity of the feasible set. Thus, we solve it approximately with a technique based on Newton’s method; see Algorithm 4 in the appendix.

Lagrangian Perceptual Attack (LPA) The second of our two attacks uses a Lagrangian relaxation of the attack problem (3) similar to that used by Carlini and Wagner (2017) for constructing $L_{2}$ and $L_{\infty}$ adversarial examples. We call this attack the Lagrangian Perceptual Attack (LPA). To derive the attack, we use the following Lagrangian relaxation of (3):

The perceptual constraint cost, multiplied by $\lambda$ in (5), is designed to be as long as the adversarial example is within the allowed perceptual distance; i.e. $d(\widetilde{\mathbf{x}},\mathbf{x})\leq\epsilon$; once $d(\widetilde{\mathbf{x}},\mathbf{x})>\epsilon$, however, it increases linearly by the LPIPS distance from the original input $\mathbf{x}$. Similar to $L_{p}$ attacks of Carlini and Wagner (2017), we adaptively change $\lambda$ to find an adversarial example within the allowed perceptual distance; see Appendix A.2 for details.

Perceptual Adversarial Training (PAT)

The developed perceptual attacks can be used to harden a classifier against a variety of adversarial attacks. The intuition, which we verify in Section 7, is that if a model is robust against neural perceptual attacks, it can demonstrate an enhanced robustness against other types of unforeseen adversarial attacks. Inspired by adversarial training used to robustify models against $L_{p}$ attacks, we propose a method called Perceptual Adversarial Training (PAT).

Suppose we wish to train a classifier $f(\cdot)$ over a distribution of inputs and labels $(\mathbf{x},y)\sim\mathcal{D}$ such that it is robust to the perceptual threat model with bound $\epsilon$. Let $\mathcal{L}_{\text{ce}}$ denote the cross entropy (negative log likelihood) loss and suppose the classifier $f(\cdot)$ is parameterized by $\theta_{f}$. Then, PAT consists of optimizing $f(\cdot)$ in a manner analogous to $L_{p}$ adversarial training (Madry et al., 2018):

The training formulation attempts to minimize the worst-case loss within a neighborhood of each training point $\mathbf{x}$. In PAT, the neighborhood is bounded by the LPIPS distance. Recall that the LPIPS distance is itself defined based on a particular neural network classifier. We refer to the normalized, flattened activations of the network used to define LPIPS as $\phi(\cdot)$ and $\theta_{\phi}$ to refer to its parameters. We explore two variants of PAT differentiated by the choice of the network used to define $\phi(\cdot)$. In externally-bounded PAT, a separate, pretrained network is used to calculate $\phi(\cdot)$, the LPIPS distance $d(\cdot,\cdot)$. In self-bounded PAT, the same network which is being trained for classification is used to calculate the LPIPS distance, i.e. $\theta_{\phi}\subseteq\theta_{f}$. Note that in self-bounded PAT the definition of the LPIPS distance changes during the training as the classifier is optimized.

The inner maximization in (6) is intractable to compute exactly. However, we can use the perceptual attacks developed in Section 4 to approximately solve it. Since the inner maximization must be solved repeatedly during the training process, we use an inexpensive variant of the LPA attack called Fast-LPA. In contrast to LPA, Fast-LPA does not search over values of $\lambda$. It also does not include a projection step at the end of the attack, which means it may sometimes produce adversarial examples outside the training bound. While this makes it unusable for evaluation, it is fine for training. Using Fast-LPA, PAT is nearly as fast as adversarial training; see Appendix A.3 and Algorithm 3 for details.

Perceptual Evaluation

We conduct a thorough perceptual evaluation of our NPTM and attacks to ensure that the resulting adversarial examples are imperceptible. We also compare the perceptibility of perceptual adversarial attacks to five narrow threat models: $L_{\infty}$ and $L_{2}$ attacks, JPEG attacks (Kang et al., 2019), spatially transformed adversarial examples (StAdv) (Xiao et al., 2018), and functional adversarial attacks (ReColorAdv) (Laidlaw and Feizi, 2019). The comparison allows us to determine if the LPIPS distance is a good surrogate for human comparisons of similarity. It also allows us to set bounds across threat models with approximately the same level of perceptibility.

To determine how perceptible a particular threat model is at a particular bound (e.g. $L_{\infty}$ attacks at $\epsilon=8/255$), we perform an experiment based on just noticeable differences (JND). We show pairs of images to participants on Amazon Mechanical Turk (AMT), an online crowdsourcing platform. In each pair, one image is a natural image from ImageNet-100 and one image is an adversarial perturbation of the natural image, generated using the particular attack against a classifier hardened to that attack. One of the images, chosen randomly, is shown for one second, followed by a blank screen for 250ms, followed by the second image for one second. Then, participants must choose whether they believe the images are the same or different. This procedure is identical to that used by Zhang et al. (2018) to originally validate the LPIPS distance. We report the proportion of pairs for which participants report the images are “different” as the perceptibility of the attack. In addition to adversarial example pairs, we also include sentinel image pairs which are exactly the same; only 4.1% of these were annotated as “different.”

We collect about 1,000 annotations of image pairs for each of 3 bounds for all five threat models, plus our PPGD and LPA attacks (14k annotations total for 2.8k image pairs). The three bounds for each attack are labeled as small, medium, and large; bounds with the same label have similar perceptibility across threat models (see Appendix D Table 4). The dataset of image pairs and associated annotations is available for use by the community.

To determine if the LPIPS threat model is a good surrogate for the perceptual threat model, we use various classifiers to calculate the LPIPS distance $d(\cdot,\cdot)$ between the pairs of images used in the perceptual study. For each classifier, we determine the correlation between the mean LPIPS distance it assigns to image pairs from each attack and the perceptibility of that attack (Figure 4c). We find that AlexNet (Krizhevsky et al., 2012), trained normally on ImageNet (Russakovsky et al., 2015), correlates best with human perception of these adversarial examples ($r$ = 0.94); this agrees with Zhang et al. (2018) who also find that AlexNet-based LPIPS correlates best with human perception (Figure 4). A normally trained ResNet-50 correlates similarly, but not quite as well. Because AlexNet is the best proxy for human judgements of perceptual distance, we use it for all externally-bounded evaluation attacks. Note that even with an untrained network at initialization, the LPIPS distance correlates with human perception better than the $L_{2}$ distance. This means that even during the first few epochs of self-bounded PAT, the training adversarial examples are perceptually-aligned.

We use the results of the perceptual study to investigate which attacks are strongest at a particular level of perceptibility. We evaluate each attack on a classifier hardened against that attack via adversarial training, and plot the resulting success rate against the proportion of correct annotations from the perceptual study. Out of the narrow threat models, we find that $L_{2}$ attacks are the strongest for their perceptibility. However, our proposed PPGD and LPA attacks reduce a PAT-trained classifier to even lower accuracies (8.2% for PPGD and 0% for LPA), making it the strongest attack studied.

Experiments

We compare Perceptual Adversarial Training (PAT) to adversarial training against narrow threat models ($L_{p}$, spatial, etc.) on CIFAR-10 (Krizhevsky and Hinton, 2009) and ImageNet-100 (the subset of ImageNet (Russakovsky et al., 2015) containing every tenth class by WordNet ID order). We find that PAT results in classifiers with robustness against a broad range of narrow threat models. We also show that our perceptual attacks, PPGD and LPA, are strong against adversarial training with narrow threat models. We evaluate with externally-bounded PPGD and LPA (Section 4), using AlexNet to determine the LPIPS bound because it correlates best with human judgements (Figure 4c). For $L_{2}$ and $L_{\infty}$ robustness evaluation we use AutoAttack (Croce and Hein, 2020), which combines four strong attacks, including two PGD variants and a black box attack, to give reliable evaluation.

Evaluation metrics For both datasets, we evaluate classifiers’ robustness to a range of threat models using two summary metrics. First, we compute the union accuracy against all narrow threat models ($L_{\infty}$, $L_{2}$, StAdv, ReColorAdv, and JPEG for ImageNet-100); this is the proportion of inputs for which a classifier is robust against all these attacks. Second, we compute the unseen mean accuracy, which is the mean of the accuracies against all the threat models not trained against; this measures how well robustness generalizes to other threat models.

CIFAR-10 We test ResNet-50s trained on the CIFAR-10 dataset with PAT and adversarial training (AT) against six attacks (see Table 2): $L_{\infty}$ and $L_{2}$ AutoAttack, StAdv (Xiao et al., 2018), ReColorAdv (Laidlaw and Feizi, 2019), and PPGD and LPA. This allows us to determine if PAT gives robustness against a range of adversarial attacks. We experiment with using various models to calculate the LPIPS distance during PAT. We try using the same model both for classification and to calculate the LPIPS distance (self-bounded PAT). We also use AlexNet trained on CIFAR-10 prior to PAT (externally-bounded PAT). We find that PAT outperforms $L_{p}$ adversarial training and TRADES (Zhang et al., 2019a), improving the union accuracy from <5% to >20%, and nearly doubling mean accuracy against unseen threat models from 26% to 49%. Surprisingly, we find that PAT even outperforms threat-specific AT against StAdv and ReColorAdv; see Appendix F.5 for more details. Ablation studies of PAT are presented in Appendix F.1.

ImageNet-100 We compare ResNet-50s trained on the ImageNet-100 dataset with PAT and adversarial training (Table 3). Classifiers are tested against seven attacks at the medium bound from the perceptual study (see Section 6 and Appendix Table 4). Self- and externally-bounded PAT give similar results. Both produce more than double the next highest union accuracy and also significantly increase the mean robustness against unseen threat models by around 15%.

Perceptual attacks On both CIFAR-10 and ImageNet-100, we find that Perceptual PGD (PPGD) and Lagrangian Perceptual Attack (LPA) are the strongest attacks studied. LPA is the strongest, reducing the most robust classifier to 9.8% accuracy on CIFAR-10 and 2.4% accuracy on ImageNet-100. Also, models most robust to LPA in both cases are those that have the best union and unseen mean accuracies. This demonstrates the utility of evaluating against LPA as a proxy for adversarial robustness against a range of threat models. See Appendix E for further attack experiments.

Comparison to other defenses against multiple attacks Besides the baseline of adversarially training against a single attack, we also compare PAT to adversarially training against multiple attacks (Tramer and Boneh, 2019; Maini et al., 2019). We compare three methods for multiple-attack training: choosing a random attack at each training iteration, optimizing the average loss across all attacks, and optimizing the maximum loss across all attacks. The latter two methods are very expensive, increasing training time by a factor equal to the number of attacks trained against, so we only evaluate these methods on CIFAR-10. As in Tramer and Boneh (2019), we find that the maximum loss strategy leads to the greatest union accuracy among the multiple-attack training methods. However, PAT performs even better on CIFAR-10, despite training against none of the attacks and taking one fourth of the time to train. The random strategy, which is the only feasible one on ImageNet-100, performs much worse than PAT. Even the best multiple-attack training strategies still fail to generalize to the unseen neural perceptual attacks, PPGD and LPA, achieving much lower accuracy than PAT.

On CIFAR-10, we also compare PAT to manifold regularization (MR) (Jin and Rinard, 2020), a non-adversarial training defense. MR gives union accuracy close to PAT-self, but much lower clean accuracy; for PAT-AlexNet, which gives similar clean accuracy to MR, the union accuracy is much higher.

Threat model overlap In Figure 2, we investigate how the sets of images vulnerable to $L_{2}$, spatial, and perceptual attacks overlap. Nearly all adversarial examples vulnerable to $L_{2}$ or spatial attacks are also vulnerable to LPA. However, there is only partial overlap between the examples vulnerable to $L_{2}$ and spatial attacks. This helps explain why PAT results in improved robustness against spatial attacks (and other diverse threat models) compared to $L_{2}$ adversarial training.

Why does PAT work better than $L_{p}$ adversarial training? In Figure 5, we give further explanation of why PAT results in improved robustness against diverse threat models. We generate many adversarial examples for the $L_{\infty}$, $L_{2}$, JPEG, StAdv, and ReColorAdv threat models and measure their distance from the corresponding natural inputs using $L_{p}$ distances and the neural perceptual distance, LPIPS. While $L_{p}$ distances vary widely, LPIPS gives remarkably comparable distances to different types of adversarial examples. Covering all threat models during $L_{\infty}$ or $L_{2}$ adversarial training would require using a huge training bound, resulting in poor performance. In contrast, PAT can obtain robustness against all the narrow threat models at a reasonable training bound.

Robustness against common corruptions In addition to evaluating PAT against adversarial examples, we also evaluate its robustness to random perturbations in the CIFAR/̄10/̄C and ImageNet/C datasets (Hendrycks and Dietterich, 2019). We find that PAT gives increased robustness (lower relative mCE) against these corruptions compared to adversarial training; see Appendix G for details.

Conclusion

We have presented attacks and defenses for the neural perceptual threat model (realized by the LPIPS distance) and shown that it closely approximates the true perceptual threat model, the set of all perturbations to natural inputs which fool a model but are imperceptible to humans. Our work provides a novel method for developing defenses against adversarial attacks that generalize to unforeseen threat models. Our proposed perceptual adversarial attacks and PAT could be extended to other vision algorithms, or even other domains such as audio and text.

Acknowledgments

This project was supported in part by NSF CAREER AWARD 1942230, HR 00111990077, HR00112090132, HR001119S0026, NIST 60NANB20D134, AWS Machine Learning Research Award and Simons Fellowship on “Foundations of Deep Learning.”

References

Appendix

Appendix A Perceptual Attack Algorithms

Recall from Section 4 that Perceptual PGD (PPGD) consists of repeatedly applying two steps: a first-order step in LPIPS distance to maximize the loss, followed by a projection into the allowed set of inputs. Here, we focus on the first-order step; see Appendix A.4 for how we perform projection onto the LPIPS ball.

We wish to solve the following constrained optimization for the step $\delta$ given the step size $\eta$ and current input $\mathbf{x}$:

Let $\hat{f}(\mathbf{x}):=\mathcal{L}(f(\mathbf{x}),y)$ for an input $\mathbf{x}\in\mathcal{X}$. Let $J$ be the Jacobian of $\phi(\cdot)$ at $\mathbf{x}$ and $\nabla\hat{f}$ be the gradient of $\hat{f}(\cdot)$ at $\mathbf{x}$.

where $J^{+}$ is the pseudoinverse of $J$.

We solve (8) using Lagrange multipliers. First, we take the gradient of the objective:

We can rewrite the constraint by squaring both sides to obtain

Taking the gradient of the constraint gives

Now, we set one gradient as a multiple of the other and solve for $\delta$:

Substituting into the constraint from (8) gives

We substitute this value of $\lambda$ into (10) to obtain

Solution with conjugate gradient method Calculating (11) directly is computationally intractable for most neural networks, since inverting $J^{\top}J$ and calculating the pseudoinverse of $J$ are expensive. Instead, we approximate $\delta^{*}$ by using the conjugate gradient method to solve the following linear system, based on (9):

$\nabla\hat{f}$ is easy to calculate using backpropagation. The conjugate gradient method does not require calculating fully $J^{\top}J$; instead, it only requires the ability to perform matrix-vector products $J^{\top}Jv$ for various vectors $v$.

We can approximate $Jv$ using finite differences given a small, positive value $h$:

Then, we can calculate $J^{\top}Jv$ by introducing an additional variable $u$ and using autograd:

This allows us to efficiently approximate the solution of (12) to obtain $(J^{\top}J)^{-1}\nabla\hat{f}$. We use 5 iterations of the conjugate gradient algorithm in practice.

From there, it easy to solve for $\lambda$, given that $(J^{+})^{\top}\nabla\hat{f}=J(J^{\top}J)^{-1}\nabla\hat{f}$. Then, $\delta^{*}$ can be calculated via (10). See Algorithm 1 for the full attack.

Computational complexity PPGD’s running time scales with the number of steps $T$ and the number of conjugate gradient iterations $K$. It also depends on whether the attack is self-bounded (the same network is used for classification and the LPIPS distance) or externally-bounded (different networks are used).

For each of the $T$ steps, $\theta(\widetilde{\mathbf{x}})$, $\nabla_{\widetilde{\mathbf{x}}}\mathcal{L}(f(\widetilde{\mathbf{x}}),y)$, and $\phi(\widetilde{\mathbf{x}}+h\delta_{k})$ must be calculated once (lines 4 and 15 in Algorithm 1). This takes 2 forward passes and 1 backward pass for the self-bounded case, and 3 forward passes and 1 backward pass for the externally-bounded case.

In addition, $J^{\top}Jv$ needs to be calculated (in the MultiplyJacobian routine) $K+1$ times. Each calculation of $J^{\top}Jv$ requires 1 forward and 1 backward pass, assuming $\phi(\widetilde{\mathbf{x}})$ is already calculated.

Finally, the projection step takes $n+1$ forward passes for $n$ iterations of the bisection method (see Section A.4).

In all, the algorithm requires $T(K+n+4)$ forward passes and $T(K+n+3)$ backward passes in the self-bounded case. In the externally-bounded case, it requires $T(K+n+5)$ forward passes and the same number of backward passes.

A.2 Lagrangian Perceptual Attack (LPA)

Our second attack, Lagrangian Perceptual Attack (LPA), optimizes a Lagrangian relaxation of the perceptual attack problem (3):

To optimize (13), we use a variation of gradient descent over $\widetilde{\mathbf{x}}$, starting at $\mathbf{x}$ with a small amount of noise added. We perform our modified version of gradient descent for $T$ steps. We use a step size $\eta$, which begins at $\epsilon$ and decays exponentially to $\epsilon/10$.

At each step, we begin by taking the gradient of (13) with respect to $\widetilde{\mathbf{x}}$; let $\Delta$ refer to this gradient. Then, we normalize $\Delta$ to have $L_{2}$ norm 1, i.e. $\hat{\Delta}=\Delta/\|\Delta\|_{2}$. We wish to take a step in the direction of $\hat{\Delta}$ of size $\eta$ in LPIPS distance. If we wanted to take a step of size $\eta$ in $L_{2}$ distance, we could just take the step $\eta\hat{\Delta}$. However, taking a step of particular size in LPIPS distance is harder. We assume that the LPIPS distance is approximately linear in the direction $\hat{\Delta}$. We can approximate the directional derivative of the LPIPS distance in the direction $\hat{\Delta}$ using finite differences:

Here, $h$ is a small positive value, and we assign the approximation of the directional derivative to $m$. Now, we can write the first-order Taylor expansion of the perceptual distance torwards the direction $\hat{\Delta}$ as follows:

we want to take a step of size $\eta$. Plugging in and solving, we obtain

So, the approximate step we should take is $(\eta/m)\hat{\Delta}$. We take this step at each of the $T$ iterations of our modified gradient descent method.

We begin with $\lambda=10^{-2}$. After performing gradient descent, if $d(\mathbf{x},\widetilde{\mathbf{x}})>\epsilon$ (i.e. the adversarial example is outside the constraint) we increase $\lambda$ by a factor of 10 and repeat the optimization. We repeat this entire process five times, meaning we search over $\lambda\in\{10^{-2},10^{-1},10^{0},10^{1},10^{2}\}$. Finally, if the resulting adversarial example is still outside the constraint, we project it into the threat model; see Appendix 5.

Computational complexity LPA’s running time scales with the number of iterations $S$ used to search for $\lambda$ as well as the number of gradient descent steps $T$. $\phi(\mathbf{x})$ may be calculated once during the entire attack, which speeds it up. Then, each step of gradient descent requires 2 forward and 1 backward passes in the self-bounded case, and 3 forward and 2 backward passes in the externally-bounded case.

The projection at the end of the attack requires $n+1$ forward passes for $n$ iterations of the bisection method (see Section A.4).

In total, the attack requires $2ST+n+2$ forward passes and $ST+n+2$ backward passes in the self-bounded case, and $3ST+n+2$ forward passes and $2ST+n+2$ backward passes in the externally-bounded case.

A.3 Fast Lagrangian Perceptual Attack

We use the Fast Lagrangian Perceptual Attack (Fast-LPA) for Perceptual Adversarial Training (PAT, see Section 5). Fast-LPA is similar to LPA (Appendix A.2), with two major differences. First, Fast-LPA does not search over $\lambda$ values; instead, during the $T$ gradient descent steps, $\lambda$ is increased exponentially from 1 to 10. Second, we remove the projection step at the end of the attack. This means that Fast-LPA may produce adversarial examples outside the threat model. This means that Fast-LPA cannot be used for evaluation, but it is fine for training.

Computational complexity Fast-LPA’s running time can be calculated similarly to LPA’s (see Section A.2), except that $S=1$ and there is no projection step. Let $T$ be the number of steps taken during the attack. Then Fast-LPA requires $2T+1$ forward passes and $T+1$ backward passes for the self-bounded case, and $3T+1$ forward passes and $2T+1$ backward passes for the externally-bounded case.

In comparison, PGD with $T$ iterations requires $T$ forward passes and $T$ backward passes. Thus, Fast-LPA is slightly slower, requiring $T+1$ more forward passes and no more backward passes.

A.4 Perceptual Projection

We explored two methods of projecting adversarial examples into the LPIPS thread model. The method we use throughout the paper is based on Newton’s method and is shown in algorithm 4. However, we also experimented with the bisection root finding method, shown in Algorithm 5 (also see Appendix E).

In general, given an adversarial example $\widetilde{\mathbf{x}}$, original input $\mathbf{x}$, and LPIPS bound $\epsilon$, we wish to find a projection $\widetilde{\mathbf{x}}^{\prime}$ of $\widetilde{\mathbf{x}}$ such that $d(\widetilde{\mathbf{x}}^{\prime},\mathbf{x})\leq\epsilon$. Assume for this section that $d(\widetilde{\mathbf{x}},\mathbf{x})>\epsilon$, i.e. the current adversarial example $\widetilde{\mathbf{x}}$ is outside the bound. If $d(\widetilde{\mathbf{x}},\mathbf{x})\leq\epsilon$, then we can just let $\widetilde{\mathbf{x}}^{\prime}=\widetilde{\mathbf{x}}$ and be done.

Newton’s method The second projection method we explored uses the generalized Newton–Raphson method to attempt to find the closest projection $\widetilde{\mathbf{x}}^{\prime}$ to the current adversarial example $\widetilde{\mathbf{x}}$ such that the projection is within the threat model, i.e. $d(\widetilde{\mathbf{x}}^{\prime},\mathbf{x})\leq\epsilon$. To find such a projection, we again define a function $r(\cdot)$ and look for its roots:

If we can find a projection $\widetilde{\mathbf{x}}^{\prime}$ close to $\widetilde{\mathbf{x}}$ such that $r(\widetilde{\mathbf{x}}^{\prime})\leq 0$, then this projection will be contained within the threat model, since

To find such a root, we use the generalized Newton-Raphson method, an iterative algorithm. Beginning with $\widetilde{\mathbf{x}}^{\prime}_{0}=\widetilde{\mathbf{x}}$, we update $\widetilde{\mathbf{x}}^{\prime}$ iteratively using the step

where $A^{+}$ denotes the pseudoinverse of $A$, and $s$ is a small positive constant (the “overshoot”), which helps the algorithm converge. We continue this process until $r(\widetilde{\mathbf{x}}^{\prime}_{t})\leq 0$, at which point the projection is complete.

This algorithm usually takes 2-3 steps to converge with $s=10^{-2}$. Each step requires 1 forward and 1 backward pass to calculate $r(\widetilde{\mathbf{x}}^{\prime}_{t})$ and its gradient. The method also requires 1 forward pass at the beginning to calculate $\phi(\mathbf{x})$.

Bisection method The first projection method we explored (and the one we use throughout the paper) attempts to find a projection $\widetilde{\mathbf{x}}^{\prime}$ along the line connecting the current adversarial example $\widetilde{\mathbf{x}}$ and original input $\mathbf{x}$. Let $\delta=\widetilde{\mathbf{x}}-\mathbf{x}$. Then we can represent our final projection $\widetilde{\mathbf{x}}^{\prime}$ as a point between $\mathbf{x}$ and $\widetilde{\mathbf{x}}$ as

This function has the following properties:

$r(0)<0$, since $r(0)=d(\mathbf{x},\mathbf{x})-\epsilon=-\epsilon$.

$r(1)>0$, since $r(1)=d(\widetilde{\mathbf{x}},\mathbf{x})-\epsilon>0$ because $d(\widetilde{\mathbf{x}},\mathbf{x})>\epsilon$.

$r(\alpha)=0$ iff $d(\widetilde{\mathbf{x}}^{\prime},\mathbf{x})=\epsilon$.

We use the bisection root finding method to find a root $\alpha^{*}$ of $r(\cdot)$ on the interval $$, which exists since$r(\cdot)$ is continuous and because of items 1 and 2 above. By item 3, at this root, the projected adversarial example is within the threat model:

We use $n=10$ iterations of the bisection method to calculate $\alpha^{*}$. This requires $n+1$ forward passes through the LPIPS network, since $\phi(\mathbf{x})$ must be calculated once, and $\phi(\mathbf{x}+\alpha\delta)$ must be calculated $n$ times. See Algorithm 5 for the full projection algorithm.

Appendix B Additional Related Work

Here, we expand on the related work discussed in Section 2 discuss some additional existing work on adversarial robustness.

Adversarial attacks Much of the initial work on adversarial robustness focused on perturbations to natural images which were bounded by the $L_{2}$ or $L_{\infty}$ distance [Carlini and Wagner, 2017, Goodfellow et al., 2015, Madry et al., 2018]. However, recently the community has discovered many other types of perturbations that are imperceptible and can be optimized to fool a classifier, but are outside $L_{p}$ threat models. These include spatial perturbations using flow fields [Xiao et al., 2018], translation and rotation [Engstrom et al., 2017], and Wassterstein distance bounds [Wong et al., 2019]. Attacks that manipulate the colors in images uniformly also been proposed [Hosseini and Poovendran, 2018, Hosseini et al., 2017, Zhang et al., 2019b] and have been generalized into “functional adversarial attacks” by Laidlaw and Feizi .

A couple papers have proposed adversarial threat models that do not focus on a simple, manually defined perturbation type. Dunn et al. use a generative model of images; they perturb the features at various layers in the generator to create adversarial examples. Xu et al. train an autoencoder and then perturb images in representation space rather than pixel space.

Appendix C Additional Adversarial Examples

Appendix D Additional Perceptual Study Results

Appendix E Perceptual Attack Experiments

We experiment with variations of the two validation attacks, PPGD and LPA, described in Section 4. As described in Appendix A.4, we developed two methods for projecting candidate adversarial examples into the LPIPS ball surrounding a natural input. We attack a single model using PPGD and LPA with both projection methods. We also compare self-bounded to externally-bounded attacks.

We find that LPA tends to be more powerful than PPGD. Finally, we note that externally-bounded LPA is extremely powerful, reducing the accuracy of a PAT-trained classifier on ImageNet-100 to just 2.4%.

Besides these experiments, we always use externally-bounded attacks with AlexNet for evaluation. AlexNet correlates with human perception of adversarial examples (Figure 6) and provides a standard measure of LPIPS distance; in contrast, self-bounded attacks by definition have varying bounds across evaluated models.

Appendix F PAT Experiments

We perform an ablation study of Perceptual Adversarial Training (PAT). First, we examine Fast-LPA, the training attack. We attempt training without step size ($\eta$) decay and/or without increasing $\lambda$ during Fast-LPA, and find that PAT performs best with both $\eta$ decay and $\lambda$ increase.

Training a classifier with PAT gives robustness against a wide range of adversarial threat models (see Section 7). However, it tends to give low accuracy against natural, unperturbed inputs. Thus, we use a technique from Balaji et al. to improve natural accuracy in PAT-trained models: at each training step, only inputs which are classified correctly without any perturbation are attacked. In addition to increasing natural accuracy, this also improves the speed of PAT since only some inputs from each batch must be attacked. In this ablation study, we compare attacking every input with Fast-LPA during training to only attacking the natural inputs which are already classified correctly. We find that the latter method achieves higher natural accuracy at the cost of some robust accuracy.

F.2 Projection During Training

We choose not to add a projection step to the end of Fast-LPA during training because it slows down the attack, requiring many more passes through the network per training step. However, we tested self-bounded PAT with a projection step and found that it increased clean accuracy slightly but decreased robust accuracy significantly. We believe this is because not projecting increases the effective bound on the training attacks, leading to better robustness. To test this, we tried training without projection using a smaller bound ($\epsilon=0.4$ instead of $\epsilon=0.5$) and found the results closely matched the results when using projection at the larger bound. That is, PAT with projection at $\epsilon=0.5$ is similar to PAT without projection at $\epsilon=0.4$. These results are shown in 7.

F.3 Self-Bounded vs. AlexNet-Bounded PAT

Performing externally-bounded PAT with AlexNet produces more robust models on CIFAR-10 than self-bounded PAT. This is not the case on ImageNet-100, where self- and AlexNet-bounded PAT perform similarly.

There is a simple explanation for this: the effective training bound on CIFAR-10 is greater for AlexNet-bounded PAT than for self-bounded PAT. To measure this, we generate adversarial examples for all the test threat models on CIFAR-10 ($L_{2}$, $L_{\infty}$, StAdv, and ReColorAdv). We find that the average LPIPS distance for all adversarial examples using AlexNet is 1.13; for a PAT-trained ResNet-50, it is 0.88. Because of this disparity, we use a lower training bound for self-bounded PAT ($\epsilon=0.5$) than for AlexNet-bounded PAT ($\epsilon=1$). However, this means that the average test attack has 76% greater LPIPS distance than the training attacks for self-bounded PAT, whereas the average test attack has only 13% greater LPIPS distance for AlexNet-bounded PAT. This explains why AlexNet-bounded PAT gives better robustness; it only has to generalize to slightly larger attacks on average.

We tried performing AlexNet-bounded PAT with a more comparable bound ($\epsilon=0.7$) to self-bounded PAT. This gives the average test attack about 80% greater LPIPS distance than the training attacks, similar to self-bounded PAT. Table 8 shows that the results are more similar for self-bounded and AlexNet-bounded PAT with $\epsilon=0.7$.

F.4 Accuracy-Robustness Tradeoff

Tsipras et al. have noted that there is often a tradeoff the between adversarial robustness of a classifier and its accuracy. That is, models which have higher accuracy under adversarial attack may have lower accuracy against clean images. We observe this phenomenon with adversarial training and PAT. Since PAT gives greater robustness against several narrow threat models, models trained with it tend to have lower accuracy on clean images than models trained with narrow adversarial training. In Figure 8, we show the robust and clean accuracies of several models trained on CIFAR-10 and ImageNet-100 with PAT and adversarial training. While some PAT models have lower clean accuracy than adversarially trained models, at least one PAT model on each dataset surpasses the Pareto frontier of the accuracy-robustness tradeoff for adversarial training. That is, there are PAT-trained models on both datasets with both higher robust accuracy and higher clean accuracy than adversarial training.

F.5 Performance Against StAdv and ReColorAdv

It was surprising to find that PAT outperformed threat-specific adversarial training (AT) against the StAdv and ReColorAdv attacks on CIFAR-10 (it does not do so on ImageNet-100). In Table 2 (partially reproduced in Table 9 below), PAT-AlexNet improves robustness over AT against StAdv from 54% to 65%; PAT-self improves robustness over AT against ReColorAdv from 65% to 71%.

We conjecture that, for these threat models, this is because training against a wider set of perturbations at training time helps generalize robustness to new inputs at test time, even within the same threat model. To test this, we additionally train classifiers using adversarial training against the StAdv and ReColorAdv attacks with double the default bound. The results are shown in Table 9 below. We find that, because these classifiers are exposed to a wider range of spatial and recoloring perturbations during training, they perform better than PAT against those attacks at test time (76% vs 65% for StAdv and 81% vs 71% for ReColorAdv).

This suggests that PAT not only improves robustness against a wide range of adversarial threat models, it can actually improve robustness over threat-specific adversarial training by incorporating a wider range of attacks during training.

Appendix G Common Corruptions Evaluation

We evaluate the robustness of PAT-trained models to common corruptions in addition to adversarial examples on CIFAR-10 and ImageNet-100. In particular, we test PAT-trained classifiers on CIFAR-10-C and ImageNet-100-C, where ImageNet-100-C is the 100-class subset of ImageNet-C formed by taking every tenth class [Hendrycks and Dietterich, 2019]. These datasets are based on random corruptions of CIFAR-10 and ImageNet, respectively, using 15 perturbation types with 5 levels of severity. The perturbation types are split into four general categories: “noise,” “blur,” “weather,” and “digital.”

The metric we use to evaluate PAT against common corruptions is mean relative corruption error (relative mCE). The relative corruption error is defined by Hendrycks and Dietterich for a classifier $f$ and corruption type $c$ as

where $E^{f}_{s,c}$ is the error of classifier $f$ against corruption type $c$ at severity level $s$, and $E^{f}_{\text{clean}}$ is the error of classifier $f$ on unperturbed inputs. The relative mCE is defined as the mean relative CE over all perturbation types.

The relative mCE for classifiers trained with normal training, adversarial training, and PAT is shown in Tables 10 and 11. PAT gives better robustness (lower relative mCE) against common corruptions on both CIFAR-10-C and ImageNet-100-C. The only category of perturbations where $L_{2}$ adversarial training outperforms PAT is “noise” on CIFAR-10-C, which makes sense because Gaussian and other types of noise are symmetrically distributed in an $L_{2}$ ball. For the other perturbation types and on ImageNet-100-C, PAT outperforms $L_{2}$ and $L_{\infty}$ adversarial training, indicating that robustness against a wider range of worst-case perturbations also gives robustness against a wider range of random perturbations.

Appendix H Experiment Details

For all experiments, we train ResNet-50 [He et al., 2016] with SGD for 100 epochs. We use 10 attack iterations for training and 200 for testing, except for PPGD and LPA, where we use 40 for testing since they are more expensive. Self-bounded PAT takes about 12 hours to train for CIFAR-10 on an Nvidia RTX 2080 Ti GPU, and about 5 days to train for ImageNet-100 on 4 GPUs. We implement PPGD, LPA, and PAT using PyTorch [Paszke et al., 2017].

We preprocess images after adversarial perturbation, but before classification, by standardizing them based on the mean and standard deviation of each channel for all images in the dataset. We use the default data augmentation techniques from the robustness library [Engstrom et al., 2019]. The CIFAR-10 dataset can be obtained from https://www.cs.toronto.edu/~kriz/cifar.html. The ImageNet-100 dataset is a subset of the ImageNet Large Scale Visual Recognition Challenge (2012) [Russakovsky et al., 2015] including only every tenth class by WordNet ID order. It can be obtained from http://www.image-net.org/download-images.

Calculating the LPIPS distance using a neural network classifier $g(\cdot)$ requires choosing layers whose normalized, flattened activations $\phi(\cdot)$ should be compared between images. For AlexNet and VGG-16, we use the same layers to calculate LPIPS distance as do Zhang et al. . For AlexNet [Krizhevsky et al., 2012], we use the activations after each of the first five ReLU functions. For VGG-16 [Simonyan and Zisserman, 2014], we use the activations directly before the five max pooling layers. In ResNet-50, we use the outputs of the conv2_x, conv3_x, conv4_x, and conv5_x layers, as listed in Table 1 of He et al. .