Year: 2019

Abstract:
Many machine learning image classifiers are vulnerable to adversarial attacks, inputs with perturbations designed to intentionally trigger misclassification. Current adversarial methods directly alter pixel colors and evaluate against pixel norm-balls: pixel perturbations smaller than a specified magnitude, according to a measurement norm. This evaluation, however, has limited practical utility since perturbations in the pixel space do not correspond to underlying real-world phenomena of image formation that lead to them and has no security motivation attached. Pixels in natural images are measurements of light that has interacted with the geometry of a physical scene. As such, we propose a novel evaluation measure, parametric normballs, by directly perturbing physical parameters that underly image formation. One enabling contribution we present is a physically-based differentiable renderer that allows us to propagate pixel gradients to the parametric space of lighting and geometry. Our approach enables physically-based adversarial attacks, and our differentiable renderer leverages models from the interactive rendering literature to balance the performance and accuracy trade-offs necessary for a memory-efficient and scalable adversarial data augmentation workflow.

text: Many machine learning image classifiers are vulnerable to adversarial attacks, inputs with perturbations designed to intentionally trigger misclassification. Current adversarial methods directly alter pixel colors and evaluate against pixel norm-balls: pixel perturbations smaller than a specified magnitude, according to a measurement norm. This evaluation, however, has limited practical utility since perturbations in the pixel space do not correspond to underlying real-world phenomena of image formation that lead to them and has no security motivation attached. Pixels in natural images are measurements of light that has interacted with the geometry of a physical scene. As such, we propose a novel evaluation measure, parametric normballs, by directly perturbing physical parameters that underly image formation. One enabling contribution we present is a physically-based differentiable renderer that allows us to propagate pixel gradients to the parametric space of lighting and geometry. Our approach enables physically-based adversarial attacks, and our differentiable renderer leverages models from the interactive rendering literature to balance the performance and accuracy trade-offs necessary for a memory-efficient and scalable adversarial data augmentation workflow.

heading: 1 INTRODUCTION
text: Research in adversarial examples continues to contribute to the development of robust (semi-)supervised learning (Miyato et al., 2018), data augmentation (Goodfellow et al., 2015; Sun et al., 2018), and machine learning understanding (Kanbak et al., 2018). One important caveat of the approach pursued by much of the literature in adversarial machine learning, as discussed recently (Goodfellow,
2018; Gilmer et al., 2018), is the reliance on overly simplified attack metrics: namely, the use of pixel value differences between an adversary and an input image, also referred to as the pixel norm-balls.
The pixel norm-balls game considers pixel perturbations of norm-constrained magnitude (Goodfellow et al., 2015), and is used to develop adversarial attackers, defenders and training strategies. The pixel norm-ball game is attractive from a research perspective due to its simplicity and well-posedness: no knowledge of image formation is required and any arbitrary pixel perturbation remains eligible (so long as it is “small”, in the perceptual sense). Although the pixel norm-ball is useful for research purposes, it only captures limited real-world security scenarios.
Despite the ability to devise effective adversarial methods through the direct employment of optimizations using the pixel norm-balls measure, the pixel manipulations they promote are divorced from the types of variations present in the real world, limiting their usefulness “in the wild”. Moreover, this methodology leads to defenders that are only effective when defending against unrealistic images/attacks, not generalizing outside of the space constrained by pixel norm-balls. In order to consider conditions that enable adversarial attacks in the real world, we advocate for a new measurement norm that is rooted in the physical processes that underly realistic image synthesis, moving away from overly simplified metrics, e.g., pixel norm-balls.
Our proposed solution – parametric norm-balls – rely on perturbations of physical parameters of a synthetic image formation model, instead of pixel color perturbations (Figure 2). To achieve this, we use a physically-based differentiable renderer which allows us to perturb the underlying parameters of the image formation process. Since these parameters indirectly control pixel colors, perturbations in this parametric space implicitly span the space of natural images. We will demonstrate two advantages that fall from considering perturbations in this parametric space: (1) they enable adversarial approaches that more readily apply to real-world applications, and (2) they permit the use of much more significant perturbations (compared to pixel norms), without invalidating the realism of the resulting image (Figure 1). We validate that parametric norm-balls game playing is critical for a variety of important adversarial tasks, such as building defenders robust to perturbations that can occur naturally in the real world.
We perform perturbations in the underlying image formation parameter space using a novel physicallybased differentiable renderer. Our renderer analytically computes the derivatives of pixel color with respect to these physical parameters, allowing us to extend traditional pixel norm-balls to physicallyvalid parametric norm-balls. Notably, we demonstrate perturbations on an environment’s lighting and on the shape of the 3D geometry it shades. Our differentiable renderer achieves state-of-the-art performance in speed and scalability (Section 3) and is fast enough for rendered adversarial data augmentation (Section 5): training augmented with adversarial images generated with a renderer.
Existing differentiable renders are slow and do not scalable to the volume of high-quality, highresolutions images needed to make adversarial data augmentation tractable (Section 2). Given our analytically-differentiable renderer (Section 3), we are able to demonstrate the efficacy of parametric space perturbations for generating adversarial examples. These adversaries are based on a substantially different phenomenology than their pixel norm-balls counterparts (Section 4). Ours is among the first steps towards the deployment of rendered adversarial data augmentation in real-world applications: we train a classifier with computer-generated adversarial images, evaluating the performance of the training against real photographs (i.e., captured using cameras; Section 5). We test on real photos to show the parametric adversarial data augmentation increases the classifier’s robustness to “deformations” happened in the real world. Our evaluation differs from the majority of existing literature which evaluates against computer-generated adversarial images, since our parametric space perturbation is no-longer a wholly idealized representation of the image formation model but, instead, modeled against of theory of realistic image generation.

heading: 2 RELATED WORK
text: Our work is built upon the fact that simulated or rendered images can participate in computer vision and machine learning on real-world tasks. Many previous works use rendered (simulated) data to train deep networks, and those networks can be deployed to real-world or even outperform the state-of-the-art networks trained on real photos (Movshovitz-Attias et al., 2016; Chen et al., 2016; Varol et al., 2017; Su et al., 2015; Johnson-Roberson et al., 2017; Veeravasarapu et al., 2017b; Sadeghi & Levine, 2016; James & Johns, 2016). For instance, Veeravasarapu et al. (2017a) show that training with 10% real-world data and 90% simulation data can reach the level of training with full real data. Tremblay et al. (2018) even demonstrate that the network trained on synthetic data yields a better performance than using real data alone. As rendering can cheaply provide a theoretically infinite supply of annotated input data, it can generate data which is orders of magnitude larger than existing datasets. This emerging trend of training on synthetic data provides an exciting direction for future machine learning development. Our work complements these works. We demonstrate the utility of rendering can be used to study the potential danger lurking in misclassification due to subtle changes to geometry and lighting. This provides a future direction of combining with synthetic data generation pipelines to perform physically based adversarial training on synthetic data.
Adversarial Examples Szegedy et al. (2014) expose the vulnerability of modern deep neural nets using purposefully-manipulated images with human-imperceptible misclassification-inducing noise. Goodfellow et al. (2015) introduce a fast method to harness adversarial examples, leading to the idea of pixel norm-balls for evaluating adversarial attackers/defenders. Since then, many significant developments in adversarial techniques have been proposed (Akhtar & Mian, 2018; Szegedy et al., 2014; Rozsa et al., 2016; Kurakin et al., 2017; Moosavi Dezfooli et al., 2016; Dong et al., 2018; Papernot et al., 2017; Moosavi-Dezfooli et al., 2017; Chen et al., 2017; Su et al., 2017). Our work extends this progression in constructing adversarial examples, a problem that lies at the foundation of adversarial machine learning. Kurakin et al. (2016) study the transferability of attacks to the physical world by printing then photographing adversarial images. Athalye et al. (2017) and Eykholt et al. (2018) propose extensions to non-planar (yet, still fixed) geometry and multiple viewing angles. These works still rely fundamentally on the direct pixel or texture manipulation on physical objects. Since these methods assume independence between pixels in the image or texture space they remain variants of pixel norm-balls. This leads to unrealistic attack images that cannot model real-world scenarios (Goodfellow, 2018; Hendrycks & Dietterich, 2018; Gilmer et al., 2018). Zeng et al. (2017) generate adversarial examples by altering physical parameters using a rendering network (Liu et al., 2017) trained to approximate the physics of realistic image formation. This data-driven approach leads to an image formation model biased towards the rendering style present in the training data. This method also relies on differentiation through the rendering network in order to compute adversaries, which requires high-quality training on a large amount of data. Even with perfect training, in their reported performance, it still requires 12 minutes on average to find new adversaries, we only take a few seconds Section 4.1. Our approach is based on a differentiable physically-based renderer that directly (and, so, more convincingly) models the image formation process, allowing us to alter physical parameters – like geometry and lighting – and compute
derivatives (and adversarial examples) much more rapidly compared to the (Zeng et al., 2017). We summarize the difference between our approach and the previous non-image adversarial attacks in Table 1.
Differentiable Renderer Applying parametric norm-balls requires that we differentiate the image formation model with respect to the physical parameters of the image formation model. Modern realistic computer graphics models do not expose facilities to directly accommodate the computation of derivatives or automatic differentiation of pixel colors with respect to geometry and lighting variables. A physically-based
differentiable renderer is fundamental to computing derivative of pixel colors with respect to scene parameters and can benefit machine learning in several ways, including promoting the development of novel network architectures (Liu et al., 2017), in computing adversarial examples (Athalye et al., 2017; Zeng et al., 2017), and in generalizing neural style transfer to a 3D context (Kato et al., 2018; Liu et al., 2018). Recently, various techniques have been proposed to obtain these derivatives: Wu et al. (2017); Liu et al. (2017); Eslami et al. (2016) use neural networks to learn the image formation process provided a large amount of input/output pairs. This introduces unnecessary bias in favor of the training data distribution, leading to inaccurate derivatives due to imperfect learning. Kato et al. (2018) propose a differentiable renderer based on a simplified image formation model and an underlying linear approximation. Their approach requires no training and is unbiased, but their approximation of the image formation and the derivatives introduce more errors. Loper & Black (2014); Genova et al. (2018) use automatic differentiation to build fully differentiable renderers. These renderers, however, are expensive to evaluate, requiring orders of magnitude more computation and much larger memory footprints compared to our method.
Our novel differentiable renderer overcomes these limitations by efficiently computing analytical derivatives of a physically-based image formation model. The key idea is that the non-differentiable visibility change can be ignored when considering infinitesimal perturbations. We model image variations by changing geometry and realistic lighting conditions in an analytically differentiable manner, relying on an accurate model of diffuse image formation that extend spherical harmonicsbased shading methods (Appendix C). Our analytic derivatives are efficient to evaluate, have scalable memory consumption, are unbiased, and are accurate by construction (Table 2). Our renderer explicitly models the physics of the image formation processes, and so the images it generates are realistic enough to illicit correct classifications from networks trained on real-world photographs.

heading: 3 ADVERSARIAL ATTACKS IN PARAMETRIC SPACES
text: Adversarial attacks based on pixel norm-balls typically generate adversarial examples by defining a cost function over the space of images C : I → R that enforces some intuition of what failure should look like, typically using variants of gradient descent where the gradient ∂C/∂I is accessible by differentiating through networks (Szegedy et al., 2014; Goodfellow et al., 2015; Rozsa et al., 2016; Kurakin et al., 2017; Moosavi Dezfooli et al., 2016; Dong et al., 2018).
The choices for C include increasing the cross-entropy loss of the correct class (Goodfellow et al., 2015), decreasing the cross-entropy loss of the least-likely class (Kurakin et al., 2017), using a combination of cross-entropies (Moosavi Dezfooli et al., 2016), and more (Szegedy et al., 2014; Rozsa et al., 2016; Dong et al., 2018; Tramèr et al., 2017). We combine of cross-entropies to provide flexibility for choosing untargeted and targeted attacks by specifying a different set of labels:
C ( I(U, V ) ) = −CrossEntropy ( f(I(U, V )), Ld ) + CrossEntropy ( f(I(U, V )), Li ) , (1)
where I is the image, f(I) is the output of the classifier, Ld, Li are labels which a user wants to decrease and increase the predicted confidences respectively. In our experiments, Ld is the correct class and Li is either ignored or chosen according to user preference. Our adversarial attacks in the parametric space consider an image I(U, V ) is the function of physical parameters of the image formation model, including the lighting U and the geometry V . Adversarial examples constructed by perturbing physical parameters can then be computed via the chain rule
∂C ∂U = ∂C ∂I ∂I ∂U
∂C ∂V = ∂C ∂I ∂U ∂V , (2)
where ∂I/∂U, ∂I/∂V are derivatives with respect to the physical parameters and we evaluate using our physically based differentiable renderer. In our experiments, we use gradient descent for finding parametric adversarial examples where the gradient is the direction of ∂I/∂U, ∂I/∂V .

heading: 3.1 PHYSICALLY BASED DIFFERENTIABLE RENDERER
text: Rendering is the process of generating a 2D image from a 3D scene by simulating the physics of light. Light sources in the scene emit photons that then interact with objects in the scene. At each interaction, photons are either reflected, transmitted or absorbed, changing trajectory and repeating until arriving at a sensor such as a camera. A physically based renderer models the interactions mathematically (Pharr et al., 2016), and our task is to analytically differentiate the physical process.
We develop our differentiable renderer with common assumptions in real-time rendering (AkenineMoller et al., 2008) – diffuse material, local illumination, and distant light sources. Our diffuse material assumption considers materials which reflect lights uniformly for all directions, equivalent to considering non-specular objects. We assume that variations in the material (texture) are piece-wise constant with respect to our triangle mesh discretization. The local illumination assumption only considers lights that bounce directly from the light source to the camera. Lastly, we assume light sources are far away from the scene, allowing us to represent lighting with one spherical function. For a more detailed rationale of our assumptions, we refer readers to Appendix B).
These assumptions simplify the complicated integral required for rendering (Kajiya, 1986) and allow us to represent lighting in terms of spherical harmonics, an orthonormal basis for spherical functions analogous to Fourier transformation. Thus, we can analytically differentiate the rendering equation to acquire derivatives with respect to lighting, geometry, and texture (derivations found in Appendix C).
Using analytical derivatives avoids pitfalls of previous differentiable renderers (see Section 2) and make our differentiable renderer orders of magnitude faster than the previous fully differentiable renderer OPENDR (Loper & Black, 2014) (see Figure 3). Our approach is scalable to handle problems with more than
100,000 variables, while OPENDR runs out of memory for problems with more than 3,500 variables.

heading: 3.2 ADVERSARIAL LIGHTING AND GEOMETRY
text: Adversarial lighting denotes adversarial examples generated by changing the spherical harmonics lighting coefficients U (Green, 2003). As our differentiable renderer allows us to compute ∂I/∂U analytically (derivation is provided in Appendix C.4), we can simply apply the chain rule:
U ← U − γ ∂C ∂I ∂I ∂U , (3)
where ∂C/∂I is the derivative of the cost function with respect to pixel colors and can be obtained by differentiating through the network. Spherical harmonics act as an implicit constraint to prevent unrealistic lighting because natural lighting environments everyday life are dominated by lowfrequency signals. For instance, rendering of diffuse materials can be approximated with only 1% pixel intensity error by the first 2 orders of spherical harmonics (Ramamoorthi & Hanrahan, 2001). As computers can only represent a finite number of coefficients, using spherical harmonics for lighting implicitly filters out high-frequency, unrealistic lightings. Thus, perturbing the parametric space of spherical harmonics lighting gives us more realistic compared to image-pixel perturbations Figure 1.
Adversarial geometry is an adversarial example computed by changes the position of the shape’s surface. The shape is encoded as a triangle mesh with |V | vertices and |F | faces, surface points are vertex positions V ∈ R|V |×3 which determine per-face normals N ∈ R|F |×3 which in turn determine the shading of the surface. We can compute adversarial shapes by applying the chain rule:
V ← V − γ ∂C ∂I ∂I ∂N ∂N ∂V , (4)
ni hij
vj where ∂I/∂N is computed via a derivation in Appendix E. Each triangle only has one normal on its face, making ∂N/∂V computable analytically. In particular, the 3× 3 Jacobian of a unit face normal vector ni ∈ R3 of the jth face of the triangle mesh V with respect to one of its corner vertices vj ∈ R3 is
∂ni ∂vj = hijn
T i
‖hij‖2 ,
where hij ∈ R3 is the height vector: the shortest vector to the corner vj from the opposite edge.

heading: 4 RESULTS AND EVALUATION
text: We have described how to compute adversarial examples by parametric perturbations, including lighting and geometry. In this section, we show that adversarial examples exist in the parametric spaces, then we analyze the characteristics of those adversaries and parametric norm-balls.
We use 49× 3 spherical harmonics coefficients to represent environment lighting, with an initial realworld lighting condition (Ramamoorthi & Hanrahan, 2001). Camera parameters and the background images are empirically chosen to have correct initial classifications and avoid synonym sets. In Figure 4 we show that single-view adversarial lighting attack can fool the classifier (pre-trained ResNet-101 on ImageNet (He et al., 2016)). Figure 5 shows multi-view adversarial lighting, which optimizes the summation of the cost functions for each view, thus the gradient is computed as the summation over all camera views:
U ← U − ∑
i∈cameras γ ∂C ∂Ii ∂Ii ∂U . (5)
If one is interested in a more specific subspace, such as outdoor lighting conditions governed by sunlight and weather, our adversarial lighting can adapt to it. In Figure 7, we compute adversarial lights over the space of skylights by applying one more chain rule to the Preetham skylight parameters (Preetham et al., 1999; Habel et al., 2008). Details about taking these derivatives are provided in Appendix D. Although adversarial skylight exists, its low degrees of freedom (only three parameters) makes it more difficult to find adversaries.
In Figure 8 and Figure 9 we show the existence of adversarial
geometry in both single-view and multi-view cases. Note that we upsample meshes to have >10K vertices as a preprocessing step to increase the degrees of freedom available for perturbations. Multiview adversarial geometry enables us to perturb the same 3D shape from different viewing directions, which enables us to construct a deep optical illusion: The same 3D shape are classified differently from different angles. To create the optical illusion in Figure 6, we only need to specify the Li in Equation (1) to be a dog and a cat for two different views.

heading: 4.1 PROPERTIES OF PARAMETRIC NORM-BALLS AND ADVERSARIES
text: To further understand parametric adversaries, we analyze how do parametric adversarial examples generalize to black-box models. In Table 3, we test 5,000 ResNet parametric adversaries on unseen networks including AlexNet (Krizhevsky et al., 2012), DenseNet (Huang et al., 2017), SqueezeNet (Iandola et al., 2016), and VGG (Simonyan & Zisserman, 2014). Our result shows that parametric adversarial examples also share across models.
In addition to different models, we evaluate parametric adversaries on black-box viewing directions. This evaluation mimics the real-world scenario that a self-driving car would “see” a stop sign from different angles while driving. In Table 4, we randomly sample 500 correctly classified views for a given shape and perform adversarial lighting and geometry algorithms only on a subset of views, then evaluate the resulting adversarial lights/shapes on all the views. The results show that adversarial lights are more generalizable to fool unseen views; adversarial shapes, yet, are less generalizable.
Switching from pixel norm-balls to parametric norm-balls only requires to change the normconstraint from the pixel color space to the parametric space. For instance, we can perform a quantitative comparison between parametric adversarial and random perturbations in Figure 10. We use L∞-norm = 0.1 to constraint the perturbed magnitude of each lighting coefficient, and L∞-norm = 0.002 to constrain the maximum displacement of surface points along each axis. The results show how many parametric adversaries can fool the classifier out of 10,000 adversarial lights and shapes respectively. Not only do the
parametric norm-balls show the effectiveness of adversarial perturbation, evaluating robustness using parametric norm-balls has real-world implications.
Table 3: We evaluate ResNet adversaries on unseen models and show that parametric adversarial examples also share across models. The table shows the success rate of attacks (%).
Alex VGG Squeeze Dense
Lighting 81.2% 65.0% 78.6% 43.5% Geometry 70.3% 58.9% 71.1% 40.1%
Table 4: We compute parametric adversaries using a subset of views (#Views) and evaluate the success rates (%) of attacks on unseen views.
#Views 0 1 5
Lighting 0.0% 29.4% 64.2% Geometry 0.0% 0.6% 3.6%
Time (sec.) Adversarial Lighting
105 106
54K vertices 25K vertices 15K vertices
105 106
54K vertices 25K vertices 15K vertices 1 .1
.01
Adversarial Geometry
#pixel Runtime The inset presents our runtime per iteration for computing derivatives. An adversary normally requires less than 10 iterations, thus takes a few seconds. We evaluate our CPU PYTHON implementation and the OPENGL rendering, on an Intel Xeon 3.5GHz CPU with 64GB of RAM and an NVIDIA GeForce GTX 1080. Our runtime depends on the number of pixels requiring derivatives.

heading: 5 RENDERED ADVERSARIAL DATA AUGMENTATION AGAINST REAL PHOTOS
text: We inject adversarial examples, generated using our differentiable renderer, into the training process of modern image classifiers. Our goal is to increase the robustness of these classifiers to real-world perturbations. Traditionally, adversarial training is evaluated against computer-generated adversarial images (Kurakin et al., 2017; Madry et al., 2018; Tramèr et al., 2017). In contrast, our evaluation differs from the majority of the literature, as we evaluate performance against real photos (i.e., images captured using a camera), and not computer-generated images. This evaluation method is motivated by our goal of increasing a classifier’s robustness to “perturbations” that occur in the real world and result from the physical processes underlying real-world image formation. We present preliminary steps towards this objective, resolving the lack of realism of pixel norm-balls and evaluating our augmented classifiers (i.e., those trained using our rendered adversaries) against real photographs.
Training We train the WideResNet (16 layers, 4 wide factor) (Zagoruyko & Komodakis, 2016) on CIFAR-100 (Krizhevsky & Hinton, 2009) augmented with adversarial lighting examples. We apply a common adversarial training method that adds a fixed number of adversarial examples each epoch (Goodfellow et al., 2015; Kurakin et al., 2017). We refer readers to Appendix F for the training detail. In our experiments, we compare three training scenarios: (1) CIFAR-100, (2) CIFAR-100 + 100 images under random lighting, and (3) CIFAR-100 + 100 images under adversarial lighting. Comparing to the accuracy reported in (Zagoruyko & Komodakis, 2016), WideResNets trained on these three cases all have comparable performance (≈ 77%) on the CIFAR-100 test set.
Testing We create a test set of real photos, captured in a laboratory setting with controlled lighting and camera parameters: we photographed oranges using a calibrated Prosilica GT 1920 camera under different lighting conditions, each generated by projecting different lighting patterns using an LG PH550 projector. This hardware lighting setup projects lighting patterns from a fixed solid angle of directions onto the scene objects. Figure 11 illustrates samples from the 500 real photographs of our dataset. We evaluate the robustness of our classifier models according to test accuracy. Of note, average prediction accuracies over five trained WideResNets on our test data under the three training cases are (1) 4.6%, (2) 40.4%, and (3) 65.8%. This result
supports the fact that training on rendered images can improve the networks’ performance on real photographs. Our preliminary experiments motivate the potential of relying on rendered adversarial training to increase the robustness to visual phenomena present in the real-world inputs.

heading: 6 LIMITATIONS & FUTURE WORK
text: Using parametric norm-balls to remove the lack of realism of pixel norm-balls is only the first step to bring adversarial machine learning to real-world. More evaluations beyond the lab experimental data could uncover the potential of the rendered adversarial data augmentation. Coupling the differentiable renderer with methods for reconstructing 3D scenes, such as (Veeravasarapu et al., 2017b; Tremblay et al., 2018), has the potential to develop a complete pipeline for rendered adversarial training. We can take a small set of real images, constructing 3D virtual scenes which have real image statistics, using our approach to manipulate the predicted parameters to construct the parametric adversarial
examples, then perform rendered adversarial training. This direction has the potential to produce limitless simulated adversarial data augmentation for real-world tasks.
Our differentiable renderer models the change of realistic environment lighting and geometry. Incorporating real-time rendering techniques from the graphics community could further improve the quality of rendering. Removing the locally constant texture assumption could improve our results. Extending the derivative computation to materials could enable “adversarial materials”. Incorporating derivatives of the visibility change and propagating gradient information to shape skeleton could also create “adversarial poses”. These extensions offer a set of tools for modeling real security scenarios. For instance, we can train a self-driving car classifier that can robustly recognize pedestrians under different poses, lightings, and cloth deformations.

heading: ACKNOWLEDGMENTS
text: This work is funded in part by NSERC Discovery Grants (RGPIN–2017–05235 & RGPAS–2017–507938), Connaught Funds (NR2016–17), the Canada Research Chairs Program, the Fields Institute, and gifts by Adobe Systems Inc., Autodesk Inc., MESH Inc. We thank members of Dynamic Graphics Project for feedback and draft reviews; Wenzheng Chen for photography equipments; Colin Raffel and David Duvenaud for discussions and feedback.

heading: Supplementary Material

heading: A COMPARISON BETWEEN PERTURBATION SPACES
text: We extend our comparisons against pixel norm-balls methods (Figure 1) by visualizing the results and the generated perturbations (Figure 12). We hope this figure elucidates that our parametric perturbation are more realistic several scales of perturbations.
B PHYSICALLY BASED RENDERING
Physically based rendering (PBR) seeks to model the flow of light, typically the assumption that there exists a collection of light sources that generate light; a camera that receives this light; and a scene that modulates the flow light between the light sources and camera (Pharr et al., 2016). What follows is a brief discussion of the general task of rendering an image from a scene description and the approximations we take in order to make our renderer efficient yet differentiable.
Computer graphics has dedicated decades of effort into developing methods and technologies to enable PBR to synthesize of photorealistic images under a large gamut of performance
requirements. Much of this work is focused around taking approximations of the cherished Rendering equation (Kajiya, 1986), which describes the propagation of light through a point in space. If we let uo be the output radiance, p be the point in space, ωo be the output direction, ue be the emitted radiance, ui be incoming radiance, ωi be the incoming angle, fr be the way light be reflected off the material at that given point in space we have:
uo(p, ωo) = ue(p, ωo) + ∫ S2 fr(p, ωi, ωo)ui(p, ωi)(ωi · n)dωi.
From now on we will ignore the emission term ue as it is not pertinent to our discussion. Furthermore, because the speed of light is substantially faster than the exposure time of our eyes, what we perceive is not the propagation of light at an instant, but the steady state solution to the rendering equation evaluated at every point in space. Explicitly computing this steady state is intractable for our applications and will mainly serve as a reference for which to place a plethora of assumptions and simplifications we will make for the sake of tractability. Many of these methods focus on ignoring light with nominal effects on the final rendered image vis a vis assumptions on the way light travels. For instance, light is usually assumed to have nominal interacts with air, which is described as the assumption that the space between objects is a vacuum, which constrains the interactions of light to the objects in a scene. Another common assumption is that light does not penetrate objects, which makes it difficult to render objects like milk and human skin1. This constrains the complexity of light propagation to the behavior of light bouncing off of object surfaces.
B.1 LOCAL ILLUMINATION
It is common to see assumptions that limit number of bounces light is allowed.In our case we chose to assume that the steady state is sufficiently approximated by an extremely low number of iterations: one. This means that it seems sufficient to model the lighting of a point in space by the light sent to it directly by light sources. Working with such a strong simplification does, of course, lead to a few artifacts. For instance, light occluded by other objects is ignored so shadows disappear and auxiliary techniques are usually employed to evaluate shadows (Williams, 1978; Miller, 1994).
When this assumption is coupled with a camera we approach what is used in standard rasterization systems such as OPENGL (Shreiner & Group, 2009), which is what we use. These systems compute the illumination of a single pixel by determining the fragment of an object visible through that pixel and only computing the light that traverses directly from the light sources, through that fragment, to that pixel. The lighting of a fragment is therefore determined by a point and the surface normal at that point, so we write the fragment’s radiance as R(p,n, ωo) = uo(p, ωo):
R(p,n, ωo) = ∫ S2 fr(p, ωi, ωo)ui(p, ωi)(ωi · n)dωi. (6)
B.2 LAMBERTIAN MATERIAL
Lambertian Non-Lambertian
Figure 15: We consider the Lambertian material (left) where lights get reflected uniformly in every direction.
Each point on an object has a model approximating the transfer of incoming light to a given output direction fr, which is usually called the material. On a single object the material parameters may vary quite a bit and the correspondence between points and material parameters is usually called the texture map which forms the texture of an object. There exists a wide gamut of material models, from mirror materials that transport light from a single input direction to a single output direction, to materials that reflect light evenly in all directions, to materials liked brushed metal that reflect differently along different angles. For the sake
of document we only consider diffuse materials, also called Lambertian materials, where we assume
1this is why simple renderers make these sorts of objects look like plastic
that incoming light is reflected uniformly, i.e fr is a constant function with respect to angle, which we denote fr(p, ωi, ωo) = ρ(p):
R(p,n) = ρ(p) ∫ Ω(n) u(p, ω)(ω · n)dω. (7)
This function ρ is usually called the albedo, which can be perceived as color on the surface for diffuse material, and we reduce our integration domain to the upper hemisphere Ω(n) in order to model light not bouncing through objects. Furthermore, since only the only ω and u are the incoming ones we can now suppress the “incoming” in our notation and just use ω and u respectively.

heading: B.3 ENVIRONMENT MAPPING
text: The illumination of static, distant objects such as the ground, the sky, or mountains do not change in any noticeable fashion when objects in a scene are moved around, so u can be written entirely in terms of ω, u(p, ω) = u(ω). If their illumination forms a constant it seems prudent to pre-compute or cache their contributions to the illumination of a scene. This is what is usually called environment mapping and they fit in the rendering equation as a representation for the total lighting of a scene, i.e the total incoming radiance ui. Because the environment is distant, it is common to also assume that the position of the object receiving light from an environment map does not matter so this simplifies ui to be independent of position:
R(p,n) = ρ(p) ∫ Ω(n) u(ω) (ω · n) dω. (8)

heading: B.4 SPHERICAL HARMONICS
text: Despite all of our simplifications, the inner integral is still a fairly generic function over S2. Many techniques for numerically integrating the rendering equation have emerged in the graphics community and we choose one which enables us to perform pre-computation and select a desired spectral accuracy: spherical harmonics. Spherical harmonics are a basis on S2 so, given a spherical harmonics expansion of the integrand, the evaluation of the above integral can be reduced to a weighted product of coefficients. This particular basis is chosen because it acts as a sort of Fourier basis for functions on the sphere and so the bases are each associated with a frequency, which leads to a convenient multi-resolution structure. In fact, the rendering of diffuse objects under distant lighting can be 99% approximated by just the first few spherical harmonics bases (Ramamoorthi & Hanrahan, 2001).
We will only need to note that the spherical harmonics bases Y ml are denoted with the subscript with l as the frequency and that there are 2l + 1 functions per frequency, denoted by superscripts m between −l to l inclusively. For further details on them please take a glance at Appendix C. If we approximate a function f in terms of spherical harmonics coefficients f ≈ ∑ lm fl,mY m l the integral can be precomputed as∫ S2 f ≈ ∫ S2 ∑ lm fl,mY m l = ∑ lm fl,m ∫ S2 Y ml , (9)
Thus we have defined a reduced rendering equation that can be efficiently evaluated using OPENGL while maintaining differentiability with respect to lighting and vertices. In the following appendix we will derive the derivatives necessary to implement our system.

heading: C DIFFERENTIABLE RENDERER
text: Rendering computes an image of a 3D shape given lighting conditions and the prescribed material properties on the surface of the shape. Our differentiable renderer assumes Lambertian reflectance, distant light sources, local illumination, and piece-wise constant textures. We will discuss how to explicitly compute the derivatives used in the main body of this text. Here we give a detailed discussion about spherical harmonics and their advantages.

heading: C.1 SPHERICAL HARMONICS
text: Spherical harmonics are usually defined in terms of the Legendre polynomials, which are a class of orthogonal polynomials defined by the recurrence relation
P0 = 1 (10) P1 = x (11)
(l + 1)Pl+1(x) = (2l + 1)xPl(x)− lPl−1(x). (12)
The associated Legendre polynomials are a generalization of the Legendre polynomials and can be fully defined by the relations
P 0l = Pl (13) (l −m+ 1)Pml+1(x) = (2l + 1)xPml (x)− (l +m)Pml−1(x) (14)
2mxPml (x) = − √ 1− x2 [ Pm+1l (x) + (l +m)(l −m+ 1)P m−1 l (x) ] . (15)
Using the associated Legendre polynomials Pml we can define the spherical harmonics basis as
Y ml (θ, φ) = K m l  (−1)m √ 2P−ml (cos θ) sin(−mφ) m < 0 (−1)m √ 2Pml (cos θ) cos(mφ) m > 0
P 0l (cos θ) m = 0
. (16)
where Kml =
√ (2l + 1)(l − |m|)!
4π(l + |m|)! . (17)
We will use the fact that the associated Legendre polynomials correspond to the spherical harmonics bases that are rotationally symmetric along the z axis (m = 0).
In order to incorporate spherical harmonics into Equation 8, we change the integral domain from the upper hemisphere Ω(n) back to S2 via a max operation
R(p,n) = ρ(p) ∫ Ω(n) u(ω)(ω · n)dω (18)
= ρ(p) ∫ S2 u(ω) max(ω · n, 0)dω. (19)
We see that the integral is comprised of two components: a lighting component u(ω) and a component that depends on the normal max(ω · n, 0). The strategy is to pre-compute the two components by projecting onto spherical harmonics, and evaluating the integral via a dot product at runtime, as we will now derive.

heading: C.2 LIGHTING IN SPHERICAL HARMONICS
text: Approximating the lighting component u(ω) in Equation 19 using spherical harmonics Y ml up to band n can be written as
u(ω) ≈ n∑ l=0 l∑ m=−l Ul,mY m l (ω),
where Ul,m ∈ R are coefficients. By using the orthogonality of spherical harmonics we can use evaluate these coefficients as an integral between u(ω) and Y ml (ω)
Ul,m = 〈u, Y ml 〉S2 = ∫ S2 u(ω)Y ml (ω)dω,
which can be evaluated via quadrature.

heading: C.3 CLAMPED COSINE IN SPHERICAL HARMONICS
text: So far, we have projected the lighting term u(ω) onto the spherical harmonics basis. To complete evaluating Equation 19 we also need to approximate the second component max(ω ·n, 0) in spherical
harmonics. This is the so-called the clamped cosine function.
g(ω,n) = max(ω · n, 0) = n∑ l=0 l∑ m=−l Gl,m(n)Y m l (ω),
where Gl,m(n) ∈ R can be computed by projecting g(ω,n) onto Y ml (ω)
Gl,m(n) = ∫ S2 max(ω · n, 0)Y ml (ω)dω.
Unfortunately, this formulation turns out to be tricky to compute. Instead, the common practice is to analytically compute the coefficients for unit z direction G̃l,m = Gl,m(nz) = Gl,m([0, 0, 1]ᵀ) and evaluate the coefficients for different normals Gl,m(n) by rotating G̃l,m. This rotation, G̃l,m, can be computed analytically:
G̃l,m = ∫ S2 max(ω · nz, 0)Y ml (ω)dω
= ∫ 2π 0 ∫ π 0 max([sin θ cosφ, sin θ sinφ, cos θ][0, 0, 1]ᵀ, 0)Y ml (θ, φ) sin θdθdφ
= ∫ 2π 0 ∫ π 0 max(cos θ, 0)Y ml (θ, φ) sin θdθdφ
= ∫ 2π 0 ∫ π/2 0 cos θ Y ml (θ, φ) sin θdθdφ. (20)
In fact, because max(ω ·nz, 0) is rotationally symmetric around the z-axis, its projection onto Y ml (ω) will have many zeros except the rotationally symmetric spherical harmonics Y 0l . In other words, G̃l,m is non-zero only when m = 0. So we can simplify Equation 20 to
G̃l = G̃l,0 = 2π ∫ π/2 0 cos θ Y 0l (θ) sin θdθ.
The evaluation of this integral can be found in Appendix A in (Basri & Jacobs, 2003). We provide this here as well:
G̃l =  √ π 2 l = 0√ π 3 l = 1 (−1) l2 +1 (l−2)! √ (2l+1)π 2l( l2−1)!( l 2 +1)!
l ≥ 2, even 0 l ≥ 2, odd
.
The spherical harmonics coefficients Gl,m(n) of the clamped cosine function g(ω,n) can be computed by rotating G̃l (Sloan et al., 2005) using this formula
Gl,m(n) =
√ 4π
2l + 1 G̃l Y
m l (n). (21)
So far we have projected the two terms in Equation 19 into the spherical harmonics basis. Orthogonality of spherical harmonics makes the evaluation of this integral straightforward:∫
S2 u(ω) max(ω · n, 0)dω = ∫ S2 [∑ l,m Ul,mY m l (ω) ][∑ j,k Gj,k(n)Y k j (ω) ] dω
= ∑ j,k,l,m Ul,mGj,k(n)δ l jδ m k (22)
= ∑ l,m Ul,mGl,m(n). (23)
This, in conjunction with Equation 21allows us to derive the rendering equation using spherical harmonics lighting for Lambertian objects:
R(p,n) = ρ(p) n∑ l=0 l∑ m=−l Ul,m
√ 4π
2l + 1 G̃l Y
m l (n). (24)
So far we have only considered the shading of a specific point p with surface normal n. If we consider the rendered image I given a shape V , lighting U , and camera parameters η, the image I is the evaluation of the rendering equation R of each point in V visible through each pixel in the image. This pixel to point mapping is determined by η. Therefore, we can write I as
I(V,U, η) = ρ(V, η) n∑ l=0 l∑ m=−l Ul,m
√ 4π
2l + 1 G̃l Y m l (N(V ))︸ ︷︷ ︸
F (V,U)
, (25)
where N(V ) is the surface normal. We exploit the notation and use ρ(V, η) to represent the texture of V mapped to the image space through η.

heading: C.4 LIGHTING AND TEXTURE DERIVATIVES
text: For our applications we must differentiate Equation 25 with respect to lighting and material parameters. The derivative with respect to the lighting coefficients U can be obtained by
∂I ∂U = ∂ρ ∂U F + ρ ∂F ∂U (26)
= 0 + ρ n∑ l=0 l∑ m=−l ∂F ∂Ul,m . (27)
This is the Jacobian matrix that maps from spherical harmonics coefficients to pixels. The term ∂F/∂Ul,m can then be computed as
∂F
∂Ul,m =
√ 4π
2l + 1 G̃l Y
m l (N(V )). (28)
The derivative with respect to texture is defined by
∂I ∂ρ = n∑ l=0 l∑ m=−l Ul,m
√ 4π
2l + 1 G̃l Y
m l (N(V )). (29)
Note that we assume texture variations are piece-wise constant with respect to our triangle mesh discretization.

heading: D DIFFERENTIATING SKYLIGHT PARAMETERS
text: To model possible outdoor daylight conditions, we use the analytical Preetham skylight model (Preetham et al., 1999). This model is calibrated by atmospheric data and parameterized by two intuitive parameters: turbidity τ , which describes the cloudiness of the atmosphere, and two polar angles θs ∈ [0, π/2], φs ∈ [0, 2π], which are encode the direction of the sun. Note that θs, φs are not the polar angles θ, φ for representing incoming light direction ω in u(ω). The spherical harmonics representation of the Preetham skylight is presented in (Habel et al., 2008) as
u(ω) = 6∑ l=0 l∑ m=−l Ul,m(θs, φs, τ)Y m l (ω).
This is derived by first performing a non-linear least squares fit to write Ul,m as a polynomial of θs and τ which lets them solve for Ũl,m(θs, τ) = Ul,m(θs, 0, τ)
Ũl,m(θs, τ) = 13∑ i=0 7∑ j=0 (pl,m)i,jθ i sτ j ,
where (pl,m)i,j are scalar coefficients, then Ul,m(θs, φs, τ) can be computed by applying a spherical harmonics rotation with φs using
Ul,m(θs, φs, τ) = Ũl,m(θs, τ) cos(mφs) + Ũl,−m(θs, τ) sin(mφs).
We refer the reader to (Preetham et al., 1999) for more detail. For the purposes of this article we just need the above form to compute the derivatives.

heading: D.1 DERIVATIVES
text: The derivatives of the lighting with respect to the skylight parameters (θs, φs, τ) are
∂Ul,m(θs, φs, τ)
∂φs = −mŨl,m(θs, τ) sin(mφs) +mŨl,−m(θs, τ) cos(mφs) (30)
∂Ul,m(θs, φs, τ) ∂θs = ∂Ũl,m(θs, τ) cos(mφs) + Ũl,−m(θs, τ) sin(mφs) ∂θs (31)
= ∑ ij iθi−1s τ j(pl,m)i,j cos(mφs) + ∑ ij iθi−1s (pl,−m)i,j sin(mφs) (32)
∂Ul,m(θs, φs, τ) ∂τ = ∑ ij jθisτ j−1(pl,m)i,j cos(mφs) + ∑ ij jθisτ j−1(pl,−m)i,j sin(mφs) (33)

heading: E DERIVATIVES OF SURFACE NORMALS
text: Taking the derivative of the rendered image I with respect to surface normals N is an essential task for computing the derivative of I with respect to the geometry V . Specifically, the derivative of the rendering equation Equation 25 with respect to V is
∂I ∂V = ∂ρ ∂V F + ρ ∂F ∂V (34)
= ∂ρ
∂V F + ρ
∂F
∂N
∂N ∂V (35)
We assume the texture variations are piece-wise constant with respect to our triangle mesh discretization and omit the first term ∂ρ/∂V as the magnitude is zero. Computing ∂N/∂V is provided in Section 3.2. Computing ∂F/∂Ni on face i is
∂F ∂Ni = n∑ l=0 l∑ m=−l Ul,m
√ 4π
2l + 1 G̃l ∂Y ml ∂Ni , (36)
where the ∂Yml /∂Ni is the derivative of the spherical harmonics with respect to the face normal Ni.
To begin this derivation recall the relationship between a unit normal vector n = (nx, ny, nz) and its corresponding polar angles θ, φ
θ = cos−1 (
nz√ n2x + n 2 y + n 2 z
) φ = tan−1 ( ny nx ) ,
we can compute the derivative of spherical harmonics with respect to the normal vector through
∂Y ml (θ, φ)
∂n
= Kml  (−1)m √ 2 [ ∂P−ml (cos θ) ∂θ ∂θ ∂n sin(−mφ) + P−ml (cos θ) ∂ sin(−mφ) ∂φ ∂φ ∂n ] m < 0 (−1)m √ 2 [ ∂Pml (cos θ) ∂θ ∂θ ∂n cos(mφ) + Pml (cos θ) ∂ cos(mφ) ∂φ ∂φ ∂n ] m > 0 ∂P 0l (cos θ)
∂θ
∂θ ∂n m = 0
= Kml  (−1)m √ 2 [ ∂P−ml (cos θ) ∂θ ∂θ ∂n sin(−mφ)−mP−ml (cos θ) cos(−mφ) ∂φ ∂n ] m < 0 (−1)m √ 2 [ ∂Pml (cos θ) ∂θ ∂θ ∂n cos(mφ)−mPml (cos θ) sin(mφ) ∂φ ∂n ] m > 0 ∂P 0l (cos θ)
∂θ
∂θ ∂n m = 0
(37)
Note that the derivative of the associated Legendre polynomials Pml (cos θ) can be computed by applying the recurrence formula Dunster (2010)
∂Pml (cos θ) ∂θ = − cos θ(l + 1)Pml (cos θ) + (l −m+ 1)Pml+1(cos θ) cos2 θ − 1 × (− sin θ)
= − cos θ(l + 1)Pml (cos θ) + (l −m+ 1)Pml+1(cos θ)
sin θ . (38)
Thus the derivatives of polar angles (θ, φ) with respect to surface normals n = [nx, ny, nz] are
∂θ ∂n = [ ∂θ ∂nx , ∂θ ∂ny , ∂θ ∂nz ] = [ nxnz, nynz, −(n2x + n2y) ] (n2x + n 2 y + n 2 z) √ n2x + n 2 y , (39)
∂φ ∂n = [ ∂φ ∂nx , ∂φ ∂ny , ∂φ ∂nz ] = [ −ny n2x + n 2 y , nx n2x + n 2 y , 0 ] . (40)
In summary, the results of Equation 37, Equation 38, Equation 39, and Equation 40 tell us how to compute ∂Yml /∂Ni. Then the derivative of the pixel j with respect to vertex p which belongs to face i can be computed as
∂Ij ∂Vp ≈ ρj ∂F ∂Ni ∂Ni ∂Vp
= ρj n∑ l=0 l∑ m=−l Ul,m
√ 4π
2l + 1 G̃l ∂Y ml (θ, φ)
∂Ni
∂Ni ∂Vp . (41)

heading: F ADVERSARIAL TRAINING IMPLEMENTATION DETAIL
text: Our adversarial training is based on the basic idea of injecting adversarial examples into the training set at each step and continuously updating the adversaries according to the current model parameters (Goodfellow et al., 2015; Kurakin et al., 2017). Our experiments inject 100 adversarial lighting examples to the CIFAR-100 data (≈ 0.17% of the training set) and keep updating these adversaries at each epoch.
We compute the adversarial lighting examples using the orange models collected from cgtrader.com and turbosquid.com. We uses five gray-scale background colors with intensities 0.0, 0.25, 0.5, 0.75, 1.0 to mimic images in the CIFAR-100 which contains many pure color backgrounds. Our orthographic cameras are placed at polar angle θ = π/3 with 10 uniformly sampled azimuthal angles ranging from φ = 0 to 2π. Our initial spherical harmonics lighting is the same as
other experiments, using the real-world lighting data provided in (Ramamoorthi & Hanrahan, 2001). Our stepsize for computing adversaries is 0.05 along the direction of lighting gradients. We run our adversarial lighting iterations until fooling the network or reaching the maximum 30 iterations to avoid too extreme lighting conditions, such as turning the lights off.
Our random lighting examples are constructed at each epoch by randomly perturb the lighting coefficients ranging from -0.5 to 0.5.
When training the 16-layers WideResNet (Zagoruyko & Komodakis, 2016) with wide-factor 4, we use batch size 128, learning rate 0.125, dropout rate 0.3, and the standard cross entropy loss. We implement the training using PYTORCH (Paszke et al., 2017), with the SGD optimizer and set the Nesterov momentum 0.9, weight decay 5e-4. We train the model for 150 epochs and use the one with best accuracy on the validation set. Figure 16 shows examples of our adversarial lights at different training stages. In the early stages, the model is not robust to different lighting conditions, thus small lighting perturbations are sufficient to fool the model. In the late stages, the network becomes more robust to different lightings. Thus it requires dramatic changes to fool a model or even fail to fool the model within 30 iterations.
G EVALUATE RENDERING QUALITY
We evaluated our rendering quality by whether our rendered images are recognizable by models trained on real photographs. Although large 3D shape datasets, such as ShapeNet (Chang et al., 2015), are available, they do not have have geometries or textures at the resolutions necessary to create realistic renderings. We collected 75 high-quality textured 3D shapes from cgtrader.com and turbosquid.com to evaluate our rendering quality. We augmented the shapes by changing the field of view, backgrounds, and viewing directions, then keep the configurations that were correctly classified by a pre-trained ResNet-101 on ImageNet. Specifically, we place the centroid, calculated as the weighted average of the mesh vertices where the weights are the vertex areas, at the origin and normalize shapes to range -1 to 1; the field of view is chosen to be 2 and 3 in the same unit with the normalized shape; background images include plain colors
and real photos, which have small influence on model predictions; viewing directions are chosen to be 60 degree zenith and uniformly sampled 16 views from 0 to 2π azimuthal angle. In Figure 17, we show that the histogram of model confidence on the correct labels over 10,000 correctly classified rendered images from our differentiable renderer. The confidence is computed using softmax function and the results show that our rendering quality is faithful enough to be recognized by models trained on natural images.

Review summaries:
The paper demonstrates a method for constructing adversarial examples by modifications or perturbations to physical parameters in the scene itself---specifically scene lighting and object geometry---such that images taken of that scene are able to fool a classifier. It achieves this through a novel differentiable rendering engine, which allows the proposed method to back-propagate gradients to the desired physical parameters. Also interesting in the paper is the use of spherical harmonics, which restrict the algorithm to plausible lighting. The method is computationally efficient and appears to work well, generating plausible scenes that fool a classifier when imaged from different viewpoints.

This work presents a method to generate adversary examples capable of fooling a neural network classifier. Szegedy et al. (2013) were the first to expose the weakness of neural networks against adversarial attacks, by adding a human-imperceptible noise to images to induce misclassification. Since then, several works tackled this problem by modifying the image directly in the pixel space: the norm-balls convention. The authors argue that this leads to non-realistic attacks and that a network would not benefit from training with these adversarial images when performing in the real world. Their solution and contributions are parametric norm-balls: unlike state-of-the-art methods, they perform perturbations in the image formation space, namely the geometry and the lighting, which are indeed perturbations that could happen in real life. For that, they defined a differentiable renderer by making some assumptions to simplify its expression compared to solving a light transport equation. The main simplifications are the direct illumination to gain computation efficiency and the distant illumination and diffuse material assumptions to represent lighting in terms of spherical harmonics as in Ramamoorthi et al. (2001), which require only 9 parameters to approximate lighting. This allows them to analytically derivate their loss function according to the geometry and lighting and therefore generate their adversary examples via gradient descent. They show that their adversary images generalize to other classifiers than the one used (ResNet). They then show that injecting these images into the training set increase the robustness of WideResNet against real attacks. These real attack images were taken by the authors in a laboratory with varying illumination.