Add files using upload-large-folder tool

parse/train/B186cP9gx/B186cP9gx.md

@@ -0,0 +1,113 @@
+# EIGENVALUES OF THE HESSIAN IN DEEP LEARNING: SINGULARITY AND BEYOND
+
+Levent Sagun Mathematics Department New York University sagun@cims.nyu.edu
+
+Leon Bottou´   
+Facebook AI Research New York   
+leon@bottou.org
+
+Yann LeCun Computer Science Department New York University yann@cs.nyu.edu
+
+# ABSTRACT
+
+We look at the eigenvalues of the Hessian of a loss function before and after training. The eigenvalue distribution is seen to be composed of two parts, the bulk which is concentrated around zero, and the edges which are scattered away from zero. We present empirical evidence for the bulk indicating how overparametrized the system is, and for the edges that depend on the input data.
+
+# 1 INTRODUCTION
+
+Given a (piece-wise) differentiable loss function, and a gradient based algorithm to minimize it, the knowledge of the second order information about it can tell us quite a bit about how the landscape looks like, and how we could modify our algorithm to make it go faster and find better solutions. But, one of the biggest challenges in second order optimization methods is in accessing that second order information itself. In particular, in deep learning there have been many proposals to accelerate training using second order information. Ngiam et al. (2011) has an in depth review of some of the proposals for approximating the Hessian of the loss function. Nevertheless, given the computational complexity of the problems at hand, it is hard to acquire information on what the actual Hessian looks like. This work is part of a series of papers that explore the data-model-algorithm connection along with Sagun et al. (2014; 2015) and it builds on top of the intuition developed in LeCun et al. (2012). We also note that the singularity of the Fisher information matrix have been explored (see for instance Watanabe (2007)). In another recent work, Dauphin et al. (2014) investigate saddle points of the landscape, in particular, they locate saddle points that are near the training path. In this work, however, we strictly focus on the Hessian of the loss function at the exact point of the training. We train the main examples using gradient descent. We perform our calculations of the Hessian using the implementation for the exact Hessian vector product that has been introduced in Pearlmutter (1994). And we find two new observations: one where the eigenvalues are zero, and one where we have a large, positive, and discrete set of eigenvalues.
+
+In this short note, we show how the data and the architecture depends on the eigenvalues of the Hessian of the loss function. In particular, we observe that the top discrete eigenvalues depend on the data, and the bulk of the eigenvalues depend on the architecture. Furthermore, as we keep growing the size of the network, we observe that the discrete part that depends on data remains the same, but the concentration around zero sharpens.
+
+There are various conclusions and implications of this singularity. Recent research suggest new insights into convergence properties of gradient based algorithms in non-convex systems (Lee et al., 2016; Hardt et al., 2015). The results come together with their implications on neural networks. However, the proofs require the system at hand to be non-degenerate. An immediate conclusion of our observation is that the Hessian of the loss function is very singular. Therefore, a lot of the theory and methodology that assumes non-singular Hessian cannot be applied without an appropriate modification.
+
+# 2 THE CASE OF THE FULLY-CONNECTED NETWORK
+
+# 2.1 MNIST WITH INCREASING SIZES OF HIDDEN LAYERS
+
+We calculate the exact Hessian of the loss function of a network with two hidden layers. The inputs are 1000 randomly selected examples of $2 8 * 2 8$ MNIST data, the network has one hidden layer with ReLU nonlinearity, the top layer has a softmax and a negative log likelihood loss function at the end. We train the system with gradient descent (i.e. with minibatch size equal to the number of examples). We plot the histogram of the eigenvalues of the Hessian for a varying number of hidden units after convergence. The Hessian at the end of the training turns out to be extremely singular, and increasing the number of units in hidden layers only add to the singularity of the Hessian (see figure 1). The effect of the training on the eigenvalue spectrum of the model with 10 hidden-units is visible when comparing figure 1 and figure 2 (left).
+
+![](images/dd1acc1635843f37ab94f9cf60f9e2da4f2083a0eab4254d2e20839b469cbdce.jpg)  
+Figure 1: (left) Full Hessian matrix for a 784-2-10 system after convergence. (right) Eigenvalue profile for increasingly bigger networks. For $k$ hidden networks there are $( 7 8 4 + 1 ) * k + ( k + 1 ) *$ $k + ( k + 1 ) * 1 0$ eigenvalues.
+
+# 2.2 VARYING THE DATA
+
+To demonstrate how the eigenvalue distribution may depend on data itself, we keep the same architecture and change the inputs to random patterns. Initially, a random point in the weight space is selected, and we calculated the Hessian without any training (first two histograms of figure 2). After training the system until the norm of the gradient is close to zero. We again calculate the exact Hessian and plot the histogram of their eigenvalues which can be seen in the last one in figure 2.
+
+![](images/dbd3e0af2d2bd3b422bbe9ae65f92bdbab9f8fcd532be25af456a3f4e83c2ffc.jpg)  
+Figure 2: Comparing random input (last two) with the MNIST data (first). Initial eigenvalue profiles are very different, as well as the final profile when compared to figure 1.
+
+# 3 A SIMPLER CASE
+
+In this section, we will repeat the same experiment in two-dimensional data, in an attempt to understand better the connection between the data and the spectrum of the Hessian. A simple figure can be seen in figure 3. We create two Gaussian blobs, centered at $( 1 , 1 )$ and $( - 1 , - 1 )$ , and first we keep the standard deviation the same, and increase the network size.
+
+![](images/a5b2f09a14544328cbe6a2d353c6731b174e2ce612242a052acb7714ecfb8e64.jpg)  
+Figure 3: The input data for the simple case.
+
+The network architecture is similar, this time with two hidden layers and a fully connected network with ReLU nonlinearities including a softmax at the top layer combined with a negative loglikelihood loss function. We train the system with gradient descent with constant step size. At the end of the training the norm of the gradient is at the order of $1 0 ^ { - 4 }$ .
+
+![](images/96d054e39eaf077474555be323200e40b663b27ad51a06f28dae6d87aa779415.jpg)  
+Figure 4: Increasing the network size: Systems with 18, 74, 162, 282, and 434 parameters, respectively. And a network with MSE loss.
+
+There are two eigenvalues that are isolated, and away from the bulk of the spectrum. Increasing the network only adds to the concentration of eigenvalues at and around zero (see figure 4). To give an insight into how the Hessian’s themselves look like, in figure 6 we plot the full Hessian matrices for three of the systems above after training.
+
+Moreover, this property of the singular and discrete parts is not specific to the log loss. In figure 5, we plot the histogram for a system that is trained on the same data as in figure 3, and the same architecture. But the training is carried out with the mean square loss rather than the negative loglikelihood. Consistent with our previous observations, we still see the same discrete, data-dependent part, and the part that is at zero.
+
+![](images/d78b500e86e48df19ea2b8e1173790b3681ece06c52972fd00d204608978b894.jpg)  
+Figure 5: Spectrum for the loss with the mean square loss.
+
+![](images/56c7efe5a491974dbb598a3b011b0a7a40513aa6172f7a19a7a26ad08702eefe.jpg)  
+Figure 6: Hessian heatmaps for 18, 74 and 162 paramters systems after training. The plots are 90 degrees rotates counter-clock wise.
+
+The training procedure itself acts like a process by which the eigenvalues concentrate at zero. To demonstrate this in further detail we calculated the full Hessian peridoically throughout the training. In figure 7 we plot the eigenvalue profile as the training progresses.
+
+All of the training has been done with random initializations on the weight space with the same standard deviation. In other words, initial points are randomly chosen on the surface of a sphere with a fixed radius given the total number of parameters. This begs the question of the effect of the choice of the initial point. Therefore, now we fix the network size, and repeat the experiment with different random initializations over 5K times. In figure 8 we plot the fluctuations of the top eigenvalue.
+
+The next question is how the spectrum responds to the increased complexity of data. The notion of complexity for a given dataset can be tricky to describe, here we use a loose notion of complexity to point out the fact that the more complex data is the less separable one. To this end, we keep the architecture the same, and increase the standard deviation of the two Gaussian blobs. They are still centered at the same two points, but it becomes harder to separate them as they merge together. Gradient descent still converges to a low-cost value, but the error is higher, and it can’t learn how to separate them perfectly as the blobs merge together. In figure 9, we observe that the top two eigenvalues grow significantly, and beyond its natural fluctuations due to the initialization. We also note that the norm of the weights are similar for all the cases, therefore the growth in the sizes of eigenvalues can not solely be accounted for the growth in weights.
+
+![](images/e94fd0cf79fcc2289e65dc61ff5925cb6e40a198c66630de45a6d239f1ae0002.jpg)  
+Figure 7: Eigenvalue profile during the training procedure.
+
+![](images/83f42e916d5c819b62f679e30c7bcfc2eed23b19130849669781aea0662a2360.jpg)  
+Figure 8: Top eigenvalue fluctuations over 5000 runs of the same system with same data and algorithm but different initial points.
+
+# 4 CONCLUSION
+
+We show that the Hessian of the loss functions in deep learning is degenerate. This has implications on the theoretical work which requires improvements in its premises. One such step has been taken in Panageas & Piliouras (2016) in relaxing the isolated singularity condition that was assumed in Lee et al. (2016). From a practical point of view this has multiple implications:
+
+• The landscape may be flat beyond the notion of wide basins. • Training stops at a point that has a small gradient. The norm of the gradient is not zero, therefore it does not, technically speaking, converge to a critical point. • There are still negative eigenvalues even when they are small in magnitude.
+
+This suggests that we may be able to look beyond the classical notions of basins when exploring the energy landscapes of loss functions. Next obvious question is to find low energy paths between solutions to show the kind of flatness in such landscapes. This will be explored in a subsequent work in the same series.
+
+![](images/c494a36f1d013d88138f4b17e3eb8dbcc4753f72bc91263a76a8c5cfaae6d07c.jpg)  
+Figure 9: Response of the top eigenvalues to the increasingly less-separable data. The numbers on top of the figures indicate the standard deviation of the Gaussian blobs. Their means are kept the same at $( 1 , 1 )$ and $( - 1 , - 1 )$ , respectively.
+
+We also demonstrate the two phases of the spectrum, one that is concentrated around zero that depends on the size of the model, and the second part that is away from the bulk of the spectrum, that is isolated and depends on the data.
+
+This kind of two-phased non-degeneracy can, in fact, be a desirable property. A degenerate Hessian implies locally flat regions. A degenerate Hessian at the scale that we observe in deep learning may imply flat regions across space, at the global scale.
+
+• We can devise separate methods for the directions that correspond to the top eigenvalues. • We can take advantage of the directions that correspond to the zero or small eigenvalues by attempting to find paths of low energies in the weight space.
+
+As a first step to the last item, initial experiments are promising: Let’s take a random point on the weight space and train two systems from that point: (1) with gradient descent, and (2) with stochastic gradient descent. At each step, take a straight line between the two points and interpolate the cost value. The resulting profile is completely flat even when the points keep diverging from one another. Next, take two random initial points on the weight space, so now they are orthogonal to each other. And train two systems with different shuffling of data for SGD. This time one would expect the line interpolation to give arbitrary values since the initial points are completely orthogonal, surprisingly, the line interpolation also decreases albeit not as flat as the previous one. Further considerations on connecting paths between solutions in the weight space of loss functions can be found in Freeman & Bruna (2016).
+
+![](images/6748bb39191314495e4007b3bab22f2e125251a32c216292586f5262943af024.jpg)  
+Figure 10: $z$ -axis is the distance between points. The left most and right most curves in each plot are actual training profiles, and the lines in between are interpolations only. (left figure) same initial point (right figure) random (hence orthogonal) initial points.
+
+# ACKNOWLEDGMENTS
+
+We would like to thank Afonso Bandeira, Yann Dauphin, Ruoyu Sun, Arthur Szlam and Soumith Chintala for valuable discussions. We also thank the reviewers for valuable feedback. Part of the research has been conducted when the first author was an intern at FAIR.
+
+# REFERENCES
+
+Yann N Dauphin, Razvan Pascanu, Caglar Gulcehre, Kyunghyun Cho, Surya Ganguli, and Yoshua Bengio. Identifying and attacking the saddle point problem in high-dimensional non-convex optimization. In Advances in Neural Information Processing Systems, pp. 2933–2941, 2014.   
+C Daniel Freeman and Joan Bruna. Topology and geometry of deep rectified network optimization landscapes. arXiv preprint arXiv:1611.01540, 2016.   
+Moritz Hardt, Benjamin Recht, and Yoram Singer. Train faster, generalize better: Stability of stochastic gradient descent. arXiv preprint arXiv:1509.01240, 2015.   
+Yann A LeCun, Leon Bottou, Genevieve B Orr, and Klaus-Robert M ´ uller. Efficient backprop. In ¨ Neural networks: Tricks of the trade, pp. 9–48. Springer, 2012.   
+Jason D Lee, Max Simchowitz, Michael I Jordan, and Benjamin Recht. Gradient descent converges to minimizers. University of California, Berkeley, 1050:16, 2016.   
+Jiquan Ngiam, Adam Coates, Ahbik Lahiri, Bobby Prochnow, Quoc V Le, and Andrew Y Ng. On optimization methods for deep learning. In Proceedings of the 28th International Conference on Machine Learning (ICML-11), pp. 265–272, 2011.   
+Ioannis Panageas and Georgios Piliouras. Gradient descent only converges to minimizers: Nonisolated critical points and invariant regions. arXiv preprint arXiv:1605.00405, 2016.   
+Barak A Pearlmutter. Fast exact multiplication by the hessian. Neural computation, 6(1):147–160, 1994.   
+Levent Sagun, V Ugur G ˘ uney, G ¨ erard Ben Arous, and Yann LeCun. Explorations on high dimen- ´ sional landscapes. ICLR 2015 Workshop Contribution, arXiv:1412.6615, 2014.
+
+Levent Sagun, Thomas Trogdon, and Yann LeCun. Universality in halting time and its applications in optimization. arXiv preprint arXiv:1511.06444, 2015.
+
+Sumio Watanabe. Almost all learning machines are singular. In Foundations of Computational Intelligence, 2007. FOCI 2007. IEEE Symposium on, pp. 383–388. IEEE, 2007.

parse/train/B186cP9gx/B186cP9gx_content_list.json

@@ -0,0 +1,613 @@
+[
+    {
+        "type": "text",
+        "text": "EIGENVALUES OF THE HESSIAN IN DEEP LEARNING: SINGULARITY AND BEYOND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Levent Sagun Mathematics Department New York University sagun@cims.nyu.edu ",
+        "bbox": [
+            183,
+            170,
+            362,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Leon Bottou´   \nFacebook AI Research New York   \nleon@bottou.org ",
+        "bbox": [
+            400,
+            170,
+            552,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun Computer Science Department New York University yann@cs.nyu.edu ",
+        "bbox": [
+            589,
+            170,
+            794,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            262,
+            544,
+            277
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We look at the eigenvalues of the Hessian of a loss function before and after training. The eigenvalue distribution is seen to be composed of two parts, the bulk which is concentrated around zero, and the edges which are scattered away from zero. We present empirical evidence for the bulk indicating how overparametrized the system is, and for the edges that depend on the input data. ",
+        "bbox": [
+            232,
+            310,
+            764,
+            380
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            446,
+            336,
+            463
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Given a (piece-wise) differentiable loss function, and a gradient based algorithm to minimize it, the knowledge of the second order information about it can tell us quite a bit about how the landscape looks like, and how we could modify our algorithm to make it go faster and find better solutions. But, one of the biggest challenges in second order optimization methods is in accessing that second order information itself. In particular, in deep learning there have been many proposals to accelerate training using second order information. Ngiam et al. (2011) has an in depth review of some of the proposals for approximating the Hessian of the loss function. Nevertheless, given the computational complexity of the problems at hand, it is hard to acquire information on what the actual Hessian looks like. This work is part of a series of papers that explore the data-model-algorithm connection along with Sagun et al. (2014; 2015) and it builds on top of the intuition developed in LeCun et al. (2012). We also note that the singularity of the Fisher information matrix have been explored (see for instance Watanabe (2007)). In another recent work, Dauphin et al. (2014) investigate saddle points of the landscape, in particular, they locate saddle points that are near the training path. In this work, however, we strictly focus on the Hessian of the loss function at the exact point of the training. We train the main examples using gradient descent. We perform our calculations of the Hessian using the implementation for the exact Hessian vector product that has been introduced in Pearlmutter (1994). And we find two new observations: one where the eigenvalues are zero, and one where we have a large, positive, and discrete set of eigenvalues. ",
+        "bbox": [
+            174,
+            492,
+            825,
+            742
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this short note, we show how the data and the architecture depends on the eigenvalues of the Hessian of the loss function. In particular, we observe that the top discrete eigenvalues depend on the data, and the bulk of the eigenvalues depend on the architecture. Furthermore, as we keep growing the size of the network, we observe that the discrete part that depends on data remains the same, but the concentration around zero sharpens. ",
+        "bbox": [
+            174,
+            750,
+            823,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "There are various conclusions and implications of this singularity. Recent research suggest new insights into convergence properties of gradient based algorithms in non-convex systems (Lee et al., 2016; Hardt et al., 2015). The results come together with their implications on neural networks. However, the proofs require the system at hand to be non-degenerate. An immediate conclusion of our observation is that the Hessian of the loss function is very singular. Therefore, a lot of the theory and methodology that assumes non-singular Hessian cannot be applied without an appropriate modification. ",
+        "bbox": [
+            174,
+            825,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 THE CASE OF THE FULLY-CONNECTED NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            612,
+            117
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 MNIST WITH INCREASING SIZES OF HIDDEN LAYERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            137,
+            584,
+            151
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We calculate the exact Hessian of the loss function of a network with two hidden layers. The inputs are 1000 randomly selected examples of $2 8 * 2 8$ MNIST data, the network has one hidden layer with ReLU nonlinearity, the top layer has a softmax and a negative log likelihood loss function at the end. We train the system with gradient descent (i.e. with minibatch size equal to the number of examples). We plot the histogram of the eigenvalues of the Hessian for a varying number of hidden units after convergence. The Hessian at the end of the training turns out to be extremely singular, and increasing the number of units in hidden layers only add to the singularity of the Hessian (see figure 1). The effect of the training on the eigenvalue spectrum of the model with 10 hidden-units is visible when comparing figure 1 and figure 2 (left). ",
+        "bbox": [
+            173,
+            165,
+            825,
+            291
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/dd1acc1635843f37ab94f9cf60f9e2da4f2083a0eab4254d2e20839b469cbdce.jpg",
+        "image_caption": [
+            "Figure 1: (left) Full Hessian matrix for a 784-2-10 system after convergence. (right) Eigenvalue profile for increasingly bigger networks. For $k$ hidden networks there are $( 7 8 4 + 1 ) * k + ( k + 1 ) *$ $k + ( k + 1 ) * 1 0$ eigenvalues. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            319,
+            816,
+            525
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 VARYING THE DATA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            625,
+            351,
+            638
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate how the eigenvalue distribution may depend on data itself, we keep the same architecture and change the inputs to random patterns. Initially, a random point in the weight space is selected, and we calculated the Hessian without any training (first two histograms of figure 2). After training the system until the norm of the gradient is close to zero. We again calculate the exact Hessian and plot the histogram of their eigenvalues which can be seen in the last one in figure 2. ",
+        "bbox": [
+            173,
+            654,
+            825,
+            724
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/dbd3e0af2d2bd3b422bbe9ae65f92bdbab9f8fcd532be25af456a3f4e83c2ffc.jpg",
+        "image_caption": [
+            "Figure 2: Comparing random input (last two) with the MNIST data (first). Initial eigenvalue profiles are very different, as well as the final profile when compared to figure 1. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            739,
+            808,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 A SIMPLER CASE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            348,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we will repeat the same experiment in two-dimensional data, in an attempt to understand better the connection between the data and the spectrum of the Hessian. A simple figure can be seen in figure 3. We create two Gaussian blobs, centered at $( 1 , 1 )$ and $( - 1 , - 1 )$ , and first we keep the standard deviation the same, and increase the network size. ",
+        "bbox": [
+            173,
+            133,
+            825,
+            190
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/a5b2f09a14544328cbe6a2d353c6731b174e2ce612242a052acb7714ecfb8e64.jpg",
+        "image_caption": [
+            "Figure 3: The input data for the simple case. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            374,
+            212,
+            614,
+            315
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The network architecture is similar, this time with two hidden layers and a fully connected network with ReLU nonlinearities including a softmax at the top layer combined with a negative loglikelihood loss function. We train the system with gradient descent with constant step size. At the end of the training the norm of the gradient is at the order of $1 0 ^ { - 4 }$ . ",
+        "bbox": [
+            173,
+            376,
+            825,
+            433
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/96d054e39eaf077474555be323200e40b663b27ad51a06f28dae6d87aa779415.jpg",
+        "image_caption": [
+            "Figure 4: Increasing the network size: Systems with 18, 74, 162, 282, and 434 parameters, respectively. And a network with MSE loss. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            450,
+            812,
+            758
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "There are two eigenvalues that are isolated, and away from the bulk of the spectrum. Increasing the network only adds to the concentration of eigenvalues at and around zero (see figure 4). To give an insight into how the Hessian’s themselves look like, in figure 6 we plot the full Hessian matrices for three of the systems above after training. ",
+        "bbox": [
+            174,
+            832,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Moreover, this property of the singular and discrete parts is not specific to the log loss. In figure 5, we plot the histogram for a system that is trained on the same data as in figure 3, and the same architecture. But the training is carried out with the mean square loss rather than the negative loglikelihood. Consistent with our previous observations, we still see the same discrete, data-dependent part, and the part that is at zero. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/d78b500e86e48df19ea2b8e1173790b3681ece06c52972fd00d204608978b894.jpg",
+        "image_caption": [
+            "Figure 5: Spectrum for the loss with the mean square loss. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            374,
+            132,
+            614,
+            301
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            377,
+            823,
+            420
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/56c7efe5a491974dbb598a3b011b0a7a40513aa6172f7a19a7a26ad08702eefe.jpg",
+        "image_caption": [
+            "Figure 6: Hessian heatmaps for 18, 74 and 162 paramters systems after training. The plots are 90 degrees rotates counter-clock wise. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            218,
+            439,
+            782,
+            617
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The training procedure itself acts like a process by which the eigenvalues concentrate at zero. To demonstrate this in further detail we calculated the full Hessian peridoically throughout the training. In figure 7 we plot the eigenvalue profile as the training progresses. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            728
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "All of the training has been done with random initializations on the weight space with the same standard deviation. In other words, initial points are randomly chosen on the surface of a sphere with a fixed radius given the total number of parameters. This begs the question of the effect of the choice of the initial point. Therefore, now we fix the network size, and repeat the experiment with different random initializations over 5K times. In figure 8 we plot the fluctuations of the top eigenvalue. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            819
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The next question is how the spectrum responds to the increased complexity of data. The notion of complexity for a given dataset can be tricky to describe, here we use a loose notion of complexity to point out the fact that the more complex data is the less separable one. To this end, we keep the architecture the same, and increase the standard deviation of the two Gaussian blobs. They are still centered at the same two points, but it becomes harder to separate them as they merge together. Gradient descent still converges to a low-cost value, but the error is higher, and it can’t learn how to separate them perfectly as the blobs merge together. In figure 9, we observe that the top two eigenvalues grow significantly, and beyond its natural fluctuations due to the initialization. We also note that the norm of the weights are similar for all the cases, therefore the growth in the sizes of eigenvalues can not solely be accounted for the growth in weights. ",
+        "bbox": [
+            173,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/e94fd0cf79fcc2289e65dc61ff5925cb6e40a198c66630de45a6d239f1ae0002.jpg",
+        "image_caption": [
+            "Figure 7: Eigenvalue profile during the training procedure. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            112,
+            764,
+            304
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/83f42e916d5c819b62f679e30c7bcfc2eed23b19130849669781aea0662a2360.jpg",
+        "image_caption": [
+            "Figure 8: Top eigenvalue fluctuations over 5000 runs of the same system with same data and algorithm but different initial points. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            253,
+            357,
+            732,
+            585
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            657,
+            825,
+            700
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            719,
+            318,
+            736
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We show that the Hessian of the loss functions in deep learning is degenerate. This has implications on the theoretical work which requires improvements in its premises. One such step has been taken in Panageas & Piliouras (2016) in relaxing the isolated singularity condition that was assumed in Lee et al. (2016). From a practical point of view this has multiple implications: ",
+        "bbox": [
+            176,
+            751,
+            825,
+            808
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• The landscape may be flat beyond the notion of wide basins. • Training stops at a point that has a small gradient. The norm of the gradient is not zero, therefore it does not, technically speaking, converge to a critical point. • There are still negative eigenvalues even when they are small in magnitude. ",
+        "bbox": [
+            215,
+            818,
+            823,
+            883
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This suggests that we may be able to look beyond the classical notions of basins when exploring the energy landscapes of loss functions. Next obvious question is to find low energy paths between solutions to show the kind of flatness in such landscapes. This will be explored in a subsequent work in the same series. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/c494a36f1d013d88138f4b17e3eb8dbcc4753f72bc91263a76a8c5cfaae6d07c.jpg",
+        "image_caption": [
+            "Figure 9: Response of the top eigenvalues to the increasingly less-separable data. The numbers on top of the figures indicate the standard deviation of the Gaussian blobs. Their means are kept the same at $( 1 , 1 )$ and $( - 1 , - 1 )$ , respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            107,
+            790,
+            505
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            607,
+            821,
+            635
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also demonstrate the two phases of the spectrum, one that is concentrated around zero that depends on the size of the model, and the second part that is away from the bulk of the spectrum, that is isolated and depends on the data. ",
+        "bbox": [
+            174,
+            642,
+            823,
+            684
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This kind of two-phased non-degeneracy can, in fact, be a desirable property. A degenerate Hessian implies locally flat regions. A degenerate Hessian at the scale that we observe in deep learning may imply flat regions across space, at the global scale. ",
+        "bbox": [
+            174,
+            690,
+            823,
+            733
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• We can devise separate methods for the directions that correspond to the top eigenvalues. • We can take advantage of the directions that correspond to the zero or small eigenvalues by attempting to find paths of low energies in the weight space. ",
+        "bbox": [
+            209,
+            748,
+            823,
+            797
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As a first step to the last item, initial experiments are promising: Let’s take a random point on the weight space and train two systems from that point: (1) with gradient descent, and (2) with stochastic gradient descent. At each step, take a straight line between the two points and interpolate the cost value. The resulting profile is completely flat even when the points keep diverging from one another. Next, take two random initial points on the weight space, so now they are orthogonal to each other. And train two systems with different shuffling of data for SGD. This time one would expect the line interpolation to give arbitrary values since the initial points are completely orthogonal, surprisingly, the line interpolation also decreases albeit not as flat as the previous one. Further considerations on connecting paths between solutions in the weight space of loss functions can be found in Freeman & Bruna (2016). ",
+        "bbox": [
+            174,
+            813,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/6748bb39191314495e4007b3bab22f2e125251a32c216292586f5262943af024.jpg",
+        "image_caption": [
+            "Figure 10: $z$ -axis is the distance between points. The left most and right most curves in each plot are actual training profiles, and the lines in between are interpolations only. (left figure) same initial point (right figure) random (hence orthogonal) initial points. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            235,
+            159,
+            764,
+            340
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            438,
+            326,
+            450
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank Afonso Bandeira, Yann Dauphin, Ruoyu Sun, Arthur Szlam and Soumith Chintala for valuable discussions. We also thank the reviewers for valuable feedback. Part of the research has been conducted when the first author was an intern at FAIR. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            502
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            525,
+            285,
+            540
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Yann N Dauphin, Razvan Pascanu, Caglar Gulcehre, Kyunghyun Cho, Surya Ganguli, and Yoshua Bengio. Identifying and attacking the saddle point problem in high-dimensional non-convex optimization. In Advances in Neural Information Processing Systems, pp. 2933–2941, 2014.   \nC Daniel Freeman and Joan Bruna. Topology and geometry of deep rectified network optimization landscapes. arXiv preprint arXiv:1611.01540, 2016.   \nMoritz Hardt, Benjamin Recht, and Yoram Singer. Train faster, generalize better: Stability of stochastic gradient descent. arXiv preprint arXiv:1509.01240, 2015.   \nYann A LeCun, Leon Bottou, Genevieve B Orr, and Klaus-Robert M ´ uller. Efficient backprop. In ¨ Neural networks: Tricks of the trade, pp. 9–48. Springer, 2012.   \nJason D Lee, Max Simchowitz, Michael I Jordan, and Benjamin Recht. Gradient descent converges to minimizers. University of California, Berkeley, 1050:16, 2016.   \nJiquan Ngiam, Adam Coates, Ahbik Lahiri, Bobby Prochnow, Quoc V Le, and Andrew Y Ng. On optimization methods for deep learning. In Proceedings of the 28th International Conference on Machine Learning (ICML-11), pp. 265–272, 2011.   \nIoannis Panageas and Georgios Piliouras. Gradient descent only converges to minimizers: Nonisolated critical points and invariant regions. arXiv preprint arXiv:1605.00405, 2016.   \nBarak A Pearlmutter. Fast exact multiplication by the hessian. Neural computation, 6(1):147–160, 1994.   \nLevent Sagun, V Ugur G ˘ uney, G ¨ erard Ben Arous, and Yann LeCun. Explorations on high dimen- ´ sional landscapes. ICLR 2015 Workshop Contribution, arXiv:1412.6615, 2014. ",
+        "bbox": [
+            169,
+            549,
+            826,
+            926
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Levent Sagun, Thomas Trogdon, and Yann LeCun. Universality in halting time and its applications in optimization. arXiv preprint arXiv:1511.06444, 2015. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Sumio Watanabe. Almost all learning machines are singular. In Foundations of Computational Intelligence, 2007. FOCI 2007. IEEE Symposium on, pp. 383–388. IEEE, 2007. ",
+        "bbox": [
+            173,
+            141,
+            823,
+            170
+        ],
+        "page_idx": 7
+    }
+]

parse/train/H1TWfmnNf/H1TWfmnNf.md

@@ -0,0 +1,322 @@
+# DO CONVOLUTIONAL NEURAL NETWORKS ACT AS COMPOSITIONAL NEAREST NEIGHBORS?
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We present a simple approach based on pixel-wise nearest neighbors to understand and interpret the internal operations of state-of-the-art neural networks for pixel-level tasks. Specifically, we aim to understand the synthesis and prediction mechanisms of state-of-the-art convolutional neural networks for pixel-level tasks. To this end, we primarily analyze the synthesis process of generative models and the prediction mechanism of discriminative models. The main hypothesis of this work is that convolutional neural networks for pixel-level tasks learn a fast compositional nearest neighbor synthesis or prediction function. Our experiments on semantic segmentation and image-to-image translation show qualitative and quantitative evidence supporting this hypothesis.
+
+# 1 INTRODUCTION
+
+Convolutional neural networks (CNNs) have revolutionized computer vision, producing impressive results for discriminative tasks such as image classification and semantic segmentation. More recently, they have also produced startlingly impressive results for image generation through generative models. However, in both cases, such feed-forward networks largely operate as “black boxes.” As a community, we are still not able to succinctly state why and how such feed-forward functions generate a particular output from a given input. If a network fails on a particular input, why? How will a network behave on never-before-seen data? To answer such questions, there is a renewed interest in so-called explainable $A I ^ { 1 }$ . The central goal in this (re)invigorated space is the development of machine learning systems that are designed to be more interpretable and explanatory.
+
+Explanation-by-correspondence: One attractive approach to interpretability stems from casebased reasoning or “explanation-by-example” (Lipton, 2016). Such an approach dates back to classic AI systems that predict medical diagnoses or legal judgments that were justified through case studies or historical precedent (Aamodt $\&$ Plaza, 1994). For example, radiologists can justify diagnoses of an imaged tumor as ‘malignant’ by reference to a previously-seen example (Caruana et al., 1999). However, this approach can generate only $N$ explanations given $N$ training exemplars. Our work demonstrates that deep networks can generate exponentially more explanations through composition: e.g., this part of the image looks like this part of exemplar A, while another part looks like that part of exemplar B. We term this “explanation-by-correspondence”, since our explanations provide detailed correspondence of parts (or even pixels) of a query image to a set of exemplars.
+
+Spatial prediction: In this work, we focus on the class of CNNs designed to make predictions at each image pixel. Many problems in computer vision can be cast in this framework, e.g., semantic segmentation, depth estimation, image synthesis, and image translation. We explore a simple hypothesis for explaining the behavior of such networks: they operate by cutting-and-pasting image patches found in training data. Consider the top row of Fig. 1, where we visualize the output of Isola et al. (2016)’s translation network trained to synthesize images of building facades from label masks. Why does the network generate the strange diagonal gray edge at the top? To answer this question, we visualize image pixels extracted from the closest-matching nearest-neighbor (NN) patches found in the training data. Remarkably, NN-synthesis looks quite similar to the CNN output, providing a clear explanation for the synthesized corner artifact.
+
+![](images/3068de974981f909e4dbd8e7e2ab4168f3e7f7946c8802c8d041f6e90ffc8e33.jpg)  
+Figure 1: We propose a non-parametric method to explain and modify the behavior of convolutional Figure 1: We propose a non-parametric method to explain and modifyrametric method to explain and modify the behavior of convolutionalnetworks, including those that classify pixels and those that generate images. For example, given the label mask on the top, why does a network generate strange gray border artifacts? Given the cluding those that classify pixels and those that generate images. Forluding those that classify pixels and those that generate images. For enetworks, including those that classify pixels and those that generate classify pixels and those that generate images. For example, givenimage on the bottom, how is a network able to segment out the left-most telephone pole in shadow? ask on the top, why does a network generate strange gray border artifk on the top, why does a network generate strange gray border artifacthe label mask on the top, why does a network generate strange grayy does a network generate strange gray border artifacts? Given theWe advocate an “explanation-by-example” approach to interpretation (Caruana et al., 1999). Next to the CNN output, we show the closest-matching training exemplar image. It appears to provide e bottom, how is a network able to segment out the barely-visible la bottom, how is a network able to segment out the barely-visible lam                       coarse explanations of such behaviors, though the quality of the output is still lacking (e.g., addixplanation-by-example” approach to interpretation (Caruana et al., 19planation-by-example” approach to interpretation (Caruana et al., 199vocate an “explanation-by-example” approach to interpretation (Carumple” approach to interpretation (Caruana et al., 1999). Next to thetional cars are hallucinated in the bottom row). One the right, we show the output obtained through CNN output, we show the closest-matching training exemplar image.est-matching training exemplar image. It appears to provide coarsea compositional nearest-neighbor operation that simply (1) matches input patches to those in the training set and (2) returns the corresponding output label. This means that the output is created by s of such behaviors, though the quality of the output is still lacking (e.g.of such behaviors, though the quality of the output is still lacking (e.g.,                        cutting-and-pasting (composing) patches of training images. To ensure that inconsistent patches are ated in the bottom row). One the right, we show the output obtainedted in the bottom row). One the right, we show the output obtained tare hallucinated in the bottom row). One the right, we show the outrow). One the right, we show the output obtained through a com-not composed together, one needs to match patches using an embedding that captures both global semantics (e.g., architectural styles) and local structure (e.g., windows versus doors). We demonearest-neighbor operation that simply (1) matches input patches to thoarest-neighbor operation that simply (1) matches input patches to those                   strate that local convolutional neighborhoods of feature activations produce such rich embedding. eturns the corresponding output label. This means that the output is crturns the corresponding output label. This means that the output is creaset and (2) returns the corresponding output label. This means that thending output label. This means that the output is created by cutting-Such a perspective allows one to explain errors and modify the biases of a network by changing the and-pasting (composing) patches of thes of training images. To ensure thatset of image patches used for non-parametric matching.
+
+., architectural styles) and local structure (e.g., windows versus doors). architectural styles) and local structure (e.g., windows versus doors). Wmantics (e.g., architectural styles) and local structure (e.g., windows ves) and local structure (e.g., windows versus doors). We demonstrateCompositional nearest-neighbors: Our central thesis is consistent with recent work on network that local convolutional neighborhoods of feature activations produceorhoods of feature activations produce such rich embedding. Such amemorization (Zhang et al., 2016), but notably, naive memorization fails to explain how and why perspective allows one to explain errors and modify the biases of a neain errors and modify the biases of a network by changing the set ofnetworks generalize to never-before-seen data. We explain the latter through composition: the synallows one to explain errors and modify the biases of a network by challows one to explain errors and modify the biases of a network by chan                         thesized output in Fig. 1 consists of image patches copied from different training images. Given a es useds used foimagerametricdatabase of $N$ r non-parametrnon-parametricatches used foratching. [Devtraining images with $K$ matching. [Deva: Can you switcmatching. [Deva: Can you switchon-parametric matching. [Deva: Ca Can you switch the order of compixels each, global nearest-neighbors can produce $N$ the ore orde you s nnpossible and global nn, like teaser-deva.pdf?]a.pdf?]output images. On the other hand, compositional nearest-neighbors can produce $( N K ) ^ { K }$ outputs, nn, like teaser-deva.pdf?]n, like teaser-deva.pdf?]an exponentially larger set of outputs. Each output image can be obtained by independently matching each of the $K$ patches in the input query to one of $N K$ patches in the training set. However, many of these outputs may be unrealistic. For example, one should not synthesize a facade by composing a door above a window. To ensure global consistency, one needs to match patches using a carefully-tuned metric that captures such global knowledge. But where do we obtain such a metric?
+
+Patch embeddings: Much past work has demonstrated that intermediate feature activations of a nal nearest-neighbors: Our central thesis is consistent with recent wal nearest-neighbors: Our central thesis is consistent with recent woCompositional nearest-neighbors: Our central thesis is consistent bors: Our central thesis is consistent with recent work on networkneural network can be interpreted as global embeddings for comparing entire images. For exammemorization (Zhang et al., 2016), but notably, naive memorization f016), but notably, naive memorization fails to explain how and whyple, Sharif Razavian et al. (2014); Devlin et al. (2015) show that the penultimate (“FC7”) layer of n (Zhang et al., 2016), but notably, naive memorization fails to expla (Zhang et al., 2016), but notably, naive memorization fails to explainimage classification networks learn embeddings of images that produce remarkably accurate nearestneralize to never-before-seen data. We explain the latter through comperalize to never-before-seen data. We explain the latter through compos                  neighbors. We apply this observation to spatial prediction networks in order to learn local embeddings of image patches or even pixels. These embeddings are quite rich in that they encode semantic knowledge that is both local (geometric structures centered at the pixel) and global (e.g., color and architectural style of the entire facade).
+
+Correspondence and bias: Beyond being a mechanism for interpretation, we demonstrate that compositional NN matching is a viable algorithm that may approach the accuracy of highly-tuned CNNs. Although slower than a feed-forward net, compositional matching is attractive in two respects: (1) It provides spatial correspondences between pixels in the predicted output and pixels in the training set. Spatial correspondences may be useful in practical applications such as label transfer (Liu et al., 2011). (2) Implicit biases of the network can be explicitly manipulated by changing the set of images used for matching – it need not be the same set used for training the network. As an illustrative example, we can force a pre-trained image generation network to predict European or American building facades by restricting the set of images used for matching. Such a manipulation may, for example, be used to modify a biased face recognition network to process genders and races in a more egalitarian fashion.
+
+Contribution: We introduce a Compositional Nearest Neighbors pipeline for interpreting and modifying the behavior of Convolutional Neural Networks. Specifically, we demonstrate that CNNs appear to work by memorizing image patches from training data, and then composing them into new configurations. To make compositional matching viable, CNNs learn a local embedding of image patches that captures both global and local semantics. An accurate local embedding is crucial in order to efficiently process an exponentially-large set of potential outputs. We validate our hypothesis on state-of-the-art networks for image translation and semantic image segmentation. Finally, we also show evidence that compositional matching can be used to predict activations of internal layers, generate spatial correspondences, and manipulate the implicitly-learned biases of a network.
+
+# 2 RELATED WORK
+
+We broadly classify networks for spatial prediction into two categories: (1) discriminative prediction, where one is seeking to infer high-level semantic information from RGB values; and (2) image generation, where the intent is to synthesize a new image from a given input “prior”. There is a broad literature for each of these tasks, and here we discuss the ones most relevant to ours.
+
+Discriminative models: An influential formulation for state-of-the-art spatial prediction tasks is that of fully convolutional networks (Long et al., 2015). These have been used for pixel prediction problems such as semantic segmentation (Long et al., 2015; Hariharan et al., 2015; Ronneberger et al., 2015; Bansal et al., 2017a; Chen et al., 2016), depth/surface-normal estimation (Bansal et al., 2016; Eigen & Fergus, 2015), or low-level edge detection (Xie & Tu, 2015; Bansal et al., 2017a). Substantial progress has been made to improve the performance by employing deeper architectures (He et al., 2015), or increasing the capacity of the models (Bansal et al., 2017a), or utilizing skip connections, or intermediate supervision (Xie & Tu, 2015). However, we do not precisely know what these models are actually capturing to do pixel-level prediction. In the race for better performance, the interpretability of these models has been typically ignored. In this work, we focus on interpreting encoder-decoder architectures for spatial classification (Ronneberger et al., 2015; Badrinarayanan et al., 2017).
+
+Image generation: Goodfellow et al. (2014) proposed a two-player min-max formulation where a generator $G$ synthesized an image from random noise $z$ , and a discriminator $( D )$ is used to distinguish the generated images from the real images. While this Generative Adversarial Network (GAN) formulation was originally proposed to synthesize an image from random noise vectors $z$ , this formulation could also be used to synthesize new images from other priors, such as, a low resolution image or label mask by treating $z$ as an explicit input to be conditioned upon. This conditional image synthesis via generative adversarial formulation has been well utilized by multiple follow-up works to synthesize a new image conditioned on a low-resolution image (Denton et al., 2015), class labels (Radford et al., 2015), and other inputs (Isola et al., 2016; Zhu et al., 2017). While the quality of synthesis from different inputs has rapidly improved in recent history, interpretation of GANs has been relatively unexplored. In this work, we examine the influential Pix2Pix network Isola et al. (2016) and demonstrate an intuitive non-parametric representation for explaining its impressive results.
+
+Interpretability: There is a substantial body of work (Zeiler & Fergus, 2014; Mahendran & Vedaldi, 2015; Zhou et al., 2014; Bau et al., 2017) on interpreting general convolutional neural networks (CNNs). The earlier work of Zeiler & Fergus (2014) presented an approach to understand and visualize the functioning of intermediate layers of CNN. Mahendran & Vedaldi (2015) proposed to invert deep features to visualize what is learned by CNNs, similar to inverting HOG features to understand object detection (Vondrick et al., 2013). Zhou et al. (2014) demonstrated that object detectors automatically pop up while learning the representation for scene categories. Krishnan & Ramanan (2016) explored interactive modification of a pre-trained network to learn novel concepts, and recently Bau et al. (2017) proposed to quantify interpretability by measuring scene semantics such as objects, parts, texture, material etc. Despite this, understanding the space of pixel-level CNNs is not well studied. The recent work of PixelNN (Bansal et al., 2017b) focuses on highquality image synthesis by making use of a two-stage matching process that begins by feed-forward CNN processing and ends with a nonparametric matching of high-frequency detail. We differ in our focus on interpretability rather than image synthesis, our examination of networks for both discriminative classification and image synthesis, and our simpler single-stage matching process that does not require feed-forward processing.
+
+Compositionality: The design of part-based models (Crandall et al., 2005; Felzenszwalb et al., 2008), pictorial structures or spring-like connections (Fischler & Elschlager, 1973; Felzenszwalb & Huttenlocher, 2005), star-constellation models (Weber et al., 2000; Fergus et al., 2003), and the recent works using CNNs share a common theme of compositionality. While the earlier works explicitly enforce the idea of composing different parts for object recognition in the algorithmic formulation, there have been suggestions that CNNs also take a compositional approach (Zeiler & Fergus, 2014; Krishnan & Ramanan, 2016; Bau et al., 2017). We see compositional embeddings as rather different than compositional objects/parts. Using (Hinton, 1986)’s terminology, embeddings can be viewed as “distributed representations”, while objects/parts can be viewed as “sparse representations”. Much past work has argued that distributed representations are central to the success of deep networks (LeCun et al., 2015). We agree and posit that this is one reason why CNNs outperform classic hierarchical models of parts/objects. Specifically, Girshick et al. (2015) point out that classic part models can be implemented as CNNs with sparse activations, where individual neurons correspond to individual part responses. In practice, many neurons are not interpretable when examined individually, as pointed out by Zhou et al. (2014). An embedding perspective offers one solution that does not require individual dimensions to be meaningful - e.g., nearest neighbors in an embedding will not change if one applies a well-behaved linear transformation (e.g., rotation) to the embedding space. This is consistent with past work (Szegedy et al., 2013) that suggests that that linear combinations of activations are equally as informative as the original activations. Finally, if high-level activations represent objects, how can 4K activations (e.g., the typical dimension of FC7) represent $3 0 \mathrm { K } +$ objects (Biederman, 1987)? Our central thesis is that activations do not correspond to individual objects/parts, but rather the dimensions of a local embedding space in which objects/parts are points (matchable with nearest-neighbors).
+
+# 3 COMPOSITIONAL NEAREST NEIGHBORS
+
+We now introduce our method to interpret various fully convolutional networks designed for pixellevel tasks.
+
+Global nearest-neighbors: Our starting point is the observation that classification networks can be interpreted as linear classifiers defined on nonlinear features extracted from the penultimate layer (e.g., “FC7” features) of the network. We formalize this perspective with the following notation:
+
+$$
+\operatorname { L a b e l } ( x ) = k ^ { * } \quad { \mathrm { w h e r e } } \quad k ^ { * } = { \underset { k \in \{ 1 \ldots K \} } { \operatorname { a r g m a x } } } \ w _ { k } \cdot \phi ( x ) , \qquad [ \operatorname { K - w a y } \ { \mathrm { c l a s s i f i c a t i o n } } ]
+$$
+
+where $\boldsymbol { \phi } ( \boldsymbol { x } ) \in \mathbb { R } ^ { N }$ corresponds to the penultimate FC7 features computed from input image $x$ . Typically, the parameters of the linear classifier $\{ w _ { y } \}$ and those of the feature encoder $\phi ( \cdot )$ are trained on large-scale supervised datasets:
+
+$$
+\mathcal { D } = \{ ( x _ { n } , y _ { n } ) \} . \quad [ \mathrm { T r a i n i n g ~ d a t a b a s e } ]
+$$
+
+Devlin et al. (2015) make the observation that penultimate features $\phi ( x )$ can be interpreted as an embedding in $\mathbb { R } ^ { N }$ . By extracting such embeddings for training images $x _ { n }$ , Devlin et al. (2015) build
+
+![](images/086b38ab71ff270080fe87eb0eb7bf231b3635e2466888a05e7e6ce45710b947.jpg)  
+Figure 2: Overview of pipeline: Given an input label or image (top-left of each box), our approach extracts an embedding for each pixel. We visualize two pixels with a yellow and white dot. The embedding captures both local and global context, which are crudely visualized with the surrounding rectangular box. We then find the closest matching patches in the training set (with a nearest neighbor search), and then report back the corresponding pixel labels to generate the final output (bottom-left of each box). We visualize an example for label-to-image synthesis on the left, and image-to-label prediction on the right.
+
+a nonparametric nearest-neighbor (NN) predictor for complex tasks such as image captioning. We write this as follows:
+
+$$
+\operatorname { L a b e l } ( x ) = y _ { n ^ { * } } \quad { \mathrm { w h e r e } } \quad n ^ { * } = \operatorname { a r g m i n } _ { n } \operatorname { D i s t } \Bigl ( \phi ( x ) , \phi ( x _ { n } ) \Bigr ) . \qquad [ \operatorname { G l o b a l } \operatorname { N I }
+$$
+
+Importantly, the above NN classifier performs quite well even when feature encoders $\phi ( \cdot )$ are trained for classification rather than as an explicit embedding. In some sense, deep nets seem to implicitly learn embeddings upon which simple linear classifiers (or regressors) operate. We argue that such a NN perspective is useful in interpreting the predicted classification since the corresponding training example can be seen as a visual “explanation” of the prediction - e.g., the predicted label for $x$ is “dog” because $x$ looks similar to training image $x _ { n * }$ .
+
+Pixel nearest-neighbors: We now extend the above observation to pixel-prediction networks that return back a prediction for each pixel $i$ in an image:
+
+$$
+\operatorname { L a b e l } _ { i } ( x ) = k ^ { * } \quad { \mathrm { w h e r e } } \quad k ^ { * } = \operatorname { a r g m a x } _ { k \in \{ 1 . . . K \} } w _ { k } \cdot \phi _ { i } ( x ) . \qquad [ \operatorname { K - w a y } \operatorname { p i x e l } \operatorname { c l a s s i f i c a t i o n } ]
+$$
+
+We write $\mathrm { L a b e l } _ { i } ( \cdot )$ for the label of the $i ^ { t h }$ pixel and $\phi _ { i } ( \cdot )$ for its corresponding feature vector. Because we will also examine pixel-level prediction networks trained to output a continuous value, we write out the following formulation for pixel-level regression:
+
+$$
+\mathrm { P r e d i c t } _ { i } ( x ) = W \phi _ { i } ( x ) \quad \mathrm { w h e r e } \quad W \in \mathbb { R } ^ { M \times N } . \qquad [ \mathrm { P i x e l ~ r e g r e s s i o n } ]
+$$
+
+For concreteness, consider a Pix2Pix (Isola et al., 2016) network trained to regress RGB values at each pixel location. These predictions are obtained by convolving features from the penultimate layer with filters of size $4 \times 4 \times 1 2 8$ . In this case, the three filters that generate R,G, and B values can be written as a matrix $W$ of size $M \times N$ , where $M = 3$ and $N = 4 * 4 * 1 2 8 = 2 0 4 8$ . Analogously, $\phi _ { i } ( x )$ corresponds to $N$ dimensional features extracted by reshaping local $4 \times 4$ convolutional neighborhoods of features from the penultimate feature map (of size $H \times W \times 1 2 8$ ). We now can perform nearest-neighbor regression to output pixel values:
+
+$$
+\mathsf { r e d i c t } _ { i } ( x ) = y _ { n ^ { * } , m ^ { * } } \quad \mathrm { w h e r e } \quad ( n ^ { * } , m ^ { * } ) = \underset { n , m } { \mathrm { a r g m i n } } \mathrm { D i s t } \Big ( \phi _ { i } ( x ) , \phi _ { m } ( x _ { n } ) \Big ) , \qquad [ \mathrm { C o m p ~ N N ~ P i x e l s ~ o f ~ \phi _ { i } ( x ) ~ , }
+$$
+
+where $y _ { n ^ { * } , m ^ { * } }$ refers to the $m ^ { t h }$ pixel from the $n ^ { t h }$ training image. Importantly, pixel-level nearest neighbors reveals spatial correspondences for each output pixel. We demonstrate that these can be used to provide an intuitive explanation of pixel outputs, including an explanation of errors that otherwise seem quite mysterious (see Fig.1 and Fig. 2).
+
+Distance function: We explored different distance functions such as Euclidean and cosine distance. Similar to past work (Devlin et al., 2015), we found that cosine distance consistently performed slightly better, so we use that in all of our experiments.
+
+![](images/10f6fef70cbf81fb141b8eeff16ec182f7dc49ff393ea7106efecb1bb82dc1ca.jpg)  
+Figure 3: We visualize a non-parametric approach to computing activations from internal layers. By matching to a training database of $\mathop { d e c o d e r _ { 4 } }$ features from Pix2Pix, we can compute activations for the next layer (decoder3) with nearest-neighbors. Each image represents a feature map of 3 continuous channels visualized in the R,G, and B planes. The collective set of 4 images displays 12 out of the 256 channels in decoder3. Global nearest-neighbors (i.e., matching to the training image with the most similar $\mathop { d e c o d e r _ { 4 } }$ layer and returning its associated decoder3 layer) produces poor matches, but compositional-pasting matches together from different exemplars produce activations that are nearly identical to those computed by the underlying CNN.
+
+Convolutional embeddings: We now extend our compositional nearest-neighbor formulation to internal convolutional layers. Recall that activations $a$ at a spatial position $i$ and layer $j$ can be computed using thresholded linear functions of features (activations) from the previous layer:
+
+$$
+a _ { i j } ( x ) = \operatorname* { m a x } { \Bigl ( } 0 , W \phi _ { i j } ( x ) { \Bigr ) } , \qquad \mathrm { w h e r e } \quad a _ { i j } \in \mathbb { R } ^ { M } , \phi _ { i j } \in \mathbb { R } ^ { N } , W \in \mathbb { R } ^ { M \times N }
+$$
+
+where we write $a _ { i j }$ for the vector of activations corresponding to the $i ^ { t h }$ pixel position from layer $j$ , possibly computed with bilinear interpolation (Long et al., 2015). We write $\phi _ { i j }$ for the local convolutional neighborhood of features (activations) from the previous layer that are linearly combined with bank of linear filters $W$ to produce $a _ { i j }$ . For concreteness, let the previous layer be decoder4 from Pix2Pix, and the current layer be decoder3. We can then write, $a _ { i j } \in R ^ { M }$ where $M = 2 5 6$ and $\phi _ { i j } \in R ^ { N }$ where $N = 4 * 4 * 5 1 2 = 8 1 9 2$ . We similarly posit that one can produce approximate activations by nearest neighbors. Specifically, let us run Pix2Pix on the set of training images, and construct a dataset of training patches with features $\phi _ { i j } ( x _ { n } )$ as data and corresponding activation vectors $a _ { i j } ( x _ { n } )$ as labels. We can then predict activation maps for a query image $x$ with NN:
+
+$$
+a _ { i j } ( x ) = a _ { m ^ { * } , j } ( x _ { n ^ { * } } ) \quad { \mathrm { w h e r e } } \quad ( m ^ { * } , n ^ { * } ) = \underset { m , n } { \mathrm { a r g m i n } } \ : \mathrm { D i s t } \Bigl ( \phi _ { i j } ( x ) , \phi _ { m j } ( x _ { n } ) \Bigr ) .
+$$
+
+Notably, this is done without requiring explicit access to the filters $W$ . Rather such responses are implicitly encoded in the training dataset of patches and activation labels. We show that such an approach actually produces reasonable activations (Fig. 3).
+
+Patch nearest-neighbors: The previous paragraph demonstrated that composing image patches using embeddings from interior layers could “explain” the behavior of the subsequent layer. We now ask a more ambitious question - could such a procedure “explain” the behavior of all subsequent layers? That is, could it produce output predictions that mimic the behavior of the entire network? To do so, we regress the final-layer pixel value from each stored patch:
+
+$$
+{ \mathrm { P r e d i c t } } _ { i j } ( x ) = y _ { n ^ { * } , m ^ { * } } \quad { \mathrm { w h e r e } } \quad ( n ^ { * } , m ^ { * } ) = { \underset { n , m } { \mathrm { a r g m i n } } } { \mathrm { D i s t } } \Bigl ( \phi _ { i j } ( x ) , \phi _ { m j } ( x _ { n } ) \Bigr ) .
+$$
+
+[Comp NN Patches]
+
+As written, the above procedure is inefficient because features are interpolated (to pixel resolution) before they are matched to the patch database. Instead, it is natural to match features at their native resolution, and then interpolate the matches. This results in significant speed ups. For example, the bottleneck layer has an activation map of size $1 \times 1 \times 5 1 2$ . Matching to bottleneck features in the re y refers to pixels of set S (m⇤) from the nth training image.training set is quite fast because it acts as a compact global descriptor for matching entire images. j   The downside is that the matches are not compositional. By matching to convolutional embeddings rse-to-fine nearest-neighbor search: An important special case is the bottleneck feature, whichextracted from later layers, one can compute progressively more compositional matches, that are omputed from an activation map of size 1 ⇥ 1 ⇥ 512. In this case, we posit that the corresponding512initially global, then patch-based, and finally pixel-based (see Fig. 4). In our experiments, we found ure ij (x) 2 R is a good global descriptor of image x. In our experiments, we found thatthat such patch embeddings could be used to prune the NN pixel search, significantly speeding up run-time performance (e.g., we first prune the training database to a shortlist of images with similar bottleneck features, and then search through these images for similar patches, and then search through those patches for similar pixels).
+
+![](images/0c1372504d35f1c2317feb5577039d1e3798a26a4860ffdf287db12a4dec58b1.jpg)  
+Comp-NN in different embedding space: [Deva: Add the input label image on theFigure 4: Adding composition by matching to later layers: We apply compositional nearestneighbor matching to features extracted from different layers, starting with the bottleneck layer 6  2     and progressing to the penultimate deconv2 layer. We match local neighborhoods of convolutional embeddings, which naturally allows for more composition as we use later laters.
+
+![](images/2f69f8c3f1a1c1a94d612af578ad3b9b81228e2ebe646b107d6af265738d00e4.jpg)  
+ixels to apply a linear projection. For correctness, considering feature positions i in decoder4Figure 5: Original labels v.s. self-supervised labels: Given the label input on the left, we show reh a shape of 32 ⇤ 32 ⇤ 256, we can rewrite i as (x, y) where x = i/32, y = i%32. Thus, eachsults of Pix2Pix in the Convolutional Neural Networks column, and non-parametric matching to the ure is corresponding to a 8 ⇤ 8 image patch on final output with a shape of 256 ⇤ 256 ⇤ 3. Hence,training set using the original labels and the predicted “self-supervised” labels of the Pix2Pix netj      ⇤    ⇤  ⇤    ⇤work. Generating images with the predicted labels looks smoother, though the qualitative behavior ...3]. Thus, one can generate output results by constructing a dataset of training patches withof the network is still explained by the original training labels. We quantify this in our experimental ij n     n,Sj (i)         results, and include additional qualitative visualizations of the original and self-supervised labels in Figs. 13 and 14.
+
+Bias modification: Finally, our results suggest that the matching database from Eq.(2) serves as mory by changing the dataset of training images x , labels y , or both. We experimentan explicit “associative memory” of a network (Carpenter, 1989). We can explicitly modify the various modifications in our experimental results. Onememory by changing the dataset of training images $\ { \bar { \{ \{ x } }   _ { n } \}$ cation th, labels $\left\{ y _ { n } \right\}$ sistently produced, or both. We experiment other visual results was to refine the training labels to those predicted by a network:with various modifications in our experimental results. One modification that consistently produced     smoother visual results was to refine the training labels to those predicted by a network:
+
+$$
+\{ \left( x _ { n } , y _ { n } \right) \} \Rightarrow \{ \left( x _ { n } , C N N ( x _ { n } ) \right) \} .
+$$
+
+Such as procedure for “self-supervised” learning is sometimes used when training labels are known to be noisy. From an associative network perspective, we posit that such labels capture a more 7faithful representation of a network’s internal memory. Unless otherwise specified, all results make use of the above matching database. We visualize the impact of self-supervised labels in Fig. 5.
+
+![](images/68dc94203828b1287562ac58c3ff7116df6b24f7b97e1ec0388f4d5d1ec6db6d.jpg)  
+Figure 6: Reconstruction: We can use our nonparametric matching framework to generate reconstructions by replacing the exemplar target label $y _ { n }$ with the exemplar input image $x _ { n }$ . This can be done for both image generation and discrete label prediction. We find that, perhaps surprisingly, pixel embeddings contain enough local information to reconstruct the input pixel. We show additional results in Fig. 10.
+
+Reconstruction: We found that replacing the label $y _ { n }$ with the input image $x _ { n }$ is a helpful diagnostic for visualization. This illustrates the ability of the learned embedding and compositional matching framework to reconstruct the input query. The reconstructed input for a global NN match is simply the best-matching exemplar input image (see Fig. 6). We find that, perhaps surprisingly, pixel embeddings contain enough local information to reconstruct the input pixel. We show additional results in our experimental results.
+
+$$
+\left\{ \left( x _ { n } , y _ { n } \right) \right\} \Rightarrow \left\{ \left( x _ { n } , x _ { n } \right) \right\} \quad { \mathrm { [ R e c o n s t r u c t i o n ] } }
+$$
+
+# 3.1 SUFFICIENT STATISTICS FOR PIXEL-LEVEL TASKS
+
+We now discuss information-theoretic properties of the introduced nearest-neighbor embedding $\phi _ { i } ( \cdot )$ presented in Sec. 3. Specifically, we show that this embedding produces sufficient statistics (Tishby & Zaslavsky, 2015; Shwartz-Ziv & Tishby, 2017; Achille & Soatto, 2017) for various pixel level tasks.
+
+Global embeddings: We begin with the simpler case of predicting a global class label $y$ from an image $x$ . If we assume that the input image $x$ , global feature embedding $\phi ( x )$ , and output label $y$ form a Markov chain $x \to \phi ( x ) \to y$ , we can write the following:
+
+$$
+p ( y ~ | ~ \phi ( x ) , ~ x ) = p ( y ~ | ~ \phi ( x ) ) . \qquad [ \mathrm { S u f f i c i e n c y } ]
+$$
+
+As Achille & Soatto (2017) show, standard loss functions in deep learning (such as cross-entropy) search for an embedding that minimizes the entropy of the label $y$ given the representation $\phi ( x )$ . This observation explicitly shows that the embedding $\phi ( x )$ is trained to serve as a sufficient representation of the data $x$ that is rich enough in information to predict the label $y$ . In particular, if the learned embedding satisfies the above Markov assumption, the prediction $y$ will not improve even when given access to the raw data $x$ .
+
+Pixel-wise embeddings: Spatial networks predict a set of pixel-wise labels $\{ y _ { i } \}$ given an input image. If we assume that the pixel-wise labels are conditionally independent given $\{ \phi _ { i } ( x ) \}$ and $x$ , then we can write the joint posterior distribution over labels with the following product:
+
+$$
+\begin{array} { l l } { { p ( \{ y _ { i } \} \mid \phi ( x ) , x ) = \displaystyle { \prod _ { i } p ( y _ { i } \mid \phi ( x ) , x ) } } } & { { \quad \scriptstyle { [ \mathrm { C o n d i t i o n a l ~ S p a t i a l ~ I n d e p e n d e n c e } ] } } } \\ { { \displaystyle { \phantom { \sum _ { i } p ( y _ { i } \mid \phi ( x ) , x ) } } } } & { { \quad \scriptstyle { [ \mathrm { S u f f i c i e n c y } ] } } } \end{array}
+$$
+
+where $\phi _ { i } ( x )$ are the sufficient statistics needed to predict label $y _ { i }$ , and $\phi ( x ) ~ = ~ \{ \phi _ { i } ( x ) \}$ is the aggregate set of these sufficient statistics. One can similarly show that pixel-wise cross-entropy losses jointly minimize the entropy of the labels $y _ { i }$ given $\phi _ { i } ( x )$ . This suggests that pixel-wise features $\phi _ { i } ( x )$ do serve as a remarkably rich characterization of the image. This characterization includes both global properties (e.g., the color of a building facade being synthesized) as well as local properties (e.g., the presence of a particular window ledge being synthesized). Importantly, this requires the conditional independence assumption from Eq. (11) to be conditioned on the entire image $x$ rather than just the local pixel value $x _ { i }$ (from which it would be hard to extract global properties).
+
+An interesting observation from the factorization shown in Eq. (12) is that we can synthesize an image by predicting pixel values independently. Thus, this theoretical observation suggests that a simple nearest-neighbor regression for every output pixel can synthesize plausible images.
+
+Multi-layered representations: The above pixel-wise formulation also suggests that internal feature layers serve as sufficient representations to predict activations for subsequent layers. Interestingly, skip connections that directly connect lower layers to higher layers break the Markov independence assumption. In other words, skip connections suggest that higher layer features often do not serve as sufficient representations, in that subsequent predictions improve when given access to earlier layers. However, Eq.(12) technically still holds so long as we write $\phi _ { i } ( x )$ for the concatenated representation including lower-level features. For example, in Pix2Pix, we write $\phi _ { i } ( x ) \in \mathbb { R } ^ { N }$ where $N = 4 * 4 * ( 6 4 + 6 4 ) = 2 0 4 8$ , where the second set of 64 channel features are copied from the first encoder layer. In the next Section, we show qualitative and quantitative experiments supporting this analysis.
+
+Prior work on embeddings: Now that our framework has been described both algorithmically and theoretically, we compare it to a large body of related work. The idea that intermediate CNN layers learn embeddings is not new. This dates back at least to Caruana et al. (1999), and was popularized in recent history with (Sharif Razavian et al., 2014; Devlin et al., 2015). Indeed, much contemporary work makes use of “off-the-shelf” CNN layers as features, where earlier layers tend to encode more generic feature representations (Zeiler & Fergus, 2013). However, such representations are typically global and refer to the entire image. Alternatively, one can extract local pixel-based feature representations, but these are typically defined by $1 x 1$ slices of a convolutional feature map (Hariharan et al., 2015; Long et al., 2014). Our theoretical analysis, while quite straightforward, shows that the optimal local representation (in terms of sufficiency) is given by a convolutional neighborhood of overlapping activations. Finally, we show that compositional matching with such local embeddings significantly outperforms global matching (see Fig. 3), and rivals the accuracy of feedforward CNN predictions (Table 1).
+
+# 4 EXPERIMENTS
+
+We now present experimental results for discriminative networks trained for semantic segmentation, as well as generative networks trained for image synthesis. The goal of the experiments is to show that images generated with a simple NN regression are a good way to interpret the internal operations of a convolutional neural network.
+
+Networks: We use SegNet (Badrinarayanan et al., 2017), a recent state-of-the-art network for image segmentation, and Pix2Pix (Isola et al., 2016), a state-of-the-art network for conditional image synthesis and translation. We evaluate our findings for multiple datasets and tasks on which the original networks were trained. These include tasks such as synthesizing facades from architectural labels and vice versa, predicting segmentation class labels from urban RGB images, and synthesizing Google maps from aerial or satellite views.
+
+Semantic segmentation: We use the CityScape (Cordts et al., 2016) and CamVid (Brostow et al., 2008; 2009) datasets for the task of semantic segmentation. Both datasets are annotated with semantic class labels for outdoor images collected from a car driving on the road. We use SegNet (Badrinarayanan et al., 2017) for CamVid sequences, and Pix2Pix (Isola et al., 2016) for the CityScape dataset. Figure 7 shows qualitatively results for these datasets. We can observe in Figure 7 that the compositional NN produces a nearly-identical result (CompNN column) to the one produced by the network (Pix2Pix and SegNet columns). This suggests that our method enables a good interpretation of discriminative deep networks on pixel-level classification.
+
+![](images/e460edc990296b1f2b28a4c77e96e98f0530f4aca69e53025c155769f3c66238.jpg)  
+Figure 7: Semantic segmentation: The results of semantic segmentation on cityscape and CamVid dataset. This result suggests the following observations. First, the difference between images generated by generative networks (Pix2Pix and SegNet columns) and NN embedding (CompNN column) is surprisingly small. Thus, our method can perfectly interpret discriminative deep networks on pixel-level classification. Second, we can notice some noise edges with a high gradient (see columns 5-8). This phenomenon can also be used to understand the difficulty of image segmentation task: borders with high gradients are usually hard to classify due to the ambiguous patches in training set.
+
+![](images/04b1d2bfaa03d00629870b27eade55e7537d0fba1b1daa89447ffe463c4800b4.jpg)  
+Figure 8: Image synthesis: The results suggest that Comp NN (our approach) can also explain the results from $\mathrm { P i x 2 P i x }$ . We conclude this because our approach reproduces color and the structure of the Pix2Pix output, including a few artifacts (e.g., the image cuts in the 6th and 7th columns).
+
+Architectural labels-to-facades: We followed Isola et al. (2016) for this setting and used the annotations from (Tylecek & ˇ Sˇ ara, 2013). There are 400 training images in this dataset, and 100 images ´ in the validation set. We use the same dataset to generate architectural labels from images of facades. Pix2Pix (Isola et al., 2016) models are trained using 400 images from the training set for both labels-to-facades and vice versa. Figure 8 shows qualitative examples of synthesizing real-world images using pixel-wise nearest neighbor embedding in its first and second rows. We observe that the NN-embedding perfectly explains the generation of deformed edges (see CompNN column), and how the generative architecture is eventually memorizing patches from the training set.
+
+Satellite-to-maps: This dataset contains 1096 training images and 1000 testing images scraped from Google Maps. We use the same settings used by Isola et al. (2016) for this task. Figure 8 qualitatively shows in its third row how Google maps are synthesized from satellite images. We can observe that our synthesis (CompNN column) is nearly identical to the image generated by the network (Pix2Pix columns).
+
+![](images/958bb1fb75d50205cb552e76a02cd06ad915669a35f5392c7ed5f97eb977e62f.jpg)  
+Figure 9: Bias modification: Given the same label input, we show different results obtained by matching to different databases (using an embedding learned by Pix2Pix). By modifying the database to include specific buildings from specific locations, one can introduce and remove implicit biases in the original network (e.g.,one can generate “European” facades versus “American” facades).
+
+Bias modification: Figure 9 shows that the output of nonparametric matching (3rd - 6th columns from left to right) can be controlled through explicit modification of the matching database. In simple words, this experiment shows that we can control properties of the synthesized image by simply specifying the exemplars in the database. We can observe in Figure 9 that the synthesized images preserve the structure (e.g., windows, doors, and roof), since it is the conditional input, but the textural components (e.g., color) change given different databases.
+
+Reconstruction: This experiment shows that the learned embeddings of a CNN also enables the reconstruction of the input images in a compositional fashion (as discussed in Sec. 3). The results of this experiment are shown in Fig. 10. The Figure has the following organization. In the middle columns (enclosed in a box), the Figure shows the input and output images. The first two columns (from left-to-right) show the reconstructions of the input images using a global nearest-neighbors and the proposed compositional nearest-neighbors approach. The last two columns show the reconstruction of the output images, also using a global nearest-neighbors and the proposed compositional nearest-neighbors approach. We can observe that the reconstructions of the input images using the global nearest-neighbors approach overall resembles the structure of the scene. However, the reconstructions of the input images using the proposed compositional nearest-neighbors reproduce the input scene with a remarkable accuracy. These results suggest that the learned embedding is rich in global and local information to either reconstruct both the input and output images. We can conclude then that CNNs understand an input image by finding the patches from the training images that enable the composition of an image reproducing the input. To the best of our knowledge, this is the first approach that reconstructs an input image using training instances using a learned pixel-embedding.
+
+Correspondence map: Figure 11 shows a correspondence map that explicitly illustrates how an output image is synthesized by cutting-and-pasting patches from training images. We can observe that patches are selected from many different styles of facades, but in such a manner that ensures that the composed output is globally consistent while maintaining the appropriate local structures (such as windows, doors, awnings, etc.). This implies the learned patch embedding captures both global semantics and local structure.
+
+Quantitative evaluation: We present the quantitative analysis of our pixel-wise nearest neighbor approach with an end-to-end pipeline in Table 1. We report classification accuracy of ground truth labels and mean intersection-over-union (IoU) compared to the predicted labels for the task of semantic segmentation. We can observe in Table 1 that compositional matching approaches the accuracy of the baseline CNN, and dramatically outperforms global matching (sometimes by a factor of 2X). Finally, self-supervised labels (SS) overall perform similarly to the original labels (O), but almost consistently help for compositional matching and consistently hurt for global matching. We posit that this is due to the fact that self-supervised labels tend to be overly-smoothed, and so act as a form of spatial regularization that helps compositional matching.
+
+![](images/b3e6b0fa986c001e0a672b33f13b53d50b97ad7caf1f7aa860efd8e51c8424ba.jpg)  
+Figure 10: Reconstruction: Given the correspondences of NN features from penultimate the layer, we reconstruct the test input images (third column from left-to-right) by using the compositional nearest-neighbor approach: copying and pasting corresponding image patches from the input images of the training set. The reconstructions using a compositional nearest-neighbor approach is shown in the second column, while the reconstructions using a global nearest-neighbor approach is shown in the first column. The learned embedding thus enables not only the reconstruction of the input image, but also of the output image (see the last two columns). These results suggest that the embedding possess not only the information relevant to a specific task, but also semantic information from the original image. We can conclude then that CNNs understand an input image by finding the patches from the training images that enable the composition of an image reproducing the input.
+
+Implementation Details: We used U-net as the generator for Pix2Pix, and used publicly available Tensorflow code for $\operatorname { P i x } 2 \mathrm { P i x } ^ { 2 }$ and SegNet3. For a slightly faster computation, we used the Eigen Library to implement the cosine distance. For Cityscape dataset, we shortlist 100 global neighborhoods using global bottleneck features for compositional NN searching. This leads to a 30 times speedup. For CamVid dataset, we shortlist 10 global neighborhoods. We can observe in previous results that the quality of generated images is hardly affected. We used 40-threads for these experiments. The average compute time per image is 22 minutes and 13 minutes for Cityscape and CamVid dataset respectively.
+
+# 5 DISCUSSION
+
+In this paper, we have presented a simple approach based on pixel-wise nearest neighbors to understand and interpret the functioning of convolutional neural networks for spatial prediction tasks. Our analysis suggests that CNNs behave as compositional nearest neighbor operators over a training set of patch-label pairs that act as an associative memory. But beyond simply memorizing, CNNs can generalize to novel data by composing together local patches from different training instances. Also, we argued that networks for pixel-level tasks learn sufficient statistics that enable the gener
+
+![](images/997d1d9f4f2790a842b44294ac144c73b0abc51535b2e1402c12dfe5a7e304a2.jpg)  
+Figure 11: Correspondence map: Given the input label mask on the top left, we show the groundtruth image and the output of Pix2Pix below. Why does Pix2Pix synthesize the peculiar red awning from the input mask? To provide an explanation, we use CompNN to synthesize an image by explicitly cutting-and-pasting (composing) patches from training images. We color code pixels in the training images to denote correspondences. For example, CompNN copies doors from training image A (blue) and the red awning from training image C (yellow).
+
+<table><tr><td>Approach</td><td colspan="3">Facades CityScape CamVid (Mean Pixel Accuracy)</td><td colspan="3">Facades CityScape (Mean IoU)</td></tr><tr><td>Baseline CNN</td><td>0.545</td><td>0.735</td><td>0.790</td><td>0.157</td><td>0.217</td><td>0.444</td></tr><tr><td>Comp NN (SS)</td><td>0.505</td><td>0.738</td><td>0.767</td><td>0.137</td><td>0.210</td><td>0.378</td></tr><tr><td>Comp NN (O)</td><td>0.493</td><td>0.722</td><td>0.754</td><td>0.134</td><td>0.217</td><td>0.372</td></tr><tr><td>Global Bottleneck NN (SS)</td><td>0.324</td><td>0.579</td><td>0.564</td><td>0.057</td><td>0.109</td><td>0.246</td></tr><tr><td>Global Bottleneck NN (O)</td><td>0.381</td><td>0.585</td><td>0.570</td><td>0.065</td><td>0.133</td><td>0.226</td></tr><tr><td>Global Decode2 NN (SS)</td><td>0.387</td><td>0.590</td><td>0.659</td><td>0.087</td><td>0.110</td><td>0.287</td></tr><tr><td>Global Decode2 NN (O)</td><td>0.393</td><td>0.600</td><td>0.664</td><td>0.090</td><td>0.136</td><td>0.308</td></tr></table>
+
+Table 1: We compare compositional nearest neighbors (CompNN) to the baseline CNN and different global nearest neighbor approaches, obtained by matching feature maps from different layers (Global-Bottleneck and Global-Decode2). We report mean pixel accuracy and intersection-overunion, where predicted segmentation labels are compared to ground-truth labels. We specifically use the embedding learned by Isola et al. (2016) for Facades-to-Labels (Facades) and CityScape, and embedding learned by Badrinarayanan et al. (2017) for CamVid. On average, CompNN performs $5 \%$ worse than the baseline CNN, though in some cases (CityScapes) it performs equally. However, compositional matching dramatically outperforms global matching, sometimes by a factor of 2X (Facade and CityScape IoU). In terms of global matching, the last feature layer (Decode2) strictly outperforms the intermediate Bottleneck layer, but is significantly larger ( $1 2 \mathrm { { 8 ^ { 3 } } }$ versus 512 dimensions). Finally, self-supervised labels (SS) overall perform similarly to the original labels (O), but almost consistently help for compositional matching and consistently hurt for global matching. We posit that this is due to the fact that self-supervised labels tend to be overly-smoothed, and so act as a form of spatial regularization for compositional matching.
+
+ation of pixel predictions. Our analysis and experiments not only support this argument, but also enables example-based explanations of network behavior and explicit modulation of the implicit biases learned by the network. We hope that our framework enables further analysis of convolutional networks from a non-parametric perspective.
+
+# REFERENCES
+
+Agnar Aamodt and Enric Plaza. Case-based reasoning: Foundational issues, methodological variations, and system approaches. AI communications, 7(1):39–59, 1994.
+
+Alessandro Achille and Stefano Soatto. On the emergence of invariance and disentangling in deep representations. CoRR, abs/1706.01350, 2017. URL http://arxiv.org/abs/1706.01350.
+
+Vijay Badrinarayanan, Alex Kendall, and Roberto Cipolla. Segnet: A deep convolutional encoder-decoder architecture for scene segmentation. IEEE Transactions on Pattern Analysis and Machine Intelligence (TPAMI), 2017.
+
+Aayush Bansal, Bryan Russell, and Abhinav Gupta. Marr Revisited: 2D-3D model alignment via surface normal prediction. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016.
+
+Aayush Bansal, Xinlei Chen, Bryan Russell, Abhinav Gupta, and Deva Ramanan. PixelNet: Representation of the pixels, by the pixels, and for the pixels. arXiv:1702.06506, 2017a.
+
+Aayush Bansal, Yaser Sheikh, and Deva Ramanan. PixelNN: Example-based image synthesis. CoRR, abs/1708.05349, 2017b.
+
+David Bau, Bolei Zhou, Aditya Khosla, Aude Oliva, and Antonio Torralba. Network dissection: Quantifying interpretability of deep visual representations. CoRR, abs/1704.05796, 2017.
+
+I. Biederman. Recognition by components: a theory of human image interpretation. Pyschological review, 94: 115–147, 1987.
+
+Gabriel J. Brostow, Jamie Shotton, Julien Fauqueur, and Roberto Cipolla. Segmentation and recognition using structure from motion point clouds. In Proc. of the European Conference on Computer Vision (ECCV), pp. 44–57, 2008.
+
+Gabriel J Brostow, Julien Fauqueur, and Roberto Cipolla. Semantic object classes in video: A high-definition ground truth database. Pattern Recognition Letters, 30(2):88–97, 2009.
+
+Gail A Carpenter. Neural network models for pattern recognition and associative memory. Neural networks, 2 (4):243–257, 1989.
+
+Rich Caruana, Hooshang Kangarloo, JD Dionisio, Usha Sinha, and David Johnson. Case-based explanation of non-case-based learning methods. In Proceedings of the AMIA Symposium, pp. 212. American Medical Informatics Association, 1999.
+
+Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L. Yuille. Deeplab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected crfs. CoRR, abs/1606.00915, 2016.
+
+Marius Cordts, Mohamed Omran, Sebastian Ramos, Timo Rehfeld, Markus Enzweiler, Rodrigo Benenson, Uwe Franke, Stefan Roth, and Bernt Schiele. The cityscapes dataset for semantic urban scene understanding. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016.
+
+David Crandall, Pedro Felzenszwalb, and Daniel Huttenlocher. Spatial priors for part-based recognition using statistical models. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2005.
+
+Emily L. Denton, Soumith Chintala, Arthur Szlam, and Robert Fergus. Deep generative image models using a laplacian pyramid of adversarial networks. CoRR, abs/1506.05751, 2015.
+
+Jacob Devlin, Saurabh Gupta, Ross B. Girshick, Margaret Mitchell, and C. Lawrence Zitnick. Exploring nearest neighbor approaches for image captioning. CoRR, abs/1505.04467, 2015.
+
+David Eigen and Rob Fergus. Predicting depth, surface normals and semantic labels with a common multiscale convolutional architecture. In Proc. of the IEEE International Conference on Computer Vision (ICCV), 2015.
+
+Pedro Felzenszwalb, David McAllester, and Deva Ramanan. A discriminatively trained, multiscale, deformable part model. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2008.   
+Pedro F. Felzenszwalb and Daniel P. Huttenlocher. Pictorial structures for object recognition. International Journal of Computer Vision, 2005.   
+R. Fergus, P. Perona, and A. Zisserman. Object class recognition by unsupervised scale-invariant learning. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2003.   
+M. A. Fischler and R. A. Elschlager. The representation and matching of pictorial structures. IEEE Trans. Comput., 22(1), January 1973.   
+Ross Girshick, Forrest Iandola, Trevor Darrell, and Jitendra Malik. Deformable part models are convolutional neural networks. In Proceedings of the IEEE conference on Computer Vision and Pattern Recognition, pp. 437–446, 2015.   
+Ian J. Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron C. Courville, and Yoshua Bengio. Generative adversarial networks. CoRR, abs/1406.2661, 2014.   
+Bharath Hariharan, Pablo Arbelaez, Ross Girshick, and Jitendra Malik. Hypercolumns for object segmentation ´ and fine-grained localization. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2015.   
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. arXiv preprint arXiv:1512.03385, 2015.   
+Geoffrey E. Hinton. Learning distributed representations of concepts. In Proceedings of the Eighth Annual Conference of the Cognitive Science Society, pp. 1–12. Hillsdale, NJ: Erlbaum, 1986.   
+Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. arxiv, 2016.   
+Vivek Krishnan and Deva Ramanan. Tinkering under the hood: Interactive zero-shot learning with net surgery. CoRR, abs/1612.04901, 2016.   
+Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444, 2015.   
+Zachary C Lipton. The mythos of model interpretability. arXiv preprint arXiv:1606.03490, 2016.   
+Ce Liu, Jenny Yuen, and Antonio Torralba. Nonparametric scene parsing via label transfer. IEEE Transactions on Pattern Analysis and Machine Intelligence, 33(12):2368–2382, 2011.   
+Jonathan Long, Ning Zhang, and Trevor Darrell. Do convnets learn correspondence? In Advances in Neural Information Processing Systems (NIPS), 2014.   
+Jonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional models for semantic segmentation. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2015.   
+Aravindh Mahendran and Andrea Vedaldi. Understanding deep image representations by inverting them. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2015.   
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. CoRR, abs/1511.06434, 2015.   
+Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. CoRR, abs/1505.04597, 2015.   
+Ali Sharif Razavian, Hossein Azizpour, Josephine Sullivan, and Stefan Carlsson. Cnn features off-the-shelf: an astounding baseline for recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition workshops, pp. 806–813, 2014.   
+Ravid Shwartz-Ziv and Naftali Tishby. Opening the black box of deep neural networks via information. arXiv preprint arXiv:1703.00810, 2017.   
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian J. Goodfellow, and Rob Fergus. Intriguing properties of neural networks. CoRR, abs/1312.6199, 2013.   
+Naftali Tishby and Noga Zaslavsky. Deep learning and the information bottleneck principle. CoRR, abs/1503.02406, 2015. URL http://arxiv.org/abs/1503.02406.   
+Radim Tylecek and Radim ˇ Sˇ ara. Spatial pattern templates for recognition of objects with regular structure. In ´ Proc. German Conference on Pattern Recognition (GCPR), Saarbrucken, Germany, 2013.   
+C. Vondrick, A. Khosla, T. Malisiewicz, and A. Torralba. HOGgles: Visualizing Object Detection Features. Proc. of the IEEE International Conference on Computer Vision (ICCV), 2013.   
+Markus Weber, Max Welling, and Pietro Perona. Towards automatic discovery of object categories. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2000.   
+Saining Xie and Zhuowen Tu. Holistically-nested edge detection. In Proc. of the IEEE International Conference on Computer Vision (ICCV), 2015.   
+Matthew D. Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. CoRR, abs/1311.2901, 2013.   
+Matthew D. Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In Proc. of the European Conference on Computer Vision (ECCV), pp. 818–833, 2014.   
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. arXiv preprint arXiv:1611.03530, 2016.   
+Bolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Object detectors emerge in \` deep scene cnns. In Proc. of the International Conference on Learning Representations (ICLR), 2014.   
+Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A. Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. CoRR, abs/1703.10593, 2017.
+
+# A APPENDIX: ADDITIONAL EXPERIMENTAL RESULTS
+
+# A.1 GLOBAL NEAREST NEIGHBORS
+
+We also present synthesized images using a global nearest neighbors (NN) approach. In this case, we use the global information from the bottleneck features and FC7 features. These bottleneck features can reveal which patches are learned and which training instances have more influence than others.
+
+![](images/4e210df7e3260fa44a989104201db13c850bf65c128e0d308edf855f4a812960.jpg)  
+Figure 12: Global NN v.s. Comp NN. We show synthesized images using our CompNN methods and four global NN approaches (global nearest neighbor on bottleneck feature embedding and Decode2 feature embedding using self-supervised labels and original labels respectively). We can observe that (1) compositional nearest neighbor outperforms other global nearest neighbor approaches, (2) using Decode2 features (the penultimate layer) sometimes can generate more similar structures (See row 1,4).
+
+Fig. 12 shows the synthesized images using several global NN approaches and a CompNN approach. We can observe that the results of global NN approaches overall resembles global properties of the output of the Convolutional Neural Network (CNN) and of the CompNN approach. For instance, in the top two rows, the output of the global NN resembles the color of the facade and structural properties of the buildings. Also, in the bottom two rows, we can observe that the global NN overall captures the organization of the scene because many labels in the global NN overlap considerably with the output of the CNN and the ground truth.
+
+# A.2 COMPOSITIONAL NEAREST NEIGHBORS
+
+In this section, we show more results of our proposed Compositional Nearest Neighbors. Both self-supervised labels and original labels are evaluated in this section. We can observe in Fig.13 that the results of the Compositional Nearest Neighbors (CompNN) approach are quite similar to those of the Convolutional Neural Network. We can also observe that the CompNN produces smoother results when it uses self-supervised labels than when it uses the original ones. Moreover, the self-supervised CompNN method produces results that are more alike to those of the Convolutional Neural Network.
+
+![](images/f08ed120cf4fe69833a6a3dff6248b0c348be41d38064611ee033789439acd4a.jpg)  
+Figure 13: Compositional Nearest Neighbors (CompNN) segmentation results using self-supervised and original labels. Overall, CompNN produces similar results compared with those of the Convolutional Neural Network. In particular, CompNN produces smoother results when it uses selfsupervised labels than when it uses the original labels.
+
+# A.3 ADDITIONAL IMAGE SYNTHESIS RESULTS
+
+Fig. 14 shows additional image syntheses using a CNN and CompNN with original and self-supervised labels. As discussed earlier, the CompNN with self-supervised labels produces a smoother image than when it uses the original labels.
+
+# B APPENDIX: EXPERIMENTAL DETAILS
+
+# B.1 COMPUTATIONAL COMPLEXITY
+
+Although Compositional Nearest Neighbors provide insights into the internal operations of a CNN, its computational complexity is very high. In this section, we show some experimental details to speed up the CompNN process. Assume a dataset with $N$ images, each with $H \times W$ pixels, and $M$ filters from the last layer of a CNN. Then, the computational complexity for synthesizing one image using CompNN is
+
+$$
+O ( N H ^ { 2 } W ^ { 2 } M ^ { 2 } ) .
+$$
+
+![](images/dbc31d4ab73668499da889f3a9dc86a24c58d1198ecc8d04d39ae2478552ba4a.jpg)  
+Figure 14: Synthesized images for pixel-wise prediction tasks with a Convolutional Neural Network, and Compositional Nearest Neighbors using self-supervised and original labels.
+
+We now introduce several approaches to speed up searching process. (1) Although Numpy from Python calculates the distance between two features quickly, the iterations for synthesizing a pixel are slow. To alleviate this, we implemented the CompNN using $\mathrm { C } { + } { + }$ . (2) When a dataset has a large number of training instances, we used bottleneck features to narrow the training set. Especially in the segmentation problem, we can generate OK results with only 5-10 training reference. (3) Our implementation uses several threads in order to speedup the process. Specifically, each thread is in charge of synthesizing a disjoint set of pixels.
+
+The synthesis of facades using the Facades dataset (400 training samples) takes about 2 hours with 20-30 threads on the CPU. This can be used as a reference for experiments on other datasets.

parse/train/H1TWfmnNf/H1TWfmnNf_content_list.json

@@ -0,0 +1,1534 @@
+[
+    {
+        "type": "text",
+        "text": "DO CONVOLUTIONAL NEURAL NETWORKS ACT AS COMPOSITIONAL NEAREST NEIGHBORS? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            746,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present a simple approach based on pixel-wise nearest neighbors to understand and interpret the internal operations of state-of-the-art neural networks for pixel-level tasks. Specifically, we aim to understand the synthesis and prediction mechanisms of state-of-the-art convolutional neural networks for pixel-level tasks. To this end, we primarily analyze the synthesis process of generative models and the prediction mechanism of discriminative models. The main hypothesis of this work is that convolutional neural networks for pixel-level tasks learn a fast compositional nearest neighbor synthesis or prediction function. Our experiments on semantic segmentation and image-to-image translation show qualitative and quantitative evidence supporting this hypothesis. ",
+        "bbox": [
+            233,
+            270,
+            764,
+            409
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            441,
+            336,
+            458
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Convolutional neural networks (CNNs) have revolutionized computer vision, producing impressive results for discriminative tasks such as image classification and semantic segmentation. More recently, they have also produced startlingly impressive results for image generation through generative models. However, in both cases, such feed-forward networks largely operate as “black boxes.” As a community, we are still not able to succinctly state why and how such feed-forward functions generate a particular output from a given input. If a network fails on a particular input, why? How will a network behave on never-before-seen data? To answer such questions, there is a renewed interest in so-called explainable $A I ^ { 1 }$ . The central goal in this (re)invigorated space is the development of machine learning systems that are designed to be more interpretable and explanatory. ",
+        "bbox": [
+            173,
+            476,
+            825,
+            601
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Explanation-by-correspondence: One attractive approach to interpretability stems from casebased reasoning or “explanation-by-example” (Lipton, 2016). Such an approach dates back to classic AI systems that predict medical diagnoses or legal judgments that were justified through case studies or historical precedent (Aamodt $\\&$ Plaza, 1994). For example, radiologists can justify diagnoses of an imaged tumor as ‘malignant’ by reference to a previously-seen example (Caruana et al., 1999). However, this approach can generate only $N$ explanations given $N$ training exemplars. Our work demonstrates that deep networks can generate exponentially more explanations through composition: e.g., this part of the image looks like this part of exemplar A, while another part looks like that part of exemplar B. We term this “explanation-by-correspondence”, since our explanations provide detailed correspondence of parts (or even pixels) of a query image to a set of exemplars. ",
+        "bbox": [
+            173,
+            608,
+            825,
+            747
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Spatial prediction: In this work, we focus on the class of CNNs designed to make predictions at each image pixel. Many problems in computer vision can be cast in this framework, e.g., semantic segmentation, depth estimation, image synthesis, and image translation. We explore a simple hypothesis for explaining the behavior of such networks: they operate by cutting-and-pasting image patches found in training data. Consider the top row of Fig. 1, where we visualize the output of Isola et al. (2016)’s translation network trained to synthesize images of building facades from label masks. Why does the network generate the strange diagonal gray edge at the top? To answer this question, we visualize image pixels extracted from the closest-matching nearest-neighbor (NN) patches found in the training data. Remarkably, NN-synthesis looks quite similar to the CNN output, providing a clear explanation for the synthesized corner artifact. ",
+        "bbox": [
+            173,
+            753,
+            825,
+            892
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/3068de974981f909e4dbd8e7e2ab4168f3e7f7946c8802c8d041f6e90ffc8e33.jpg",
+        "image_caption": [
+            "Figure 1: We propose a non-parametric method to explain and modify the behavior of convolutional Figure 1: We propose a non-parametric method to explain and modifyrametric method to explain and modify the behavior of convolutionalnetworks, including those that classify pixels and those that generate images. For example, given the label mask on the top, why does a network generate strange gray border artifacts? Given the cluding those that classify pixels and those that generate images. Forluding those that classify pixels and those that generate images. For enetworks, including those that classify pixels and those that generate classify pixels and those that generate images. For example, givenimage on the bottom, how is a network able to segment out the left-most telephone pole in shadow? ask on the top, why does a network generate strange gray border artifk on the top, why does a network generate strange gray border artifacthe label mask on the top, why does a network generate strange grayy does a network generate strange gray border artifacts? Given theWe advocate an “explanation-by-example” approach to interpretation (Caruana et al., 1999). Next to the CNN output, we show the closest-matching training exemplar image. It appears to provide e bottom, how is a network able to segment out the barely-visible la bottom, how is a network able to segment out the barely-visible lam                       coarse explanations of such behaviors, though the quality of the output is still lacking (e.g., addixplanation-by-example” approach to interpretation (Caruana et al., 19planation-by-example” approach to interpretation (Caruana et al., 199vocate an “explanation-by-example” approach to interpretation (Carumple” approach to interpretation (Caruana et al., 1999). Next to thetional cars are hallucinated in the bottom row). One the right, we show the output obtained through CNN output, we show the closest-matching training exemplar image.est-matching training exemplar image. It appears to provide coarsea compositional nearest-neighbor operation that simply (1) matches input patches to those in the training set and (2) returns the corresponding output label. This means that the output is created by s of such behaviors, though the quality of the output is still lacking (e.g.of such behaviors, though the quality of the output is still lacking (e.g.,                        cutting-and-pasting (composing) patches of training images. To ensure that inconsistent patches are ated in the bottom row). One the right, we show the output obtainedted in the bottom row). One the right, we show the output obtained tare hallucinated in the bottom row). One the right, we show the outrow). One the right, we show the output obtained through a com-not composed together, one needs to match patches using an embedding that captures both global semantics (e.g., architectural styles) and local structure (e.g., windows versus doors). We demonearest-neighbor operation that simply (1) matches input patches to thoarest-neighbor operation that simply (1) matches input patches to those                   strate that local convolutional neighborhoods of feature activations produce such rich embedding. eturns the corresponding output label. This means that the output is crturns the corresponding output label. This means that the output is creaset and (2) returns the corresponding output label. This means that thending output label. This means that the output is created by cutting-Such a perspective allows one to explain errors and modify the biases of a network by changing the and-pasting (composing) patches of thes of training images. To ensure thatset of image patches used for non-parametric matching. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            102,
+            785,
+            422
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "., architectural styles) and local structure (e.g., windows versus doors). architectural styles) and local structure (e.g., windows versus doors). Wmantics (e.g., architectural styles) and local structure (e.g., windows ves) and local structure (e.g., windows versus doors). We demonstrateCompositional nearest-neighbors: Our central thesis is consistent with recent work on network that local convolutional neighborhoods of feature activations produceorhoods of feature activations produce such rich embedding. Such amemorization (Zhang et al., 2016), but notably, naive memorization fails to explain how and why perspective allows one to explain errors and modify the biases of a neain errors and modify the biases of a network by changing the set ofnetworks generalize to never-before-seen data. We explain the latter through composition: the synallows one to explain errors and modify the biases of a network by challows one to explain errors and modify the biases of a network by chan                         thesized output in Fig. 1 consists of image patches copied from different training images. Given a es useds used foimagerametricdatabase of $N$ r non-parametrnon-parametricatches used foratching. [Devtraining images with $K$ matching. [Deva: Can you switcmatching. [Deva: Can you switchon-parametric matching. [Deva: Ca Can you switch the order of compixels each, global nearest-neighbors can produce $N$ the ore orde you s nnpossible and global nn, like teaser-deva.pdf?]a.pdf?]output images. On the other hand, compositional nearest-neighbors can produce $( N K ) ^ { K }$ outputs, nn, like teaser-deva.pdf?]n, like teaser-deva.pdf?]an exponentially larger set of outputs. Each output image can be obtained by independently matching each of the $K$ patches in the input query to one of $N K$ patches in the training set. However, many of these outputs may be unrealistic. For example, one should not synthesize a facade by composing a door above a window. To ensure global consistency, one needs to match patches using a carefully-tuned metric that captures such global knowledge. But where do we obtain such a metric? ",
+        "bbox": [
+            173,
+            694,
+            825,
+            847
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Patch embeddings: Much past work has demonstrated that intermediate feature activations of a nal nearest-neighbors: Our central thesis is consistent with recent wal nearest-neighbors: Our central thesis is consistent with recent woCompositional nearest-neighbors: Our central thesis is consistent bors: Our central thesis is consistent with recent work on networkneural network can be interpreted as global embeddings for comparing entire images. For exammemorization (Zhang et al., 2016), but notably, naive memorization f016), but notably, naive memorization fails to explain how and whyple, Sharif Razavian et al. (2014); Devlin et al. (2015) show that the penultimate (“FC7”) layer of n (Zhang et al., 2016), but notably, naive memorization fails to expla (Zhang et al., 2016), but notably, naive memorization fails to explainimage classification networks learn embeddings of images that produce remarkably accurate nearestneralize to never-before-seen data. We explain the latter through comperalize to never-before-seen data. We explain the latter through compos                  neighbors. We apply this observation to spatial prediction networks in order to learn local embeddings of image patches or even pixels. These embeddings are quite rich in that they encode semantic knowledge that is both local (geometric structures centered at the pixel) and global (e.g., color and architectural style of the entire facade). ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Correspondence and bias: Beyond being a mechanism for interpretation, we demonstrate that compositional NN matching is a viable algorithm that may approach the accuracy of highly-tuned CNNs. Although slower than a feed-forward net, compositional matching is attractive in two respects: (1) It provides spatial correspondences between pixels in the predicted output and pixels in the training set. Spatial correspondences may be useful in practical applications such as label transfer (Liu et al., 2011). (2) Implicit biases of the network can be explicitly manipulated by changing the set of images used for matching – it need not be the same set used for training the network. As an illustrative example, we can force a pre-trained image generation network to predict European or American building facades by restricting the set of images used for matching. Such a manipulation may, for example, be used to modify a biased face recognition network to process genders and races in a more egalitarian fashion. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            305
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Contribution: We introduce a Compositional Nearest Neighbors pipeline for interpreting and modifying the behavior of Convolutional Neural Networks. Specifically, we demonstrate that CNNs appear to work by memorizing image patches from training data, and then composing them into new configurations. To make compositional matching viable, CNNs learn a local embedding of image patches that captures both global and local semantics. An accurate local embedding is crucial in order to efficiently process an exponentially-large set of potential outputs. We validate our hypothesis on state-of-the-art networks for image translation and semantic image segmentation. Finally, we also show evidence that compositional matching can be used to predict activations of internal layers, generate spatial correspondences, and manipulate the implicitly-learned biases of a network. ",
+        "bbox": [
+            174,
+            311,
+            825,
+            438
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            468,
+            344,
+            484
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We broadly classify networks for spatial prediction into two categories: (1) discriminative prediction, where one is seeking to infer high-level semantic information from RGB values; and (2) image generation, where the intent is to synthesize a new image from a given input “prior”. There is a broad literature for each of these tasks, and here we discuss the ones most relevant to ours. ",
+        "bbox": [
+            174,
+            506,
+            823,
+            561
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Discriminative models: An influential formulation for state-of-the-art spatial prediction tasks is that of fully convolutional networks (Long et al., 2015). These have been used for pixel prediction problems such as semantic segmentation (Long et al., 2015; Hariharan et al., 2015; Ronneberger et al., 2015; Bansal et al., 2017a; Chen et al., 2016), depth/surface-normal estimation (Bansal et al., 2016; Eigen & Fergus, 2015), or low-level edge detection (Xie & Tu, 2015; Bansal et al., 2017a). Substantial progress has been made to improve the performance by employing deeper architectures (He et al., 2015), or increasing the capacity of the models (Bansal et al., 2017a), or utilizing skip connections, or intermediate supervision (Xie & Tu, 2015). However, we do not precisely know what these models are actually capturing to do pixel-level prediction. In the race for better performance, the interpretability of these models has been typically ignored. In this work, we focus on interpreting encoder-decoder architectures for spatial classification (Ronneberger et al., 2015; Badrinarayanan et al., 2017). ",
+        "bbox": [
+            173,
+            569,
+            825,
+            736
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Image generation: Goodfellow et al. (2014) proposed a two-player min-max formulation where a generator $G$ synthesized an image from random noise $z$ , and a discriminator $( D )$ is used to distinguish the generated images from the real images. While this Generative Adversarial Network (GAN) formulation was originally proposed to synthesize an image from random noise vectors $z$ , this formulation could also be used to synthesize new images from other priors, such as, a low resolution image or label mask by treating $z$ as an explicit input to be conditioned upon. This conditional image synthesis via generative adversarial formulation has been well utilized by multiple follow-up works to synthesize a new image conditioned on a low-resolution image (Denton et al., 2015), class labels (Radford et al., 2015), and other inputs (Isola et al., 2016; Zhu et al., 2017). While the quality of synthesis from different inputs has rapidly improved in recent history, interpretation of GANs has been relatively unexplored. In this work, we examine the influential Pix2Pix network Isola et al. (2016) and demonstrate an intuitive non-parametric representation for explaining its impressive results. ",
+        "bbox": [
+            173,
+            743,
+            825,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Interpretability: There is a substantial body of work (Zeiler & Fergus, 2014; Mahendran & Vedaldi, 2015; Zhou et al., 2014; Bau et al., 2017) on interpreting general convolutional neural networks (CNNs). The earlier work of Zeiler & Fergus (2014) presented an approach to understand and visualize the functioning of intermediate layers of CNN. Mahendran & Vedaldi (2015) proposed to invert deep features to visualize what is learned by CNNs, similar to inverting HOG features to understand object detection (Vondrick et al., 2013). Zhou et al. (2014) demonstrated that object detectors automatically pop up while learning the representation for scene categories. Krishnan & Ramanan (2016) explored interactive modification of a pre-trained network to learn novel concepts, and recently Bau et al. (2017) proposed to quantify interpretability by measuring scene semantics such as objects, parts, texture, material etc. Despite this, understanding the space of pixel-level CNNs is not well studied. The recent work of PixelNN (Bansal et al., 2017b) focuses on highquality image synthesis by making use of a two-stage matching process that begins by feed-forward CNN processing and ends with a nonparametric matching of high-frequency detail. We differ in our focus on interpretability rather than image synthesis, our examination of networks for both discriminative classification and image synthesis, and our simpler single-stage matching process that does not require feed-forward processing. ",
+        "bbox": [
+            174,
+            104,
+            825,
+            325
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Compositionality: The design of part-based models (Crandall et al., 2005; Felzenszwalb et al., 2008), pictorial structures or spring-like connections (Fischler & Elschlager, 1973; Felzenszwalb & Huttenlocher, 2005), star-constellation models (Weber et al., 2000; Fergus et al., 2003), and the recent works using CNNs share a common theme of compositionality. While the earlier works explicitly enforce the idea of composing different parts for object recognition in the algorithmic formulation, there have been suggestions that CNNs also take a compositional approach (Zeiler & Fergus, 2014; Krishnan & Ramanan, 2016; Bau et al., 2017). We see compositional embeddings as rather different than compositional objects/parts. Using (Hinton, 1986)’s terminology, embeddings can be viewed as “distributed representations”, while objects/parts can be viewed as “sparse representations”. Much past work has argued that distributed representations are central to the success of deep networks (LeCun et al., 2015). We agree and posit that this is one reason why CNNs outperform classic hierarchical models of parts/objects. Specifically, Girshick et al. (2015) point out that classic part models can be implemented as CNNs with sparse activations, where individual neurons correspond to individual part responses. In practice, many neurons are not interpretable when examined individually, as pointed out by Zhou et al. (2014). An embedding perspective offers one solution that does not require individual dimensions to be meaningful - e.g., nearest neighbors in an embedding will not change if one applies a well-behaved linear transformation (e.g., rotation) to the embedding space. This is consistent with past work (Szegedy et al., 2013) that suggests that that linear combinations of activations are equally as informative as the original activations. Finally, if high-level activations represent objects, how can 4K activations (e.g., the typical dimension of FC7) represent $3 0 \\mathrm { K } +$ objects (Biederman, 1987)? Our central thesis is that activations do not correspond to individual objects/parts, but rather the dimensions of a local embedding space in which objects/parts are points (matchable with nearest-neighbors). ",
+        "bbox": [
+            173,
+            332,
+            825,
+            651
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 COMPOSITIONAL NEAREST NEIGHBORS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            671,
+            539,
+            688
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We now introduce our method to interpret various fully convolutional networks designed for pixellevel tasks. ",
+        "bbox": [
+            173,
+            703,
+            823,
+            732
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Global nearest-neighbors: Our starting point is the observation that classification networks can be interpreted as linear classifiers defined on nonlinear features extracted from the penultimate layer (e.g., “FC7” features) of the network. We formalize this perspective with the following notation: ",
+        "bbox": [
+            174,
+            738,
+            825,
+            780
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f1379188a8de3754e8cbe38e8d7bc29e6ba397d84aeebf5864036e060efd3be6.jpg",
+        "text": "$$\n\\operatorname { L a b e l } ( x ) = k ^ { * } \\quad { \\mathrm { w h e r e } } \\quad k ^ { * } = { \\underset { k \\in \\{ 1 \\ldots K \\} } { \\operatorname { a r g m a x } } } \\ w _ { k } \\cdot \\phi ( x ) , \\qquad [ \\operatorname { K - w a y } \\ { \\mathrm { c l a s s i f i c a t i o n } } ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            235,
+            786,
+            759,
+            815
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\boldsymbol { \\phi } ( \\boldsymbol { x } ) \\in \\mathbb { R } ^ { N }$ corresponds to the penultimate FC7 features computed from input image $x$ . Typically, the parameters of the linear classifier $\\{ w _ { y } \\}$ and those of the feature encoder $\\phi ( \\cdot )$ are trained on large-scale supervised datasets: ",
+        "bbox": [
+            174,
+            821,
+            825,
+            864
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/576c37b5ca610461707ad3a1be87afa8242c89741cac79c3588d46624903fac1.jpg",
+        "text": "$$\n\\mathcal { D } = \\{ ( x _ { n } , y _ { n } ) \\} . \\quad [ \\mathrm { T r a i n i n g ~ d a t a b a s e } ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            871,
+            629,
+            890
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Devlin et al. (2015) make the observation that penultimate features $\\phi ( x )$ can be interpreted as an embedding in $\\mathbb { R } ^ { N }$ . By extracting such embeddings for training images $x _ { n }$ , Devlin et al. (2015) build ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/086b38ab71ff270080fe87eb0eb7bf231b3635e2466888a05e7e6ce45710b947.jpg",
+        "image_caption": [
+            "Figure 2: Overview of pipeline: Given an input label or image (top-left of each box), our approach extracts an embedding for each pixel. We visualize two pixels with a yellow and white dot. The embedding captures both local and global context, which are crudely visualized with the surrounding rectangular box. We then find the closest matching patches in the training set (with a nearest neighbor search), and then report back the corresponding pixel labels to generate the final output (bottom-left of each box). We visualize an example for label-to-image synthesis on the left, and image-to-label prediction on the right. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            103,
+            807,
+            258
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "a nonparametric nearest-neighbor (NN) predictor for complex tasks such as image captioning. We write this as follows: ",
+        "bbox": [
+            173,
+            393,
+            823,
+            422
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/163d19c35f4ba5d7aa0c29a0a4a1e79244a84ac928e09ba15085bcd62630039e.jpg",
+        "text": "$$\n\\operatorname { L a b e l } ( x ) = y _ { n ^ { * } } \\quad { \\mathrm { w h e r e } } \\quad n ^ { * } = \\operatorname { a r g m i n } _ { n } \\operatorname { D i s t } \\Bigl ( \\phi ( x ) , \\phi ( x _ { n } ) \\Bigr ) . \\qquad [ \\operatorname { G l o b a l } \\operatorname { N I }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            422,
+            741,
+            453
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Importantly, the above NN classifier performs quite well even when feature encoders $\\phi ( \\cdot )$ are trained for classification rather than as an explicit embedding. In some sense, deep nets seem to implicitly learn embeddings upon which simple linear classifiers (or regressors) operate. We argue that such a NN perspective is useful in interpreting the predicted classification since the corresponding training example can be seen as a visual “explanation” of the prediction - e.g., the predicted label for $x$ is “dog” because $x$ looks similar to training image $x _ { n * }$ . ",
+        "bbox": [
+            174,
+            457,
+            825,
+            541
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Pixel nearest-neighbors: We now extend the above observation to pixel-prediction networks that return back a prediction for each pixel $i$ in an image: ",
+        "bbox": [
+            173,
+            547,
+            825,
+            577
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b4be8991639712792433c17c97ba6bfef7cc4f54822c74cd1a6b45554caa4bc0.jpg",
+        "text": "$$\n\\operatorname { L a b e l } _ { i } ( x ) = k ^ { * } \\quad { \\mathrm { w h e r e } } \\quad k ^ { * } = \\operatorname { a r g m a x } _ { k \\in \\{ 1 . . . K \\} } w _ { k } \\cdot \\phi _ { i } ( x ) . \\qquad [ \\operatorname { K - w a y } \\operatorname { p i x e l } \\operatorname { c l a s s i f i c a t i o n } ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            214,
+            579,
+            781,
+            608
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We write $\\mathrm { L a b e l } _ { i } ( \\cdot )$ for the label of the $i ^ { t h }$ pixel and $\\phi _ { i } ( \\cdot )$ for its corresponding feature vector. Because we will also examine pixel-level prediction networks trained to output a continuous value, we write out the following formulation for pixel-level regression: ",
+        "bbox": [
+            174,
+            612,
+            825,
+            655
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ff1635e039e21b20bf93b66273326e30e034a3b8acf857d0462d7888f3867055.jpg",
+        "text": "$$\n\\mathrm { P r e d i c t } _ { i } ( x ) = W \\phi _ { i } ( x ) \\quad \\mathrm { w h e r e } \\quad W \\in \\mathbb { R } ^ { M \\times N } . \\qquad [ \\mathrm { P i x e l ~ r e g r e s s i o n } ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            266,
+            659,
+            732,
+            678
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For concreteness, consider a Pix2Pix (Isola et al., 2016) network trained to regress RGB values at each pixel location. These predictions are obtained by convolving features from the penultimate layer with filters of size $4 \\times 4 \\times 1 2 8$ . In this case, the three filters that generate R,G, and B values can be written as a matrix $W$ of size $M \\times N$ , where $M = 3$ and $N = 4 * 4 * 1 2 8 = 2 0 4 8$ . Analogously, $\\phi _ { i } ( x )$ corresponds to $N$ dimensional features extracted by reshaping local $4 \\times 4$ convolutional neighborhoods of features from the penultimate feature map (of size $H \\times W \\times 1 2 8$ ). We now can perform nearest-neighbor regression to output pixel values: ",
+        "bbox": [
+            173,
+            680,
+            825,
+            779
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c13abb85ec8da90b15693ad6c696c776df5cd5dac6022aa66fd8666d23cf2976.jpg",
+        "text": "$$\n\\mathsf { r e d i c t } _ { i } ( x ) = y _ { n ^ { * } , m ^ { * } } \\quad \\mathrm { w h e r e } \\quad ( n ^ { * } , m ^ { * } ) = \\underset { n , m } { \\mathrm { a r g m i n } } \\mathrm { D i s t } \\Big ( \\phi _ { i } ( x ) , \\phi _ { m } ( x _ { n } ) \\Big ) , \\qquad [ \\mathrm { C o m p ~ N N ~ P i x e l s ~ o f ~ \\phi _ { i } ( x ) ~ , }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            183,
+            781,
+            826,
+            813
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $y _ { n ^ { * } , m ^ { * } }$ refers to the $m ^ { t h }$ pixel from the $n ^ { t h }$ training image. Importantly, pixel-level nearest neighbors reveals spatial correspondences for each output pixel. We demonstrate that these can be used to provide an intuitive explanation of pixel outputs, including an explanation of errors that otherwise seem quite mysterious (see Fig.1 and Fig. 2). ",
+        "bbox": [
+            174,
+            818,
+            825,
+            876
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Distance function: We explored different distance functions such as Euclidean and cosine distance. Similar to past work (Devlin et al., 2015), we found that cosine distance consistently performed slightly better, so we use that in all of our experiments. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/10f6fef70cbf81fb141b8eeff16ec182f7dc49ff393ea7106efecb1bb82dc1ca.jpg",
+        "image_caption": [
+            "Figure 3: We visualize a non-parametric approach to computing activations from internal layers. By matching to a training database of $\\mathop { d e c o d e r _ { 4 } }$ features from Pix2Pix, we can compute activations for the next layer (decoder3) with nearest-neighbors. Each image represents a feature map of 3 continuous channels visualized in the R,G, and B planes. The collective set of 4 images displays 12 out of the 256 channels in decoder3. Global nearest-neighbors (i.e., matching to the training image with the most similar $\\mathop { d e c o d e r _ { 4 } }$ layer and returning its associated decoder3 layer) produces poor matches, but compositional-pasting matches together from different exemplars produce activations that are nearly identical to those computed by the underlying CNN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            228,
+            102,
+            771,
+            289
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Convolutional embeddings: We now extend our compositional nearest-neighbor formulation to internal convolutional layers. Recall that activations $a$ at a spatial position $i$ and layer $j$ can be computed using thresholded linear functions of features (activations) from the previous layer: ",
+        "bbox": [
+            174,
+            443,
+            825,
+            486
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fb6cdaf554a3fc15477c82b1d2ac70e485e15763163708dc7ce2221ed419b97d.jpg",
+        "text": "$$\na _ { i j } ( x ) = \\operatorname* { m a x } { \\Bigl ( } 0 , W \\phi _ { i j } ( x ) { \\Bigr ) } , \\qquad \\mathrm { w h e r e } \\quad a _ { i j } \\in \\mathbb { R } ^ { M } , \\phi _ { i j } \\in \\mathbb { R } ^ { N } , W \\in \\mathbb { R } ^ { M \\times N }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            233,
+            492,
+            764,
+            518
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where we write $a _ { i j }$ for the vector of activations corresponding to the $i ^ { t h }$ pixel position from layer $j$ , possibly computed with bilinear interpolation (Long et al., 2015). We write $\\phi _ { i j }$ for the local convolutional neighborhood of features (activations) from the previous layer that are linearly combined with bank of linear filters $W$ to produce $a _ { i j }$ . For concreteness, let the previous layer be decoder4 from Pix2Pix, and the current layer be decoder3. We can then write, $a _ { i j } \\in R ^ { M }$ where $M = 2 5 6$ and $\\phi _ { i j } \\in R ^ { N }$ where $N = 4 * 4 * 5 1 2 = 8 1 9 2$ . We similarly posit that one can produce approximate activations by nearest neighbors. Specifically, let us run Pix2Pix on the set of training images, and construct a dataset of training patches with features $\\phi _ { i j } ( x _ { n } )$ as data and corresponding activation vectors $a _ { i j } ( x _ { n } )$ as labels. We can then predict activation maps for a query image $x$ with NN: ",
+        "bbox": [
+            173,
+            526,
+            825,
+            657
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6e14ec8c99a8c352b3b986f097346e55b295aaa06d8fe998fc05c10424ad4edd.jpg",
+        "text": "$$\na _ { i j } ( x ) = a _ { m ^ { * } , j } ( x _ { n ^ { * } } ) \\quad { \\mathrm { w h e r e } } \\quad ( m ^ { * } , n ^ { * } ) = \\underset { m , n } { \\mathrm { a r g m i n } } \\ : \\mathrm { D i s t } \\Bigl ( \\phi _ { i j } ( x ) , \\phi _ { m j } ( x _ { n } ) \\Bigr ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            173,
+            664,
+            678,
+            695
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Notably, this is done without requiring explicit access to the filters $W$ . Rather such responses are implicitly encoded in the training dataset of patches and activation labels. We show that such an approach actually produces reasonable activations (Fig. 3). ",
+        "bbox": [
+            176,
+            702,
+            826,
+            744
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Patch nearest-neighbors: The previous paragraph demonstrated that composing image patches using embeddings from interior layers could “explain” the behavior of the subsequent layer. We now ask a more ambitious question - could such a procedure “explain” the behavior of all subsequent layers? That is, could it produce output predictions that mimic the behavior of the entire network? To do so, we regress the final-layer pixel value from each stored patch: ",
+        "bbox": [
+            173,
+            751,
+            826,
+            821
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d9b2cf94746e6bec2c1139e6abb07caf68cd3257f0d43603fc06df3e530d2514.jpg",
+        "text": "$$\n{ \\mathrm { P r e d i c t } } _ { i j } ( x ) = y _ { n ^ { * } , m ^ { * } } \\quad { \\mathrm { w h e r e } } \\quad ( n ^ { * } , m ^ { * } ) = { \\underset { n , m } { \\mathrm { a r g m i n } } } { \\mathrm { D i s t } } \\Bigl ( \\phi _ { i j } ( x ) , \\phi _ { m j } ( x _ { n } ) \\Bigr ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            169,
+            828,
+            691,
+            859
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "[Comp NN Patches] ",
+        "bbox": [
+            720,
+            834,
+            852,
+            849
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As written, the above procedure is inefficient because features are interpolated (to pixel resolution) before they are matched to the patch database. Instead, it is natural to match features at their native resolution, and then interpolate the matches. This results in significant speed ups. For example, the bottleneck layer has an activation map of size $1 \\times 1 \\times 5 1 2$ . Matching to bottleneck features in the re y refers to pixels of set S (m⇤) from the nth training image.training set is quite fast because it acts as a compact global descriptor for matching entire images. j   The downside is that the matches are not compositional. By matching to convolutional embeddings rse-to-fine nearest-neighbor search: An important special case is the bottleneck feature, whichextracted from later layers, one can compute progressively more compositional matches, that are omputed from an activation map of size 1 ⇥ 1 ⇥ 512. In this case, we posit that the corresponding512initially global, then patch-based, and finally pixel-based (see Fig. 4). In our experiments, we found ure \u0000ij (x) 2 R is a good global descriptor of image x. In our experiments, we found thatthat such patch embeddings could be used to prune the NN pixel search, significantly speeding up run-time performance (e.g., we first prune the training database to a shortlist of images with similar bottleneck features, and then search through these images for similar patches, and then search through those patches for similar pixels). ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/0c1372504d35f1c2317feb5577039d1e3798a26a4860ffdf287db12a4dec58b1.jpg",
+        "image_caption": [
+            "Comp-NN in different embedding space: [Deva: Add the input label image on theFigure 4: Adding composition by matching to later layers: We apply compositional nearestneighbor matching to features extracted from different layers, starting with the bottleneck layer 6  2     and progressing to the penultimate deconv2 layer. We match local neighborhoods of convolutional embeddings, which naturally allows for more composition as we use later laters. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            104,
+            820,
+            193
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/2f69f8c3f1a1c1a94d612af578ad3b9b81228e2ebe646b107d6af265738d00e4.jpg",
+        "image_caption": [
+            "ixels to apply a linear projection. For correctness, considering feature positions i in decoder4Figure 5: Original labels v.s. self-supervised labels: Given the label input on the left, we show reh a shape of 32 ⇤ 32 ⇤ 256, we can rewrite i as (x, y) where x = i/32, y = i%32. Thus, eachsults of Pix2Pix in the Convolutional Neural Networks column, and non-parametric matching to the ure is corresponding to a 8 ⇤ 8 image patch on final output with a shape of 256 ⇤ 256 ⇤ 3. Hence,training set using the original labels and the predicted “self-supervised” labels of the Pix2Pix netj      ⇤    ⇤  ⇤    ⇤work. Generating images with the predicted labels looks smoother, though the qualitative behavior ...3]. Thus, one can generate output results by constructing a dataset of training patches withof the network is still explained by the original training labels. We quantify this in our experimental ij n     n,Sj (i)         results, and include additional qualitative visualizations of the original and self-supervised labels in Figs. 13 and 14. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            289,
+            782,
+            493
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            633,
+            825,
+            761
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Bias modification: Finally, our results suggest that the matching database from Eq.(2) serves as mory by changing the dataset of training images x , labels y , or both. We experimentan explicit “associative memory” of a network (Carpenter, 1989). We can explicitly modify the various modifications in our experimental results. Onememory by changing the dataset of training images $\\ { \\bar { \\{ \\{ x } }   _ { n } \\}$ cation th, labels $\\left\\{ y _ { n } \\right\\}$ sistently produced, or both. We experiment other visual results was to refine the training labels to those predicted by a network:with various modifications in our experimental results. One modification that consistently produced \u0000\u0000 \u0000 \u0000 \u0000 smoother visual results was to refine the training labels to those predicted by a network: ",
+        "bbox": [
+            173,
+            766,
+            825,
+            837
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/772a8f528085efca673a89876b1e1ccc2fbcf69755453b882ddbcdb4088fb2bd.jpg",
+        "text": "$$\n\\{ \\left( x _ { n } , y _ { n } \\right) \\} \\Rightarrow \\{ \\left( x _ { n } , C N N ( x _ { n } ) \\right) \\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            843,
+            526,
+            862
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Such as procedure for “self-supervised” learning is sometimes used when training labels are known to be noisy. From an associative network perspective, we posit that such labels capture a more 7faithful representation of a network’s internal memory. Unless otherwise specified, all results make use of the above matching database. We visualize the impact of self-supervised labels in Fig. 5. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/68dc94203828b1287562ac58c3ff7116df6b24f7b97e1ec0388f4d5d1ec6db6d.jpg",
+        "image_caption": [
+            "Figure 6: Reconstruction: We can use our nonparametric matching framework to generate reconstructions by replacing the exemplar target label $y _ { n }$ with the exemplar input image $x _ { n }$ . This can be done for both image generation and discrete label prediction. We find that, perhaps surprisingly, pixel embeddings contain enough local information to reconstruct the input pixel. We show additional results in Fig. 10. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            101,
+            815,
+            260
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Reconstruction: We found that replacing the label $y _ { n }$ with the input image $x _ { n }$ is a helpful diagnostic for visualization. This illustrates the ability of the learned embedding and compositional matching framework to reconstruct the input query. The reconstructed input for a global NN match is simply the best-matching exemplar input image (see Fig. 6). We find that, perhaps surprisingly, pixel embeddings contain enough local information to reconstruct the input pixel. We show additional results in our experimental results. ",
+        "bbox": [
+            173,
+            368,
+            825,
+            453
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/69ed4d5b2bf6d1b9b5b388d110be54dd18dde467e928e4f215ada278b135f807.jpg",
+        "text": "$$\n\\left\\{ \\left( x _ { n } , y _ { n } \\right) \\right\\} \\Rightarrow \\left\\{ \\left( x _ { n } , x _ { n } \\right) \\right\\} \\quad { \\mathrm { [ R e c o n s t r u c t i o n ] } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            479,
+            653,
+            500
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.1 SUFFICIENT STATISTICS FOR PIXEL-LEVEL TASKS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            520,
+            562,
+            536
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We now discuss information-theoretic properties of the introduced nearest-neighbor embedding $\\phi _ { i } ( \\cdot )$ presented in Sec. 3. Specifically, we show that this embedding produces sufficient statistics (Tishby & Zaslavsky, 2015; Shwartz-Ziv & Tishby, 2017; Achille & Soatto, 2017) for various pixel level tasks. ",
+        "bbox": [
+            173,
+            546,
+            825,
+            603
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Global embeddings: We begin with the simpler case of predicting a global class label $y$ from an image $x$ . If we assume that the input image $x$ , global feature embedding $\\phi ( x )$ , and output label $y$ form a Markov chain $x \\to \\phi ( x ) \\to y$ , we can write the following: ",
+        "bbox": [
+            173,
+            609,
+            825,
+            654
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e7154050fdb9a40731d843435e150e1d6ffdc4f7ac7de88f871304e8dc28cf2f.jpg",
+        "text": "$$\np ( y ~ | ~ \\phi ( x ) , ~ x ) = p ( y ~ | ~ \\phi ( x ) ) . \\qquad [ \\mathrm { S u f f i c i e n c y } ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            659,
+            656,
+            676
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As Achille & Soatto (2017) show, standard loss functions in deep learning (such as cross-entropy) search for an embedding that minimizes the entropy of the label $y$ given the representation $\\phi ( x )$ . This observation explicitly shows that the embedding $\\phi ( x )$ is trained to serve as a sufficient representation of the data $x$ that is rich enough in information to predict the label $y$ . In particular, if the learned embedding satisfies the above Markov assumption, the prediction $y$ will not improve even when given access to the raw data $x$ . ",
+        "bbox": [
+            174,
+            681,
+            823,
+            766
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Pixel-wise embeddings: Spatial networks predict a set of pixel-wise labels $\\{ y _ { i } \\}$ given an input image. If we assume that the pixel-wise labels are conditionally independent given $\\{ \\phi _ { i } ( x ) \\}$ and $x$ , then we can write the joint posterior distribution over labels with the following product: ",
+        "bbox": [
+            174,
+            772,
+            823,
+            815
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5b956c96126743d6f46c5b022d82acdcd51631578e5b92aaf891753bec1ea1fd.jpg",
+        "text": "$$\n\\begin{array} { l l } { { p ( \\{ y _ { i } \\} \\mid \\phi ( x ) , x ) = \\displaystyle { \\prod _ { i } p ( y _ { i } \\mid \\phi ( x ) , x ) } } } & { { \\quad \\scriptstyle { [ \\mathrm { C o n d i t i o n a l ~ S p a t i a l ~ I n d e p e n d e n c e } ] } } } \\\\ { { \\displaystyle { \\phantom { \\sum _ { i } p ( y _ { i } \\mid \\phi ( x ) , x ) } } } } & { { \\quad \\scriptstyle { [ \\mathrm { S u f f i c i e n c y } ] } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            233,
+            820,
+            763,
+            890
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $\\phi _ { i } ( x )$ are the sufficient statistics needed to predict label $y _ { i }$ , and $\\phi ( x ) ~ = ~ \\{ \\phi _ { i } ( x ) \\}$ is the aggregate set of these sufficient statistics. One can similarly show that pixel-wise cross-entropy losses jointly minimize the entropy of the labels $y _ { i }$ given $\\phi _ { i } ( x )$ . This suggests that pixel-wise features $\\phi _ { i } ( x )$ do serve as a remarkably rich characterization of the image. This characterization includes both global properties (e.g., the color of a building facade being synthesized) as well as local properties (e.g., the presence of a particular window ledge being synthesized). Importantly, this requires the conditional independence assumption from Eq. (11) to be conditioned on the entire image $x$ rather than just the local pixel value $x _ { i }$ (from which it would be hard to extract global properties). ",
+        "bbox": [
+            171,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            200
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "An interesting observation from the factorization shown in Eq. (12) is that we can synthesize an image by predicting pixel values independently. Thus, this theoretical observation suggests that a simple nearest-neighbor regression for every output pixel can synthesize plausible images. ",
+        "bbox": [
+            176,
+            208,
+            825,
+            251
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Multi-layered representations: The above pixel-wise formulation also suggests that internal feature layers serve as sufficient representations to predict activations for subsequent layers. Interestingly, skip connections that directly connect lower layers to higher layers break the Markov independence assumption. In other words, skip connections suggest that higher layer features often do not serve as sufficient representations, in that subsequent predictions improve when given access to earlier layers. However, Eq.(12) technically still holds so long as we write $\\phi _ { i } ( x )$ for the concatenated representation including lower-level features. For example, in Pix2Pix, we write $\\phi _ { i } ( x ) \\in \\mathbb { R } ^ { N }$ where $N = 4 * 4 * ( 6 4 + 6 4 ) = 2 0 4 8$ , where the second set of 64 channel features are copied from the first encoder layer. In the next Section, we show qualitative and quantitative experiments supporting this analysis. ",
+        "bbox": [
+            173,
+            257,
+            825,
+            396
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Prior work on embeddings: Now that our framework has been described both algorithmically and theoretically, we compare it to a large body of related work. The idea that intermediate CNN layers learn embeddings is not new. This dates back at least to Caruana et al. (1999), and was popularized in recent history with (Sharif Razavian et al., 2014; Devlin et al., 2015). Indeed, much contemporary work makes use of “off-the-shelf” CNN layers as features, where earlier layers tend to encode more generic feature representations (Zeiler & Fergus, 2013). However, such representations are typically global and refer to the entire image. Alternatively, one can extract local pixel-based feature representations, but these are typically defined by $1 x 1$ slices of a convolutional feature map (Hariharan et al., 2015; Long et al., 2014). Our theoretical analysis, while quite straightforward, shows that the optimal local representation (in terms of sufficiency) is given by a convolutional neighborhood of overlapping activations. Finally, we show that compositional matching with such local embeddings significantly outperforms global matching (see Fig. 3), and rivals the accuracy of feedforward CNN predictions (Table 1). ",
+        "bbox": [
+            173,
+            404,
+            825,
+            583
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            619,
+            326,
+            635
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We now present experimental results for discriminative networks trained for semantic segmentation, as well as generative networks trained for image synthesis. The goal of the experiments is to show that images generated with a simple NN regression are a good way to interpret the internal operations of a convolutional neural network. ",
+        "bbox": [
+            174,
+            659,
+            823,
+            714
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Networks: We use SegNet (Badrinarayanan et al., 2017), a recent state-of-the-art network for image segmentation, and Pix2Pix (Isola et al., 2016), a state-of-the-art network for conditional image synthesis and translation. We evaluate our findings for multiple datasets and tasks on which the original networks were trained. These include tasks such as synthesizing facades from architectural labels and vice versa, predicting segmentation class labels from urban RGB images, and synthesizing Google maps from aerial or satellite views. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            805
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Semantic segmentation: We use the CityScape (Cordts et al., 2016) and CamVid (Brostow et al., 2008; 2009) datasets for the task of semantic segmentation. Both datasets are annotated with semantic class labels for outdoor images collected from a car driving on the road. We use SegNet (Badrinarayanan et al., 2017) for CamVid sequences, and Pix2Pix (Isola et al., 2016) for the CityScape dataset. Figure 7 shows qualitatively results for these datasets. We can observe in Figure 7 that the compositional NN produces a nearly-identical result (CompNN column) to the one produced by the network (Pix2Pix and SegNet columns). This suggests that our method enables a good interpretation of discriminative deep networks on pixel-level classification. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/e460edc990296b1f2b28a4c77e96e98f0530f4aca69e53025c155769f3c66238.jpg",
+        "image_caption": [
+            "Figure 7: Semantic segmentation: The results of semantic segmentation on cityscape and CamVid dataset. This result suggests the following observations. First, the difference between images generated by generative networks (Pix2Pix and SegNet columns) and NN embedding (CompNN column) is surprisingly small. Thus, our method can perfectly interpret discriminative deep networks on pixel-level classification. Second, we can notice some noise edges with a high gradient (see columns 5-8). This phenomenon can also be used to understand the difficulty of image segmentation task: borders with high gradients are usually hard to classify due to the ambiguous patches in training set. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            104,
+            813,
+            299
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/04b1d2bfaa03d00629870b27eade55e7537d0fba1b1daa89447ffe463c4800b4.jpg",
+        "image_caption": [
+            "Figure 8: Image synthesis: The results suggest that Comp NN (our approach) can also explain the results from $\\mathrm { P i x 2 P i x }$ . We conclude this because our approach reproduces color and the structure of the Pix2Pix output, including a few artifacts (e.g., the image cuts in the 6th and 7th columns). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            439,
+            807,
+            671
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Architectural labels-to-facades: We followed Isola et al. (2016) for this setting and used the annotations from (Tylecek & ˇ Sˇ ara, 2013). There are 400 training images in this dataset, and 100 images ´ in the validation set. We use the same dataset to generate architectural labels from images of facades. Pix2Pix (Isola et al., 2016) models are trained using 400 images from the training set for both labels-to-facades and vice versa. Figure 8 shows qualitative examples of synthesizing real-world images using pixel-wise nearest neighbor embedding in its first and second rows. We observe that the NN-embedding perfectly explains the generation of deformed edges (see CompNN column), and how the generative architecture is eventually memorizing patches from the training set. ",
+        "bbox": [
+            173,
+            761,
+            825,
+            875
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Satellite-to-maps: This dataset contains 1096 training images and 1000 testing images scraped from Google Maps. We use the same settings used by Isola et al. (2016) for this task. Figure 8 qualitatively shows in its third row how Google maps are synthesized from satellite images. We can observe that our synthesis (CompNN column) is nearly identical to the image generated by the network (Pix2Pix columns). ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/958bb1fb75d50205cb552e76a02cd06ad915669a35f5392c7ed5f97eb977e62f.jpg",
+        "image_caption": [
+            "Figure 9: Bias modification: Given the same label input, we show different results obtained by matching to different databases (using an embedding learned by Pix2Pix). By modifying the database to include specific buildings from specific locations, one can introduce and remove implicit biases in the original network (e.g.,one can generate “European” facades versus “American” facades). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            107,
+            816,
+            199
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            353,
+            823,
+            382
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bias modification: Figure 9 shows that the output of nonparametric matching (3rd - 6th columns from left to right) can be controlled through explicit modification of the matching database. In simple words, this experiment shows that we can control properties of the synthesized image by simply specifying the exemplars in the database. We can observe in Figure 9 that the synthesized images preserve the structure (e.g., windows, doors, and roof), since it is the conditional input, but the textural components (e.g., color) change given different databases. ",
+        "bbox": [
+            174,
+            388,
+            825,
+            472
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Reconstruction: This experiment shows that the learned embeddings of a CNN also enables the reconstruction of the input images in a compositional fashion (as discussed in Sec. 3). The results of this experiment are shown in Fig. 10. The Figure has the following organization. In the middle columns (enclosed in a box), the Figure shows the input and output images. The first two columns (from left-to-right) show the reconstructions of the input images using a global nearest-neighbors and the proposed compositional nearest-neighbors approach. The last two columns show the reconstruction of the output images, also using a global nearest-neighbors and the proposed compositional nearest-neighbors approach. We can observe that the reconstructions of the input images using the global nearest-neighbors approach overall resembles the structure of the scene. However, the reconstructions of the input images using the proposed compositional nearest-neighbors reproduce the input scene with a remarkable accuracy. These results suggest that the learned embedding is rich in global and local information to either reconstruct both the input and output images. We can conclude then that CNNs understand an input image by finding the patches from the training images that enable the composition of an image reproducing the input. To the best of our knowledge, this is the first approach that reconstructs an input image using training instances using a learned pixel-embedding. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            700
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Correspondence map: Figure 11 shows a correspondence map that explicitly illustrates how an output image is synthesized by cutting-and-pasting patches from training images. We can observe that patches are selected from many different styles of facades, but in such a manner that ensures that the composed output is globally consistent while maintaining the appropriate local structures (such as windows, doors, awnings, etc.). This implies the learned patch embedding captures both global semantics and local structure. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            791
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Quantitative evaluation: We present the quantitative analysis of our pixel-wise nearest neighbor approach with an end-to-end pipeline in Table 1. We report classification accuracy of ground truth labels and mean intersection-over-union (IoU) compared to the predicted labels for the task of semantic segmentation. We can observe in Table 1 that compositional matching approaches the accuracy of the baseline CNN, and dramatically outperforms global matching (sometimes by a factor of 2X). Finally, self-supervised labels (SS) overall perform similarly to the original labels (O), but almost consistently help for compositional matching and consistently hurt for global matching. We posit that this is due to the fact that self-supervised labels tend to be overly-smoothed, and so act as a form of spatial regularization that helps compositional matching. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/b3e6b0fa986c001e0a672b33f13b53d50b97ad7caf1f7aa860efd8e51c8424ba.jpg",
+        "image_caption": [
+            "Figure 10: Reconstruction: Given the correspondences of NN features from penultimate the layer, we reconstruct the test input images (third column from left-to-right) by using the compositional nearest-neighbor approach: copying and pasting corresponding image patches from the input images of the training set. The reconstructions using a compositional nearest-neighbor approach is shown in the second column, while the reconstructions using a global nearest-neighbor approach is shown in the first column. The learned embedding thus enables not only the reconstruction of the input image, but also of the output image (see the last two columns). These results suggest that the embedding possess not only the information relevant to a specific task, but also semantic information from the original image. We can conclude then that CNNs understand an input image by finding the patches from the training images that enable the composition of an image reproducing the input. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            104,
+            769,
+            449
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Implementation Details: We used U-net as the generator for Pix2Pix, and used publicly available Tensorflow code for $\\operatorname { P i x } 2 \\mathrm { P i x } ^ { 2 }$ and SegNet3. For a slightly faster computation, we used the Eigen Library to implement the cosine distance. For Cityscape dataset, we shortlist 100 global neighborhoods using global bottleneck features for compositional NN searching. This leads to a 30 times speedup. For CamVid dataset, we shortlist 10 global neighborhoods. We can observe in previous results that the quality of generated images is hardly affected. We used 40-threads for these experiments. The average compute time per image is 22 minutes and 13 minutes for Cityscape and CamVid dataset respectively. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            743
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            765,
+            310,
+            781
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have presented a simple approach based on pixel-wise nearest neighbors to understand and interpret the functioning of convolutional neural networks for spatial prediction tasks. Our analysis suggests that CNNs behave as compositional nearest neighbor operators over a training set of patch-label pairs that act as an associative memory. But beyond simply memorizing, CNNs can generalize to novel data by composing together local patches from different training instances. Also, we argued that networks for pixel-level tasks learn sufficient statistics that enable the gener",
+        "bbox": [
+            174,
+            799,
+            825,
+            882
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/997d1d9f4f2790a842b44294ac144c73b0abc51535b2e1402c12dfe5a7e304a2.jpg",
+        "image_caption": [
+            "Figure 11: Correspondence map: Given the input label mask on the top left, we show the groundtruth image and the output of Pix2Pix below. Why does Pix2Pix synthesize the peculiar red awning from the input mask? To provide an explanation, we use CompNN to synthesize an image by explicitly cutting-and-pasting (composing) patches from training images. We color code pixels in the training images to denote correspondences. For example, CompNN copies doors from training image A (blue) and the red awning from training image C (yellow). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            104,
+            789,
+            356
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/d55be43bbdfa42984883f9b068370a8e18b8341306ead0379592eb9060ce94e5.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Approach</td><td colspan=\"3\">Facades CityScape CamVid (Mean Pixel Accuracy)</td><td colspan=\"3\">Facades CityScape (Mean IoU)</td></tr><tr><td>Baseline CNN</td><td>0.545</td><td>0.735</td><td>0.790</td><td>0.157</td><td>0.217</td><td>0.444</td></tr><tr><td>Comp NN (SS)</td><td>0.505</td><td>0.738</td><td>0.767</td><td>0.137</td><td>0.210</td><td>0.378</td></tr><tr><td>Comp NN (O)</td><td>0.493</td><td>0.722</td><td>0.754</td><td>0.134</td><td>0.217</td><td>0.372</td></tr><tr><td>Global Bottleneck NN (SS)</td><td>0.324</td><td>0.579</td><td>0.564</td><td>0.057</td><td>0.109</td><td>0.246</td></tr><tr><td>Global Bottleneck NN (O)</td><td>0.381</td><td>0.585</td><td>0.570</td><td>0.065</td><td>0.133</td><td>0.226</td></tr><tr><td>Global Decode2 NN (SS)</td><td>0.387</td><td>0.590</td><td>0.659</td><td>0.087</td><td>0.110</td><td>0.287</td></tr><tr><td>Global Decode2 NN (O)</td><td>0.393</td><td>0.600</td><td>0.664</td><td>0.090</td><td>0.136</td><td>0.308</td></tr></table>",
+        "bbox": [
+            173,
+            467,
+            813,
+            690
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 1: We compare compositional nearest neighbors (CompNN) to the baseline CNN and different global nearest neighbor approaches, obtained by matching feature maps from different layers (Global-Bottleneck and Global-Decode2). We report mean pixel accuracy and intersection-overunion, where predicted segmentation labels are compared to ground-truth labels. We specifically use the embedding learned by Isola et al. (2016) for Facades-to-Labels (Facades) and CityScape, and embedding learned by Badrinarayanan et al. (2017) for CamVid. On average, CompNN performs $5 \\%$ worse than the baseline CNN, though in some cases (CityScapes) it performs equally. However, compositional matching dramatically outperforms global matching, sometimes by a factor of 2X (Facade and CityScape IoU). In terms of global matching, the last feature layer (Decode2) strictly outperforms the intermediate Bottleneck layer, but is significantly larger ( $1 2 \\mathrm { { 8 ^ { 3 } } }$ versus 512 dimensions). Finally, self-supervised labels (SS) overall perform similarly to the original labels (O), but almost consistently help for compositional matching and consistently hurt for global matching. We posit that this is due to the fact that self-supervised labels tend to be overly-smoothed, and so act as a form of spatial regularization for compositional matching. ",
+        "bbox": [
+            173,
+            704,
+            825,
+            900
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "ation of pixel predictions. Our analysis and experiments not only support this argument, but also enables example-based explanations of network behavior and explicit modulation of the implicit biases learned by the network. We hope that our framework enables further analysis of convolutional networks from a non-parametric perspective. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            180,
+            285,
+            194
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Agnar Aamodt and Enric Plaza. Case-based reasoning: Foundational issues, methodological variations, and system approaches. AI communications, 7(1):39–59, 1994. ",
+        "bbox": [
+            176,
+            202,
+            823,
+            228
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Alessandro Achille and Stefano Soatto. On the emergence of invariance and disentangling in deep representations. CoRR, abs/1706.01350, 2017. URL http://arxiv.org/abs/1706.01350. ",
+        "bbox": [
+            176,
+            236,
+            821,
+            263
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Vijay Badrinarayanan, Alex Kendall, and Roberto Cipolla. Segnet: A deep convolutional encoder-decoder architecture for scene segmentation. IEEE Transactions on Pattern Analysis and Machine Intelligence (TPAMI), 2017. ",
+        "bbox": [
+            174,
+            270,
+            823,
+            310
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Aayush Bansal, Bryan Russell, and Abhinav Gupta. Marr Revisited: 2D-3D model alignment via surface normal prediction. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016. ",
+        "bbox": [
+            174,
+            318,
+            823,
+            358
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Aayush Bansal, Xinlei Chen, Bryan Russell, Abhinav Gupta, and Deva Ramanan. PixelNet: Representation of the pixels, by the pixels, and for the pixels. arXiv:1702.06506, 2017a. ",
+        "bbox": [
+            173,
+            366,
+            825,
+            393
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Aayush Bansal, Yaser Sheikh, and Deva Ramanan. PixelNN: Example-based image synthesis. CoRR, abs/1708.05349, 2017b. ",
+        "bbox": [
+            174,
+            401,
+            823,
+            428
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "David Bau, Bolei Zhou, Aditya Khosla, Aude Oliva, and Antonio Torralba. Network dissection: Quantifying interpretability of deep visual representations. CoRR, abs/1704.05796, 2017. ",
+        "bbox": [
+            174,
+            436,
+            825,
+            463
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "I. Biederman. Recognition by components: a theory of human image interpretation. Pyschological review, 94: 115–147, 1987. ",
+        "bbox": [
+            174,
+            472,
+            823,
+            498
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Gabriel J. Brostow, Jamie Shotton, Julien Fauqueur, and Roberto Cipolla. Segmentation and recognition using structure from motion point clouds. In Proc. of the European Conference on Computer Vision (ECCV), pp. 44–57, 2008. ",
+        "bbox": [
+            173,
+            506,
+            823,
+            545
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Gabriel J Brostow, Julien Fauqueur, and Roberto Cipolla. Semantic object classes in video: A high-definition ground truth database. Pattern Recognition Letters, 30(2):88–97, 2009. ",
+        "bbox": [
+            171,
+            554,
+            823,
+            582
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Gail A Carpenter. Neural network models for pattern recognition and associative memory. Neural networks, 2 (4):243–257, 1989. ",
+        "bbox": [
+            173,
+            589,
+            823,
+            616
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Rich Caruana, Hooshang Kangarloo, JD Dionisio, Usha Sinha, and David Johnson. Case-based explanation of non-case-based learning methods. In Proceedings of the AMIA Symposium, pp. 212. American Medical Informatics Association, 1999. ",
+        "bbox": [
+            174,
+            623,
+            823,
+            662
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L. Yuille. Deeplab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected crfs. CoRR, abs/1606.00915, 2016. ",
+        "bbox": [
+            171,
+            671,
+            823,
+            710
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Marius Cordts, Mohamed Omran, Sebastian Ramos, Timo Rehfeld, Markus Enzweiler, Rodrigo Benenson, Uwe Franke, Stefan Roth, and Bernt Schiele. The cityscapes dataset for semantic urban scene understanding. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016. ",
+        "bbox": [
+            173,
+            718,
+            823,
+            758
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "David Crandall, Pedro Felzenszwalb, and Daniel Huttenlocher. Spatial priors for part-based recognition using statistical models. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2005. ",
+        "bbox": [
+            173,
+            767,
+            823,
+            806
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Emily L. Denton, Soumith Chintala, Arthur Szlam, and Robert Fergus. Deep generative image models using a laplacian pyramid of adversarial networks. CoRR, abs/1506.05751, 2015. ",
+        "bbox": [
+            171,
+            814,
+            823,
+            842
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Jacob Devlin, Saurabh Gupta, Ross B. Girshick, Margaret Mitchell, and C. Lawrence Zitnick. Exploring nearest neighbor approaches for image captioning. CoRR, abs/1505.04467, 2015. ",
+        "bbox": [
+            173,
+            849,
+            823,
+            877
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "David Eigen and Rob Fergus. Predicting depth, surface normals and semantic labels with a common multiscale convolutional architecture. In Proc. of the IEEE International Conference on Computer Vision (ICCV), 2015. ",
+        "bbox": [
+            176,
+            885,
+            823,
+            922
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Pedro Felzenszwalb, David McAllester, and Deva Ramanan. A discriminatively trained, multiscale, deformable part model. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2008.   \nPedro F. Felzenszwalb and Daniel P. Huttenlocher. Pictorial structures for object recognition. International Journal of Computer Vision, 2005.   \nR. Fergus, P. Perona, and A. Zisserman. Object class recognition by unsupervised scale-invariant learning. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2003.   \nM. A. Fischler and R. A. Elschlager. The representation and matching of pictorial structures. IEEE Trans. Comput., 22(1), January 1973.   \nRoss Girshick, Forrest Iandola, Trevor Darrell, and Jitendra Malik. Deformable part models are convolutional neural networks. In Proceedings of the IEEE conference on Computer Vision and Pattern Recognition, pp. 437–446, 2015.   \nIan J. Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron C. Courville, and Yoshua Bengio. Generative adversarial networks. CoRR, abs/1406.2661, 2014.   \nBharath Hariharan, Pablo Arbelaez, Ross Girshick, and Jitendra Malik. Hypercolumns for object segmentation ´ and fine-grained localization. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2015.   \nKaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. arXiv preprint arXiv:1512.03385, 2015.   \nGeoffrey E. Hinton. Learning distributed representations of concepts. In Proceedings of the Eighth Annual Conference of the Cognitive Science Society, pp. 1–12. Hillsdale, NJ: Erlbaum, 1986.   \nPhillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. arxiv, 2016.   \nVivek Krishnan and Deva Ramanan. Tinkering under the hood: Interactive zero-shot learning with net surgery. CoRR, abs/1612.04901, 2016.   \nYann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444, 2015.   \nZachary C Lipton. The mythos of model interpretability. arXiv preprint arXiv:1606.03490, 2016.   \nCe Liu, Jenny Yuen, and Antonio Torralba. Nonparametric scene parsing via label transfer. IEEE Transactions on Pattern Analysis and Machine Intelligence, 33(12):2368–2382, 2011.   \nJonathan Long, Ning Zhang, and Trevor Darrell. Do convnets learn correspondence? In Advances in Neural Information Processing Systems (NIPS), 2014.   \nJonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional models for semantic segmentation. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2015.   \nAravindh Mahendran and Andrea Vedaldi. Understanding deep image representations by inverting them. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2015.   \nAlec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. CoRR, abs/1511.06434, 2015.   \nOlaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. CoRR, abs/1505.04597, 2015.   \nAli Sharif Razavian, Hossein Azizpour, Josephine Sullivan, and Stefan Carlsson. Cnn features off-the-shelf: an astounding baseline for recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition workshops, pp. 806–813, 2014.   \nRavid Shwartz-Ziv and Naftali Tishby. Opening the black box of deep neural networks via information. arXiv preprint arXiv:1703.00810, 2017.   \nChristian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian J. Goodfellow, and Rob Fergus. Intriguing properties of neural networks. CoRR, abs/1312.6199, 2013.   \nNaftali Tishby and Noga Zaslavsky. Deep learning and the information bottleneck principle. CoRR, abs/1503.02406, 2015. URL http://arxiv.org/abs/1503.02406.   \nRadim Tylecek and Radim ˇ Sˇ ara. Spatial pattern templates for recognition of objects with regular structure. In ´ Proc. German Conference on Pattern Recognition (GCPR), Saarbrucken, Germany, 2013.   \nC. Vondrick, A. Khosla, T. Malisiewicz, and A. Torralba. HOGgles: Visualizing Object Detection Features. Proc. of the IEEE International Conference on Computer Vision (ICCV), 2013.   \nMarkus Weber, Max Welling, and Pietro Perona. Towards automatic discovery of object categories. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2000.   \nSaining Xie and Zhuowen Tu. Holistically-nested edge detection. In Proc. of the IEEE International Conference on Computer Vision (ICCV), 2015.   \nMatthew D. Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. CoRR, abs/1311.2901, 2013.   \nMatthew D. Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In Proc. of the European Conference on Computer Vision (ECCV), pp. 818–833, 2014.   \nChiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. arXiv preprint arXiv:1611.03530, 2016.   \nBolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Object detectors emerge in \\` deep scene cnns. In Proc. of the International Conference on Learning Representations (ICLR), 2014.   \nJun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A. Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. CoRR, abs/1703.10593, 2017. ",
+        "bbox": [
+            171,
+            71,
+            826,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            828,
+            416
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX: ADDITIONAL EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            637,
+            118
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "A.1 GLOBAL NEAREST NEIGHBORS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            135,
+            436,
+            148
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We also present synthesized images using a global nearest neighbors (NN) approach. In this case, we use the global information from the bottleneck features and FC7 features. These bottleneck features can reveal which patches are learned and which training instances have more influence than others. ",
+        "bbox": [
+            176,
+            161,
+            825,
+            200
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/4e210df7e3260fa44a989104201db13c850bf65c128e0d308edf855f4a812960.jpg",
+        "image_caption": [
+            "Figure 12: Global NN v.s. Comp NN. We show synthesized images using our CompNN methods and four global NN approaches (global nearest neighbor on bottleneck feature embedding and Decode2 feature embedding using self-supervised labels and original labels respectively). We can observe that (1) compositional nearest neighbor outperforms other global nearest neighbor approaches, (2) using Decode2 features (the penultimate layer) sometimes can generate more similar structures (See row 1,4). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            229,
+            812,
+            593
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Fig. 12 shows the synthesized images using several global NN approaches and a CompNN approach. We can observe that the results of global NN approaches overall resembles global properties of the output of the Convolutional Neural Network (CNN) and of the CompNN approach. For instance, in the top two rows, the output of the global NN resembles the color of the facade and structural properties of the buildings. Also, in the bottom two rows, we can observe that the global NN overall captures the organization of the scene because many labels in the global NN overlap considerably with the output of the CNN and the ground truth. ",
+        "bbox": [
+            173,
+            723,
+            825,
+            800
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "A.2 COMPOSITIONAL NEAREST NEIGHBORS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            820,
+            495,
+            834
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "In this section, we show more results of our proposed Compositional Nearest Neighbors. Both self-supervised labels and original labels are evaluated in this section. We can observe in Fig.13 that the results of the Compositional Nearest Neighbors (CompNN) approach are quite similar to those of the Convolutional Neural Network. We can also observe that the CompNN produces smoother results when it uses self-supervised labels than when it uses the original ones. Moreover, the self-supervised CompNN method produces results that are more alike to those of the Convolutional Neural Network. ",
+        "bbox": [
+            174,
+            847,
+            825,
+            922
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/f08ed120cf4fe69833a6a3dff6248b0c348be41d38064611ee033789439acd4a.jpg",
+        "image_caption": [
+            "Figure 13: Compositional Nearest Neighbors (CompNN) segmentation results using self-supervised and original labels. Overall, CompNN produces similar results compared with those of the Convolutional Neural Network. In particular, CompNN produces smoother results when it uses selfsupervised labels than when it uses the original labels. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            102,
+            802,
+            607
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "A.3 ADDITIONAL IMAGE SYNTHESIS RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            700,
+            511,
+            715
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Fig. 14 shows additional image syntheses using a CNN and CompNN with original and self-supervised labels. As discussed earlier, the CompNN with self-supervised labels produces a smoother image than when it uses the original labels. ",
+        "bbox": [
+            173,
+            727,
+            826,
+            765
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "B APPENDIX: EXPERIMENTAL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            786,
+            521,
+            803
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "B.1 COMPUTATIONAL COMPLEXITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            818,
+            436,
+            833
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Although Compositional Nearest Neighbors provide insights into the internal operations of a CNN, its computational complexity is very high. In this section, we show some experimental details to speed up the CompNN process. Assume a dataset with $N$ images, each with $H \\times W$ pixels, and $M$ filters from the last layer of a CNN. Then, the computational complexity for synthesizing one image using CompNN is ",
+        "bbox": [
+            174,
+            843,
+            825,
+            895
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0f2b0063355dcfb128bc4ec97e4e6d56f135f34d57d2762c8ae04a9f9924704c.jpg",
+        "text": "$$\nO ( N H ^ { 2 } W ^ { 2 } M ^ { 2 } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            444,
+            904,
+            555,
+            921
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/dbc31d4ab73668499da889f3a9dc86a24c58d1198ecc8d04d39ae2478552ba4a.jpg",
+        "image_caption": [
+            "Figure 14: Synthesized images for pixel-wise prediction tasks with a Convolutional Neural Network, and Compositional Nearest Neighbors using self-supervised and original labels. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            104,
+            802,
+            602
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "We now introduce several approaches to speed up searching process. (1) Although Numpy from Python calculates the distance between two features quickly, the iterations for synthesizing a pixel are slow. To alleviate this, we implemented the CompNN using $\\mathrm { C } { + } { + }$ . (2) When a dataset has a large number of training instances, we used bottleneck features to narrow the training set. Especially in the segmentation problem, we can generate OK results with only 5-10 training reference. (3) Our implementation uses several threads in order to speedup the process. Specifically, each thread is in charge of synthesizing a disjoint set of pixels. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            750
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "The synthesis of facades using the Facades dataset (400 training samples) takes about 2 hours with 20-30 threads on the CPU. This can be used as a reference for experiments on other datasets. ",
+        "bbox": [
+            174,
+            756,
+            823,
+            781
+        ],
+        "page_idx": 18
+    }
+]

parse/train/HKtsGW-lNbw/HKtsGW-lNbw.md

@@ -0,0 +1,236 @@
+# Online and Offline Reinforcement Learning by Planning with a Learned Model
+
+Julian Schrittwieser∗ DeepMind swj@google.com
+
+Thomas Hubert∗ DeepMind tkhubert@google.com
+
+Amol Mandhane DeepMind mandhane@google.com
+
+Mohammadamin Barekatain DeepMind barekatain@google.com
+
+Ioannis Antonoglou   
+DeepMind   
+University College London   
+ioannisa@google.com David Silver DeepMind   
+University College London   
+davidsilver@google.com
+
+# Abstract
+
+Learning efficiently from small amounts of data has long been the focus of modelbased reinforcement learning, both for the online case when interacting with the environment and the offline case when learning from a fixed dataset. However, to date no single unified algorithm has demonstrated state-of-the-art results in both settings. In this work, we describe the Reanalyse algorithm which uses modelbased policy and value improvement operators to compute new improved training targets on existing data points, allowing efficient learning for data budgets varying by several orders of magnitude. We further show that Reanalyse can also be used to learn entirely from demonstrations without any environment interactions, as in the case of offline Reinforcement Learning (offline RL). Combining Reanalyse with the MuZero algorithm, we introduce MuZero Unplugged, a single unified algorithm for any data budget, including offline RL. In contrast to previous work, our algorithm does not require any special adaptations for the off-policy or offline RL settings. MuZero Unplugged sets new state-of-the-art results in the RL Unplugged offline RL benchmark as well as in the online RL benchmark of Atari in the standard 200 million frame setting.
+
+# 1 Introduction
+
+Offline reinforcement learning holds the promise of learning useful policies from many existing real-world datasets in a wide range of important problems such as robotics, healthcare or education (Levine et al., 2020). Learning effectively from offline data is crucial for such tasks where interaction with the environment is costly or comes with safety concerns, but a large amount of logged and other offline data is often available.
+
+A wide variety of effective reinforcement learning (RL) algorithms for the online case have been described, achieving impressive results in video games (Mnih et al., 2015), robotic control (Akkaya et al., 2019) and many other problems. However, applying these online RL algorithms to offline data often remains challenging due to off-policy issues, with the best results in offline RL so far obtained by specialised offline algorithms (Kumar et al., 2020; Wang et al., 2020; Agarwal et al., 2020). At the same time, model-based reinforcement learning (RL) has long focused on learning efficiently from little data, even going as far as learning completely within a model of the environment (Hafner et al., 2018) - an approach ideally suited for offline RL.
+
+So far, these developments have been relatively independent, with no unified algorithm that could achieve state-of-the art results in both the online and offline settings.
+
+In this paper, we describe the Reanalyse algorithm, a simple yet effective technique for policy and value improvement at any data budget, including the fully offline case. A preliminary version of Reanalyse was briefly introduced in the context of MuZero (Schrittwieser et al., 2020), but limited to data efficiency improvements in the discrete action case. Here, we delve deeper into the algorithm and push its capabilities much further – ultimately to the point where most or all of the data is reanalysed.
+
+Starting with the possible uses of Reanalyse, we show how it can be used for data efficient learning and offline RL, leading to MuZero Unplugged. We demonstrate its effectiveness for the online case through results on Atari and for the offline case through results on the RL Unplugged benchmark for Atari and DM Control.
+
+# 2 Related Work
+
+Recent work by Levine et al. (2020) provides a thorough review of offline RL literature and presents an excellent introduction to the subject. Much research has focused on regularising the value or policy learning to counteract off-policy issues and learn only from high quality data. Critic-Regularized Regression (CRR) uses a critic to filter out bad actions and uses only good actions to train the policy (Wang et al., 2020). Random Ensemble Mixture (REM) regularises q-value estimation by using random convex combinations of ensemble members during training, and the ensemble mean during evaluation (Agarwal et al., 2020). Conservative Q-Learning (CQL) learns a conservative Q-function, used to lower bound the value of the current policy (Kumar et al., 2020). Pessimistic Offline Policy Optimization (POPO) also uses a pessimistic value function for policy learning (He & Hou, 2021).
+
+Existing work has also demonstrated the promise of model-based RL for offline learning (Matsushima et al., 2020; Argenson & Dulac-Arnold, 2020), but has often been restricted to tasks with lowdimensional action or state spaces, and has not been applied to visually more complex tasks such as Atari (Bellemare et al., 2013).
+
+Model-Based Offline Reinforcement Learning (MOReL) implements a two-step procedure, first learning a pessimistic MDP from offline data using Gaussian dynamics models, then a policy within this learned MDP (Kidambi et al., 2020). Results are presented for state-based control tasks. Modelbased Offline Policy Optimization (MOPO) penalises rewards by the uncertainty of the model dynamics to avoid distributional shift issues (Yu et al., 2020). Offline Reinforcement Learning from Images with Latent Space Models (LOMPO) extends MOPO to image based tasks (Rafailov et al., 2021). Results are reported on newly introduced datasets with image observations, which the authors aim to open-source in the near future. Deep Averagers with Costs MDP (DAC-MDP) (Shrestha et al., 2021) builds non-parametric models from the offline data, solves these tabular MDPs using value iteration, then generalizes back to the original MDP.
+
+Most previous approaches primarily use the learned model for uncertainty estimation and to train a policy; they do not directly use the learned model for planning over action sequences. In contrast, our method focuses on using the learned model directly for policy and value improvement through planning both offline (when learning from data) and online (when interacting with an environment). It requires no regularisation of the value or policy function either in the online or offline case, works well even in very high dimensional state spaces and is equally applicable to both discrete and continuous action spaces.
+
+Reanalyse is also qualitatively different from Dyna (Sutton, 1991) in several important regards: it uses both value and policy rather than value function alone; and it also updates the state representation. In the specific case of MuZero Reanalyse it also performs a tree search rather than a single step lookahead used in Dyna.
+
+A combination of MuZero Unplugged with regularisation approaches such as introduced in the previous work discussed above (Kidambi et al., 2020; Yu et al., 2020; Rafailov et al., 2021) is possible; we leave such investigations for future work.
+
+# 3 Reanalyse
+
+Reanalyse takes advantage of model-based value and policy improvement operators to generate new value and policy training targets for a given state (Algorithm 1). In this work, we will use MuZero’s Monte Carlo Tree Search (MCTS) planning algorithm combined with its learned model of the environment dynamics as the improvement operator.2
+
+As the learned model and its predictions are updated and improved throughout training, Reanalyse can be repeatedly applied to the same state to generate better and better training targets. The improved training targets in turn are used to improve the model and predictions, leading to a virtuous cycle of improvement.
+
+Algorithm 1 The Reanalyse algorithm. MuZero Unplugged instantiates representation, predict, dynamics with the MuZero network architecture; plan with MCTS; loss with the MuZero loss in eqn (1); and optimise with Adam.
+
+for $\mathrm { s t e p } \gets 0 . . . N$ do t ∼ random(1 : T ) s0t = representation(h1:t, θ) for $\mathrm { i }  0 . . . k$ do π it , $\nu _ { t } ^ { i } =$ plan(representation(h1:t+i, θ), θ) pit, vit = predict(sit, θ) ri+1t , si+1t = dynamics(sit, at+i, θ) end for $l = \mathrm { l o s s } ( h _ { t : t + k } , \{ r , p , v , u , \pi , \nu \} _ { t } ^ { 0 : k } , \theta )$ $\Delta \theta = \mathrm { o p t i m i s e } ( l , \theta )$   
+end for
+
+To run MCTS and compute new targets for a training point, the representation function of MuZero maps the history $h _ { 1 : t }$ of observations, actions and rewards up to timestep $t$ into an agent state or embedding $s _ { t }$ . The search over possible future action sequences then takes place entirely in this embedding space, by rolling the dynamics forward and applying prediction functions at every step. These predictions output the key quantities required by planning: the policy, value function and reward. The resulting MCTS statistics at the root of the search tree - visit counts for the actions and value estimate averaged over the tree - are then used as new training targets. During reanalysis, no actions $a$ are selected – instead the agent updates its model and prediction parameters based on the data it has already experienced.
+
+Specifically, MuZero Reanalyse jointly adjusts its parameters $\theta$ to repeatedly optimise the following loss at every time-step $t$ , applied to a model that is unrolled $0 . . . K$ steps into the future,
+
+$$
+l _ { t } ( \theta ) = \sum _ { k = 0 } ^ { K } l ^ { p } ( \pi _ { t + k } , p _ { t } ^ { k } ) + \ \sum _ { k = 0 } ^ { K } l ^ { v } ( z _ { t + k } , v _ { t } ^ { k } ) + \sum _ { k = 1 } ^ { K } l ^ { r } ( u _ { t + k } , r _ { t } ^ { k } )
+$$
+
+where $p _ { t } ^ { k } , v _ { t } ^ { k }$ , and $r _ { k } ^ { t }$ are respectively the policy, value and reward prediction produced by the $k$ -step unrolled model. The respective targets for these predictions are drawn from the corresponding time-step $t + k$ of the real trajectory: $\pi _ { t + k } , \nu _ { t + k }$ are the improved policy and value generated by the search, $z _ { t + k } = u _ { t + k + 1 } + . . . + \gamma ^ { n - 1 } u _ { t + k + n } + \gamma ^ { n } \nu _ { t + k + n }$ is an $n$ -step return, and $u _ { t + k }$ is the true reward.
+
+The policy and value predictions are then updated towards the new training targets, in the same way they would be for targets computed based on environment interactions - through minimising losses $l ^ { p } , l ^ { v }$ and $l ^ { r }$ . In other words, Reanalyse requires no changes on the part of the learner and can be implemented purely in terms of adapting the actors to generate improved targets based on stored data instead of environment interactions.
+
+Since the actual MCTS procedure used to Reanalyse a state is the same as the one used to choose an action when interacting with an environment, it is straightforward to perform a mix of both. We refer to this ratio between targets computed from direct interactions with the environment, and targets
+
+![](images/55451c2b71572810e2f011f5b32046df76b1abd82c0dbb913534ab85b1c99e0b.jpg)  
+Figure 1: Reanalyse scaling in Atari. By varying the Reanalyse fraction alone, MuZero can learn efficiently at data budgets differing by orders of magnitude. All other parameters are held constant. Left: Final scores in Ms. Pac-Man for different Reanalyse fractions. Note the logarithmic $\mathbf { X }$ -axis: Linear improvements in score require exponentially more data, matching scaling laws such as described by (Kaplan et al., 2020) for language models.
+
+<table><tr><td>Reanalyse</td><td>Median</td><td>Mean</td><td>#Frames</td></tr><tr><td>50.0%</td><td>1331.7%</td><td>4094.4%</td><td>2000M</td></tr><tr><td>95.0%</td><td>1006.4%</td><td>2856.2%</td><td>200M</td></tr><tr><td>99.5%</td><td>126.6%</td><td>450.6%</td><td>20M</td></tr></table>
+
+Right: Mean & median human normalised scores over 57 Atari games, by Reanalyse fraction.
+
+computed by reanalysing existing data points as the Reanalyse fraction. A Reanalyse fraction of $0 \%$ refers to training by only interacting with the environment, no Reanalyse of stored data, whereas a fraction of $100 \%$ refers to the fully offline case with no environment interaction at all.
+
+Since Reanalyse only uses stored data points and the learned model to compute improved targets, it can be employed flexibly for many different purposes:
+
+• Data Efficiency. The simplest use of Reanalyse is to improve data efficiency by repeatedly computing updated targets on previously collected data throughout training. By scaling the Reanalyse fraction as described in Section 4, learning can be optimised for any data budget. For this purpose, the data to be reanalysed is sampled from the $N$ most recent environment interactions; in the limit this includes all interactions throughout training. Offline RL. When increasing the Reanalyse fraction to $100 \%$ , learning takes place entirely from stored offline data as described in Section 5, without any interaction with the environment. Offline data may be obtained from a variety of sources, such as other agents, logged data from a heuristic control system or human examples. Demonstrations. Reanalyse can be used to quickly bootstrap learning from demonstrations containing desirable behaviour that might otherwise be hard to discover - collected for instance from humans - while still interacting with the environment, learning from both sources of data at the same time. This is useful to skip past what might otherwise be hard exploration problems while still improving beyond the quality of the initial demonstrations. Exploitation of good episodes. When using Reanalyse to improve data efficiency, Reanalyse is applied to the most recently collected data. If instead data is ordered by some other metric, such as episode reward, Reanalyse can be used to quickly learn from rare events, such as rewards observed in hard-exploration tasks. This variant is most useful in deterministic environments, as it could otherwise bias the value estimates in stochastic environments.
+
+In this paper, we will focus on the data efficiency and offline RL cases. Remaining cases require no adjustments to the algorithm and only differ in the source of data to be reanalysed. Further combinations of the cases above are also possible, such as a mix of exploitation and data efficiency Reanalyse which we leave for future work.
+
+The Reanalyse algorithm has some similarities to experience replay (Lin, 1992). Whereas replay performs multiple gradient descent updates for the same data point and target, Reanalyse uses modelbased improvement operators to generate multiple training targets for the same data point. Reanalyse and replay have independent effects and can be combined to further improve data efficiency of learning; in fact we do so for all experiments in this paper.
+
+# 4 Reanalyse for Data Efficiency
+
+By adjusting the ratio between targets computed from interactions with the environment and from stored trajectories (Reanalyse fraction), Reanalyse can be used to train MuZero at any desired data
+
+<table><tr><td>Loss</td><td>Median</td><td>Mean</td></tr><tr><td>a BC</td><td>53.3 %</td><td>48.5 %</td></tr><tr><td>DQN</td><td>86.2 %</td><td>89.5 %</td></tr><tr><td>IQN</td><td>100.8 %</td><td>96.1 %</td></tr><tr><td>BCQ</td><td>107.5 %</td><td>120.0 %</td></tr><tr><td>REM</td><td>107.9 %</td><td>113.5 %</td></tr><tr><td>CRR (ours)</td><td>155.6 %</td><td>271.2 %</td></tr><tr><td>b MuZero BC</td><td>54.0 %</td><td>46.9 %</td></tr><tr><td>MuZero Unplugged</td><td>265.3 %</td><td>595.5 %</td></tr></table>
+
+<table><tr><td>Game</td><td>QR-DQN</td><td>REM</td><td>CQL(H)</td><td>MZ</td></tr><tr><td>asterix (1%)</td><td>359.8</td><td>363.3</td><td>592.4</td><td>27220.5</td></tr><tr><td>breakout</td><td>6.8</td><td>4.5</td><td>61.1</td><td>251.9</td></tr><tr><td>pong</td><td>-14.5</td><td>-20.8</td><td>19.3</td><td>-16.2</td></tr><tr><td>qbert</td><td>156.0</td><td>160.1</td><td>14012.0</td><td>6953.2</td></tr><tr><td>seaquest</td><td>250.1</td><td>370.5</td><td>779.4</td><td>4964.0</td></tr><tr><td>asterix (10%)</td><td>1293.9</td><td>3912.3</td><td>156.3</td><td>40554.0</td></tr><tr><td>breakout</td><td>61.8</td><td>56.9</td><td>269.3</td><td>485.8</td></tr><tr><td>pong</td><td>12.7</td><td>9.5</td><td>18.5</td><td>15.6</td></tr><tr><td>qbert</td><td>9420.5</td><td>5800.0</td><td>13855.6</td><td>16817.9</td></tr><tr><td>seaquest</td><td>353.1</td><td>3643.5</td><td>3674.1</td><td>8556.3</td></tr></table>
+
+# Table 1: RL Unplugged Atari benchmark.
+
+Left: Overall results. Mean and median normalised scores over the 46 Atari games of the RL Unplugged benchmark. a) Baseline algorithms. CRR results are for our own reimplementation, other results are from (Gulcehre et al., 2020). b) Results using the MuZero network architecture.
+
+Behaviour cloning (BC) with the MuZero network replicated the baseline BC results from a), confirming correct import of the dataset and evaluation settings. Critic Regularized Regression (CRR) (Wang et al., 2020) significantly improved performance of the policy. MuZero Unplugged training with Reanalyse loss and MCTS for action selection led to overall best performance.
+
+Right: Low-data setting. QR-DQN (Dabney et al., 2018), REM (Agarwal et al., 2020), CQL(H) (Kumar et al., 2020) and MuZero Unplugged results when trained on only $1 \%$ (top, 2 million frames) or $10 \%$ (bottom, 20 million frames) of Atari data. QR-DQN and REM results from (Agarwal et al., 2020). MuZero Unplugged performance improves consistently when trained on more data.
+
+budget, as shown in Figure 1. The total amount of computation for each training run (number of updates on the learner and number of searches on the actors) is held constant.
+
+As training progresses, the policy produced by MCTS with the latest network weights will increasingly differ from the policy originally used to generate the trajectories that are being reanalysed. This can bias the state distribution used for training as well as some of the training targets:
+
+• The policy prediction $p _ { t }$ for a state $s _ { t }$ is always updated towards the MCTS statistics $\pi _ { t }$ for that same state. In this way, the policy can be learned completely independently from the trajectory; no off-policy issues can arise.   
+• The reward prediction only depends on the state and the action that was taken from this state and is not affected by off-policy issues as such. However, if the state distribution is very biased - in the extreme an action may never be observed - the reward function will be unable to learn the correct reward prediction for these cases, limiting the maximum policy improvement step.   
+The situation for the value function depends on the choice of training target; when using an n-step TD return such as in Atari $( n = 5$ ), the target depends on the trajectory and off-policy issues can potentially arise. Whether this is an issue depends on how different the data distribution is from the policy that is being learned. Empirically, we observed that the gain from bootstrapping with the actually observed environment rewards seems to outweigh any harm from being off-policy. We speculate that the bias introduced by early bootstrapping may be larger than the bias introduced by off-policy targets, as also seen in prior work (Vinyals et al., 2019).
+
+# 5 MuZero Unplugged: Offline RL with Reanalyse
+
+We obtain MuZero Unplugged, an offline version of MuZero, by adjusting the Reanalyse fraction to $100 \%$ - learning without any environment interactions, purely from stored trajectories. In contrast to previous work, we perform no off-policy corrections or adjustments to the value and policy learning: the exact same algorithm applies to both the online and offline case.
+
+We used the RL Unplugged (Gulcehre et al., 2020) benchmark dataset for all offline RL experiments in this paper. To demonstrate the generality of the approach, we report results for both discrete and continuous action spaces as well as state and pixel based data, specifically:
+
+Table 2: Median score in RL Unplugged Atari: ablations of action selection and training loss. Median normalized scores over the 46 Atari games from RL Unplugged.   
+
+<table><tr><td>Loss Unroll</td><td colspan="3">supervised 0 1</td><td>CRR 5</td><td>Reanalyse 5</td></tr><tr><td>policy</td><td>60.6</td><td>61.4</td><td>5 54.0</td><td>155.6</td><td>203.2</td></tr><tr><td>value</td><td>92.2</td><td>105.0</td><td>159.2</td><td>153.0</td><td>239.9</td></tr><tr><td>MCTS</td><td>1</td><td>137.3</td><td>169.7</td><td>172.5</td><td>265.3</td></tr></table>
+
+Rows of the table correspond to different action selection methods: sampling according to the policy probabilities, selecting the action with the highest value or selecting according to MCTS visit counts. Columns correspond to different number of unroll steps of the MuZero learned model and different losses. The leftmost three columns use the action from the training data as a supervised policy target, the rightmost two columns use the CRR and the Reanalyse loss respectively. For the case of 0 unroll steps, an action-value head is used to predict action values, instead of the state-value predicted by the normal model. All columns use a 5-step TD bootstrap towards a target network as the value target. For all action selection methods, Reanalyse loss led to the best performance; for all losses, MCTS action selection also led to the best performance. Overall, the combination of MCTS action selection and Reanalyse loss - the MuZero Unplugged algorithm - led to the best results.
+
+• DM Control Suite, 9 different tasks, number of frames varies by task (Table 3). Continuous action space with 1 to 21 dimensions, state observations.
+
+• Atari, 46 games with 200M frames each. Discrete action space, pixel observations, stochasticity through sticky actions (Machado et al., 2017).
+
+MuZero Unplugged was highly effective in either setting, outperforming baseline algorithms in Atari (Table 1) as well as the DM Control Suite (Table 3). We performed no tuning of hyperparameters for these experiments, instead using the same hyperparameter values as for the online RL case (Schrittwieser et al., 2020; Hubert et al., 2021).
+
+To add another strong baseline for the Atari benchmark, we also implemented Critic Regularized Regression (CRR), a recent offline RL algorithm (Wang et al., 2020). For the critic value required by CRR we used the value head of MuZero model, trained by 5-step TD with respect to a target network, as in previous work (Schrittwieser et al., 2020) and the same as used for MuZero Unplugged. Using CRR to train the policy head led to improved results in Atari (Table 1a, CRR), matching results reported for continuous action tasks, but did not reach the same performance as MuZero Unplugged.
+
+Performance of MuZero Unplugged was robust across the whole range of 46 Atari games in the RL Unplugged benchmark, reaching the same or better performance as the DQN policy used to generate the data in 44 games, and slightly worse performance in only 2 games (Figure 2). Improvements in performance with respect to the training data were considerable, exceeding a 20 times increase in score in several games.
+
+To examine the performance of MuZero Unplugged in detail and ascertain the contributions of action selection methods and training losses, we also performed a set of ablations (Tables 2 and 7) based on the Atari dataset. We chose Atari because the large number of diverse levels enables robust performance estimates and its discrete action space allows us to cleanly disentangle the contributions of value and policy predictions as well as planning with MCTS. In contrast, for continuous action spaces such as in the DM Control suite, the contributions of policy and value are entangled, as the value function can only evaluate actions already sampled from the policy.
+
+For our ablations, we considered three possible action selection methods: Sampling actions according to the policy network probabilities, selecting the action with the maximum value, or selecting actions based on the MCTS visit count distribution (rows of Table 2). We also considered different losses and network architectures: the leftmost three columns use variants of the MuZero learned model with 0 (no model at all), 1 or 5 steps of model unroll, all trained using the supervised behaviour cloning policy target and a 5-step TD value target based on a target network. The next column used CRR to train the policy. The last column used the the MCTS visit count distribution from the Reanalyse loss. These ablations allow us to separately measure the contribution of MCTS at training time (rightmost column) and evaluation time (bottom row), with the combination of MCTS at evaluation time and Reanalyse loss (bottom right cell) corresponding to MuZero Unplugged.
+
+As expected, the policy prediction was insensitive to the choice of model depth, but benefited from an improved training target: the CRR loss significantly improved results. Best results were obtained when using the rich MCTS visit count distribution from the Reanalyse loss as a training target (top row of Table 2).
+
+When selecting actions according to the value estimate for each action (middle row of Table 2), the depth of the learned model was surprisingly important. The difference between estimating q-values (0-step model) and state-values (1-step model) was small, with both attaining results similar to the IQN baseline (Table 1a) — expected, since all of these results use a distributional value prediction. However, learning a full 5-step model led to a big improvement even though only 1-step value predictions were used for evaluation. We speculate that learning a full 5-step model is beneficial because it regularises the network representation and acts as a useful auxiliary loss.3
+
+<table><tr><td rowspan="2">Task</td><td rowspan="2"># dims # episodes</td><td rowspan="2"></td><td colspan="4">Baselines</td><td rowspan="2">MuZero BC Unplugged</td></tr><tr><td>BC</td><td>D4PG</td><td>BRAC</td><td>RABM</td></tr><tr><td>cartpole.swingup</td><td>1</td><td>40</td><td>386.0</td><td>856.0</td><td>869.0</td><td>798.0</td><td>143.7 343.3</td></tr><tr><td>finger.turn_hard</td><td></td><td>500</td><td>238.0</td><td>714.0</td><td>227.0</td><td>433.0</td><td>308.8 405.0</td></tr><tr><td>fish.swim</td><td>２55</td><td>200</td><td>444.0</td><td>180.0</td><td>222.0</td><td>504.0</td><td>542.8 585.4</td></tr><tr><td>manipulator.insert_ball</td><td></td><td>1500</td><td>385.0</td><td>154.0</td><td>55.6</td><td>409.0</td><td>412.7 557.0</td></tr><tr><td>manipulator.insert_peg</td><td>5</td><td>1500</td><td>279.0</td><td>50.4</td><td>49.5</td><td>290.0</td><td>309.9 432.7</td></tr><tr><td>walker.stand</td><td>6</td><td>200</td><td>386.0</td><td>930.0</td><td>829.0</td><td>689.0 444.4</td><td>759.8</td></tr><tr><td>walker.walk</td><td>6</td><td>200</td><td>380.0</td><td>549.0</td><td>786.0</td><td>651.0 496.3</td><td>901.5</td></tr><tr><td>cheetah.run</td><td>6</td><td>300</td><td>408.0</td><td>308.0</td><td>539.0</td><td>304.0 592.9</td><td>798.9</td></tr><tr><td>humanoid.run</td><td>21</td><td>3000</td><td>382.0</td><td>1.7</td><td>9.6</td><td>303.0 408.5</td><td>633.4</td></tr><tr><td>mean</td><td></td><td></td><td>365.3</td><td>415.9</td><td>398.5</td><td>486.8</td><td>406.7 601.9</td></tr></table>
+
+Table 3: Results for DM Control benchmark from RL Unplugged. Mean final score on 9 DM Control tasks, as well as mean score across all tasks. First three columns indicate task, action dimensonality and dataset size, subsequent four columns reproduce baseline results from (Gulcehre et al., 2020). Final columns show performance of Behaviour Cloning (BC) with the MuZero network and results for MuZero Unplugged. As the data sets for the DM Control tasks are very small and vary a hundredfold between tasks, to keep the number of model parameters per datapoint constant and prevent memorisation, we scaled the neural network according to channel $\begin{array} { r } { s = { \sqrt { \frac { d a t a p o i n t s } { l a y e r s } } } } \end{array}$ . For an ablation of network size see Table 9.
+
+Keeping the 5-step model but changing the loss for the policy head, we observed that CRR had no effect on the quality of the value prediction for action selection, while the richer MCTS visit count distribution from the Reanalyse loss led to another big improvement. Even though the policy head is not used when selecting actions according to the maximum 1-step value, we hypothesise that the auxiliary loss has a strong regularising effect and further improved the internal representation of the model. This matches the results of (Silver et al., 2017) that training a single combined network to estimate both policy and value led to improved value prediction accuracy.
+
+Finally, using MCTS to select actions at evaluation time (bottom row of Table 2) improved results no matter which loss was used at training time, with best results obtained when using MCTS for both training and evaluation - the full MuZero Unplugged algorithm.
+
+We also verified that our training setup correctly interpreted the offline data4 and reproduced the baseline performance when using the same loss: Using the actions played in the training data as a supervised policy target to train a policy head using cross-entropy loss and sampling from it for evaluation (Table 1, policy BC a and b) reproduced the behaviour cloning (BC) baseline results.
+
+Table 4: Comparison of MuZero Unplugged and CRR. Results for CRR (Wang et al., 2020) were reported by selecting the checkpoint with the highest mean reward from each training run. Since this does not follow the offline policy selection guidelines from RL Unplugged and is therefore not directly comparable to the baseline results, we compared to it separately. The same highest mean reward evaluation scheme as used in CRR was used for MuZero Unplugged results in this table as well. All other tables report results at the end of training.   
+
+<table><tr><td>Task</td><td>CRR BC</td><td>MuZero Unplugged</td></tr><tr><td>cartpole.swingup</td><td>664.0</td><td>501.8 594.3</td></tr><tr><td>finger.turn_hard</td><td>714.0</td><td>333.8 759.0</td></tr><tr><td>fish.swim</td><td>517.0 556.8</td><td>681.6</td></tr><tr><td>manipulator.insert_ball</td><td>625.0 465.6</td><td>659.2</td></tr><tr><td>manipulator.insert_peg</td><td>387.0</td><td>325.9 556.0</td></tr><tr><td>walker.stand</td><td>797.0 473.3</td><td>887.2</td></tr><tr><td>walker.walk</td><td>901.0 637.9</td><td>949.5</td></tr><tr><td>cheetah.run</td><td>577.0</td><td>765.3 869.9</td></tr><tr><td>humanoid.run</td><td>586.0</td><td></td></tr><tr><td>mean</td><td>640.9 497.4</td><td>416.5 643.1 733.3</td></tr></table>
+
+# 6 Offline RL and Continuous Action Spaces
+
+An important motivation for offline RL is the application to real-world systems such as robotics, which often have continuous and high-dimensional action spaces. To investigate the applicability of MuZero Unplugged to this setting, we used the DM Control Suite dataset from the RL Unplugged dataset. DM Control is a collection of physics based benchmark tasks (Tassa et al., 2018) with a variety of robotic bodies of different action and state dimensionalities (Table 3).
+
+In order to use planning and Reanalyse with continuous action spaces, we used the sample based search extension of MuZero introduced by (Hubert et al., 2021). This extension uses a policy head to produce a set of candidate actions to search over, where the MCTS considers only the sampled actions instead of fully enumerating the action space. Finally, the policy is updated towards the search distribution only at the sampled actions.
+
+When applying Reanalyse for data efficiency improvements to data generated by the agent itself, no modifications are required to use sample based search and Reanalyse together. In offline RL or when reanalysing demonstrations from a source other than the agent itself, the policy that generated the actions making up the dataset is often quite different from the one learned by MuZero Unplugged, and unlikely to sample the same actions, at least at the beginning of training. Since in this case the MCTS (and by extension, Reanalyse) can only consider actions that have been sampled from the policy, it would be unlikely to learn about the actions contained in the dataset, and thus unable to sample them from the policy in the future. This effect is most pronounced in very high dimensional action spaces.
+
+To prevent this issue, we explicitly included the action from the trajectory being reanalysed in the sample of actions searched over at the root of the MCTS tree. This serves the same purpose as the Dirichlet exploration noise used in standard MuZero - encouraging the MCTS to explore actions it would not otherwise consider. For the prior of the injected action we therefore use the same value as for the Dirichlet probability mass, $2 5 \%$ , though the algorithm is not sensitive to the exact value. This step is redundant for discrete action spaces (such as in Atari) where the policy already always produces a prior for all possible actions.
+
+We compared the performance of MuZero Unplugged to offline RL algorithms from the literature such as D4PG (Barth-Maron et al., 2018), BRAC (Wu et al., 2019) and RABM (Siegel et al., 2020; Gulcehre et al., 2020) (Table 3), as well as the recent Critic Regularized Regression (CRR) (Wang et al., 2020) algorithm (Table 4, shown separately as CRR was evaluated by selecting the maximum performance throughout training and results are thus not comparable to the other baselines).
+
+We first measured the performance of Behaviour Cloning (BC) when implemented using the MuZero network to ensure we used the offline dataset correctly and that it matches the evaluation environment. Overall performance indeed approximately matches the BC baseline (Table 3).
+
+MuZero Unplugged outperformed baseline algorithms both in individual tasks and for the mean return5 averaged across all tasks. It did best in difficult high-dimensional tasks such as humanoid.run or the manipulator tasks, classified as ”hard” by (Wang et al., 2020), compared to ”easy” for the other tasks. Performance in the simplest tasks, especially cartpole, was somewhat lower — primarily due to the very small datasets6 leading to overfitting of the learned model and value function throughout training: in cartpole, performance of the best checkpoint (Figure 4) was much better than performance at the end of training (Figure 3). Additional regularisation techniques such as dropout (Hinton et al., 2012) could be employed to prevent this. We leave this for future work since we are primarily interested in performance on complex tasks that we consider most representative of real-world problems.
+
+# 7 Limitations
+
+MuZero Unplugged uses a deterministic model, potentially limiting its performance in stochastic or partially observed environments. The learned model is a single time-step model, which may limit the time horizon of planning. MuZero Unplugged also does not employ explicit forms of regularizations; combination with existing methods from the literature may improve its performance on very small datasets.
+
+The MCTS improvement operator in MuZero Unplugged requires a suitable value function; in environments where value learning is very difficult this may limit the magnitude of the improvement obtained by Reanalyse.
+
+# 8 Conclusions
+
+In this paper we have investigated the Reanalyse algorithm and its applications to both data efficient online RL at any data budget and completely offline RL. We combined Reanalyse with MuZero to obtain MuZero Unplugged, a unified model-based RL algorithm that achieved a new state of the art in both online and offline reinforcement learning. Specifically, MuZero Unplugged outperformed prior baselines in the Atari Learning Environment both using a standard online budget of 200 million frames and other data budgets spanning multiple orders of magnitude. Furthermore, MuZero Unplugged also outperformed offline baselines in the RL Unplugged benchmark for Atari and continuous control. Unlike previous approaches, MuZero Unplugged uses the same algorithm for multiple regimes without any special treatment for off-policy or offline data.
+
+This work represents a further step towards the vision of a single algorithm that can address a wide range of reinforcement learning applications, extending the capabilities of model-based planning algorithms to encompass new dimensions such as online and offline learning, using discrete and continuous action spaces, across pixel and state-based observation spaces, in addition to the wide array of challenging planning tasks addressed by prior work (Silver et al., 2018).
+
+# Acknowledgements
+
+We would like to thank Caglar Gulcehre for providing very detailed feedback and helpful suggestions to improve the paper.
+
+All of the work in this paper was funded by DeepMind.
+
+# References
+
+Agarwal, R., Schuurmans, D., and Norouzi, M. An optimistic perspective on offline reinforcement learning. In International Conference on Machine Learning, pp. 104–114. PMLR, 2020.   
+Akkaya, I., Andrychowicz, M., Chociej, M., Litwin, M., McGrew, B., Petron, A., Paino, A., Plappert, M., Powell, G., Ribas, R., et al. Solving rubik’s cube with a robot hand. arXiv preprint arXiv:1910.07113, 2019.   
+Argenson, A. and Dulac-Arnold, G. Model-based offline planning, 2020.   
+Ba, J. L., Kiros, J. R., and Hinton, G. E. Layer normalization, 2016.   
+Barth-Maron, G., Hoffman, M. W., Budden, D., Dabney, W., Horgan, D., TB, D., Muldal, A., Heess, N., and Lillicrap, T. Distributed Distributional Deterministic Policy Gradients, 2018.   
+Bellemare, M. G., Naddaf, Y., Veness, J., and Bowling, M. The Arcade Learning Environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 47:253–279, 2013.   
+Bradbury, J., Frostig, R., Hawkins, P., Johnson, M. J., Leary, C., Maclaurin, D., Necula, G., Paszke, A., VanderPlas, J., Wanderman-Milne, S., and Zhang, Q. JAX: composable transformations of Python+NumPy programs, 2018. URL http://github.com/google/jax.   
+Dabney, W., Rowland, M., Bellemare, M. G., and Munos, R. Distributional reinforcement learning with quantile regression. In AAAI, 2018.   
+Espeholt, L., Soyer, H., Munos, R., Simonyan, K., Mnih, V., Ward, T., Doron, Y., Firoiu, V., Harley, T., Dunning, I., et al. IMPALA: Scalable distributed deep-RL with importance weighted actor-learner architectures. In Proceedings of the International Conference on Machine Learning (ICML), 2018.   
+Google, 2018. Cloud TPU. https://cloud.google.com/tpu/. Accessed: 2019.   
+Gulcehre, C., Wang, Z., Novikov, A., Paine, T. L., Colmenarejo, S. G., Zolna, K., Agarwal, R., Merel, J., Mankowitz, D., Paduraru, C., Dulac-Arnold, G., Li, J., Norouzi, M., Hoffman, M., Nachum, O., Tucker, G., Heess, N., and de Freitas, N. RL Unplugged: Benchmarks for Offline Reinforcement Learning. 2020. URL https://arxiv.org/pdf/2006.13888.   
+Hafner, D., Lillicrap, T., Fischer, I., Villegas, R., Ha, D., Lee, H., and Davidson, J. Learning latent dynamics for planning from pixels. arXiv preprint arXiv:1811.04551, 2018.   
+He, K., Zhang, X., Ren, S., and Sun, J. Identity mappings in deep residual networks. CoRR, abs/1603.05027, 2016. URL http://arxiv.org/abs/1603.05027.   
+He, Q. and Hou, X. POPO: Pessimistic Offline Policy Optimization, 2021.   
+Hennigan, T., Cai, T., Norman, T., and Babuschkin, I. Haiku: Sonnet for JAX, 2020. URL http://github.com/deepmind/dm-haiku.   
+Hessel, M., Modayil, J., Van Hasselt, H., Schaul, T., Ostrovski, G., Dabney, W., Horgan, D., Piot, B., Azar, M., and Silver, D. Rainbow: Combining improvements in deep reinforcement learning. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018.   
+Hinton, G. E., Srivastava, N., Krizhevsky, A., Sutskever, I., and Salakhutdinov, R. R. Improving neural networks by preventing co-adaptation of feature detectors. arXiv preprint arXiv:1207.0580, 2012.   
+Hubert, T., Schrittwieser, J., Antonoglou, I., Barekatain, M., Schmitt, S., and Silver, D. Learning and Planning in Complex Action Spaces. arXiv e-prints, April 2021.   
+Jaderberg, M., Mnih, V., Czarnecki, W. M., Schaul, T., Leibo, J. Z., Silver, D., and Kavukcuoglu, K. Reinforcement learning with unsupervised auxiliary tasks. arXiv preprint arXiv:1611.05397, 2016.   
+Kaplan, J., McCandlish, S., Henighan, T., Brown, T. B., Chess, B., Child, R., Gray, S., Radford, A., Wu, J., and Amodei, D. Scaling laws for neural language models, 2020.   
+Kidambi, R., Rajeswaran, A., Netrapalli, P., and Joachims, T. MOReL : Model-Based Offline Reinforcement Learning, 2020.   
+Kingma, D. P. and Ba, J. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2015.   
+Kumar, A., Zhou, A., Tucker, G., and Levine, S. Conservative Q-learning for Offline Reinforcement Learning, 2020.   
+Levine, S., Kumar, A., Tucker, G., and Fu, J. Offline reinforcement learning: Tutorial, review, and perspectives on open problems, 2020.   
+Lin, L.-J. Self-improving reactive agents based on reinforcement learning, planning and teaching. Machine learning, 8(3-4):293–321, 1992.   
+Loshchilov, I. and Hutter, F. Fixing weight decay regularization in adam. CoRR, abs/1711.05101, 2017. URL http://arxiv.org/abs/1711.05101.   
+Machado, M., Bellemare, M., Talvitie, E., Veness, J., Hausknecht, M., and Bowling, M. Revisiting the Arcade Learning Environment: Evaluation protocols and open problems for general agents. Journal of Artificial Intelligence Research, 61, 09 2017. doi: 10.1613/jair.5699.   
+Matsushima, T., Furuta, H., Matsuo, Y., Nachum, O., and Gu, S. Deployment-efficient reinforcement learning via model-based offline optimization, 2020.   
+Mnih, V., Kavukcuoglu, K., Silver, D., Rusu, A. A., Veness, J., Bellemare, M. G., Graves, A., Riedmiller, M., Fidjeland, A. K., Ostrovski, G., et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529, 2015.   
+Rafailov, R., Yu, T., Rajeswaran, A., and Finn, C. Offline reinforcement learning from images with latent space models. In Learning for Dynamics and Control, pp. 1154–1168. PMLR, 2021.   
+Schaul, T., Quan, J., Antonoglou, I., and Silver, D. Prioritized experience replay. In International Conference on Learning Representations, Puerto Rico, 2016.   
+Schmitt, S., Hessel, M., and Simonyan, K. Off-policy actor-critic with shared experience replay. arXiv preprint arXiv:1909.11583, 2019.   
+Schrittwieser, J., Antonoglou, I., Hubert, T., Simonyan, K., Sifre, L., Schmitt, S., Guez, A., Lockhart, E., Hassabis, D., Graepel, T., Lillicrap, T. P., and Silver, D. Mastering Atari, Go, Chess and Shogi by Planning with a Learned Model. Nature, 588(7839):604–609, 2020.   
+Shrestha, A. K., Lee, S., Tadepalli, P., and Fern, A. Deepaveragers: Offline reinforcement learning by solving derived non-parametric $\{ { \mathrm { m d p } } \} { \mathrm { s } }$ . In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id $\equiv$ eMP1j9efXtX.   
+Siegel, N. Y., Springenberg, J. T., Berkenkamp, F., Abdolmaleki, A., Neunert, M., Lampe, T., Hafner, R., and Riedmiller, M. Keep doing what worked: Behavioral modelling priors for offline reinforcement learning. arXiv preprint arXiv:2002.08396, 2020.   
+Silver, D., Schrittwieser, J., Simonyan, K., Antonoglou, I., Huang, A., Guez, A., Hubert, T., Baker, L., Lai, M., Bolton, A., Chen, Y., Lillicrap, T., Hui, F., Sifre, L., van den Driessche, G., Graepel, T., and Hassabis, D. Mastering the game of Go without human knowledge. Nature, 550:354–359, October 2017.   
+Silver, D., Hubert, T., Schrittwieser, J., Antonoglou, I., Lai, M., Guez, A., Lanctot, M., Sifre, L., Kumaran, D., Graepel, T., et al. A general reinforcement learning algorithm that masters chess, shogi, and Go through self-play. Science, 362(6419):1140–1144, 2018.   
+Sutton, R. S. Dyna, an integrated architecture for learning, planning, and reacting. ACM Sigart Bulletin, 2(4):160–163, 1991.   
+Tassa, Y., Doron, Y., Muldal, A., Erez, T., Li, Y., de Las Casas, D., Budden, D., Abdolmaleki, A., Merel, J., Lefrancq, A., Lillicrap, T., and Riedmiller, M. Deepmind control suite, 2018.   
+Vinyals, O., Babuschkin, I., Czarnecki, W. M., Mathieu, M., Dudzik, A., Chung, J., Choi, D. H., Powell, R., Ewalds, T., Georgiev, P., et al. Grandmaster level in StarCraft II using multi-agent reinforcement learning. Nature, pp. 1–5, 2019.   
+Wang, Z., Novikov, A., Zolna, K., Merel, J. S., Springenberg, J. T., Reed, S. E., Shahriari, B., Siegel, N., Gulcehre, C., Heess, N., et al. Critic Regularized Regression. Advances in Neural Information Processing Systems, 33, 2020.   
+Wu, Y., Tucker, G., and Nachum, O. Behavior regularized offline reinforcement learning. arXiv preprint arXiv:1911.11361, 2019.   
+Yu, T., Thomas, G., Yu, L., Ermon, S., Zou, J., Levine, S., Finn, C., and Ma, T. MOPO: Model-based Offline Policy Optimization, 2020.

parse/train/HKtsGW-lNbw/HKtsGW-lNbw_content_list.json

@@ -0,0 +1,1099 @@
+[
+    {
+        "type": "text",
+        "text": "Online and Offline Reinforcement Learning by Planning with a Learned Model ",
+        "text_level": 1,
+        "bbox": [
+            217,
+            122,
+            781,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Julian Schrittwieser∗ DeepMind swj@google.com ",
+        "bbox": [
+            217,
+            226,
+            366,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Thomas Hubert∗ DeepMind tkhubert@google.com ",
+        "bbox": [
+            406,
+            226,
+            573,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Amol Mandhane DeepMind mandhane@google.com ",
+        "bbox": [
+            617,
+            226,
+            784,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mohammadamin Barekatain DeepMind barekatain@google.com ",
+        "bbox": [
+            187,
+            290,
+            393,
+            332
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ioannis Antonoglou   \nDeepMind   \nUniversity College London   \nioannisa@google.com David Silver DeepMind   \nUniversity College London   \ndavidsilver@google.com ",
+        "bbox": [
+            415,
+            290,
+            594,
+            344
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            619,
+            290,
+            808,
+            345
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            381,
+            535,
+            396
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Learning efficiently from small amounts of data has long been the focus of modelbased reinforcement learning, both for the online case when interacting with the environment and the offline case when learning from a fixed dataset. However, to date no single unified algorithm has demonstrated state-of-the-art results in both settings. In this work, we describe the Reanalyse algorithm which uses modelbased policy and value improvement operators to compute new improved training targets on existing data points, allowing efficient learning for data budgets varying by several orders of magnitude. We further show that Reanalyse can also be used to learn entirely from demonstrations without any environment interactions, as in the case of offline Reinforcement Learning (offline RL). Combining Reanalyse with the MuZero algorithm, we introduce MuZero Unplugged, a single unified algorithm for any data budget, including offline RL. In contrast to previous work, our algorithm does not require any special adaptations for the off-policy or offline RL settings. MuZero Unplugged sets new state-of-the-art results in the RL Unplugged offline RL benchmark as well as in the online RL benchmark of Atari in the standard 200 million frame setting. ",
+        "bbox": [
+            232,
+            412,
+            766,
+            633
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            659,
+            310,
+            676
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Offline reinforcement learning holds the promise of learning useful policies from many existing real-world datasets in a wide range of important problems such as robotics, healthcare or education (Levine et al., 2020). Learning effectively from offline data is crucial for such tasks where interaction with the environment is costly or comes with safety concerns, but a large amount of logged and other offline data is often available. ",
+        "bbox": [
+            174,
+            690,
+            825,
+            760
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A wide variety of effective reinforcement learning (RL) algorithms for the online case have been described, achieving impressive results in video games (Mnih et al., 2015), robotic control (Akkaya et al., 2019) and many other problems. However, applying these online RL algorithms to offline data often remains challenging due to off-policy issues, with the best results in offline RL so far obtained by specialised offline algorithms (Kumar et al., 2020; Wang et al., 2020; Agarwal et al., 2020). At the same time, model-based reinforcement learning (RL) has long focused on learning efficiently from little data, even going as far as learning completely within a model of the environment (Hafner et al., 2018) - an approach ideally suited for offline RL. ",
+        "bbox": [
+            174,
+            766,
+            825,
+            877
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "So far, these developments have been relatively independent, with no unified algorithm that could achieve state-of-the art results in both the online and offline settings. ",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we describe the Reanalyse algorithm, a simple yet effective technique for policy and value improvement at any data budget, including the fully offline case. A preliminary version of Reanalyse was briefly introduced in the context of MuZero (Schrittwieser et al., 2020), but limited to data efficiency improvements in the discrete action case. Here, we delve deeper into the algorithm and push its capabilities much further – ultimately to the point where most or all of the data is reanalysed. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            195
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Starting with the possible uses of Reanalyse, we show how it can be used for data efficient learning and offline RL, leading to MuZero Unplugged. We demonstrate its effectiveness for the online case through results on Atari and for the offline case through results on the RL Unplugged benchmark for Atari and DM Control. ",
+        "bbox": [
+            174,
+            202,
+            825,
+            257
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            311,
+            321,
+            330
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recent work by Levine et al. (2020) provides a thorough review of offline RL literature and presents an excellent introduction to the subject. Much research has focused on regularising the value or policy learning to counteract off-policy issues and learn only from high quality data. Critic-Regularized Regression (CRR) uses a critic to filter out bad actions and uses only good actions to train the policy (Wang et al., 2020). Random Ensemble Mixture (REM) regularises q-value estimation by using random convex combinations of ensemble members during training, and the ensemble mean during evaluation (Agarwal et al., 2020). Conservative Q-Learning (CQL) learns a conservative Q-function, used to lower bound the value of the current policy (Kumar et al., 2020). Pessimistic Offline Policy Optimization (POPO) also uses a pessimistic value function for policy learning (He & Hou, 2021). ",
+        "bbox": [
+            174,
+            366,
+            825,
+            491
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Existing work has also demonstrated the promise of model-based RL for offline learning (Matsushima et al., 2020; Argenson & Dulac-Arnold, 2020), but has often been restricted to tasks with lowdimensional action or state spaces, and has not been applied to visually more complex tasks such as Atari (Bellemare et al., 2013). ",
+        "bbox": [
+            174,
+            497,
+            825,
+            553
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Model-Based Offline Reinforcement Learning (MOReL) implements a two-step procedure, first learning a pessimistic MDP from offline data using Gaussian dynamics models, then a policy within this learned MDP (Kidambi et al., 2020). Results are presented for state-based control tasks. Modelbased Offline Policy Optimization (MOPO) penalises rewards by the uncertainty of the model dynamics to avoid distributional shift issues (Yu et al., 2020). Offline Reinforcement Learning from Images with Latent Space Models (LOMPO) extends MOPO to image based tasks (Rafailov et al., 2021). Results are reported on newly introduced datasets with image observations, which the authors aim to open-source in the near future. Deep Averagers with Costs MDP (DAC-MDP) (Shrestha et al., 2021) builds non-parametric models from the offline data, solves these tabular MDPs using value iteration, then generalizes back to the original MDP. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            698
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Most previous approaches primarily use the learned model for uncertainty estimation and to train a policy; they do not directly use the learned model for planning over action sequences. In contrast, our method focuses on using the learned model directly for policy and value improvement through planning both offline (when learning from data) and online (when interacting with an environment). It requires no regularisation of the value or policy function either in the online or offline case, works well even in very high dimensional state spaces and is equally applicable to both discrete and continuous action spaces. ",
+        "bbox": [
+            174,
+            704,
+            825,
+            801
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Reanalyse is also qualitatively different from Dyna (Sutton, 1991) in several important regards: it uses both value and policy rather than value function alone; and it also updates the state representation. In the specific case of MuZero Reanalyse it also performs a tree search rather than a single step lookahead used in Dyna. ",
+        "bbox": [
+            174,
+            806,
+            825,
+            863
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A combination of MuZero Unplugged with regularisation approaches such as introduced in the previous work discussed above (Kidambi et al., 2020; Yu et al., 2020; Rafailov et al., 2021) is possible; we leave such investigations for future work. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 Reanalyse ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            289,
+            106
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Reanalyse takes advantage of model-based value and policy improvement operators to generate new value and policy training targets for a given state (Algorithm 1). In this work, we will use MuZero’s Monte Carlo Tree Search (MCTS) planning algorithm combined with its learned model of the environment dynamics as the improvement operator.2 ",
+        "bbox": [
+            174,
+            121,
+            825,
+            176
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As the learned model and its predictions are updated and improved throughout training, Reanalyse can be repeatedly applied to the same state to generate better and better training targets. The improved training targets in turn are used to improve the model and predictions, leading to a virtuous cycle of improvement. ",
+        "bbox": [
+            174,
+            183,
+            825,
+            238
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 The Reanalyse algorithm. MuZero Unplugged instantiates representation, predict, dynamics with the MuZero network architecture; plan with MCTS; loss with the MuZero loss in eqn (1); and optimise with Adam. ",
+        "bbox": [
+            173,
+            253,
+            821,
+            296
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "for $\\mathrm { s t e p } \\gets 0 . . . N$ do t ∼ random(1 : T ) s0t = representation(h1:t, θ) for $\\mathrm { i }  0 . . . k$ do π it , $\\nu _ { t } ^ { i } =$ plan(representation(h1:t+i, θ), θ) pit, vit = predict(sit, θ) ri+1t , si+1t = dynamics(sit, at+i, θ) end for $l = \\mathrm { l o s s } ( h _ { t : t + k } , \\{ r , p , v , u , \\pi , \\nu \\} _ { t } ^ { 0 : k } , \\theta )$ $\\Delta \\theta = \\mathrm { o p t i m i s e } ( l , \\theta )$   \nend for ",
+        "bbox": [
+            178,
+            297,
+            500,
+            454
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To run MCTS and compute new targets for a training point, the representation function of MuZero maps the history $h _ { 1 : t }$ of observations, actions and rewards up to timestep $t$ into an agent state or embedding $s _ { t }$ . The search over possible future action sequences then takes place entirely in this embedding space, by rolling the dynamics forward and applying prediction functions at every step. These predictions output the key quantities required by planning: the policy, value function and reward. The resulting MCTS statistics at the root of the search tree - visit counts for the actions and value estimate averaged over the tree - are then used as new training targets. During reanalysis, no actions $a$ are selected – instead the agent updates its model and prediction parameters based on the data it has already experienced. ",
+        "bbox": [
+            173,
+            469,
+            825,
+            594
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Specifically, MuZero Reanalyse jointly adjusts its parameters $\\theta$ to repeatedly optimise the following loss at every time-step $t$ , applied to a model that is unrolled $0 . . . K$ steps into the future, ",
+        "bbox": [
+            173,
+            601,
+            823,
+            630
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/61850c8ffea8a9a0e50a3db7695a83e872d85be4e03cbf155ad160823db94484.jpg",
+        "text": "$$\nl _ { t } ( \\theta ) = \\sum _ { k = 0 } ^ { K } l ^ { p } ( \\pi _ { t + k } , p _ { t } ^ { k } ) + \\ \\sum _ { k = 0 } ^ { K } l ^ { v } ( z _ { t + k } , v _ { t } ^ { k } ) + \\sum _ { k = 1 } ^ { K } l ^ { r } ( u _ { t + k } , r _ { t } ^ { k } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            645,
+            700,
+            689
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $p _ { t } ^ { k } , v _ { t } ^ { k }$ , and $r _ { k } ^ { t }$ are respectively the policy, value and reward prediction produced by the $k$ -step unrolled model. The respective targets for these predictions are drawn from the corresponding time-step $t + k$ of the real trajectory: $\\pi _ { t + k } , \\nu _ { t + k }$ are the improved policy and value generated by the search, $z _ { t + k } = u _ { t + k + 1 } + . . . + \\gamma ^ { n - 1 } u _ { t + k + n } + \\gamma ^ { n } \\nu _ { t + k + n }$ is an $n$ -step return, and $u _ { t + k }$ is the true reward. ",
+        "bbox": [
+            174,
+            693,
+            825,
+            762
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The policy and value predictions are then updated towards the new training targets, in the same way they would be for targets computed based on environment interactions - through minimising losses $l ^ { p } , l ^ { v }$ and $l ^ { r }$ . In other words, Reanalyse requires no changes on the part of the learner and can be implemented purely in terms of adapting the actors to generate improved targets based on stored data instead of environment interactions. ",
+        "bbox": [
+            173,
+            768,
+            825,
+            839
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Since the actual MCTS procedure used to Reanalyse a state is the same as the one used to choose an action when interacting with an environment, it is straightforward to perform a mix of both. We refer to this ratio between targets computed from direct interactions with the environment, and targets ",
+        "bbox": [
+            174,
+            844,
+            825,
+            887
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/55451c2b71572810e2f011f5b32046df76b1abd82c0dbb913534ab85b1c99e0b.jpg",
+        "image_caption": [
+            "Figure 1: Reanalyse scaling in Atari. By varying the Reanalyse fraction alone, MuZero can learn efficiently at data budgets differing by orders of magnitude. All other parameters are held constant. Left: Final scores in Ms. Pac-Man for different Reanalyse fractions. Note the logarithmic $\\mathbf { X }$ -axis: Linear improvements in score require exponentially more data, matching scaling laws such as described by (Kaplan et al., 2020) for language models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            90,
+            514,
+            213
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/95c6261156eb8e6dde29d795ac65a702c939e7c286428d66202fdfbdcde866c0.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Reanalyse</td><td>Median</td><td>Mean</td><td>#Frames</td></tr><tr><td>50.0%</td><td>1331.7%</td><td>4094.4%</td><td>2000M</td></tr><tr><td>95.0%</td><td>1006.4%</td><td>2856.2%</td><td>200M</td></tr><tr><td>99.5%</td><td>126.6%</td><td>450.6%</td><td>20M</td></tr></table>",
+        "bbox": [
+            537,
+            119,
+            818,
+            185
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Right: Mean & median human normalised scores over 57 Atari games, by Reanalyse fraction. ",
+        "bbox": [
+            169,
+            294,
+            787,
+            308
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "computed by reanalysing existing data points as the Reanalyse fraction. A Reanalyse fraction of $0 \\%$ refers to training by only interacting with the environment, no Reanalyse of stored data, whereas a fraction of $100 \\%$ refers to the fully offline case with no environment interaction at all. ",
+        "bbox": [
+            176,
+            330,
+            823,
+            372
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Since Reanalyse only uses stored data points and the learned model to compute improved targets, it can be employed flexibly for many different purposes: ",
+        "bbox": [
+            171,
+            378,
+            823,
+            407
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Data Efficiency. The simplest use of Reanalyse is to improve data efficiency by repeatedly computing updated targets on previously collected data throughout training. By scaling the Reanalyse fraction as described in Section 4, learning can be optimised for any data budget. For this purpose, the data to be reanalysed is sampled from the $N$ most recent environment interactions; in the limit this includes all interactions throughout training. Offline RL. When increasing the Reanalyse fraction to $100 \\%$ , learning takes place entirely from stored offline data as described in Section 5, without any interaction with the environment. Offline data may be obtained from a variety of sources, such as other agents, logged data from a heuristic control system or human examples. Demonstrations. Reanalyse can be used to quickly bootstrap learning from demonstrations containing desirable behaviour that might otherwise be hard to discover - collected for instance from humans - while still interacting with the environment, learning from both sources of data at the same time. This is useful to skip past what might otherwise be hard exploration problems while still improving beyond the quality of the initial demonstrations. Exploitation of good episodes. When using Reanalyse to improve data efficiency, Reanalyse is applied to the most recently collected data. If instead data is ordered by some other metric, such as episode reward, Reanalyse can be used to quickly learn from rare events, such as rewards observed in hard-exploration tasks. This variant is most useful in deterministic environments, as it could otherwise bias the value estimates in stochastic environments. ",
+        "bbox": [
+            217,
+            417,
+            826,
+            690
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we will focus on the data efficiency and offline RL cases. Remaining cases require no adjustments to the algorithm and only differ in the source of data to be reanalysed. Further combinations of the cases above are also possible, such as a mix of exploitation and data efficiency Reanalyse which we leave for future work. ",
+        "bbox": [
+            174,
+            702,
+            825,
+            757
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The Reanalyse algorithm has some similarities to experience replay (Lin, 1992). Whereas replay performs multiple gradient descent updates for the same data point and target, Reanalyse uses modelbased improvement operators to generate multiple training targets for the same data point. Reanalyse and replay have independent effects and can be combined to further improve data efficiency of learning; in fact we do so for all experiments in this paper. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            834
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 Reanalyse for Data Efficiency ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            852,
+            450,
+            869
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "By adjusting the ratio between targets computed from interactions with the environment and from stored trajectories (Reanalyse fraction), Reanalyse can be used to train MuZero at any desired data ",
+        "bbox": [
+            173,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/a60b290b047789fb9aea57612566531d5fcde4a5ef6abd4596a69ea0426483b3.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Loss</td><td>Median</td><td>Mean</td></tr><tr><td>a BC</td><td>53.3 %</td><td>48.5 %</td></tr><tr><td>DQN</td><td>86.2 %</td><td>89.5 %</td></tr><tr><td>IQN</td><td>100.8 %</td><td>96.1 %</td></tr><tr><td>BCQ</td><td>107.5 %</td><td>120.0 %</td></tr><tr><td>REM</td><td>107.9 %</td><td>113.5 %</td></tr><tr><td>CRR (ours)</td><td>155.6 %</td><td>271.2 %</td></tr><tr><td>b MuZero BC</td><td>54.0 %</td><td>46.9 %</td></tr><tr><td>MuZero Unplugged</td><td>265.3 %</td><td>595.5 %</td></tr></table>",
+        "bbox": [
+            173,
+            102,
+            467,
+            237
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/20046900120cd7bfd2f302e0c1b3cd22aaa60524d3eae7dccb4fdcd9f694d88c.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Game</td><td>QR-DQN</td><td>REM</td><td>CQL(H)</td><td>MZ</td></tr><tr><td>asterix (1%)</td><td>359.8</td><td>363.3</td><td>592.4</td><td>27220.5</td></tr><tr><td>breakout</td><td>6.8</td><td>4.5</td><td>61.1</td><td>251.9</td></tr><tr><td>pong</td><td>-14.5</td><td>-20.8</td><td>19.3</td><td>-16.2</td></tr><tr><td>qbert</td><td>156.0</td><td>160.1</td><td>14012.0</td><td>6953.2</td></tr><tr><td>seaquest</td><td>250.1</td><td>370.5</td><td>779.4</td><td>4964.0</td></tr><tr><td>asterix (10%)</td><td>1293.9</td><td>3912.3</td><td>156.3</td><td>40554.0</td></tr><tr><td>breakout</td><td>61.8</td><td>56.9</td><td>269.3</td><td>485.8</td></tr><tr><td>pong</td><td>12.7</td><td>9.5</td><td>18.5</td><td>15.6</td></tr><tr><td>qbert</td><td>9420.5</td><td>5800.0</td><td>13855.6</td><td>16817.9</td></tr><tr><td>seaquest</td><td>353.1</td><td>3643.5</td><td>3674.1</td><td>8556.3</td></tr></table>",
+        "bbox": [
+            473,
+            89,
+            816,
+            248
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 1: RL Unplugged Atari benchmark. ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            247,
+            470,
+            262
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Left: Overall results. Mean and median normalised scores over the 46 Atari games of the RL Unplugged benchmark. a) Baseline algorithms. CRR results are for our own reimplementation, other results are from (Gulcehre et al., 2020). b) Results using the MuZero network architecture. ",
+        "bbox": [
+            173,
+            262,
+            821,
+            303
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Behaviour cloning (BC) with the MuZero network replicated the baseline BC results from a), confirming correct import of the dataset and evaluation settings. Critic Regularized Regression (CRR) (Wang et al., 2020) significantly improved performance of the policy. MuZero Unplugged training with Reanalyse loss and MCTS for action selection led to overall best performance. ",
+        "bbox": [
+            176,
+            304,
+            823,
+            357
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Right: Low-data setting. QR-DQN (Dabney et al., 2018), REM (Agarwal et al., 2020), CQL(H) (Kumar et al., 2020) and MuZero Unplugged results when trained on only $1 \\%$ (top, 2 million frames) or $10 \\%$ (bottom, 20 million frames) of Atari data. QR-DQN and REM results from (Agarwal et al., 2020). MuZero Unplugged performance improves consistently when trained on more data. ",
+        "bbox": [
+            174,
+            358,
+            826,
+            414
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "budget, as shown in Figure 1. The total amount of computation for each training run (number of updates on the learner and number of searches on the actors) is held constant. ",
+        "bbox": [
+            174,
+            445,
+            823,
+            473
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As training progresses, the policy produced by MCTS with the latest network weights will increasingly differ from the policy originally used to generate the trajectories that are being reanalysed. This can bias the state distribution used for training as well as some of the training targets: ",
+        "bbox": [
+            176,
+            479,
+            821,
+            522
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• The policy prediction $p _ { t }$ for a state $s _ { t }$ is always updated towards the MCTS statistics $\\pi _ { t }$ for that same state. In this way, the policy can be learned completely independently from the trajectory; no off-policy issues can arise.   \n• The reward prediction only depends on the state and the action that was taken from this state and is not affected by off-policy issues as such. However, if the state distribution is very biased - in the extreme an action may never be observed - the reward function will be unable to learn the correct reward prediction for these cases, limiting the maximum policy improvement step.   \nThe situation for the value function depends on the choice of training target; when using an n-step TD return such as in Atari $( n = 5$ ), the target depends on the trajectory and off-policy issues can potentially arise. Whether this is an issue depends on how different the data distribution is from the policy that is being learned. Empirically, we observed that the gain from bootstrapping with the actually observed environment rewards seems to outweigh any harm from being off-policy. We speculate that the bias introduced by early bootstrapping may be larger than the bias introduced by off-policy targets, as also seen in prior work (Vinyals et al., 2019). ",
+        "bbox": [
+            215,
+            532,
+            825,
+            757
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 MuZero Unplugged: Offline RL with Reanalyse ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            776,
+            599,
+            795
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We obtain MuZero Unplugged, an offline version of MuZero, by adjusting the Reanalyse fraction to $100 \\%$ - learning without any environment interactions, purely from stored trajectories. In contrast to previous work, we perform no off-policy corrections or adjustments to the value and policy learning: the exact same algorithm applies to both the online and offline case. ",
+        "bbox": [
+            174,
+            808,
+            825,
+            863
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We used the RL Unplugged (Gulcehre et al., 2020) benchmark dataset for all offline RL experiments in this paper. To demonstrate the generality of the approach, we report results for both discrete and continuous action spaces as well as state and pixel based data, specifically: ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/9e370cbefd6de7a0c53f7179fa34b3a63188a7dc9e3186d07f04747842113cef.jpg",
+        "table_caption": [
+            "Table 2: Median score in RL Unplugged Atari: ablations of action selection and training loss. Median normalized scores over the 46 Atari games from RL Unplugged. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Loss Unroll</td><td colspan=\"3\">supervised 0 1</td><td>CRR 5</td><td>Reanalyse 5</td></tr><tr><td>policy</td><td>60.6</td><td>61.4</td><td>5 54.0</td><td>155.6</td><td>203.2</td></tr><tr><td>value</td><td>92.2</td><td>105.0</td><td>159.2</td><td>153.0</td><td>239.9</td></tr><tr><td>MCTS</td><td>1</td><td>137.3</td><td>169.7</td><td>172.5</td><td>265.3</td></tr></table>",
+        "bbox": [
+            302,
+            89,
+            694,
+            172
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Rows of the table correspond to different action selection methods: sampling according to the policy probabilities, selecting the action with the highest value or selecting according to MCTS visit counts. Columns correspond to different number of unroll steps of the MuZero learned model and different losses. The leftmost three columns use the action from the training data as a supervised policy target, the rightmost two columns use the CRR and the Reanalyse loss respectively. For the case of 0 unroll steps, an action-value head is used to predict action values, instead of the state-value predicted by the normal model. All columns use a 5-step TD bootstrap towards a target network as the value target. For all action selection methods, Reanalyse loss led to the best performance; for all losses, MCTS action selection also led to the best performance. Overall, the combination of MCTS action selection and Reanalyse loss - the MuZero Unplugged algorithm - led to the best results. ",
+        "bbox": [
+            173,
+            207,
+            826,
+            344
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• DM Control Suite, 9 different tasks, number of frames varies by task (Table 3). Continuous action space with 1 to 21 dimensions, state observations. ",
+        "bbox": [
+            215,
+            390,
+            823,
+            417
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• Atari, 46 games with 200M frames each. Discrete action space, pixel observations, stochasticity through sticky actions (Machado et al., 2017). ",
+        "bbox": [
+            217,
+            425,
+            823,
+            453
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "MuZero Unplugged was highly effective in either setting, outperforming baseline algorithms in Atari (Table 1) as well as the DM Control Suite (Table 3). We performed no tuning of hyperparameters for these experiments, instead using the same hyperparameter values as for the online RL case (Schrittwieser et al., 2020; Hubert et al., 2021). ",
+        "bbox": [
+            174,
+            469,
+            825,
+            525
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To add another strong baseline for the Atari benchmark, we also implemented Critic Regularized Regression (CRR), a recent offline RL algorithm (Wang et al., 2020). For the critic value required by CRR we used the value head of MuZero model, trained by 5-step TD with respect to a target network, as in previous work (Schrittwieser et al., 2020) and the same as used for MuZero Unplugged. Using CRR to train the policy head led to improved results in Atari (Table 1a, CRR), matching results reported for continuous action tasks, but did not reach the same performance as MuZero Unplugged. ",
+        "bbox": [
+            174,
+            531,
+            825,
+            614
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Performance of MuZero Unplugged was robust across the whole range of 46 Atari games in the RL Unplugged benchmark, reaching the same or better performance as the DQN policy used to generate the data in 44 games, and slightly worse performance in only 2 games (Figure 2). Improvements in performance with respect to the training data were considerable, exceeding a 20 times increase in score in several games. ",
+        "bbox": [
+            174,
+            621,
+            825,
+            690
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To examine the performance of MuZero Unplugged in detail and ascertain the contributions of action selection methods and training losses, we also performed a set of ablations (Tables 2 and 7) based on the Atari dataset. We chose Atari because the large number of diverse levels enables robust performance estimates and its discrete action space allows us to cleanly disentangle the contributions of value and policy predictions as well as planning with MCTS. In contrast, for continuous action spaces such as in the DM Control suite, the contributions of policy and value are entangled, as the value function can only evaluate actions already sampled from the policy. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            795
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For our ablations, we considered three possible action selection methods: Sampling actions according to the policy network probabilities, selecting the action with the maximum value, or selecting actions based on the MCTS visit count distribution (rows of Table 2). We also considered different losses and network architectures: the leftmost three columns use variants of the MuZero learned model with 0 (no model at all), 1 or 5 steps of model unroll, all trained using the supervised behaviour cloning policy target and a 5-step TD value target based on a target network. The next column used CRR to train the policy. The last column used the the MCTS visit count distribution from the Reanalyse loss. These ablations allow us to separately measure the contribution of MCTS at training time (rightmost column) and evaluation time (bottom row), with the combination of MCTS at evaluation time and Reanalyse loss (bottom right cell) corresponding to MuZero Unplugged. ",
+        "bbox": [
+            174,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As expected, the policy prediction was insensitive to the choice of model depth, but benefited from an improved training target: the CRR loss significantly improved results. Best results were obtained when using the rich MCTS visit count distribution from the Reanalyse loss as a training target (top row of Table 2). ",
+        "bbox": [
+            174,
+            126,
+            825,
+            181
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "When selecting actions according to the value estimate for each action (middle row of Table 2), the depth of the learned model was surprisingly important. The difference between estimating q-values (0-step model) and state-values (1-step model) was small, with both attaining results similar to the IQN baseline (Table 1a) — expected, since all of these results use a distributional value prediction. However, learning a full 5-step model led to a big improvement even though only 1-step value predictions were used for evaluation. We speculate that learning a full 5-step model is beneficial because it regularises the network representation and acts as a useful auxiliary loss.3 ",
+        "bbox": [
+            173,
+            188,
+            825,
+            285
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/a153f2f406f8663a5800e7d76538656ae2fe8aa5f487796e2dae76660d6bc182.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Task</td><td rowspan=\"2\"># dims # episodes</td><td rowspan=\"2\"></td><td colspan=\"4\">Baselines</td><td rowspan=\"2\">MuZero BC Unplugged</td></tr><tr><td>BC</td><td>D4PG</td><td>BRAC</td><td>RABM</td></tr><tr><td>cartpole.swingup</td><td>1</td><td>40</td><td>386.0</td><td>856.0</td><td>869.0</td><td>798.0</td><td>143.7 343.3</td></tr><tr><td>finger.turn_hard</td><td></td><td>500</td><td>238.0</td><td>714.0</td><td>227.0</td><td>433.0</td><td>308.8 405.0</td></tr><tr><td>fish.swim</td><td>２55</td><td>200</td><td>444.0</td><td>180.0</td><td>222.0</td><td>504.0</td><td>542.8 585.4</td></tr><tr><td>manipulator.insert_ball</td><td></td><td>1500</td><td>385.0</td><td>154.0</td><td>55.6</td><td>409.0</td><td>412.7 557.0</td></tr><tr><td>manipulator.insert_peg</td><td>5</td><td>1500</td><td>279.0</td><td>50.4</td><td>49.5</td><td>290.0</td><td>309.9 432.7</td></tr><tr><td>walker.stand</td><td>6</td><td>200</td><td>386.0</td><td>930.0</td><td>829.0</td><td>689.0 444.4</td><td>759.8</td></tr><tr><td>walker.walk</td><td>6</td><td>200</td><td>380.0</td><td>549.0</td><td>786.0</td><td>651.0 496.3</td><td>901.5</td></tr><tr><td>cheetah.run</td><td>6</td><td>300</td><td>408.0</td><td>308.0</td><td>539.0</td><td>304.0 592.9</td><td>798.9</td></tr><tr><td>humanoid.run</td><td>21</td><td>3000</td><td>382.0</td><td>1.7</td><td>9.6</td><td>303.0 408.5</td><td>633.4</td></tr><tr><td>mean</td><td></td><td></td><td>365.3</td><td>415.9</td><td>398.5</td><td>486.8</td><td>406.7 601.9</td></tr></table>",
+        "bbox": [
+            173,
+            301,
+            828,
+            489
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Results for DM Control benchmark from RL Unplugged. Mean final score on 9 DM Control tasks, as well as mean score across all tasks. First three columns indicate task, action dimensonality and dataset size, subsequent four columns reproduce baseline results from (Gulcehre et al., 2020). Final columns show performance of Behaviour Cloning (BC) with the MuZero network and results for MuZero Unplugged. As the data sets for the DM Control tasks are very small and vary a hundredfold between tasks, to keep the number of model parameters per datapoint constant and prevent memorisation, we scaled the neural network according to channel $\\begin{array} { r } { s = { \\sqrt { \\frac { d a t a p o i n t s } { l a y e r s } } } } \\end{array}$ . For an ablation of network size see Table 9. ",
+        "bbox": [
+            173,
+            501,
+            825,
+            622
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Keeping the 5-step model but changing the loss for the policy head, we observed that CRR had no effect on the quality of the value prediction for action selection, while the richer MCTS visit count distribution from the Reanalyse loss led to another big improvement. Even though the policy head is not used when selecting actions according to the maximum 1-step value, we hypothesise that the auxiliary loss has a strong regularising effect and further improved the internal representation of the model. This matches the results of (Silver et al., 2017) that training a single combined network to estimate both policy and value led to improved value prediction accuracy. ",
+        "bbox": [
+            173,
+            637,
+            825,
+            734
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally, using MCTS to select actions at evaluation time (bottom row of Table 2) improved results no matter which loss was used at training time, with best results obtained when using MCTS for both training and evaluation - the full MuZero Unplugged algorithm. ",
+        "bbox": [
+            176,
+            741,
+            821,
+            784
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also verified that our training setup correctly interpreted the offline data4 and reproduced the baseline performance when using the same loss: Using the actions played in the training data as a supervised policy target to train a policy head using cross-entropy loss and sampling from it for evaluation (Table 1, policy BC a and b) reproduced the behaviour cloning (BC) baseline results. ",
+        "bbox": [
+            176,
+            787,
+            823,
+            818
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/2d59c46ce8229b0d5600518da11c8298e046cfbb7c200d6203c6f11a390df9da.jpg",
+        "table_caption": [
+            "Table 4: Comparison of MuZero Unplugged and CRR. Results for CRR (Wang et al., 2020) were reported by selecting the checkpoint with the highest mean reward from each training run. Since this does not follow the offline policy selection guidelines from RL Unplugged and is therefore not directly comparable to the baseline results, we compared to it separately. The same highest mean reward evaluation scheme as used in CRR was used for MuZero Unplugged results in this table as well. All other tables report results at the end of training. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>CRR BC</td><td>MuZero Unplugged</td></tr><tr><td>cartpole.swingup</td><td>664.0</td><td>501.8 594.3</td></tr><tr><td>finger.turn_hard</td><td>714.0</td><td>333.8 759.0</td></tr><tr><td>fish.swim</td><td>517.0 556.8</td><td>681.6</td></tr><tr><td>manipulator.insert_ball</td><td>625.0 465.6</td><td>659.2</td></tr><tr><td>manipulator.insert_peg</td><td>387.0</td><td>325.9 556.0</td></tr><tr><td>walker.stand</td><td>797.0 473.3</td><td>887.2</td></tr><tr><td>walker.walk</td><td>901.0 637.9</td><td>949.5</td></tr><tr><td>cheetah.run</td><td>577.0</td><td>765.3 869.9</td></tr><tr><td>humanoid.run</td><td>586.0</td><td></td></tr><tr><td>mean</td><td>640.9 497.4</td><td>416.5 643.1 733.3</td></tr></table>",
+        "bbox": [
+            302,
+            89,
+            696,
+            275
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            401,
+            825,
+            429
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 Offline RL and Continuous Action Spaces ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            450,
+            555,
+            468
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "An important motivation for offline RL is the application to real-world systems such as robotics, which often have continuous and high-dimensional action spaces. To investigate the applicability of MuZero Unplugged to this setting, we used the DM Control Suite dataset from the RL Unplugged dataset. DM Control is a collection of physics based benchmark tasks (Tassa et al., 2018) with a variety of robotic bodies of different action and state dimensionalities (Table 3). ",
+        "bbox": [
+            174,
+            483,
+            825,
+            553
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In order to use planning and Reanalyse with continuous action spaces, we used the sample based search extension of MuZero introduced by (Hubert et al., 2021). This extension uses a policy head to produce a set of candidate actions to search over, where the MCTS considers only the sampled actions instead of fully enumerating the action space. Finally, the policy is updated towards the search distribution only at the sampled actions. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            628
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "When applying Reanalyse for data efficiency improvements to data generated by the agent itself, no modifications are required to use sample based search and Reanalyse together. In offline RL or when reanalysing demonstrations from a source other than the agent itself, the policy that generated the actions making up the dataset is often quite different from the one learned by MuZero Unplugged, and unlikely to sample the same actions, at least at the beginning of training. Since in this case the MCTS (and by extension, Reanalyse) can only consider actions that have been sampled from the policy, it would be unlikely to learn about the actions contained in the dataset, and thus unable to sample them from the policy in the future. This effect is most pronounced in very high dimensional action spaces. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            760
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To prevent this issue, we explicitly included the action from the trajectory being reanalysed in the sample of actions searched over at the root of the MCTS tree. This serves the same purpose as the Dirichlet exploration noise used in standard MuZero - encouraging the MCTS to explore actions it would not otherwise consider. For the prior of the injected action we therefore use the same value as for the Dirichlet probability mass, $2 5 \\%$ , though the algorithm is not sensitive to the exact value. This step is redundant for discrete action spaces (such as in Atari) where the policy already always produces a prior for all possible actions. ",
+        "bbox": [
+            174,
+            765,
+            825,
+            863
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We compared the performance of MuZero Unplugged to offline RL algorithms from the literature such as D4PG (Barth-Maron et al., 2018), BRAC (Wu et al., 2019) and RABM (Siegel et al., 2020; Gulcehre et al., 2020) (Table 3), as well as the recent Critic Regularized Regression (CRR) (Wang et al., 2020) algorithm (Table 4, shown separately as CRR was evaluated by selecting the maximum performance throughout training and results are thus not comparable to the other baselines). ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We first measured the performance of Behaviour Cloning (BC) when implemented using the MuZero network to ensure we used the offline dataset correctly and that it matches the evaluation environment. Overall performance indeed approximately matches the BC baseline (Table 3). ",
+        "bbox": [
+            176,
+            126,
+            821,
+            167
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "MuZero Unplugged outperformed baseline algorithms both in individual tasks and for the mean return5 averaged across all tasks. It did best in difficult high-dimensional tasks such as humanoid.run or the manipulator tasks, classified as ”hard” by (Wang et al., 2020), compared to ”easy” for the other tasks. Performance in the simplest tasks, especially cartpole, was somewhat lower — primarily due to the very small datasets6 leading to overfitting of the learned model and value function throughout training: in cartpole, performance of the best checkpoint (Figure 4) was much better than performance at the end of training (Figure 3). Additional regularisation techniques such as dropout (Hinton et al., 2012) could be employed to prevent this. We leave this for future work since we are primarily interested in performance on complex tasks that we consider most representative of real-world problems. ",
+        "bbox": [
+            173,
+            174,
+            825,
+            313
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 Limitations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            332,
+            302,
+            349
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "MuZero Unplugged uses a deterministic model, potentially limiting its performance in stochastic or partially observed environments. The learned model is a single time-step model, which may limit the time horizon of planning. MuZero Unplugged also does not employ explicit forms of regularizations; combination with existing methods from the literature may improve its performance on very small datasets. ",
+        "bbox": [
+            174,
+            364,
+            825,
+            433
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The MCTS improvement operator in MuZero Unplugged requires a suitable value function; in environments where value learning is very difficult this may limit the magnitude of the improvement obtained by Reanalyse. ",
+        "bbox": [
+            176,
+            440,
+            823,
+            482
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "8 Conclusions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            501,
+            307,
+            518
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper we have investigated the Reanalyse algorithm and its applications to both data efficient online RL at any data budget and completely offline RL. We combined Reanalyse with MuZero to obtain MuZero Unplugged, a unified model-based RL algorithm that achieved a new state of the art in both online and offline reinforcement learning. Specifically, MuZero Unplugged outperformed prior baselines in the Atari Learning Environment both using a standard online budget of 200 million frames and other data budgets spanning multiple orders of magnitude. Furthermore, MuZero Unplugged also outperformed offline baselines in the RL Unplugged benchmark for Atari and continuous control. Unlike previous approaches, MuZero Unplugged uses the same algorithm for multiple regimes without any special treatment for off-policy or offline data. ",
+        "bbox": [
+            174,
+            534,
+            825,
+            659
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This work represents a further step towards the vision of a single algorithm that can address a wide range of reinforcement learning applications, extending the capabilities of model-based planning algorithms to encompass new dimensions such as online and offline learning, using discrete and continuous action spaces, across pixel and state-based observation spaces, in addition to the wide array of challenging planning tasks addressed by prior work (Silver et al., 2018). ",
+        "bbox": [
+            174,
+            665,
+            825,
+            734
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            753,
+            338,
+            770
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank Caglar Gulcehre for providing very detailed feedback and helpful suggestions to improve the paper. ",
+        "bbox": [
+            176,
+            785,
+            825,
+            814
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "All of the work in this paper was funded by DeepMind. ",
+        "bbox": [
+            173,
+            820,
+            537,
+            834
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            267,
+            106
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Agarwal, R., Schuurmans, D., and Norouzi, M. An optimistic perspective on offline reinforcement learning. In International Conference on Machine Learning, pp. 104–114. PMLR, 2020.   \nAkkaya, I., Andrychowicz, M., Chociej, M., Litwin, M., McGrew, B., Petron, A., Paino, A., Plappert, M., Powell, G., Ribas, R., et al. Solving rubik’s cube with a robot hand. arXiv preprint arXiv:1910.07113, 2019.   \nArgenson, A. and Dulac-Arnold, G. Model-based offline planning, 2020.   \nBa, J. L., Kiros, J. R., and Hinton, G. E. Layer normalization, 2016.   \nBarth-Maron, G., Hoffman, M. W., Budden, D., Dabney, W., Horgan, D., TB, D., Muldal, A., Heess, N., and Lillicrap, T. Distributed Distributional Deterministic Policy Gradients, 2018.   \nBellemare, M. G., Naddaf, Y., Veness, J., and Bowling, M. The Arcade Learning Environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 47:253–279, 2013.   \nBradbury, J., Frostig, R., Hawkins, P., Johnson, M. J., Leary, C., Maclaurin, D., Necula, G., Paszke, A., VanderPlas, J., Wanderman-Milne, S., and Zhang, Q. JAX: composable transformations of Python+NumPy programs, 2018. URL http://github.com/google/jax.   \nDabney, W., Rowland, M., Bellemare, M. G., and Munos, R. Distributional reinforcement learning with quantile regression. In AAAI, 2018.   \nEspeholt, L., Soyer, H., Munos, R., Simonyan, K., Mnih, V., Ward, T., Doron, Y., Firoiu, V., Harley, T., Dunning, I., et al. IMPALA: Scalable distributed deep-RL with importance weighted actor-learner architectures. In Proceedings of the International Conference on Machine Learning (ICML), 2018.   \nGoogle, 2018. Cloud TPU. https://cloud.google.com/tpu/. Accessed: 2019.   \nGulcehre, C., Wang, Z., Novikov, A., Paine, T. L., Colmenarejo, S. G., Zolna, K., Agarwal, R., Merel, J., Mankowitz, D., Paduraru, C., Dulac-Arnold, G., Li, J., Norouzi, M., Hoffman, M., Nachum, O., Tucker, G., Heess, N., and de Freitas, N. RL Unplugged: Benchmarks for Offline Reinforcement Learning. 2020. URL https://arxiv.org/pdf/2006.13888.   \nHafner, D., Lillicrap, T., Fischer, I., Villegas, R., Ha, D., Lee, H., and Davidson, J. Learning latent dynamics for planning from pixels. arXiv preprint arXiv:1811.04551, 2018.   \nHe, K., Zhang, X., Ren, S., and Sun, J. Identity mappings in deep residual networks. CoRR, abs/1603.05027, 2016. URL http://arxiv.org/abs/1603.05027.   \nHe, Q. and Hou, X. POPO: Pessimistic Offline Policy Optimization, 2021.   \nHennigan, T., Cai, T., Norman, T., and Babuschkin, I. Haiku: Sonnet for JAX, 2020. URL http://github.com/deepmind/dm-haiku.   \nHessel, M., Modayil, J., Van Hasselt, H., Schaul, T., Ostrovski, G., Dabney, W., Horgan, D., Piot, B., Azar, M., and Silver, D. Rainbow: Combining improvements in deep reinforcement learning. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018.   \nHinton, G. E., Srivastava, N., Krizhevsky, A., Sutskever, I., and Salakhutdinov, R. R. Improving neural networks by preventing co-adaptation of feature detectors. arXiv preprint arXiv:1207.0580, 2012.   \nHubert, T., Schrittwieser, J., Antonoglou, I., Barekatain, M., Schmitt, S., and Silver, D. Learning and Planning in Complex Action Spaces. arXiv e-prints, April 2021.   \nJaderberg, M., Mnih, V., Czarnecki, W. M., Schaul, T., Leibo, J. Z., Silver, D., and Kavukcuoglu, K. Reinforcement learning with unsupervised auxiliary tasks. arXiv preprint arXiv:1611.05397, 2016.   \nKaplan, J., McCandlish, S., Henighan, T., Brown, T. B., Chess, B., Child, R., Gray, S., Radford, A., Wu, J., and Amodei, D. Scaling laws for neural language models, 2020.   \nKidambi, R., Rajeswaran, A., Netrapalli, P., and Joachims, T. MOReL : Model-Based Offline Reinforcement Learning, 2020.   \nKingma, D. P. and Ba, J. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2015.   \nKumar, A., Zhou, A., Tucker, G., and Levine, S. Conservative Q-learning for Offline Reinforcement Learning, 2020.   \nLevine, S., Kumar, A., Tucker, G., and Fu, J. Offline reinforcement learning: Tutorial, review, and perspectives on open problems, 2020.   \nLin, L.-J. Self-improving reactive agents based on reinforcement learning, planning and teaching. Machine learning, 8(3-4):293–321, 1992.   \nLoshchilov, I. and Hutter, F. Fixing weight decay regularization in adam. CoRR, abs/1711.05101, 2017. URL http://arxiv.org/abs/1711.05101.   \nMachado, M., Bellemare, M., Talvitie, E., Veness, J., Hausknecht, M., and Bowling, M. Revisiting the Arcade Learning Environment: Evaluation protocols and open problems for general agents. Journal of Artificial Intelligence Research, 61, 09 2017. doi: 10.1613/jair.5699.   \nMatsushima, T., Furuta, H., Matsuo, Y., Nachum, O., and Gu, S. Deployment-efficient reinforcement learning via model-based offline optimization, 2020.   \nMnih, V., Kavukcuoglu, K., Silver, D., Rusu, A. A., Veness, J., Bellemare, M. G., Graves, A., Riedmiller, M., Fidjeland, A. K., Ostrovski, G., et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529, 2015.   \nRafailov, R., Yu, T., Rajeswaran, A., and Finn, C. Offline reinforcement learning from images with latent space models. In Learning for Dynamics and Control, pp. 1154–1168. PMLR, 2021.   \nSchaul, T., Quan, J., Antonoglou, I., and Silver, D. Prioritized experience replay. In International Conference on Learning Representations, Puerto Rico, 2016.   \nSchmitt, S., Hessel, M., and Simonyan, K. Off-policy actor-critic with shared experience replay. arXiv preprint arXiv:1909.11583, 2019.   \nSchrittwieser, J., Antonoglou, I., Hubert, T., Simonyan, K., Sifre, L., Schmitt, S., Guez, A., Lockhart, E., Hassabis, D., Graepel, T., Lillicrap, T. P., and Silver, D. Mastering Atari, Go, Chess and Shogi by Planning with a Learned Model. Nature, 588(7839):604–609, 2020.   \nShrestha, A. K., Lee, S., Tadepalli, P., and Fern, A. Deepaveragers: Offline reinforcement learning by solving derived non-parametric $\\{ { \\mathrm { m d p } } \\} { \\mathrm { s } }$ . In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id $\\equiv$ eMP1j9efXtX.   \nSiegel, N. Y., Springenberg, J. T., Berkenkamp, F., Abdolmaleki, A., Neunert, M., Lampe, T., Hafner, R., and Riedmiller, M. Keep doing what worked: Behavioral modelling priors for offline reinforcement learning. arXiv preprint arXiv:2002.08396, 2020.   \nSilver, D., Schrittwieser, J., Simonyan, K., Antonoglou, I., Huang, A., Guez, A., Hubert, T., Baker, L., Lai, M., Bolton, A., Chen, Y., Lillicrap, T., Hui, F., Sifre, L., van den Driessche, G., Graepel, T., and Hassabis, D. Mastering the game of Go without human knowledge. Nature, 550:354–359, October 2017.   \nSilver, D., Hubert, T., Schrittwieser, J., Antonoglou, I., Lai, M., Guez, A., Lanctot, M., Sifre, L., Kumaran, D., Graepel, T., et al. A general reinforcement learning algorithm that masters chess, shogi, and Go through self-play. Science, 362(6419):1140–1144, 2018.   \nSutton, R. S. Dyna, an integrated architecture for learning, planning, and reacting. ACM Sigart Bulletin, 2(4):160–163, 1991.   \nTassa, Y., Doron, Y., Muldal, A., Erez, T., Li, Y., de Las Casas, D., Budden, D., Abdolmaleki, A., Merel, J., Lefrancq, A., Lillicrap, T., and Riedmiller, M. Deepmind control suite, 2018.   \nVinyals, O., Babuschkin, I., Czarnecki, W. M., Mathieu, M., Dudzik, A., Chung, J., Choi, D. H., Powell, R., Ewalds, T., Georgiev, P., et al. Grandmaster level in StarCraft II using multi-agent reinforcement learning. Nature, pp. 1–5, 2019.   \nWang, Z., Novikov, A., Zolna, K., Merel, J. S., Springenberg, J. T., Reed, S. E., Shahriari, B., Siegel, N., Gulcehre, C., Heess, N., et al. Critic Regularized Regression. Advances in Neural Information Processing Systems, 33, 2020.   \nWu, Y., Tucker, G., and Nachum, O. Behavior regularized offline reinforcement learning. arXiv preprint arXiv:1911.11361, 2019.   \nYu, T., Thomas, G., Yu, L., Ermon, S., Zou, J., Levine, S., Finn, C., and Ma, T. MOPO: Model-based Offline Policy Optimization, 2020. ",
+        "bbox": [
+            169,
+            103,
+            830,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            56,
+            828,
+            917
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            90,
+            828,
+            261
+        ],
+        "page_idx": 11
+    }
+]

parse/train/HyydRMZC-/HyydRMZC-.md

@@ -0,0 +1,419 @@
+# SPATIALLY TRANSFORMED ADVERSARIAL EXAMPLES
+
+Chaowei Xiao1 ∗, Jun-Yan $\mathbf { Z } \mathbf { h } \mathbf { u } ^ { 2 }$ ∗, $\mathbf { B o L i ^ { 3 } }$ , Warren $\mathbf { H e ^ { 3 } }$ , Mingyan Liu1, Dawn Song3   
+1University of Michigan, Ann Arbor, USA   
+2Massachusetts Institute of Technology, MA, USA   
+3University of California, Berkeley, USA
+
+# ABSTRACT
+
+Recent studies show that widely used deep neural networks (DNNs) are vulnerable to carefully crafted adversarial examples. Many advanced algorithms have been proposed to generate adversarial examples by leveraging the ${ \mathcal { L } } _ { p }$ distance for penalizing perturbations. Researchers have explored different defense methods to defend against such adversarial attacks. While the effectiveness of ${ \mathcal { L } } _ { p }$ distance as a metric of perceptual quality remains an active research area, in this paper we will instead focus on a different type of perturbation, namely spatial transformation, as opposed to manipulating the pixel values directly as in prior works. Perturbations generated through spatial transformation could result in large ${ \mathcal { L } } _ { p }$ distance measures, but our extensive experiments show that such spatially transformed adversarial examples are perceptually realistic and more difficult to defend against with existing defense systems. This potentially provides a new direction in adversarial example generation and the design of corresponding defenses. We visualize the spatial transformation based perturbation for different examples and show that our technique can produce realistic adversarial examples with smooth image deformation. Finally, we visualize the attention of deep networks with different types of adversarial examples to better understand how these examples are interpreted.
+
+# 1 INTRODUCTION
+
+Deep neural networks (DNNs) have demonstrated their outstanding performance in different domains, ranging from image processing (Krizhevsky et al., 2012; He et al., 2016), text analysis (Collobert & Weston, 2008) to speech recognition (Hinton et al., 2012). Though deep networks have exhibited high performance for these tasks, recently they have been shown to be particularly vulnerable to adversarial perturbations added to the input images (Szegedy et al., 2013; Goodfellow et al., 2015). These perturbed instances are called adversarial examples, which can lead to undesirable consequences in many practical applications based on DNNs. For example, adversarial examples can be used to subvert malware detection, fraud detection, or even potentially mislead autonomous navigation systems (Papernot et al., 2016b; Evtimov et al., 2017; Grosse et al., 2016) and therefore pose security risks when applied to security-related applications. A comprehensive study about adversarial examples is required to motivate effective defenses. Different methods have been proposed to generate adversarial examples such as fast gradient sign methods (FGSM) (Goodfellow et al., 2015), which can produce adversarial instances rapidly, and optimization-based methods (C&W) (Carlini & Wagner, 2017a), which search for adversarial examples with smaller magnitude of perturbation.
+
+One important criterion for adversarial examples is that the perturbed images should “look like” the original instances. The traditional attack strategies adopt $L _ { 2 }$ (or other ${ \mathcal { L } } _ { p }$ ) norm distance as a perceptual similarity metric to evaluate the distortion (Gu & Rigazio, 2014). However, this is not an ideal metric (Johnson et al., 2016; Isola et al., 2017), as $L _ { 2 }$ similarity is sensitive to lighting and viewpoint change of a pictured object. For instance, an image can be shifted by one pixel, which will lead to large $L _ { 2 }$ distance, while the translated image actually appear “the same” to human perception. Motivated by this example, in this paper we aim to look for other types of adversarial examples and propose to create perceptually realistic examples by changing the positions of pixels instead of directly manipulating existing pixel values. This has been shown to better preserve the identity and structure of the original image (Zhou et al., 2016b). Thus, the proposed spatially transformed adversarial example optimization method (stAdv) can keep adversarial examples less distinguishable from real instances (such examples can be found in Figure 3).
+
+Various defense methods have also been proposed to defend against adversarial examples. Adversarial training based methods have so far achieved the most promising results (Goodfellow et al., 2015; Tramèr et al., 2017; M ˛adry et al., 2017). They have demonstrated the robustness of improved deep networks under certain constraints. However, the spatially transformed adversarial examples are generated through a rather different principle, whereby what is being minimized is the local geometric distortion rather than the ${ \mathcal { L } } _ { p }$ pixel error between the adversarial and original instances. Thus, the previous adversarial training based defense method may appear less effective against this new attack given the fact that these examples generated by stAdv have never been seen before. This opens a new challenge about how to defend against such attacks, as well as other attacks that are not based on direct pixel value manipulation.
+
+We visualize the spatial deformation generated by stAdv; it is seen to be locally smooth and virtually imperceptible to the human eye. In addition, to better understand the properties of deep neural networks on different adversarial examples, we provide visualizations of the attention of the DNN given adversarial examples generated by different attack algorithms. We find that the spatial transformation based attack is more resilient across different defense models, including adversarially trained robust models.
+
+Our contributions are summarized as follows:
+
+• We propose to generate adversarial examples based on spatial transformation instead of direct manipulation of the pixel values, and we show realistic and effective adversarial examples on the MNIST, CIFAR-10, and ImageNet datasets.   
+We provide visualizations of optimized transformations and show that such geometric changes are small and locally smooth, leading to high perceptual quality.   
+• We empirically show that, compared to other attacks, adversarial examples generated by stAdv are more difficult to detect with current defense systems.   
+• Finally, we visualize the attention maps of deep networks on different adversarial examples and demonstrate that adversarial examples based on stAdv can more consistently mislead the adversarial trained robust deep networks compared to other existing attack methods.
+
+# 2 RELATED WORK
+
+Here we first briefly summarize the existing adversarial attack algorithms as well as the current defense methods. We then discuss the spatial transformation model used in our adversarial attack.
+
+Adversarial Examples Given a benign sample $\mathbf { x }$ , an attack instance $\mathbf { x } _ { \mathrm { a d v } }$ is referred to as an adversarial example, if a small magnitude of perturbation $\epsilon$ is added to $\mathbf { x }$ (i.e. ${ \bf x } _ { \mathrm { a d v } } = { \bf x } + { \bf \epsilon } \mathrm { ) }$ so that $\mathbf { x } _ { \mathrm { a d v } }$ is misclassified by the targeted classifier $g$ . Based on the adversarial goal, attacks can be classified into two categories: targeted and untargeted attacks. In a targeted attack, the adversary’s objective is to modify an input $\mathbf { x }$ such that the target model $g$ classifies the perturbed input $\mathbf { x } _ { \mathrm { a d v } }$ in a targeted class chosen, which differs from its ground truth. In a untargeted attack, the adversary’s objective is to cause the perturbed input $\mathbf { x } _ { \mathrm { a d v } }$ to be misclassified in any class other than its ground truth. Based on the adversarial capabilities, these attacks can be categorized as white-box and black-box attacks, where an adversary has full knowledge of the classifier and training data in the white-box setting (Szegedy et al., 2014; Goodfellow et al., 2015; Carlini & Wagner, 2017a; Moosavi-Dezfooli et al., 2015; Papernot et al., 2016b; Biggio et al., 2013; Fawzi & Frossard, 2015; Kanbak, 2017; Kurakin et al., 2016); while having zero knowledge about them in the black-box setting (Papernot et al., 2016a; Liu et al., 2017; Moosavi-Dezfooli et al., 2016; Mopuri et al., 2017). In this work, we will focus on the white-box setting to explore what a powerful adversary can do based on the Kerckhoffs’s principle (Shannon, 1949) to better motivate defense methods.
+
+Spatial Transformation In computer vision and graphics literature, Two main aspects determine the appearance of a pictured object (Szeliski, 2010): (1) the lighting and material, which determine the brightness of a point as a function of illumination and object material properties, and (2) the geometry, which determines where the projection of a point will be located in the scene. Most previous adversarial attacks (Goodfellow et al., 2015) focus on changing the lighting and material aspect, while assuming the underlying geometry stays the same during the adversarial perturbation generation process.
+
+Modeling geometric transformation with neural networks was first explored by “capsules,” computational units that locally transform their input for modeling 2D and 3D geometric changes (Hinton et al., 2011). Later, Jaderberg et al. (2015) demonstrated that similar computational units, named spatial transformers, can benefit many visual recognition tasks. Zhou et al. (2016a) adopted the spatial transformers for synthesizing novel views of the same object and has shown that a geometric method can produce more realistic results compared to pure pixel-based methods. Inspired by these successes, we also use the spatial transformers to deform the input images, but with a different goal: to generate realistic adversarial examples.
+
+Defensive Methods Following the emergence of adversarial examples, various defense methods have been studied, including adversarial training (Goodfellow et al., 2015), distillation (Papernot et al., 2016c), gradient masking (Gu & Rigazio, 2014) and feature squeezing (Xu et al., 2017). However, these defenses can either be evaded by C&W attacks or only provide marginal improvements (Carlini & Wagner, 2017b; He et al., 2017). Among these defenses, adversarial training has achieved the state-of-the-art performance. Goodfellow et al. (2015) proposed to use the fast gradient sign attack as an adversary to perform adversarial training, which is much faster, followed by ensemble adversarial training (Tramèr et al., 2017) and projected gradient descent (PGD) adversarial training (M ˛adry et al., 2017). In this work, we explicitly analyze how effective the spatial transformation based adversarial examples are under these adversarial training based defense methods.
+
+# 3 GENERATING ADVERSARIAL EXAMPLES
+
+Here we first introduce several existing attack methods and then present our formulation for producing spatially transformed adversarial examples.
+
+# 3.1 PROBLEM DEFINITION
+
+Given a learned classifier $g : \mathcal { X }  \mathcal { Y }$ from a feature space $\mathcal { X }$ to a set of classification outputs $\mathcal { V }$ (e.g., $\mathcal { V } = \{ 0 , 1 \}$ for binary classification), an adversary aims to generate adversarial example $\mathbf { x } _ { \mathrm { a d v } }$ for an original instance $\mathbf { x } \in \mathcal { X }$ with its ground truth label $y \in \mathcal { V }$ , so that the classifier predicts $g ( \mathbf { x } _ { \mathrm { a d v } } ) \neq y$ (untargeted attack) or $g ( \mathbf { x } _ { \mathrm { a d v } } ) = t$ (targeted attack) where $t$ is the target class.
+
+# 3.2 BACKGROUND: CURRENT PIXEL-VALUE BASED ATTACK METHODS
+
+All of the current methods for generating adversarial examples are built on directly modifying the pixel values of the original image.
+
+The fast gradient sign method (FGSM) (Goodfellow et al., 2015) uses a first-order approximation of the loss function to construct adversarial samples for the adversary’s target classifier $g$ . The algorithm achieves untargeted attack by performing a single gradient ascent step: ${ \bf x } _ { \mathrm { a d v } } = { \bf x } + { \bf \delta }$ $\epsilon \cdot \mathrm { s i g n } ( \nabla _ { \mathbf { x } } \ell _ { g } ( \mathbf { x } , y ) )$ , where $\ell _ { g } ( \mathbf x , y )$ is the loss function (e.g. cross-entropy loss) used to train the original model $g , y$ denotes the ground truth label, and the hyper-parameter $\epsilon$ controls the magnitude of the perturbation. A targeted version of it can be done similarly.
+
+Optimization-based attack (C&W) produces an adversarial perturbation for a targeted attack based on certain constraints (Carlini & Wagner, 2017a; Liu et al., 2017) as formulated below:
+
+$$
+\operatorname* { m i n } | | \delta | | _ { p } ^ { 2 } \quad \mathrm { s . t . } \qquad g ( \mathbf { x } + \delta ) = t \quad \mathrm { a n d } \quad \mathbf { x } + \delta \in X ,
+$$
+
+where the ${ \mathcal { L } } _ { p }$ norm penalty ensures that the added perturbation $\epsilon$ is small. The same optimization procedure can achieve untargeted attacks with a modified constraint $g ( \mathbf { x } + \delta ) \neq y$ .
+
+![](images/59a5504203b0edb3ef5204a4cf3e7c01be00b469b05918357318c0bea0ca3e40.jpg)  
+Figure 1: Generating adversarial examples with spatial transformation: the blue point denotes the coordinate of a pixel in an output adversarial image and the green point is its corresponding pixel in an input image. The flow field in red represents the displacement from the pixels in the adversarial image to the pixels in the input image.
+
+# 3.3 OUR APPROACH: SPATIALLY TRANSFORMED ADVERSARIAL EXAMPLES
+
+All the existing approaches directly modify pixel values, which may sometimes produce noticeable artifacts. Instead, we aim to smoothly change the geometry of the scene while keeping the original appearance, producing more perceptually realistic adversarial examples. In this section, we first introduce our spatial transformation model and then describe our objective function for generating spatially transformed adversarial examples.
+
+Spatial transformation We use $\mathbf { x } _ { \mathrm { a d v } } ^ { ( i ) }$ to denote the pixel value of the $i$ -th pixel and 2D coordinate (u adv, v adv) to denote its location in the adversarial image $\mathbf { x } _ { \mathrm { a d v } }$ . We assume that $\mathbf { x } _ { \mathrm { a d v } } ^ { ( i ) }$ is transformed from the pixel $\mathbf { x } ^ { ( i ) }$ from the original image. We use the per-pixel flow (displacement) field $f$ to synthesize the adversarial image $\mathbf { x } _ { \mathrm { a d v } }$ using pixels from the input $\mathbf { x }$ . For the $i$ -th pixel within $\mathbf { x } _ { \mathrm { a d v } }$ at the pixel location $( u _ { \mathrm { a d v } } ^ { ( i ) } , v _ { \mathrm { a d v } } ^ { ( i ) } )$ , we optimize the amount of displacement in each image dimension, with the pair denoted by the flow vector $f _ { i } : = ( \Delta u ^ { ( i ) } , \Delta v ^ { ( i ) } )$ . Note that the flow vector $f _ { i }$ goes from a pixel $\mathbf { x } _ { \mathrm { a d v } } ^ { ( i ) }$ in the adversarial image to its corresponding pixel $\mathbf { x } ^ { ( i ) }$ in the input image. Thus, the location of its corresponding pixel $\mathbf { x } ^ { ( i ) }$ can be derived as $( \boldsymbol { u } ^ { ( i ) } , \boldsymbol { v } ^ { ( i ) } ) = ( u _ { \mathrm { a d v } } ^ { ( i ) } + \Delta u ^ { ( i ) } , v _ { \mathrm { a d v } } ^ { ( i ) } + \Delta v ^ { ( i ) } )$ . As the $( u ^ { ( i ) } , v ^ { ( i ) } )$ can be fractional numbers and does not necessarily lie on the integer image grid, we use the differentiable bilinear interpolation (Jaderberg et al., 2015) to transform the input image with the flow field. We calculate x(i)adv as:
+
+$$
+\mathbf { x } _ { \mathrm { a d v } } ^ { ( i ) } = \sum _ { q \in \mathcal { N } ( u ^ { ( i ) } , v ^ { ( i ) } ) } \mathbf { x } ^ { ( q ) } ( 1 - | u ^ { ( i ) } - u ^ { ( q ) } | ) ( 1 - | v ^ { ( i ) } - v ^ { ( q ) } | ) ,
+$$
+
+where $\mathcal { N } ( u ^ { ( i ) } , v ^ { ( i ) } )$ are the indices of the 4-pixel neighbors at the location $( u ^ { ( i ) } , v ^ { ( i ) } )$ (top-left, topright, bottom-left, bottom-right). We can obtain the adversarial image $\mathbf { x } _ { \mathrm { a d v } }$ by calculating Equation 1 for every pixel $\mathbf { x } _ { \mathrm { a d v } } ^ { ( i ) }$ . Note that $\mathbf { x } _ { \mathrm { a d v } }$ is differentiable with respect to the flow field $f$ (Jaderberg et al., 2015; Zhou et al., 2016b). The estimated flow field essentially captures the amount of spatial transformation required to fool the classifier.
+
+Objective function Most of the previous methods constrain the added perturbation to be small regarding a ${ \mathcal { L } } _ { p }$ metric. Here instead of imposing the ${ \mathcal { L } } _ { p }$ norm on pixel space, we introduce a new regularization loss $\mathcal { L } _ { f l o w }$ on the local distortion $f$ , producing higher perceptual quality for adversarial examples. Therefore, the goal of the attack is to generate adversarial examples which can mislead the classifier as well as minimizing the local distortion introduced by the flow field $f$ .
+
+Formally, given a benign instance $\mathbf { x }$ , we obtain the flow field $f$ by minimize the following objective:
+
+$$
+f ^ { * } = \underset { f } { \mathrm { a r g m i n } } \quad \mathcal { L } _ { a d v } ( x , f ) + \tau \mathcal { L } _ { f o w } ( f ) ,
+$$
+
+where $\mathcal { L } _ { a d v }$ encourages the generated adversarial examples to be misclassified by the target classifier. $L _ { f l o w }$ ensures that the spatial transformation distance is minimized to preserve high perceptual quality, and $\tau$ balances these two losses.
+
+The goal of $\mathcal { L } _ { a d v }$ is to guarantee the targeted attack $g ( \mathbf { x } _ { \mathrm { a d v } } ) ~ = ~ t$ where $t$ is the targeted class, different from the ground truth label $y$ . Recall that we transform the input image $\mathbf { x }$ to $\mathbf { x } _ { \mathrm { a d v } }$ with the flow field $f$ (Equation 1). In practice, directly enforcing $g ( \mathbf { x } _ { \mathrm { a d v } } ) = t$ during optimization is highly non-linear, we adopt the objective function suggested in Carlini & Wagner (2017a).
+
+$$
+\mathcal { L } _ { a d v } ( x , f ) = \operatorname* { m a x } ( \operatorname* { m a x } _ { i \neq t } g ( \mathbf { x } _ { \mathrm { a d v } } ) _ { i } - g ( \mathbf { x } _ { \mathrm { a d v } } ) _ { t } , \kappa ) ,
+$$
+
+where $g ( x )$ represents the logit output of model $g , g ( x ) _ { i }$ denotes the $i$ -th element of the logit vector, and $\kappa$ is used to control the attack confidence level.
+
+To compute ${ \mathcal { L } } _ { f l o w }$ , we calculate the sum of spatial movement distance for any two adjacent pixels. Given an arbitrary pixel $p$ and its neighbors $q \in \mathcal { N } ( p )$ , we enforce the locally smooth spatial transformation perturbation $\mathcal { L } _ { f l o w }$ based on the total variation (Rudin et al., 1992):
+
+$$
+\mathcal { L } _ { f l o w } ( f ) = \sum _ { p } ^ { a l l p i x e l s } \sum _ { q \in N ( p ) } \sqrt { | | \Delta u ^ { ( p ) } - \Delta u ^ { ( q ) } | | _ { 2 } ^ { 2 } + | | \Delta v ^ { ( p ) } - \Delta v ^ { ( q ) } | | _ { 2 } ^ { 2 } } .
+$$
+
+Intuitively, minimizing the spatial transformation can help ensure the high perceptual quality for stAdv, since adjacent pixels tend to move towards close direction and distance. We solve the above optimization with L-BFGS solver (Liu & Nocedal, 1989).
+
+# 4 EXPERIMENTAL RESULTS
+
+In this section, we first show adversarial examples generated by the proposed spatial transformation method and analyze the properties of these examples from different perspectives. We then visualize the estimated flows for adversarial examples and show that with small and smooth transformation, the generated adversarial examples can already achieve a high attack success rate against deep networks. We also show that stAdv can preserve a high attack success rate against current defense methods, which motivates more sophisticated defense methods in the future. Finally, we analyze the attention regions of DNNs, to better understand the attack properties of stAdv.
+
+Experiment Setup We set $\tau$ as 0.05 for all our experiments. We use confidence $\kappa = 0$ for both C&W and stAdv for a fair comparison. We leverage L-BFGS (Liu & Nocedal, 1989) as our solver with backtracking linear search.
+
+# 4.1 ADVERSARIAL EXAMPLES BASED ON SPATIAL TRANSFORMATIONS
+
+We show adversarial examples with high perceptual quality for both MNIST (LeCun & Cortes, 1998) and CIFAR-10 (Krizhevsky et al., 2014) datasets.
+
+stAdv on MNIST In our experiments, we generate adversarial examples againsts three target models in the white-box setting on the MNIST dataset. Model A, B, and C are derived from the prior work (Tramèr et al., 2017), which represent different architectures. See Appendix A and Table 4 for more details about their network architectures. Table 1 presents the accuracy of pristine MNIST test data on each model as well as the attack success rate of adversarial examples generated by stAdv on these models. Figure 2 shows the adversarial examples against different models where the original instances appear in the diagonal. Each adversarial example achieves a targeted attack, with the target class shown on the top of the column. It is clear that the generated adversarial examples still appear to be in the same class as the original instance for humans. Another advantage for stAdv compared with traditional attacks is that examples based on stAdv seldom show noise pattern within the adversarial examples. Instead, stAdv smoothly deforms the digits and since such natural deformation also exists in the dataset digits, humans can barely notice such manipulation.
+
+Table 1: Top: accuracy of different models on pristine data (p); bottom: attack success rates of adversarial examples generated by stAdv on MNIST dataset.   
+
+<table><tr><td>Model</td><td>A</td><td>B</td><td>C</td></tr><tr><td>Accuracy (p)</td><td>98.58%</td><td>98.94%</td><td>99.11%</td></tr><tr><td>Attack Success Rate</td><td>99.95%</td><td>99.98%</td><td>100.00%</td></tr></table>
+
+![](images/cd9611ac0f4cbc32e6f9793e0769e4433e5651461d4c405c74337333c8eb72b0.jpg)  
+Figure 2: Adversarial examples generated by stAdv against different models on MNIST. The ground truth images are shown in the diagonal and the rest are adversarial examples that are misclassified to the target classes shown on the top.
+
+stAdv on CIFAR-10 For CIFAR-10, we use ResNet- $3 2 ^ { 1 }$ and wide ResNet- $3 4 ^ { 2 }$ as the target classifers (Zagoruyko & Komodakis, 2016; He et al., 2016; M ˛adry et al., 2017). We show the classification accuracy of pristine CIFAR-10 test data (p) and attack success rates of adversarial examples generated by stAdv on different models in Table 2. Figure 3 shows the generated examples on CIFAR-10 against different models. The original images are shown in the diagonal. The other images are targeted adversarial examples, with the index of the target classes shown at the top of the column. Here we use $^ { 6 6 } 0 { - } 9 ^ { 7 }$ to denote the ground truth labels of images lying in the diagonal for each corresponding column. These adversarial examples based on stAdv are randomly selected from the instances that can successfully attack the corresponding classifier. Humans can hardly distinguish these adversarial examples from the original instances.
+
+Table 2: Top: accuracy of different models on pristine data (p); bottom: attack success rates of adversarial examples generated by stAdv on the CIFAR-10 dataset. The numbers in parentheses denote the number of parameters in each target model.   
+
+<table><tr><td>Model</td><td>ResNet32 (0.47M)</td><td>Wide ResNet34 (46.16M)</td></tr><tr><td>Accuracy (p)</td><td>93.16%</td><td>95.82%</td></tr><tr><td>Attack Success Rate</td><td>99.56%</td><td>98.84%</td></tr></table>
+
+Comparison of different adversarial examples In Figure 4, we show adversarial examples that are targeted attacked to the same class (“0” for MNIST and “airplane” for CIFAR-10), which is different from their ground truth. We compare adversarial examples generated from different methods and show that those based on stAdv look more visually realistic compared with FGSM (Goodfellow et al., 2015) and C&W (Carlini & Wagner, 2017b) methods.
+
+![](images/8a6c1e281094aeefce5c496c79947e05b175ad33612122c99f8fa4f776efe68d.jpg)  
+Figure 3: Adversarial examples generated by stAdv against different models on CIFAR-10. The ground truth images are shown in the diagonal while the adversarial examples on each column are classified into the same class as the ground truth image within that column.
+
+![](images/ae8ba83f3adfa96e7c73c3735e96b7539289a1b6234b56c7f507285e36be7d74.jpg)  
+Figure 4: Comparison of adversarial examples generated by FGSM, C&W and stAdv. (Left: MNIST, right: CIFAR-10) The target class for MNIST is $ { { } ^ { 6 } }  { 0 ^ { 9 } }$ and “air plane” for CIFAR-10. We generate adversarial examples by FGSM and C&W with perturbation bounded in terms of $L _ { \infty }$ as 0.3 on MNIST and 8 on CIFAR-10.
+
+![](images/531d41d705ede2d69e965af067a2d14b6ebe5b5f6eef30ce5577cca2ea1c9a74.jpg)  
+Figure 5: Flow visualization on MNIST. A digit “0” is misclassified as “2”.
+
+# 4.2 VISUALIZING SPATIAL TRANSFORMATION
+
+To better understand the spatial transformation applied to the original images, we visualize the optimized transformation flow for different datasets, respectively. Figure 5 visualizes a transformation on an MNIST instance, where the digit $\mathbf { \bar { \theta } } ^ { 6 } 0 ^ { 9 }$ is misclassified as “2.” We can see that the adjacent flows move in a similar direction in order to generate smooth results. The flows are more focused on the edge of the digit and sometimes these flows move in different directions along the edge, which implies that the object boundary plays an important role in our stAdv optimization. Figure 6 illustrates a similar visualization on CIFAR-10. It shows that the optimized flows often focus on the area of the main object, such as the airplane. We also observe that the magnitude of flows near the edge are usually larger, which similarly indicates the importance of edges for misleading the classifiers. This observation confirms the observation that when DNNs extract edge information in the earlier layers for visual recognition tasks (Viterbi, 1998). In addition, we visualize the similar flow for the ImageNet dataset (Deng et al., 2009) in Figure 7. The top-1 label of the original image in Figure 7 (a) is “mountain bike”. Figure 7 (b)-(d) show targeted adversarial examples generated by stAdv, which have target classes “goldfish,” “Maltese dog,” and “tabby cat,” respectively, and which are predicted as such as the top-1 class. An interesting observation is that, although there are other objects within the image, nearly $90 \%$ of the spatial transformation flows tend to focus on the target object bike. Different target class corresponds to different directions for these flows, which still fall into the similar area.
+
+![](images/b90a1e172f1c1bef85679ea8478ed5db04441e9b0738d2552413e8b97f726fe0.jpg)  
+Figure 6: Flow visualization on CIFAR-10. An “airplane” image is misclassified as “bird”.
+
+![](images/6654a30cb8a43af7c43ed9d61fa164088b56d956e4eefbe00d2a6b2e48f4248e.jpg)  
+Figure 7: Flow visualization on ImageNet. (a): the original image, (b)-(c): images are misclassified into goldfish, dog and cat, respectively. Note that to display the flows more clearly, we fade out the color of the original image.
+
+# 4.3 HUMAN PERCEPTUAL STUDY
+
+To quantify the perceptual realism of stAdv’s adversarial examples, we perform a user study with human participants on Amazon Mechanical Turk (AMT). We follow the same perceptual study protocol used in prior image synthesis work (Zhang et al., 2016; Isola et al., 2017). We generate 600 images from an ImageNet-compatible dataset, described in Appendix C. In our study, the participants are asked to choose the more visually realistic image between an adversarial example generated by stAdv and its original image. During each trial, these two images appear side-by-side for 2 seconds. After the images disappear, our participants are given unlimited time to make their decision. To avoid labeling bias, we allow each user to conduct at most 50 trails. For each pair of an original image and its adversarial example, we collect about 5 annotations from different users.
+
+In total, we collected 2, 740 annotations from 93 AMT users. Examples generated by our method were chosen as the more realistic in $4 7 . 0 1 \% \pm 1 . 9 6 \%$ of the trails (perfectly realistic results would achieve $5 0 \%$ ). This indicates that our adversarial examples are almost indistinguishable from natural images.
+
+Table 3: Attack success rates of adversarial examples generated by stAdv against models A, B, and C on MNIST, and against ResNet and wide ResNet on CIFAR-10, under standard defenses.   
+
+<table><tr><td>Model</td><td>Def.</td><td>FGSM</td><td>C&amp;W.</td><td>stAdv</td></tr><tr><td rowspan="3">A</td><td>Adv.</td><td>4.3%</td><td>4.6%</td><td>32.62%</td></tr><tr><td>Ens.</td><td>1.6%</td><td>4.2%</td><td>48.07%</td></tr><tr><td>PGD</td><td>4.4%</td><td>2.96%</td><td>48.38%</td></tr><tr><td rowspan="3">B</td><td>Adv.</td><td>6.0%</td><td>4.5%</td><td>50.17%</td></tr><tr><td>Ens.</td><td>2.7%</td><td>3.18%</td><td>46.14%</td></tr><tr><td>PGD</td><td>9.0%</td><td>3.0%</td><td>49.82%</td></tr><tr><td rowspan="3">C</td><td>Adv.</td><td>3.22%</td><td>0.86%</td><td>30.44%</td></tr><tr><td>Ens.</td><td>1.45%</td><td>0.98%</td><td>28.82%</td></tr><tr><td>PGD</td><td>2.1%</td><td>0.98%</td><td>28.13%</td></tr></table>
+
+<table><tr><td>Model</td><td>Def.</td><td>FGSM</td><td>C&amp;W.</td><td>stAdv</td></tr><tr><td rowspan="2">ResNet32</td><td>Adv.</td><td>13.10%</td><td>11.9%</td><td>43.36%</td></tr><tr><td>Ens. PGD</td><td>10.00% 22.8%</td><td>10.3% 21.4%</td><td>36.89% 49.19%</td></tr><tr><td rowspan="4">wide ResNet34</td><td>Adv.</td><td>5.04%</td><td>7.61%</td><td>31.66%</td></tr><tr><td>Ens.</td><td>4.65%</td><td>8.43%</td><td>29.56%</td></tr><tr><td>PGD</td><td>14.9%</td><td>13.90%</td><td></td></tr><tr><td></td><td></td><td></td><td>31.6%</td></tr></table>
+
+# 4.4 ATTACK EFFICIENCY UNDER DEFENSE METHODS
+
+Here we generate adversarial examples in the white-box setting and test different defense methods against these samples to evaluate the strength of these attacks under defenses.
+
+We mainly focus on the adversarial training defenses due to their state-of-the-art performance. We apply three defense strategies in our evaluation: the FGSM adversarial training (Adv.) (Goodfellow et al., 2015), ensemble adversarial training (Ens.) (Tramèr et al., 2017), and projectile gradient descent (PGD) adversarial training (M ˛adry et al., 2017) methods. For adversarial training purposes, we generate adversarial examples based on $L _ { \infty }$ bound (Carlini & Wagner, 2017a) as 0.3 on MNIST and 8 on CIFAR-10. We test adversarial examples generated against model A, B, and C on MNIST as shown in Table 4, and similarly adversarial examples generated against ResNet32 and wide ResNet34 on CIFAR-10.
+
+The results on the MNIST and CIFAR-10 datasets are shown in Table 3. We observe that the three defense strategies can achieve high performance (less than $10 \%$ attack success rate) against FGSM and C&W attacks.
+
+These defense methods only achieve low defense performance on stAdv, which improve the attack success rate to more than $3 0 \%$ among all defense strategies. These results indicate that new type of adversarial strategy, such as our spatial transformation-based attack, may open new directions for developing better defense systems. However, for stAdv, we cannot use ${ \mathcal { L } } _ { p }$ norm to bound the distance as translating an image by one pixel may introduce large ${ \mathcal { L } } _ { p }$ penalty. We instead constrain the spatial transformation flow and show that our adversarial examples have high perceptual quality in Figures 2, 3, and 4 as well as Section 4.3.
+
+Mean blur defense We also test our adversarial examples against the $3 { \times } 3$ average pooling restoration mechanism (Li & Li, 2016). Table 5 in Appendix B shows the classification accuracy of recovered images after performing $3 \times 3$ average filter on different models. We find that the simple $3 \times 3$ average pooing restoration mechanism can recover the original class from fast gradient sign examples and improve the classification accuracy up to around $70 \%$ . Carlini & Wagner have also shown that such mean blur defense strategy can defend against adversarial examples generated by their attack and improve the model accuracy to around $80 \%$ (2017b). From Table 5, we can see that the mean blur defense method can only improve the model accuracy to around $50 \%$ on stAdv examples, which means adversarial examples generated by stAdv are more robust compared to other attacks. We also perform a perfect knowledge adaptive attack against the mean blur defense following the same attack strategy suggested in (Carlini & Wagner, 2017b), where we add the $3 \times 3$ average pooling layer into the original network and apply stAdv to attack the new network again. We observe that the success rate of an adaptive attack is nearly $100 \%$ , which is consistent with Carlini & Wagner’s findings (2017b).
+
+# 4.5 VISUALIZING ATTENTION OF NETWORKS ON ADVERSARIAL EXAMPLES
+
+In addition to the analyzing adversarial examples themselves, in this section, we further characterize these spatially transformed adversarial examples from the perspective of deep neural networks.
+
+![](images/2f1e2ccd33a46684daae6ba2e40ddac36cbef1277c5ec583dee5f8b733b29e33.jpg)  
+Figure 8: CAM attention visualizations for ImageNet inception_v3 model. (a) the original image and (b)-(d) stAdv adversarial examples targeting different classes. The second row shows the attention visualizations for the corresponding images displayed above.
+
+Here we apply Class Activation Mapping (CAM) (Zhou et al., 2016a), an implicit attention visualization technique for localizing the discriminative regions implicitly detected by a DNN. We use it to show the attention of the target ImageNet inception_v3 model (Szegedy et al., 2016)) for both original images and generated adversarial examples. Figure 8(a) shows an input bike image and Figure 8(b)–(d) show the targeted adversarial examples based on stAdv targeting three different classes (goldfish, dog, and cat). Figure 8(e) illustrates that the target model draws attention to the bicycle region. Interestingly, attention regions on examples generated by stAdv varies for different target classes as shown in Figure 8(f)–(h). Though humans can barely distinguish between the original image and the ones generated by stAdv, CAM map focus on completely different regions, implying that our attack can mislead the network’s attention.
+
+In addition, we also compare and visualize the attention regions of both naturally trained and the adversarial trained inception_v3 model3 on adversarial images generated by different attack algorithms (Figure 9). The ground truth top-1 label is “cinema,” so the attention region for the original image (Figure 9 (a)) includes both tower and building regions. However, when the adversarial examples are targeted attacked into the adversarial label “missile,” the attention region focuses on only the tower for all the attack algorithms as shown in Figure 9 (b)-(d) with slight different attention region sizes. More interestingly, we also test these adversarial examples on the public adversarial trained robust inception_v3 model. The result appears in Figure 9 (f)–(h). This time, the attention regions are drawn to the building again for both FGSM and C&W methods, which are close to the attention regions of the original image. The top-1 label for Figure 9 (f) and (g) are again the ground truth “cinema”, which means both FGSM and C&W fail to attack the robust model. However, Figure 9 (h) is still misclassified as “missile” under the robust model and the CAM visualization shows that the attention region still focuses on the tower. This example again implies that adversarial examples generated by stAdv are challenging to defend for the current “robust” ImageNet models.
+
+# 5 CONCLUSIONS
+
+Different from the previous works that generate adversarial examples by directly manipulating pixel values, in this work we propose a new type of perturbation based on spatial transformation, which aims to preserve high perceptual quality for adversarial examples. We have shown that adversarial examples generated by stAdv are more difficult for humans to distinguish from original instances.
+
+![](images/4a8de4df7d55ef26804bf583852dc942667e3b0ab0f81a1b59b990b11e2dfd45.jpg)  
+Figure 9: CAM attention visualizations for ImageNet inception_v3 model. The first column shows the CAM maps corresponding to the original images. Column 2-4 show the adversarial examples generated by different methods. The visualizations are drawn for Row 1 (inception_v3 model) and Row 2 (adversarial trained inception_v3 model). (a) and (e)-(g) are labeled as the ground truth “cinema”, while (b)-(d) and (h) are labeled as the adversarial target “missile.”
+
+We also analyze the attack success rate of these examples under existing defense methods and demonstrate they are harder to defend against, which opens new directions for developing more robust defense algorithms. Finally, we visualize the attention regions of DNNs on our adversarial examples to better understand this new attack.
+
+# ACKNOWLEDGMENTS
+
+We thank Zhuang Liu, Richard Shin, Kun Jin, Armin Sarabi and George Philipp for their valuable discussions on this work. This work was supported in part by Berkeley Deep Drive, the Center for Long-Term Cybersecurity, and FORCES (Foundations Of Resilient CybEr-Physical Systems), which receives support from the National Science Foundation (NSF award numbers CNS-1238959, CNS-1238962, CNS-1239054, CNS-1239166), and NSF under grants CNS-1422211 and CNS1616575.
+
+# REFERENCES
+
+Battista Biggio, Igino Corona, Davide Maiorca, Blaine Nelson, Nedim Šrndic, Pavel Laskov, Gior- ´ gio Giacinto, and Fabio Roli. Evasion attacks against machine learning at test time. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pp. 387– 402. Springer, 2013.
+
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In IEEE Symposium on Security and Privacy, 2017, 2017a.
+
+Nicholas Carlini and David Wagner. Adversarial examples are not easily detected: Bypassing ten detection methods. arXiv preprint arXiv:1705.07263, 2017b.
+
+Ronan Collobert and Jason Weston. A unified architecture for natural language processing: Deep neural networks with multitask learning. In Proceedings of the 25th international conference on Machine learning, pp. 160–167. ACM, 2008.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, pp. 248–255. IEEE, 2009.
+
+Ivan Evtimov, Kevin Eykholt, Earlence Fernandes, Tadayoshi Kohno, Bo Li, Atul Prakash, Amir Rahmati, and Dawn Song. Robust physical-world attacks on machine learning models. arXiv preprint arXiv:1707.08945, 2017.
+
+Alhussein Fawzi and Pascal Frossard. Manitest: Are classifiers really invariant? arXiv preprint arXiv:1507.06535, 2015.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In International Conference on Learning Representations, 2015.
+
+Kathrin Grosse, Nicolas Papernot, Praveen Manoharan, Michael Backes, and Patrick McDaniel. Adversarial perturbations against deep neural networks for malware classification. arXiv preprint arXiv:1606.04435, 2016.
+
+Shixiang Gu and Luca Rigazio. Towards deep neural network architectures robust to adversarial examples. arXiv preprint arXiv:1412.5068, 2014.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Warren He, James Wei, Xinyun Chen, Nicholas Carlini, and Dawn Song. Adversarial example defenses: Ensembles of weak defenses are not strong. arXiv preprint arXiv:1706.04701, 2017.
+
+Geoffrey Hinton, Li Deng, Dong Yu, George E Dahl, Abdel-rahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara N Sainath, et al. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal Processing Magazine, 29(6):82–97, 2012.
+
+Geoffrey E Hinton, Alex Krizhevsky, and Sida D Wang. Transforming auto-encoders. In International Conference on Artificial Neural Networks, pp. 44–51. Springer, 2011.
+
+Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. CVPR, 2017.
+
+Max Jaderberg, Karen Simonyan, Andrew Zisserman, et al. Spatial transformer networks. In NIPS, pp. 2017–2025, 2015.
+
+Justin Johnson, Alexandre Alahi, and Li Fei-Fei. Perceptual losses for real-time style transfer and super-resolution. In European Conference on Computer Vision, 2016.
+
+Can Kanbak. Measuring robustness of classifiers to geometric transformations. Technical report, 2017.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. ImageNet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
+
+Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. The cifar-10 dataset. online: http://www. cs. toronto. edu/kriz/cifar. html, 2014.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016.
+
+Yann LeCun and Corrina Cortes. The MNIST database of handwritten digits. 1998.
+
+Xin Li and Fuxin Li. Adversarial examples detection in deep networks with convolutional filter statistics. arXiv preprint arXiv:1612.07767, 2016.
+
+Dong C Liu and Jorge Nocedal. On the limited memory bfgs method for large scale optimization. Mathematical programming, 45(1):503–528, 1989.
+
+Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. In ICLR, 2017.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. arXiv preprint arXiv:1511.04599, 2015.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Universal adversarial perturbations. arXiv preprint arXiv:1610.08401, 2016.
+
+Konda Reddy Mopuri, Utsav Garg, and R Venkatesh Babu. Fast feature fool: A data independent approach to universal adversarial perturbations. arXiv preprint arXiv:1707.05572, 2017.
+
+Aleksander M ˛adry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv:1706.06083 [cs, stat], June 2017.
+
+Nicolas Papernot, Patrick McDaniel, and Ian Goodfellow. Transferability in machine learning: from phenomena to black-box attacks using adversarial samples. arXiv preprint arXiv:1605.07277, 2016a.
+
+Nicolas Papernot, Patrick McDaniel, Somesh Jha, Matt Fredrikson, Z Berkay Celik, and Ananthram Swami. The limitations of deep learning in adversarial settings. In 2016 IEEE European Symposium on Security and Privacy (EuroS&P), pp. 372–387. IEEE, 2016b.
+
+Nicolas Papernot, Patrick McDaniel, Xi Wu, Somesh Jha, and Ananthram Swami. Distillation as a defense to adversarial perturbations against deep neural networks. In Security and Privacy (SP), 2016 IEEE Symposium on, pp. 582–597. IEEE, 2016c.
+
+Leonid I Rudin, Stanley Osher, and Emad Fatemi. Nonlinear total variation based noise removal algorithms. Physica D: Nonlinear Phenomena, 60(1-4):259–268, 1992.
+
+Claude E Shannon. Communication theory of secrecy systems. Bell Labs Technical Journal, 28(4): 656–715, 1949.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In International Conference on Learning Representations, 2014.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2818–2826, 2016.
+
+Richard Szeliski. Computer vision: algorithms and applications. Springer Science & Business Media, 2010.
+
+Florian Tramèr, Alexey Kurakin, Nicolas Papernot, Dan Boneh, and Patrick McDaniel. Ensemble adversarial training: Attacks and defenses. arXiv preprint arXiv:1705.07204, 2017.   
+Andrew J. Viterbi. An intuitive justification and a simplified implementation of the map decoder for convolutional codes. IEEE Journal on Selected Areas in Communications, 16(2):260–264, 1998.   
+Weilin Xu, David Evans, and Yanjun Qi. Feature squeezing: Detecting adversarial examples in deep neural networks. arXiv preprint arXiv:1704.01155, 2017.   
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.   
+Richard Zhang, Phillip Isola, and Alexei A Efros. Colorful image colorization. In European Conference on Computer Vision, pp. 649–666. Springer, 2016.   
+Bolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Learning deep features for discriminative localization. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2921–2929, 2016a.   
+Tinghui Zhou, Shubham Tulsiani, Weilun Sun, Jitendra Malik, and Alexei A Efros. View synthesis by appearance flow. In ECCV, pp. 286–301. Springer, 2016b.
+
+# A MODEL ARCHITECTURES
+
+Table 4: Architecture of models applied on MNIST   
+
+<table><tr><td>A</td><td>B</td><td>C</td></tr><tr><td>Conv(64,5,5) + Relu</td><td>Conv(64,8,8) + Relu</td><td>Conv(128,3,3) + Relu</td></tr><tr><td>Conv(64,5,5) + Relu</td><td>Dropout(0.2)</td><td>Conv(64,3,3) +Relu</td></tr><tr><td>Dropout(0.25)</td><td>Conv(128,6,6)+Relu</td><td>Dropout(0.25)</td></tr><tr><td>FC(128) + Relu</td><td>Conv(128,5,5) +Relu</td><td>FC(128) +Relu</td></tr><tr><td>Dropout(0.5)</td><td>Dropout(0.5)</td><td>Dropout(0.5)</td></tr><tr><td>FC(10) + Softmax</td><td>FC(10) +Softmax</td><td>FC(10)+Softmax</td></tr></table>
+
+# B ANALYSIS FOR MEAN BLUR DEFENSE
+
+Here we evaluated adversarial examples generated by stAdv against the $3 \times 3$ average pooling restoration mechanism suggested in Li & Li (2016). Table 5 shows the classification accuracy of recovered images after performing $3 \times 3$ average pooling on different models.
+
+Table 5: Performance of adversarial examples against the mean blur defense strategy with $3 \times 3$ mean filter.   
+
+<table><tr><td>Accuracy on recovered images</td><td>A</td><td>MNIST B</td><td>C</td><td>CIFAR-10 Resnet32 wide ResNet34</td></tr><tr><td>3 × 3 Average Filter</td><td>59.00%</td><td>64.22%</td><td>79.71%</td><td>45.12%</td><td>50.12%</td></tr></table>
+
+# C ADVERSARIAL EXAMPLES FOR AN IMAGENET-COMPATIBLE SET, MNIST, AND CIFAR-10
+
+Experiment settings. In the following experiments, we perform a grid search of hyper-parameter $\tau$ so that the adversarial examples can attack the target model with minimal deformation. Values of $\tau$ are searched from 0.0005 to 0.05.
+
+ImageNet-compatible. We use benign images from the DEV set from the NIPS 2017 targeted adversarial attack competition.4 This competition provided a dataset compatible with ImageNet and containing target labels for a targeted attack. We generate targeted adversarial examples for the target inception_v3 model. In Figure 10 below, we show the original images on the left with the correct label, and we show adversarial examples generated by stAdv on the right with the target label.
+
+MNIST. We generate adversarial examples for the target Model B. In Figure 11, we show original images with ground truth classes 0–9 in the diagonal, and we show adversarial examples generated by stAdv targeting the class of the original image within that column.
+
+CIFAR-10. We generate adversarial examples for the target ResNet-32 model. In Figure 12, we show the original images in the diagonal, and we show adversarial examples generated by stAdv targeting the class of the original image within that column.
+
+Table 6 shows the magnitude of the generated flow regarding total variation (TV) and $\mathcal { L } _ { 2 }$ distance on the ImageNet-compatible set, MNIST, CIFAR-10, respectively. These metrics are calculated by the following equations, where $n$ is the number of pixels:
+
+$$
+\mathrm { T V } = \sqrt { \frac { 1 } { n } \sum _ { p } ^ { a l l p i c e l s } \sum _ { q \in \mathcal { N } ( p ) } | | \Delta u ^ { ( p ) } - \Delta u ^ { ( q ) } | | _ { 2 } ^ { 2 } + | | \Delta v ^ { ( p ) } - \Delta v ^ { ( q ) } | | _ { 2 } ^ { 2 } } .
+$$
+
+$$
+\mathcal { L } _ { 2 } = \sqrt { \frac { 1 } { n } \sum _ { p } ^ { a l l p i x e l s } | | \Delta u ^ { ( p ) } | | _ { 2 } ^ { 2 } + | | \Delta v ^ { ( p ) } | | _ { 2 } ^ { 2 } }
+$$
+
+Table 6: Evaluation Metric (the number in bracket is image size)   
+
+<table><tr><td>Metric</td><td>ImageNet-compatible (299x299)</td><td>MNIST (28x28)</td><td>CIFAR-10 (32x32)</td></tr><tr><td>flow TV</td><td>2.85×10-4±7.28×10-5</td><td>8.26×10-3±4.95×10-3</td><td>2.21× 10-3±1.26×10-3</td></tr><tr><td>flow L2</td><td>2.11 × 10-4 ±5.19 × 10-5</td><td>5.18 × 10-² ± 5.66 × 10-2</td><td>2.76 × 10-3± 2.31 × 10-3</td></tr></table>
+
+![](images/cb7773b077f6251bdffc26eb1b7c7788d71764f227d1dbf6af08b450d26cc97d.jpg)
+
+![](images/f275840c6d6359ef2851ee4ed213e3705f5cffbc3f50f4a13b45fd85def6e5aa.jpg)  
+(a) Benign image (labeled as dung beetle)
+
+![](images/ca7c6794a608fb848fd47eefcd1e3e36b68cdb80cdf3ab16f3407492dcc3ca80.jpg)  
+(c) Benign image (labeled as jeep)   
+(e) Benign image (labeled as bull mastiff)
+
+![](images/5b9c9b4627a6d5bac274078ac08fd6ead0ab690224338dccc235fe3e4514f62f.jpg)
+
+![](images/4351336944abda120b4811614d320a9f28a3ad351eb57560fbfa94786aafac3c.jpg)  
+(b) Adversarial image (labeled as scale)
+
+![](images/c6d1012d2994707d1ca3723b315469b71b06acd640d24560373bf85b5e70074b.jpg)  
+(d) Adversarial image (labeled as coil)   
+(f) Adversarial image (labeled as American lobster)
+
+![](images/0342b6961f2204467f41e914ae655457e97444ef98cef11debbb8d2adccceb4a.jpg)
+
+![](images/b73c05484fc00554b1d5e1dda7e54375e33f9ed60a8e77fa7bfd524b5c966c3c.jpg)  
+(g) Benign image (labeled as buckeye)
+
+![](images/139ed79a115288f72f48389af30068e9f24987beeaa8cdd16b1c486a30ed6f58.jpg)  
+(i) Benign image (labeled as thatch)   
+(k) Benign image (labeled as beaker)
+
+![](images/01fde2ffcea9fa03d96959aac264264293d6a67472b17bca2a312c60c82108f5.jpg)
+
+![](images/77252fb96c14f05fc77bfcaf7d41a4d3a3960dfb0c99a3e62b7c62b35f8ee833.jpg)  
+(h) Adversarial image (labeled as goose)
+
+![](images/9c99c74d7de659e9cb3ee50ced140e947ed5d641f3f412462a9140c11e27d659.jpg)  
+(j) Adversarial image (labeled as miniature poodle)   
+(l) Adversarial image (labeled as padlock)
+
+![](images/80699b1ca534803e1529fb4032712314e46f17de2a54a340c640f0414cd91d89.jpg)
+
+![](images/e2674dd70021f7507fb7b553a1e49a37e492311cb1243626b57b84b2c52dc892.jpg)  
+(m) Benign image (labeled as strawberry)
+
+![](images/74a638d91ffd4557f7b628480bc68480179a2fbf4eaed6d0c81bab555c8edf88.jpg)  
+(o) Benign image (labeled as folding chair)   
+(q) Benign image (labeled as jeep)
+
+![](images/38505fcc1c040246c1e6a3734fb1b352082f771bd65103a5d16d7595bacf3203.jpg)
+
+![](images/006d856039c24c32266946e349e06ba9d7c7c23d4b7bce29b27ea414e7502fe6.jpg)  
+(n) Adversarial image (labeled as tench)
+
+![](images/30dd611be6ad13e419430928bf4fa5675357e1b4f01e5af28934757c7086cf0d.jpg)  
+(p) Adversarial image (labeled as power drill)   
+(r) Adversarial image (labeled as house finch)
+
+![](images/6ff2561eaa132c0fa0d50aea19244038dde3f99bc9a51bb34da99ae984a135da.jpg)  
+Figure 10: Examples from an ImageNet-compatible set. Left: original image; right: adversarial image generated by stAdv against inception_v3.
+
+![](images/d79500d4c680e60878b13b44ccfb6494a82e8db0d3392187bc82c400741e8bf0.jpg)
+
+![](images/9baa44fca70aefdb3f79c3f22c6e8cfb4b17537c08af2c0c2cc5132c91ee921c.jpg)
+
+![](images/d6a9685d39a92222e4a7ea345953b147876af945ec0366d6a2618a97f54331d4.jpg)
+
+![](images/f31bf4f717a89e424649fbe6523c48cdf46c62d8caa6c4b67e769cf36bda9106.jpg)
+
+![](images/f03eff8d90e14770f746db37a3ca77a916bbe8228ad3ef521ec7b4ed16181d53.jpg)
+
+![](images/65bbb4c11da020e34a27d503e899bf944f31e8eb550bc14ca84fa6d19bf3ea4d.jpg)
+
+![](images/3b8f7cf926a4ec4e30a1da96608e4953b39f53820190ee8a1e12c1db812f817b.jpg)
+
+![](images/e9414445704c9f9e84f9049a953885bf88722c3c8634eae2f31b383442cc6481.jpg)
+
+![](images/3b938b20060c153e0c7b1a3627a8a43c4c4823350fdf981a412618f389b6d956.jpg)
+
+![](images/defd04566980b7294107673492d30544e61ae696f88c577de7ce7a75f3272540.jpg)  
+Figure 11: Adversarial examples generated by stAdv against Model B on MNIST. The original images are shown in the diagonal; the rest are adversarial examples that are classified into the same class as the original image within that column.
+
+![](images/61368515d054c4a63ac08784eecec24a64a95eddb2909e15e742869cf4f0a206.jpg)
+
+![](images/ce8df07e4ec8942f30b69a81de4d338f1c6151977b43a446cae4303c3f443250.jpg)
+
+![](images/168af0f37dd021dc35bf797bffb6207f4e617ff9f99baf080a750fb624366d71.jpg)
+
+![](images/f26608bd59b8fed5bb2eb7570c4832594cd5d115f69a496ebbacf6c2ed889a97.jpg)
+
+![](images/8c370c963942b0e753c2662882f212f6c0362fc5d19bcb3766960a152f4a70ee.jpg)
+
+![](images/15c5c49654f91c3e1693973a3fb796edc82ec83eb1897b1a60332c82bf2e495b.jpg)
+
+![](images/33a55820d187e96ae9a341ad3f194c85a6d86535b96a56eeaa322d25873a39b5.jpg)
+
+![](images/f50fb5de579879f4db17784cf31fcedaa5b7d288d32a679ff996d76618495b52.jpg)
+
+![](images/05d87e58c094eb551266bafd01e966178b7f969b8fac21fde424c9a0fc4324b3.jpg)
+
+![](images/04d2a4afc45097361558bc414bb8797fa3c41e72c08462065fc5f40972b30eaa.jpg)  
+Figure 12: Adversarial examples generated by stAdv against a ResNet-32 on CIFAR-10. The original images are shown in the diagonal; the rest are adversarial examples that are classified into the same class as the original image within that column.

parse/train/HyydRMZC-/HyydRMZC-_content_list.json

@@ -0,0 +1,2210 @@
+[
+    {
+        "type": "text",
+        "text": "SPATIALLY TRANSFORMED ADVERSARIAL EXAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            99,
+            821,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Chaowei Xiao1 ∗, Jun-Yan $\\mathbf { Z } \\mathbf { h } \\mathbf { u } ^ { 2 }$ ∗, $\\mathbf { B o L i ^ { 3 } }$ , Warren $\\mathbf { H e ^ { 3 } }$ , Mingyan Liu1, Dawn Song3   \n1University of Michigan, Ann Arbor, USA   \n2Massachusetts Institute of Technology, MA, USA   \n3University of California, Berkeley, USA ",
+        "bbox": [
+            184,
+            143,
+            758,
+            203
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            239,
+            544,
+            253
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent studies show that widely used deep neural networks (DNNs) are vulnerable to carefully crafted adversarial examples. Many advanced algorithms have been proposed to generate adversarial examples by leveraging the ${ \\mathcal { L } } _ { p }$ distance for penalizing perturbations. Researchers have explored different defense methods to defend against such adversarial attacks. While the effectiveness of ${ \\mathcal { L } } _ { p }$ distance as a metric of perceptual quality remains an active research area, in this paper we will instead focus on a different type of perturbation, namely spatial transformation, as opposed to manipulating the pixel values directly as in prior works. Perturbations generated through spatial transformation could result in large ${ \\mathcal { L } } _ { p }$ distance measures, but our extensive experiments show that such spatially transformed adversarial examples are perceptually realistic and more difficult to defend against with existing defense systems. This potentially provides a new direction in adversarial example generation and the design of corresponding defenses. We visualize the spatial transformation based perturbation for different examples and show that our technique can produce realistic adversarial examples with smooth image deformation. Finally, we visualize the attention of deep networks with different types of adversarial examples to better understand how these examples are interpreted. ",
+        "bbox": [
+            233,
+            268,
+            764,
+            518
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            545,
+            336,
+            560
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks (DNNs) have demonstrated their outstanding performance in different domains, ranging from image processing (Krizhevsky et al., 2012; He et al., 2016), text analysis (Collobert & Weston, 2008) to speech recognition (Hinton et al., 2012). Though deep networks have exhibited high performance for these tasks, recently they have been shown to be particularly vulnerable to adversarial perturbations added to the input images (Szegedy et al., 2013; Goodfellow et al., 2015). These perturbed instances are called adversarial examples, which can lead to undesirable consequences in many practical applications based on DNNs. For example, adversarial examples can be used to subvert malware detection, fraud detection, or even potentially mislead autonomous navigation systems (Papernot et al., 2016b; Evtimov et al., 2017; Grosse et al., 2016) and therefore pose security risks when applied to security-related applications. A comprehensive study about adversarial examples is required to motivate effective defenses. Different methods have been proposed to generate adversarial examples such as fast gradient sign methods (FGSM) (Goodfellow et al., 2015), which can produce adversarial instances rapidly, and optimization-based methods (C&W) (Carlini & Wagner, 2017a), which search for adversarial examples with smaller magnitude of perturbation. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            784
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One important criterion for adversarial examples is that the perturbed images should “look like” the original instances. The traditional attack strategies adopt $L _ { 2 }$ (or other ${ \\mathcal { L } } _ { p }$ ) norm distance as a perceptual similarity metric to evaluate the distortion (Gu & Rigazio, 2014). However, this is not an ideal metric (Johnson et al., 2016; Isola et al., 2017), as $L _ { 2 }$ similarity is sensitive to lighting and viewpoint change of a pictured object. For instance, an image can be shifted by one pixel, which will lead to large $L _ { 2 }$ distance, while the translated image actually appear “the same��� to human perception. Motivated by this example, in this paper we aim to look for other types of adversarial examples and propose to create perceptually realistic examples by changing the positions of pixels instead of directly manipulating existing pixel values. This has been shown to better preserve the identity and structure of the original image (Zhou et al., 2016b). Thus, the proposed spatially transformed adversarial example optimization method (stAdv) can keep adversarial examples less distinguishable from real instances (such examples can be found in Figure 3). ",
+        "bbox": [
+            174,
+            791,
+            825,
+            902
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Various defense methods have also been proposed to defend against adversarial examples. Adversarial training based methods have so far achieved the most promising results (Goodfellow et al., 2015; Tramèr et al., 2017; M ˛adry et al., 2017). They have demonstrated the robustness of improved deep networks under certain constraints. However, the spatially transformed adversarial examples are generated through a rather different principle, whereby what is being minimized is the local geometric distortion rather than the ${ \\mathcal { L } } _ { p }$ pixel error between the adversarial and original instances. Thus, the previous adversarial training based defense method may appear less effective against this new attack given the fact that these examples generated by stAdv have never been seen before. This opens a new challenge about how to defend against such attacks, as well as other attacks that are not based on direct pixel value manipulation. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            305
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We visualize the spatial deformation generated by stAdv; it is seen to be locally smooth and virtually imperceptible to the human eye. In addition, to better understand the properties of deep neural networks on different adversarial examples, we provide visualizations of the attention of the DNN given adversarial examples generated by different attack algorithms. We find that the spatial transformation based attack is more resilient across different defense models, including adversarially trained robust models. ",
+        "bbox": [
+            174,
+            313,
+            823,
+            396
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our contributions are summarized as follows: ",
+        "bbox": [
+            176,
+            404,
+            472,
+            417
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose to generate adversarial examples based on spatial transformation instead of direct manipulation of the pixel values, and we show realistic and effective adversarial examples on the MNIST, CIFAR-10, and ImageNet datasets.   \nWe provide visualizations of optimized transformations and show that such geometric changes are small and locally smooth, leading to high perceptual quality.   \n• We empirically show that, compared to other attacks, adversarial examples generated by stAdv are more difficult to detect with current defense systems.   \n• Finally, we visualize the attention maps of deep networks on different adversarial examples and demonstrate that adversarial examples based on stAdv can more consistently mislead the adversarial trained robust deep networks compared to other existing attack methods. ",
+        "bbox": [
+            215,
+            428,
+            825,
+            579
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            598,
+            341,
+            614
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Here we first briefly summarize the existing adversarial attack algorithms as well as the current defense methods. We then discuss the spatial transformation model used in our adversarial attack. ",
+        "bbox": [
+            173,
+            630,
+            823,
+            657
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Adversarial Examples Given a benign sample $\\mathbf { x }$ , an attack instance $\\mathbf { x } _ { \\mathrm { a d v } }$ is referred to as an adversarial example, if a small magnitude of perturbation $\\epsilon$ is added to $\\mathbf { x }$ (i.e. ${ \\bf x } _ { \\mathrm { a d v } } = { \\bf x } + { \\bf \\epsilon } \\mathrm { ) }$ so that $\\mathbf { x } _ { \\mathrm { a d v } }$ is misclassified by the targeted classifier $g$ . Based on the adversarial goal, attacks can be classified into two categories: targeted and untargeted attacks. In a targeted attack, the adversary’s objective is to modify an input $\\mathbf { x }$ such that the target model $g$ classifies the perturbed input $\\mathbf { x } _ { \\mathrm { a d v } }$ in a targeted class chosen, which differs from its ground truth. In a untargeted attack, the adversary’s objective is to cause the perturbed input $\\mathbf { x } _ { \\mathrm { a d v } }$ to be misclassified in any class other than its ground truth. Based on the adversarial capabilities, these attacks can be categorized as white-box and black-box attacks, where an adversary has full knowledge of the classifier and training data in the white-box setting (Szegedy et al., 2014; Goodfellow et al., 2015; Carlini & Wagner, 2017a; Moosavi-Dezfooli et al., 2015; Papernot et al., 2016b; Biggio et al., 2013; Fawzi & Frossard, 2015; Kanbak, 2017; Kurakin et al., 2016); while having zero knowledge about them in the black-box setting (Papernot et al., 2016a; Liu et al., 2017; Moosavi-Dezfooli et al., 2016; Mopuri et al., 2017). In this work, we will focus on the white-box setting to explore what a powerful adversary can do based on the Kerckhoffs’s principle (Shannon, 1949) to better motivate defense methods. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            880
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Spatial Transformation In computer vision and graphics literature, Two main aspects determine the appearance of a pictured object (Szeliski, 2010): (1) the lighting and material, which determine the brightness of a point as a function of illumination and object material properties, and (2) the geometry, which determines where the projection of a point will be located in the scene. Most previous adversarial attacks (Goodfellow et al., 2015) focus on changing the lighting and material aspect, while assuming the underlying geometry stays the same during the adversarial perturbation generation process. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Modeling geometric transformation with neural networks was first explored by “capsules,” computational units that locally transform their input for modeling 2D and 3D geometric changes (Hinton et al., 2011). Later, Jaderberg et al. (2015) demonstrated that similar computational units, named spatial transformers, can benefit many visual recognition tasks. Zhou et al. (2016a) adopted the spatial transformers for synthesizing novel views of the same object and has shown that a geometric method can produce more realistic results compared to pure pixel-based methods. Inspired by these successes, we also use the spatial transformers to deform the input images, but with a different goal: to generate realistic adversarial examples. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            291
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Defensive Methods Following the emergence of adversarial examples, various defense methods have been studied, including adversarial training (Goodfellow et al., 2015), distillation (Papernot et al., 2016c), gradient masking (Gu & Rigazio, 2014) and feature squeezing (Xu et al., 2017). However, these defenses can either be evaded by C&W attacks or only provide marginal improvements (Carlini & Wagner, 2017b; He et al., 2017). Among these defenses, adversarial training has achieved the state-of-the-art performance. Goodfellow et al. (2015) proposed to use the fast gradient sign attack as an adversary to perform adversarial training, which is much faster, followed by ensemble adversarial training (Tramèr et al., 2017) and projected gradient descent (PGD) adversarial training (M ˛adry et al., 2017). In this work, we explicitly analyze how effective the spatial transformation based adversarial examples are under these adversarial training based defense methods. ",
+        "bbox": [
+            174,
+            313,
+            825,
+            452
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 GENERATING ADVERSARIAL EXAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            478,
+            544,
+            494
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here we first introduce several existing attack methods and then present our formulation for producing spatially transformed adversarial examples. ",
+        "bbox": [
+            174,
+            513,
+            821,
+            541
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 PROBLEM DEFINITION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            564,
+            370,
+            579
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given a learned classifier $g : \\mathcal { X }  \\mathcal { Y }$ from a feature space $\\mathcal { X }$ to a set of classification outputs $\\mathcal { V }$ (e.g., $\\mathcal { V } = \\{ 0 , 1 \\}$ for binary classification), an adversary aims to generate adversarial example $\\mathbf { x } _ { \\mathrm { a d v } }$ for an original instance $\\mathbf { x } \\in \\mathcal { X }$ with its ground truth label $y \\in \\mathcal { V }$ , so that the classifier predicts $g ( \\mathbf { x } _ { \\mathrm { a d v } } ) \\neq y$ (untargeted attack) or $g ( \\mathbf { x } _ { \\mathrm { a d v } } ) = t$ (targeted attack) where $t$ is the target class. ",
+        "bbox": [
+            174,
+            592,
+            825,
+            648
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 BACKGROUND: CURRENT PIXEL-VALUE BASED ATTACK METHODS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            672,
+            673,
+            685
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "All of the current methods for generating adversarial examples are built on directly modifying the pixel values of the original image. ",
+        "bbox": [
+            176,
+            699,
+            823,
+            728
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The fast gradient sign method (FGSM) (Goodfellow et al., 2015) uses a first-order approximation of the loss function to construct adversarial samples for the adversary’s target classifier $g$ . The algorithm achieves untargeted attack by performing a single gradient ascent step: ${ \\bf x } _ { \\mathrm { a d v } } = { \\bf x } + { \\bf \\delta }$ $\\epsilon \\cdot \\mathrm { s i g n } ( \\nabla _ { \\mathbf { x } } \\ell _ { g } ( \\mathbf { x } , y ) )$ , where $\\ell _ { g } ( \\mathbf x , y )$ is the loss function (e.g. cross-entropy loss) used to train the original model $g , y$ denotes the ground truth label, and the hyper-parameter $\\epsilon$ controls the magnitude of the perturbation. A targeted version of it can be done similarly. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            819
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Optimization-based attack (C&W) produces an adversarial perturbation for a targeted attack based on certain constraints (Carlini & Wagner, 2017a; Liu et al., 2017) as formulated below: ",
+        "bbox": [
+            171,
+            825,
+            823,
+            854
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/21e85921caf1d901883db8ee9cd477f252c31f9da69156511ac345de883cfbd1.jpg",
+        "text": "$$\n\\operatorname* { m i n } | | \\delta | | _ { p } ^ { 2 } \\quad \\mathrm { s . t . } \\qquad g ( \\mathbf { x } + \\delta ) = t \\quad \\mathrm { a n d } \\quad \\mathbf { x } + \\delta \\in X ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            864,
+            676,
+            885
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where the ${ \\mathcal { L } } _ { p }$ norm penalty ensures that the added perturbation $\\epsilon$ is small. The same optimization procedure can achieve untargeted attacks with a modified constraint $g ( \\mathbf { x } + \\delta ) \\neq y$ . ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/59a5504203b0edb3ef5204a4cf3e7c01be00b469b05918357318c0bea0ca3e40.jpg",
+        "image_caption": [
+            "Figure 1: Generating adversarial examples with spatial transformation: the blue point denotes the coordinate of a pixel in an output adversarial image and the green point is its corresponding pixel in an input image. The flow field in red represents the displacement from the pixels in the adversarial image to the pixels in the input image. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            104,
+            805,
+            297
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 OUR APPROACH: SPATIALLY TRANSFORMED ADVERSARIAL EXAMPLES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            396,
+            714,
+            411
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "All the existing approaches directly modify pixel values, which may sometimes produce noticeable artifacts. Instead, we aim to smoothly change the geometry of the scene while keeping the original appearance, producing more perceptually realistic adversarial examples. In this section, we first introduce our spatial transformation model and then describe our objective function for generating spatially transformed adversarial examples. ",
+        "bbox": [
+            174,
+            424,
+            825,
+            496
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Spatial transformation We use $\\mathbf { x } _ { \\mathrm { a d v } } ^ { ( i ) }$ to denote the pixel value of the $i$ -th pixel and 2D coordinate (u adv, v adv) to denote its location in the adversarial image $\\mathbf { x } _ { \\mathrm { a d v } }$ . We assume that $\\mathbf { x } _ { \\mathrm { a d v } } ^ { ( i ) }$ is transformed from the pixel $\\mathbf { x } ^ { ( i ) }$ from the original image. We use the per-pixel flow (displacement) field $f$ to synthesize the adversarial image $\\mathbf { x } _ { \\mathrm { a d v } }$ using pixels from the input $\\mathbf { x }$ . For the $i$ -th pixel within $\\mathbf { x } _ { \\mathrm { a d v } }$ at the pixel location $( u _ { \\mathrm { a d v } } ^ { ( i ) } , v _ { \\mathrm { a d v } } ^ { ( i ) } )$ , we optimize the amount of displacement in each image dimension, with the pair denoted by the flow vector $f _ { i } : = ( \\Delta u ^ { ( i ) } , \\Delta v ^ { ( i ) } )$ . Note that the flow vector $f _ { i }$ goes from a pixel $\\mathbf { x } _ { \\mathrm { a d v } } ^ { ( i ) }$ in the adversarial image to its corresponding pixel $\\mathbf { x } ^ { ( i ) }$ in the input image. Thus, the location of its corresponding pixel $\\mathbf { x } ^ { ( i ) }$ can be derived as $( \\boldsymbol { u } ^ { ( i ) } , \\boldsymbol { v } ^ { ( i ) } ) = ( u _ { \\mathrm { a d v } } ^ { ( i ) } + \\Delta u ^ { ( i ) } , v _ { \\mathrm { a d v } } ^ { ( i ) } + \\Delta v ^ { ( i ) } )$ . As the $( u ^ { ( i ) } , v ^ { ( i ) } )$ can be fractional numbers and does not necessarily lie on the integer image grid, we use the differentiable bilinear interpolation (Jaderberg et al., 2015) to transform the input image with the flow field. We calculate x(i)adv as: ",
+        "bbox": [
+            173,
+            515,
+            826,
+            699
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5616ce92804c1059dd7a6410b5d7caba7b79380f40e6cc1b830e3fdb2074820f.jpg",
+        "text": "$$\n\\mathbf { x } _ { \\mathrm { a d v } } ^ { ( i ) } = \\sum _ { q \\in \\mathcal { N } ( u ^ { ( i ) } , v ^ { ( i ) } ) } \\mathbf { x } ^ { ( q ) } ( 1 - | u ^ { ( i ) } - u ^ { ( q ) } | ) ( 1 - | v ^ { ( i ) } - v ^ { ( q ) } | ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            708,
+            704,
+            747
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { N } ( u ^ { ( i ) } , v ^ { ( i ) } )$ are the indices of the 4-pixel neighbors at the location $( u ^ { ( i ) } , v ^ { ( i ) } )$ (top-left, topright, bottom-left, bottom-right). We can obtain the adversarial image $\\mathbf { x } _ { \\mathrm { a d v } }$ by calculating Equation 1 for every pixel $\\mathbf { x } _ { \\mathrm { a d v } } ^ { ( i ) }$ . Note that $\\mathbf { x } _ { \\mathrm { a d v } }$ is differentiable with respect to the flow field $f$ (Jaderberg et al., 2015; Zhou et al., 2016b). The estimated flow field essentially captures the amount of spatial transformation required to fool the classifier. ",
+        "bbox": [
+            173,
+            758,
+            825,
+            833
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Objective function Most of the previous methods constrain the added perturbation to be small regarding a ${ \\mathcal { L } } _ { p }$ metric. Here instead of imposing the ${ \\mathcal { L } } _ { p }$ norm on pixel space, we introduce a new regularization loss $\\mathcal { L } _ { f l o w }$ on the local distortion $f$ , producing higher perceptual quality for adversarial examples. Therefore, the goal of the attack is to generate adversarial examples which can mislead the classifier as well as minimizing the local distortion introduced by the flow field $f$ . ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Formally, given a benign instance $\\mathbf { x }$ , we obtain the flow field $f$ by minimize the following objective: ",
+        "bbox": [
+            171,
+            103,
+            823,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/59956bc6bfdb1df7bbba4e83a1b6fef761b1205e9b2c32e957faceee85831060.jpg",
+        "text": "$$\nf ^ { * } = \\underset { f } { \\mathrm { a r g m i n } } \\quad \\mathcal { L } _ { a d v } ( x , f ) + \\tau \\mathcal { L } _ { f o w } ( f ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            131,
+            637,
+            157
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { L } _ { a d v }$ encourages the generated adversarial examples to be misclassified by the target classifier. $L _ { f l o w }$ ensures that the spatial transformation distance is minimized to preserve high perceptual quality, and $\\tau$ balances these two losses. ",
+        "bbox": [
+            173,
+            161,
+            825,
+            204
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The goal of $\\mathcal { L } _ { a d v }$ is to guarantee the targeted attack $g ( \\mathbf { x } _ { \\mathrm { a d v } } ) ~ = ~ t$ where $t$ is the targeted class, different from the ground truth label $y$ . Recall that we transform the input image $\\mathbf { x }$ to $\\mathbf { x } _ { \\mathrm { a d v } }$ with the flow field $f$ (Equation 1). In practice, directly enforcing $g ( \\mathbf { x } _ { \\mathrm { a d v } } ) = t$ during optimization is highly non-linear, we adopt the objective function suggested in Carlini & Wagner (2017a). ",
+        "bbox": [
+            174,
+            210,
+            823,
+            267
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a5ba8eadf97cc4846d58449fb99f02ad94aeb46bde4975e30036b240cffc1875.jpg",
+        "text": "$$\n\\mathcal { L } _ { a d v } ( x , f ) = \\operatorname* { m a x } ( \\operatorname* { m a x } _ { i \\neq t } g ( \\mathbf { x } _ { \\mathrm { a d v } } ) _ { i } - g ( \\mathbf { x } _ { \\mathrm { a d v } } ) _ { t } , \\kappa ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            273,
+            658,
+            297
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $g ( x )$ represents the logit output of model $g , g ( x ) _ { i }$ denotes the $i$ -th element of the logit vector, and $\\kappa$ is used to control the attack confidence level. ",
+        "bbox": [
+            173,
+            306,
+            821,
+            335
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To compute ${ \\mathcal { L } } _ { f l o w }$ , we calculate the sum of spatial movement distance for any two adjacent pixels. Given an arbitrary pixel $p$ and its neighbors $q \\in \\mathcal { N } ( p )$ , we enforce the locally smooth spatial transformation perturbation $\\mathcal { L } _ { f l o w }$ based on the total variation (Rudin et al., 1992): ",
+        "bbox": [
+            174,
+            342,
+            825,
+            385
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a463ed87dd335ed6f1c7ec16fb99058a9f16ecad12884a2d2b9a0bd1bf304a05.jpg",
+        "text": "$$\n\\mathcal { L } _ { f l o w } ( f ) = \\sum _ { p } ^ { a l l p i x e l s } \\sum _ { q \\in N ( p ) } \\sqrt { | | \\Delta u ^ { ( p ) } - \\Delta u ^ { ( q ) } | | _ { 2 } ^ { 2 } + | | \\Delta v ^ { ( p ) } - \\Delta v ^ { ( q ) } | | _ { 2 } ^ { 2 } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            402,
+            735,
+            449
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, minimizing the spatial transformation can help ensure the high perceptual quality for stAdv, since adjacent pixels tend to move towards close direction and distance. We solve the above optimization with L-BFGS solver (Liu & Nocedal, 1989). ",
+        "bbox": [
+            176,
+            458,
+            823,
+            501
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            522,
+            419,
+            539
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first show adversarial examples generated by the proposed spatial transformation method and analyze the properties of these examples from different perspectives. We then visualize the estimated flows for adversarial examples and show that with small and smooth transformation, the generated adversarial examples can already achieve a high attack success rate against deep networks. We also show that stAdv can preserve a high attack success rate against current defense methods, which motivates more sophisticated defense methods in the future. Finally, we analyze the attention regions of DNNs, to better understand the attack properties of stAdv. ",
+        "bbox": [
+            173,
+            554,
+            825,
+            651
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Experiment Setup We set $\\tau$ as 0.05 for all our experiments. We use confidence $\\kappa = 0$ for both C&W and stAdv for a fair comparison. We leverage L-BFGS (Liu & Nocedal, 1989) as our solver with backtracking linear search. ",
+        "bbox": [
+            174,
+            667,
+            825,
+            710
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 ADVERSARIAL EXAMPLES BASED ON SPATIAL TRANSFORMATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            728,
+            681,
+            742
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We show adversarial examples with high perceptual quality for both MNIST (LeCun & Cortes, 1998) and CIFAR-10 (Krizhevsky et al., 2014) datasets. ",
+        "bbox": [
+            173,
+            753,
+            823,
+            782
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "stAdv on MNIST In our experiments, we generate adversarial examples againsts three target models in the white-box setting on the MNIST dataset. Model A, B, and C are derived from the prior work (Tramèr et al., 2017), which represent different architectures. See Appendix A and Table 4 for more details about their network architectures. Table 1 presents the accuracy of pristine MNIST test data on each model as well as the attack success rate of adversarial examples generated by stAdv on these models. Figure 2 shows the adversarial examples against different models where the original instances appear in the diagonal. Each adversarial example achieves a targeted attack, with the target class shown on the top of the column. It is clear that the generated adversarial examples still appear to be in the same class as the original instance for humans. Another advantage for stAdv compared with traditional attacks is that examples based on stAdv seldom show noise pattern within the adversarial examples. Instead, stAdv smoothly deforms the digits and since such natural deformation also exists in the dataset digits, humans can barely notice such manipulation. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/59628578f785dbeb78b8d72999a1068bb989cd5420f445c76e4fed323d588cbf.jpg",
+        "table_caption": [
+            "Table 1: Top: accuracy of different models on pristine data (p); bottom: attack success rates of adversarial examples generated by stAdv on MNIST dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>A</td><td>B</td><td>C</td></tr><tr><td>Accuracy (p)</td><td>98.58%</td><td>98.94%</td><td>99.11%</td></tr><tr><td>Attack Success Rate</td><td>99.95%</td><td>99.98%</td><td>100.00%</td></tr></table>",
+        "bbox": [
+            323,
+            199,
+            669,
+            251
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/cd9611ac0f4cbc32e6f9793e0769e4433e5651461d4c405c74337333c8eb72b0.jpg",
+        "image_caption": [
+            "Figure 2: Adversarial examples generated by stAdv against different models on MNIST. The ground truth images are shown in the diagonal and the rest are adversarial examples that are misclassified to the target classes shown on the top. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            272,
+            815,
+            481
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "stAdv on CIFAR-10 For CIFAR-10, we use ResNet- $3 2 ^ { 1 }$ and wide ResNet- $3 4 ^ { 2 }$ as the target classifers (Zagoruyko & Komodakis, 2016; He et al., 2016; M ˛adry et al., 2017). We show the classification accuracy of pristine CIFAR-10 test data (p) and attack success rates of adversarial examples generated by stAdv on different models in Table 2. Figure 3 shows the generated examples on CIFAR-10 against different models. The original images are shown in the diagonal. The other images are targeted adversarial examples, with the index of the target classes shown at the top of the column. Here we use $^ { 6 6 } 0 { - } 9 ^ { 7 }$ to denote the ground truth labels of images lying in the diagonal for each corresponding column. These adversarial examples based on stAdv are randomly selected from the instances that can successfully attack the corresponding classifier. Humans can hardly distinguish these adversarial examples from the original instances. ",
+        "bbox": [
+            173,
+            559,
+            825,
+            699
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/7a1557cebb39ac7bbb998a3f9b2cfe5eb1301416531c442bb195a5e0f1df0db3.jpg",
+        "table_caption": [
+            "Table 2: Top: accuracy of different models on pristine data (p); bottom: attack success rates of adversarial examples generated by stAdv on the CIFAR-10 dataset. The numbers in parentheses denote the number of parameters in each target model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>ResNet32 (0.47M)</td><td>Wide ResNet34 (46.16M)</td></tr><tr><td>Accuracy (p)</td><td>93.16%</td><td>95.82%</td></tr><tr><td>Attack Success Rate</td><td>99.56%</td><td>98.84%</td></tr></table>",
+        "bbox": [
+            274,
+            766,
+            717,
+            819
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Comparison of different adversarial examples In Figure 4, we show adversarial examples that are targeted attacked to the same class (“0” for MNIST and “airplane” for CIFAR-10), which is different from their ground truth. We compare adversarial examples generated from different methods and show that those based on stAdv look more visually realistic compared with FGSM (Goodfellow et al., 2015) and C&W (Carlini & Wagner, 2017b) methods. ",
+        "bbox": [
+            176,
+            843,
+            823,
+            886
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/8a6c1e281094aeefce5c496c79947e05b175ad33612122c99f8fa4f776efe68d.jpg",
+        "image_caption": [
+            "Figure 3: Adversarial examples generated by stAdv against different models on CIFAR-10. The ground truth images are shown in the diagonal while the adversarial examples on each column are classified into the same class as the ground truth image within that column. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            99,
+            794,
+            373
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            455,
+            823,
+            484
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/ae8ba83f3adfa96e7c73c3735e96b7539289a1b6234b56c7f507285e36be7d74.jpg",
+        "image_caption": [
+            "Figure 4: Comparison of adversarial examples generated by FGSM, C&W and stAdv. (Left: MNIST, right: CIFAR-10) The target class for MNIST is $ { { } ^ { 6 } }  { 0 ^ { 9 } }$ and “air plane” for CIFAR-10. We generate adversarial examples by FGSM and C&W with perturbation bounded in terms of $L _ { \\infty }$ as 0.3 on MNIST and 8 on CIFAR-10. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            497,
+            828,
+            575
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/531d41d705ede2d69e965af067a2d14b6ebe5b5f6eef30ce5577cca2ea1c9a74.jpg",
+        "image_caption": [
+            "Figure 5: Flow visualization on MNIST. A digit “0” is misclassified as “2”. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            217,
+            672,
+            782,
+            816
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 VISUALIZING SPATIAL TRANSFORMATION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            869,
+            508,
+            883
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To better understand the spatial transformation applied to the original images, we visualize the optimized transformation flow for different datasets, respectively. Figure 5 visualizes a transformation on an MNIST instance, where the digit $\\mathbf { \\bar { \\theta } } ^ { 6 } 0 ^ { 9 }$ is misclassified as “2.” We can see that the adjacent flows move in a similar direction in order to generate smooth results. The flows are more focused on the edge of the digit and sometimes these flows move in different directions along the edge, which implies that the object boundary plays an important role in our stAdv optimization. Figure 6 illustrates a similar visualization on CIFAR-10. It shows that the optimized flows often focus on the area of the main object, such as the airplane. We also observe that the magnitude of flows near the edge are usually larger, which similarly indicates the importance of edges for misleading the classifiers. This observation confirms the observation that when DNNs extract edge information in the earlier layers for visual recognition tasks (Viterbi, 1998). In addition, we visualize the similar flow for the ImageNet dataset (Deng et al., 2009) in Figure 7. The top-1 label of the original image in Figure 7 (a) is “mountain bike”. Figure 7 (b)-(d) show targeted adversarial examples generated by stAdv, which have target classes “goldfish,” “Maltese dog,” and “tabby cat,” respectively, and which are predicted as such as the top-1 class. An interesting observation is that, although there are other objects within the image, nearly $90 \\%$ of the spatial transformation flows tend to focus on the target object bike. Different target class corresponds to different directions for these flows, which still fall into the similar area. ",
+        "bbox": [
+            176,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/b90a1e172f1c1bef85679ea8478ed5db04441e9b0738d2552413e8b97f726fe0.jpg",
+        "image_caption": [
+            "Figure 6: Flow visualization on CIFAR-10. An “airplane” image is misclassified as “bird”. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            99,
+            784,
+            224
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/6654a30cb8a43af7c43ed9d61fa164088b56d956e4eefbe00d2a6b2e48f4248e.jpg",
+        "image_caption": [
+            "Figure 7: Flow visualization on ImageNet. (a): the original image, (b)-(c): images are misclassified into goldfish, dog and cat, respectively. Note that to display the flows more clearly, we fade out the color of the original image. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            253,
+            810,
+            392
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            462,
+            825,
+            683
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 HUMAN PERCEPTUAL STUDY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            708,
+            413,
+            720
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To quantify the perceptual realism of stAdv’s adversarial examples, we perform a user study with human participants on Amazon Mechanical Turk (AMT). We follow the same perceptual study protocol used in prior image synthesis work (Zhang et al., 2016; Isola et al., 2017). We generate 600 images from an ImageNet-compatible dataset, described in Appendix C. In our study, the participants are asked to choose the more visually realistic image between an adversarial example generated by stAdv and its original image. During each trial, these two images appear side-by-side for 2 seconds. After the images disappear, our participants are given unlimited time to make their decision. To avoid labeling bias, we allow each user to conduct at most 50 trails. For each pair of an original image and its adversarial example, we collect about 5 annotations from different users. ",
+        "bbox": [
+            174,
+            734,
+            823,
+            861
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In total, we collected 2, 740 annotations from 93 AMT users. Examples generated by our method were chosen as the more realistic in $4 7 . 0 1 \\% \\pm 1 . 9 6 \\%$ of the trails (perfectly realistic results would achieve $5 0 \\%$ ). This indicates that our adversarial examples are almost indistinguishable from natural images. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/869dad4ec2bc598d7dd28aeab08aa14568f3c767b61db60051820b4dbe2aa6d7.jpg",
+        "table_caption": [
+            "Table 3: Attack success rates of adversarial examples generated by stAdv against models A, B, and C on MNIST, and against ResNet and wide ResNet on CIFAR-10, under standard defenses. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Def.</td><td>FGSM</td><td>C&amp;W.</td><td>stAdv</td></tr><tr><td rowspan=\"3\">A</td><td>Adv.</td><td>4.3%</td><td>4.6%</td><td>32.62%</td></tr><tr><td>Ens.</td><td>1.6%</td><td>4.2%</td><td>48.07%</td></tr><tr><td>PGD</td><td>4.4%</td><td>2.96%</td><td>48.38%</td></tr><tr><td rowspan=\"3\">B</td><td>Adv.</td><td>6.0%</td><td>4.5%</td><td>50.17%</td></tr><tr><td>Ens.</td><td>2.7%</td><td>3.18%</td><td>46.14%</td></tr><tr><td>PGD</td><td>9.0%</td><td>3.0%</td><td>49.82%</td></tr><tr><td rowspan=\"3\">C</td><td>Adv.</td><td>3.22%</td><td>0.86%</td><td>30.44%</td></tr><tr><td>Ens.</td><td>1.45%</td><td>0.98%</td><td>28.82%</td></tr><tr><td>PGD</td><td>2.1%</td><td>0.98%</td><td>28.13%</td></tr></table>",
+        "bbox": [
+            178,
+            122,
+            493,
+            275
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/3563cfa4f6b84829697baadbb0084f3f19ebacd67b237db798a5cd1a3bf17032.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Def.</td><td>FGSM</td><td>C&amp;W.</td><td>stAdv</td></tr><tr><td rowspan=\"2\">ResNet32</td><td>Adv.</td><td>13.10%</td><td>11.9%</td><td>43.36%</td></tr><tr><td>Ens. PGD</td><td>10.00% 22.8%</td><td>10.3% 21.4%</td><td>36.89% 49.19%</td></tr><tr><td rowspan=\"4\">wide ResNet34</td><td>Adv.</td><td>5.04%</td><td>7.61%</td><td>31.66%</td></tr><tr><td>Ens.</td><td>4.65%</td><td>8.43%</td><td>29.56%</td></tr><tr><td>PGD</td><td>14.9%</td><td>13.90%</td><td></td></tr><tr><td></td><td></td><td></td><td>31.6%</td></tr></table>",
+        "bbox": [
+            501,
+            145,
+            833,
+            255
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 ATTACK EFFICIENCY UNDER DEFENSE METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            305,
+            560,
+            320
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Here we generate adversarial examples in the white-box setting and test different defense methods against these samples to evaluate the strength of these attacks under defenses. ",
+        "bbox": [
+            174,
+            333,
+            823,
+            361
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We mainly focus on the adversarial training defenses due to their state-of-the-art performance. We apply three defense strategies in our evaluation: the FGSM adversarial training (Adv.) (Goodfellow et al., 2015), ensemble adversarial training (Ens.) (Tramèr et al., 2017), and projectile gradient descent (PGD) adversarial training (M ˛adry et al., 2017) methods. For adversarial training purposes, we generate adversarial examples based on $L _ { \\infty }$ bound (Carlini & Wagner, 2017a) as 0.3 on MNIST and 8 on CIFAR-10. We test adversarial examples generated against model A, B, and C on MNIST as shown in Table 4, and similarly adversarial examples generated against ResNet32 and wide ResNet34 on CIFAR-10. ",
+        "bbox": [
+            174,
+            368,
+            825,
+            479
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The results on the MNIST and CIFAR-10 datasets are shown in Table 3. We observe that the three defense strategies can achieve high performance (less than $10 \\%$ attack success rate) against FGSM and C&W attacks. ",
+        "bbox": [
+            176,
+            486,
+            825,
+            529
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "These defense methods only achieve low defense performance on stAdv, which improve the attack success rate to more than $3 0 \\%$ among all defense strategies. These results indicate that new type of adversarial strategy, such as our spatial transformation-based attack, may open new directions for developing better defense systems. However, for stAdv, we cannot use ${ \\mathcal { L } } _ { p }$ norm to bound the distance as translating an image by one pixel may introduce large ${ \\mathcal { L } } _ { p }$ penalty. We instead constrain the spatial transformation flow and show that our adversarial examples have high perceptual quality in Figures 2, 3, and 4 as well as Section 4.3. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            632
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mean blur defense We also test our adversarial examples against the $3 { \\times } 3$ average pooling restoration mechanism (Li & Li, 2016). Table 5 in Appendix B shows the classification accuracy of recovered images after performing $3 \\times 3$ average filter on different models. We find that the simple $3 \\times 3$ average pooing restoration mechanism can recover the original class from fast gradient sign examples and improve the classification accuracy up to around $70 \\%$ . Carlini & Wagner have also shown that such mean blur defense strategy can defend against adversarial examples generated by their attack and improve the model accuracy to around $80 \\%$ (2017b). From Table 5, we can see that the mean blur defense method can only improve the model accuracy to around $50 \\%$ on stAdv examples, which means adversarial examples generated by stAdv are more robust compared to other attacks. We also perform a perfect knowledge adaptive attack against the mean blur defense following the same attack strategy suggested in (Carlini & Wagner, 2017b), where we add the $3 \\times 3$ average pooling layer into the original network and apply stAdv to attack the new network again. We observe that the success rate of an adaptive attack is nearly $100 \\%$ , which is consistent with Carlini & Wagner’s findings (2017b). ",
+        "bbox": [
+            174,
+            652,
+            825,
+            847
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.5 VISUALIZING ATTENTION OF NETWORKS ON ADVERSARIAL EXAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            868,
+            709,
+            882
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In addition to the analyzing adversarial examples themselves, in this section, we further characterize these spatially transformed adversarial examples from the perspective of deep neural networks. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/2f1e2ccd33a46684daae6ba2e40ddac36cbef1277c5ec583dee5f8b733b29e33.jpg",
+        "image_caption": [
+            "Figure 8: CAM attention visualizations for ImageNet inception_v3 model. (a) the original image and (b)-(d) stAdv adversarial examples targeting different classes. The second row shows the attention visualizations for the corresponding images displayed above. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            102,
+            816,
+            382
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Here we apply Class Activation Mapping (CAM) (Zhou et al., 2016a), an implicit attention visualization technique for localizing the discriminative regions implicitly detected by a DNN. We use it to show the attention of the target ImageNet inception_v3 model (Szegedy et al., 2016)) for both original images and generated adversarial examples. Figure 8(a) shows an input bike image and Figure 8(b)–(d) show the targeted adversarial examples based on stAdv targeting three different classes (goldfish, dog, and cat). Figure 8(e) illustrates that the target model draws attention to the bicycle region. Interestingly, attention regions on examples generated by stAdv varies for different target classes as shown in Figure 8(f)–(h). Though humans can barely distinguish between the original image and the ones generated by stAdv, CAM map focus on completely different regions, implying that our attack can mislead the network’s attention. ",
+        "bbox": [
+            174,
+            446,
+            825,
+            585
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In addition, we also compare and visualize the attention regions of both naturally trained and the adversarial trained inception_v3 model3 on adversarial images generated by different attack algorithms (Figure 9). The ground truth top-1 label is “cinema,” so the attention region for the original image (Figure 9 (a)) includes both tower and building regions. However, when the adversarial examples are targeted attacked into the adversarial label “missile,” the attention region focuses on only the tower for all the attack algorithms as shown in Figure 9 (b)-(d) with slight different attention region sizes. More interestingly, we also test these adversarial examples on the public adversarial trained robust inception_v3 model. The result appears in Figure 9 (f)–(h). This time, the attention regions are drawn to the building again for both FGSM and C&W methods, which are close to the attention regions of the original image. The top-1 label for Figure 9 (f) and (g) are again the ground truth “cinema”, which means both FGSM and C&W fail to attack the robust model. However, Figure 9 (h) is still misclassified as “missile” under the robust model and the CAM visualization shows that the attention region still focuses on the tower. This example again implies that adversarial examples generated by stAdv are challenging to defend for the current “robust” ImageNet models. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            787
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            809,
+            328,
+            825
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Different from the previous works that generate adversarial examples by directly manipulating pixel values, in this work we propose a new type of perturbation based on spatial transformation, which aims to preserve high perceptual quality for adversarial examples. We have shown that adversarial examples generated by stAdv are more difficult for humans to distinguish from original instances. ",
+        "bbox": [
+            176,
+            842,
+            823,
+            897
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/4a8de4df7d55ef26804bf583852dc942667e3b0ab0f81a1b59b990b11e2dfd45.jpg",
+        "image_caption": [
+            "Figure 9: CAM attention visualizations for ImageNet inception_v3 model. The first column shows the CAM maps corresponding to the original images. Column 2-4 show the adversarial examples generated by different methods. The visualizations are drawn for Row 1 (inception_v3 model) and Row 2 (adversarial trained inception_v3 model). (a) and (e)-(g) are labeled as the ground truth “cinema”, while (b)-(d) and (h) are labeled as the adversarial target “missile.” "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            102,
+            816,
+            383
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We also analyze the attack success rate of these examples under existing defense methods and demonstrate they are harder to defend against, which opens new directions for developing more robust defense algorithms. Finally, we visualize the attention regions of DNNs on our adversarial examples to better understand this new attack. ",
+        "bbox": [
+            174,
+            492,
+            825,
+            547
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            565,
+            326,
+            577
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We thank Zhuang Liu, Richard Shin, Kun Jin, Armin Sarabi and George Philipp for their valuable discussions on this work. This work was supported in part by Berkeley Deep Drive, the Center for Long-Term Cybersecurity, and FORCES (Foundations Of Resilient CybEr-Physical Systems), which receives support from the National Science Foundation (NSF award numbers CNS-1238959, CNS-1238962, CNS-1239054, CNS-1239166), and NSF under grants CNS-1422211 and CNS1616575. ",
+        "bbox": [
+            174,
+            588,
+            825,
+            671
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            285,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Battista Biggio, Igino Corona, Davide Maiorca, Blaine Nelson, Nedim Šrndic, Pavel Laskov, Gior- ´ gio Giacinto, and Fabio Roli. Evasion attacks against machine learning at test time. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pp. 387– 402. Springer, 2013. ",
+        "bbox": [
+            173,
+            126,
+            826,
+            183
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In IEEE Symposium on Security and Privacy, 2017, 2017a. ",
+        "bbox": [
+            171,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David Wagner. Adversarial examples are not easily detected: Bypassing ten detection methods. arXiv preprint arXiv:1705.07263, 2017b. ",
+        "bbox": [
+            169,
+            231,
+            823,
+            261
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ronan Collobert and Jason Weston. A unified architecture for natural language processing: Deep neural networks with multitask learning. In Proceedings of the 25th international conference on Machine learning, pp. 160–167. ACM, 2008. ",
+        "bbox": [
+            173,
+            270,
+            823,
+            313
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, pp. 248–255. IEEE, 2009. ",
+        "bbox": [
+            171,
+            321,
+            821,
+            352
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ivan Evtimov, Kevin Eykholt, Earlence Fernandes, Tadayoshi Kohno, Bo Li, Atul Prakash, Amir Rahmati, and Dawn Song. Robust physical-world attacks on machine learning models. arXiv preprint arXiv:1707.08945, 2017. ",
+        "bbox": [
+            173,
+            361,
+            823,
+            404
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alhussein Fawzi and Pascal Frossard. Manitest: Are classifiers really invariant? arXiv preprint arXiv:1507.06535, 2015. ",
+        "bbox": [
+            169,
+            412,
+            825,
+            443
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In International Conference on Learning Representations, 2015. ",
+        "bbox": [
+            169,
+            452,
+            823,
+            482
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kathrin Grosse, Nicolas Papernot, Praveen Manoharan, Michael Backes, and Patrick McDaniel. Adversarial perturbations against deep neural networks for malware classification. arXiv preprint arXiv:1606.04435, 2016. ",
+        "bbox": [
+            173,
+            491,
+            823,
+            534
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shixiang Gu and Luca Rigazio. Towards deep neural network architectures robust to adversarial examples. arXiv preprint arXiv:1412.5068, 2014. ",
+        "bbox": [
+            171,
+            544,
+            823,
+            573
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            173,
+            582,
+            825,
+            626
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Warren He, James Wei, Xinyun Chen, Nicholas Carlini, and Dawn Song. Adversarial example defenses: Ensembles of weak defenses are not strong. arXiv preprint arXiv:1706.04701, 2017. ",
+        "bbox": [
+            173,
+            635,
+            821,
+            664
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Li Deng, Dong Yu, George E Dahl, Abdel-rahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara N Sainath, et al. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal Processing Magazine, 29(6):82–97, 2012. ",
+        "bbox": [
+            173,
+            672,
+            825,
+            731
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E Hinton, Alex Krizhevsky, and Sida D Wang. Transforming auto-encoders. In International Conference on Artificial Neural Networks, pp. 44–51. Springer, 2011. ",
+        "bbox": [
+            171,
+            739,
+            821,
+            770
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. CVPR, 2017. ",
+        "bbox": [
+            173,
+            779,
+            823,
+            808
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Max Jaderberg, Karen Simonyan, Andrew Zisserman, et al. Spatial transformer networks. In NIPS, pp. 2017–2025, 2015. ",
+        "bbox": [
+            173,
+            818,
+            823,
+            847
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Justin Johnson, Alexandre Alahi, and Li Fei-Fei. Perceptual losses for real-time style transfer and super-resolution. In European Conference on Computer Vision, 2016. ",
+        "bbox": [
+            171,
+            856,
+            823,
+            886
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Can Kanbak. Measuring robustness of classifiers to geometric transformations. Technical report, 2017. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. ImageNet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. The cifar-10 dataset. online: http://www. cs. toronto. edu/kriz/cifar. html, 2014. ",
+        "bbox": [
+            173,
+            154,
+            820,
+            183
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016. ",
+        "bbox": [
+            174,
+            191,
+            823,
+            220
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun and Corrina Cortes. The MNIST database of handwritten digits. 1998. ",
+        "bbox": [
+            173,
+            228,
+            725,
+            244
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Xin Li and Fuxin Li. Adversarial examples detection in deep networks with convolutional filter statistics. arXiv preprint arXiv:1612.07767, 2016. ",
+        "bbox": [
+            173,
+            252,
+            823,
+            281
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Dong C Liu and Jorge Nocedal. On the limited memory bfgs method for large scale optimization. Mathematical programming, 45(1):503–528, 1989. ",
+        "bbox": [
+            174,
+            290,
+            823,
+            319
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. In ICLR, 2017. ",
+        "bbox": [
+            174,
+            327,
+            823,
+            356
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. arXiv preprint arXiv:1511.04599, 2015. ",
+        "bbox": [
+            173,
+            364,
+            823,
+            393
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Universal adversarial perturbations. arXiv preprint arXiv:1610.08401, 2016. ",
+        "bbox": [
+            173,
+            401,
+            823,
+            431
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Konda Reddy Mopuri, Utsav Garg, and R Venkatesh Babu. Fast feature fool: A data independent approach to universal adversarial perturbations. arXiv preprint arXiv:1707.05572, 2017. ",
+        "bbox": [
+            173,
+            439,
+            823,
+            468
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Aleksander M ˛adry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv:1706.06083 [cs, stat], June 2017. ",
+        "bbox": [
+            174,
+            476,
+            823,
+            518
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, and Ian Goodfellow. Transferability in machine learning: from phenomena to black-box attacks using adversarial samples. arXiv preprint arXiv:1605.07277, 2016a. ",
+        "bbox": [
+            174,
+            526,
+            823,
+            570
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Somesh Jha, Matt Fredrikson, Z Berkay Celik, and Ananthram Swami. The limitations of deep learning in adversarial settings. In 2016 IEEE European Symposium on Security and Privacy (EuroS&P), pp. 372–387. IEEE, 2016b. ",
+        "bbox": [
+            176,
+            578,
+            823,
+            622
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Xi Wu, Somesh Jha, and Ananthram Swami. Distillation as a defense to adversarial perturbations against deep neural networks. In Security and Privacy (SP), 2016 IEEE Symposium on, pp. 582–597. IEEE, 2016c. ",
+        "bbox": [
+            176,
+            628,
+            821,
+            672
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Leonid I Rudin, Stanley Osher, and Emad Fatemi. Nonlinear total variation based noise removal algorithms. Physica D: Nonlinear Phenomena, 60(1-4):259–268, 1992. ",
+        "bbox": [
+            171,
+            681,
+            823,
+            710
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Claude E Shannon. Communication theory of secrecy systems. Bell Labs Technical Journal, 28(4): 656–715, 1949. ",
+        "bbox": [
+            173,
+            718,
+            823,
+            747
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013. ",
+        "bbox": [
+            171,
+            755,
+            823,
+            785
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In International Conference on Learning Representations, 2014. ",
+        "bbox": [
+            174,
+            792,
+            825,
+            835
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2818–2826, 2016. ",
+        "bbox": [
+            174,
+            843,
+            820,
+            887
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Richard Szeliski. Computer vision: algorithms and applications. Springer Science & Business Media, 2010. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Florian Tramèr, Alexey Kurakin, Nicolas Papernot, Dan Boneh, and Patrick McDaniel. Ensemble adversarial training: Attacks and defenses. arXiv preprint arXiv:1705.07204, 2017.   \nAndrew J. Viterbi. An intuitive justification and a simplified implementation of the map decoder for convolutional codes. IEEE Journal on Selected Areas in Communications, 16(2):260–264, 1998.   \nWeilin Xu, David Evans, and Yanjun Qi. Feature squeezing: Detecting adversarial examples in deep neural networks. arXiv preprint arXiv:1704.01155, 2017.   \nSergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.   \nRichard Zhang, Phillip Isola, and Alexei A Efros. Colorful image colorization. In European Conference on Computer Vision, pp. 649–666. Springer, 2016.   \nBolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Learning deep features for discriminative localization. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2921–2929, 2016a.   \nTinghui Zhou, Shubham Tulsiani, Weilun Sun, Jitendra Malik, and Alexei A Efros. View synthesis by appearance flow. In ECCV, pp. 286–301. Springer, 2016b. ",
+        "bbox": [
+            171,
+            101,
+            826,
+            375
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A MODEL ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            423,
+            118
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/940f511e2a42bd1573d52c25acb84fc17b625a05fdfbad1112938f7883cbfadf.jpg",
+        "table_caption": [
+            "Table 4: Architecture of models applied on MNIST "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>A</td><td>B</td><td>C</td></tr><tr><td>Conv(64,5,5) + Relu</td><td>Conv(64,8,8) + Relu</td><td>Conv(128,3,3) + Relu</td></tr><tr><td>Conv(64,5,5) + Relu</td><td>Dropout(0.2)</td><td>Conv(64,3,3) +Relu</td></tr><tr><td>Dropout(0.25)</td><td>Conv(128,6,6)+Relu</td><td>Dropout(0.25)</td></tr><tr><td>FC(128) + Relu</td><td>Conv(128,5,5) +Relu</td><td>FC(128) +Relu</td></tr><tr><td>Dropout(0.5)</td><td>Dropout(0.5)</td><td>Dropout(0.5)</td></tr><tr><td>FC(10) + Softmax</td><td>FC(10) +Softmax</td><td>FC(10)+Softmax</td></tr></table>",
+        "bbox": [
+            272,
+            162,
+            720,
+            266
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B ANALYSIS FOR MEAN BLUR DEFENSE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            295,
+            529,
+            311
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Here we evaluated adversarial examples generated by stAdv against the $3 \\times 3$ average pooling restoration mechanism suggested in Li & Li (2016). Table 5 shows the classification accuracy of recovered images after performing $3 \\times 3$ average pooling on different models. ",
+        "bbox": [
+            178,
+            327,
+            823,
+            369
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/02d7c71ee84b91e2ff6de957ed74b339e7c3e8a04293a32f1c1d73e2175eacd3.jpg",
+        "table_caption": [
+            "Table 5: Performance of adversarial examples against the mean blur defense strategy with $3 \\times 3$ mean filter. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Accuracy on recovered images</td><td>A</td><td>MNIST B</td><td>C</td><td>CIFAR-10 Resnet32 wide ResNet34</td></tr><tr><td>3 × 3 Average Filter</td><td>59.00%</td><td>64.22%</td><td>79.71%</td><td>45.12%</td><td>50.12%</td></tr></table>",
+        "bbox": [
+            214,
+            422,
+            781,
+            473
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "C ADVERSARIAL EXAMPLES FOR AN IMAGENET-COMPATIBLE SET, MNIST, AND CIFAR-10 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            502,
+            750,
+            536
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Experiment settings. In the following experiments, we perform a grid search of hyper-parameter $\\tau$ so that the adversarial examples can attack the target model with minimal deformation. Values of $\\tau$ are searched from 0.0005 to 0.05. ",
+        "bbox": [
+            173,
+            551,
+            823,
+            593
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "ImageNet-compatible. We use benign images from the DEV set from the NIPS 2017 targeted adversarial attack competition.4 This competition provided a dataset compatible with ImageNet and containing target labels for a targeted attack. We generate targeted adversarial examples for the target inception_v3 model. In Figure 10 below, we show the original images on the left with the correct label, and we show adversarial examples generated by stAdv on the right with the target label. ",
+        "bbox": [
+            173,
+            599,
+            825,
+            684
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "MNIST. We generate adversarial examples for the target Model B. In Figure 11, we show original images with ground truth classes 0–9 in the diagonal, and we show adversarial examples generated by stAdv targeting the class of the original image within that column. ",
+        "bbox": [
+            174,
+            690,
+            821,
+            733
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "CIFAR-10. We generate adversarial examples for the target ResNet-32 model. In Figure 12, we show the original images in the diagonal, and we show adversarial examples generated by stAdv targeting the class of the original image within that column. ",
+        "bbox": [
+            174,
+            739,
+            821,
+            782
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Table 6 shows the magnitude of the generated flow regarding total variation (TV) and $\\mathcal { L } _ { 2 }$ distance on the ImageNet-compatible set, MNIST, CIFAR-10, respectively. These metrics are calculated by the following equations, where $n$ is the number of pixels: ",
+        "bbox": [
+            174,
+            789,
+            823,
+            832
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9d556e72b4374fcc31fb7fe0464ab2fbadd5ef687fa8655061d86322e201b2d5.jpg",
+        "text": "$$\n\\mathrm { T V } = \\sqrt { \\frac { 1 } { n } \\sum _ { p } ^ { a l l p i c e l s } \\sum _ { q \\in \\mathcal { N } ( p ) } | | \\Delta u ^ { ( p ) } - \\Delta u ^ { ( q ) } | | _ { 2 } ^ { 2 } + | | \\Delta v ^ { ( p ) } - \\Delta v ^ { ( q ) } | | _ { 2 } ^ { 2 } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            272,
+            838,
+            723,
+            888
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8ada63dcdb26938c7ffe9d2d7afe32d30fc75470184fcdd9085eca729ae06be3.jpg",
+        "text": "$$\n\\mathcal { L } _ { 2 } = \\sqrt { \\frac { 1 } { n } \\sum _ { p } ^ { a l l p i x e l s } | | \\Delta u ^ { ( p ) } | | _ { 2 } ^ { 2 } + | | \\Delta v ^ { ( p ) } | | _ { 2 } ^ { 2 } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            113,
+            637,
+            165
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/ff53c5ace7612e5a2d297af8bc2e7daceada6cdd221295358c1c0876d45ce52d.jpg",
+        "table_caption": [
+            "Table 6: Evaluation Metric (the number in bracket is image size) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Metric</td><td>ImageNet-compatible (299x299)</td><td>MNIST (28x28)</td><td>CIFAR-10 (32x32)</td></tr><tr><td>flow TV</td><td>2.85×10-4±7.28×10-5</td><td>8.26×10-3±4.95×10-3</td><td>2.21× 10-3±1.26×10-3</td></tr><tr><td>flow L2</td><td>2.11 × 10-4 ±5.19 × 10-5</td><td>5.18 × 10-² ± 5.66 × 10-2</td><td>2.76 × 10-3± 2.31 × 10-3</td></tr></table>",
+        "bbox": [
+            173,
+            207,
+            893,
+            263
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/cb7773b077f6251bdffc26eb1b7c7788d71764f227d1dbf6af08b450d26cc97d.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            111,
+            496,
+            357
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/f275840c6d6359ef2851ee4ed213e3705f5cffbc3f50f4a13b45fd85def6e5aa.jpg",
+        "image_caption": [
+            "(a) Benign image (labeled as dung beetle) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            380,
+            496,
+            623
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/ca7c6794a608fb848fd47eefcd1e3e36b68cdb80cdf3ab16f3407492dcc3ca80.jpg",
+        "image_caption": [
+            "(c) Benign image (labeled as jeep) ",
+            "(e) Benign image (labeled as bull mastiff) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            645,
+            496,
+            890
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/5b9c9b4627a6d5bac274078ac08fd6ead0ab690224338dccc235fe3e4514f62f.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            111,
+            816,
+            357
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/4351336944abda120b4811614d320a9f28a3ad351eb57560fbfa94786aafac3c.jpg",
+        "image_caption": [
+            "(b) Adversarial image (labeled as scale) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            380,
+            816,
+            623
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/c6d1012d2994707d1ca3723b315469b71b06acd640d24560373bf85b5e70074b.jpg",
+        "image_caption": [
+            "(d) Adversarial image (labeled as coil) ",
+            "(f) Adversarial image (labeled as American lobster) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            645,
+            818,
+            888
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/0342b6961f2204467f41e914ae655457e97444ef98cef11debbb8d2adccceb4a.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            111,
+            496,
+            357
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/b73c05484fc00554b1d5e1dda7e54375e33f9ed60a8e77fa7bfd524b5c966c3c.jpg",
+        "image_caption": [
+            "(g) Benign image (labeled as buckeye) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            378,
+            498,
+            623
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/139ed79a115288f72f48389af30068e9f24987beeaa8cdd16b1c486a30ed6f58.jpg",
+        "image_caption": [
+            "(i) Benign image (labeled as thatch) ",
+            "(k) Benign image (labeled as beaker) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            645,
+            496,
+            890
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/01fde2ffcea9fa03d96959aac264264293d6a67472b17bca2a312c60c82108f5.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            111,
+            818,
+            356
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/77252fb96c14f05fc77bfcaf7d41a4d3a3960dfb0c99a3e62b7c62b35f8ee833.jpg",
+        "image_caption": [
+            "(h) Adversarial image (labeled as goose) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            378,
+            818,
+            623
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/9c99c74d7de659e9cb3ee50ced140e947ed5d641f3f412462a9140c11e27d659.jpg",
+        "image_caption": [
+            "(j) Adversarial image (labeled as miniature poodle) ",
+            "(l) Adversarial image (labeled as padlock) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            645,
+            818,
+            890
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/80699b1ca534803e1529fb4032712314e46f17de2a54a340c640f0414cd91d89.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            111,
+            496,
+            357
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/e2674dd70021f7507fb7b553a1e49a37e492311cb1243626b57b84b2c52dc892.jpg",
+        "image_caption": [
+            "(m) Benign image (labeled as strawberry) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            378,
+            498,
+            625
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/74a638d91ffd4557f7b628480bc68480179a2fbf4eaed6d0c81bab555c8edf88.jpg",
+        "image_caption": [
+            "(o) Benign image (labeled as folding chair) ",
+            "(q) Benign image (labeled as jeep) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            645,
+            496,
+            890
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/38505fcc1c040246c1e6a3734fb1b352082f771bd65103a5d16d7595bacf3203.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            111,
+            818,
+            357
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/006d856039c24c32266946e349e06ba9d7c7c23d4b7bce29b27ea414e7502fe6.jpg",
+        "image_caption": [
+            "(n) Adversarial image (labeled as tench) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            378,
+            818,
+            623
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/30dd611be6ad13e419430928bf4fa5675357e1b4f01e5af28934757c7086cf0d.jpg",
+        "image_caption": [
+            "(p) Adversarial image (labeled as power drill) ",
+            "(r) Adversarial image (labeled as house finch) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            645,
+            818,
+            890
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/6ff2561eaa132c0fa0d50aea19244038dde3f99bc9a51bb34da99ae984a135da.jpg",
+        "image_caption": [
+            "Figure 10: Examples from an ImageNet-compatible set. Left: original image; right: adversarial image generated by stAdv against inception_v3. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            142,
+            820,
+            409
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/d79500d4c680e60878b13b44ccfb6494a82e8db0d3392187bc82c400741e8bf0.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            539,
+            710,
+            866
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/9baa44fca70aefdb3f79c3f22c6e8cfb4b17537c08af2c0c2cc5132c91ee921c.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            133,
+            710,
+            460
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "image",
+        "img_path": "images/d6a9685d39a92222e4a7ea345953b147876af945ec0366d6a2618a97f54331d4.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            549,
+            710,
+            876
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "image",
+        "img_path": "images/f31bf4f717a89e424649fbe6523c48cdf46c62d8caa6c4b67e769cf36bda9106.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            133,
+            710,
+            460
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "image",
+        "img_path": "images/f03eff8d90e14770f746db37a3ca77a916bbe8228ad3ef521ec7b4ed16181d53.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            549,
+            710,
+            876
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "image",
+        "img_path": "images/65bbb4c11da020e34a27d503e899bf944f31e8eb550bc14ca84fa6d19bf3ea4d.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            133,
+            710,
+            460
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "image",
+        "img_path": "images/3b8f7cf926a4ec4e30a1da96608e4953b39f53820190ee8a1e12c1db812f817b.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            549,
+            710,
+            875
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "image",
+        "img_path": "images/e9414445704c9f9e84f9049a953885bf88722c3c8634eae2f31b383442cc6481.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            133,
+            710,
+            460
+        ],
+        "page_idx": 23
+    },
+    {
+        "type": "image",
+        "img_path": "images/3b938b20060c153e0c7b1a3627a8a43c4c4823350fdf981a412618f389b6d956.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            549,
+            710,
+            875
+        ],
+        "page_idx": 23
+    },
+    {
+        "type": "image",
+        "img_path": "images/defd04566980b7294107673492d30544e61ae696f88c577de7ce7a75f3272540.jpg",
+        "image_caption": [
+            "Figure 11: Adversarial examples generated by stAdv against Model B on MNIST. The original images are shown in the diagonal; the rest are adversarial examples that are classified into the same class as the original image within that column. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            121,
+            710,
+            446
+        ],
+        "page_idx": 24
+    },
+    {
+        "type": "image",
+        "img_path": "images/61368515d054c4a63ac08784eecec24a64a95eddb2909e15e742869cf4f0a206.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            560,
+            710,
+            887
+        ],
+        "page_idx": 24
+    },
+    {
+        "type": "image",
+        "img_path": "images/ce8df07e4ec8942f30b69a81de4d338f1c6151977b43a446cae4303c3f443250.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            133,
+            710,
+            459
+        ],
+        "page_idx": 25
+    },
+    {
+        "type": "image",
+        "img_path": "images/168af0f37dd021dc35bf797bffb6207f4e617ff9f99baf080a750fb624366d71.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            549,
+            710,
+            875
+        ],
+        "page_idx": 25
+    },
+    {
+        "type": "image",
+        "img_path": "images/f26608bd59b8fed5bb2eb7570c4832594cd5d115f69a496ebbacf6c2ed889a97.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            133,
+            710,
+            460
+        ],
+        "page_idx": 26
+    },
+    {
+        "type": "image",
+        "img_path": "images/8c370c963942b0e753c2662882f212f6c0362fc5d19bcb3766960a152f4a70ee.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            549,
+            710,
+            875
+        ],
+        "page_idx": 26
+    },
+    {
+        "type": "image",
+        "img_path": "images/15c5c49654f91c3e1693973a3fb796edc82ec83eb1897b1a60332c82bf2e495b.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            133,
+            710,
+            460
+        ],
+        "page_idx": 27
+    },
+    {
+        "type": "image",
+        "img_path": "images/33a55820d187e96ae9a341ad3f194c85a6d86535b96a56eeaa322d25873a39b5.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            549,
+            710,
+            875
+        ],
+        "page_idx": 27
+    },
+    {
+        "type": "image",
+        "img_path": "images/f50fb5de579879f4db17784cf31fcedaa5b7d288d32a679ff996d76618495b52.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            133,
+            710,
+            460
+        ],
+        "page_idx": 28
+    },
+    {
+        "type": "image",
+        "img_path": "images/05d87e58c094eb551266bafd01e966178b7f969b8fac21fde424c9a0fc4324b3.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            549,
+            710,
+            875
+        ],
+        "page_idx": 28
+    },
+    {
+        "type": "image",
+        "img_path": "images/04d2a4afc45097361558bc414bb8797fa3c41e72c08462065fc5f40972b30eaa.jpg",
+        "image_caption": [
+            "Figure 12: Adversarial examples generated by stAdv against a ResNet-32 on CIFAR-10. The original images are shown in the diagonal; the rest are adversarial examples that are classified into the same class as the original image within that column. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            314,
+            710,
+            640
+        ],
+        "page_idx": 29
+    }
+]

parse/train/hJmtwocEqzc/hJmtwocEqzc.md

@@ -0,0 +1,302 @@
+# LOWKEY: LEVERAGING ADVERSARIAL ATTACKS TO PROTECT SOCIAL MEDIA USERS FROM FACIAL RECOGNITION
+
+Valeriia Cherepanova Department of Mathematics University of Maryland vcherepa@umd.edu
+
+Micah Goldblum Department of Computer Science University of Maryland goldblum@umd.edu
+
+Harrison Foley∗   
+Department of Computer Science   
+US Naval Academy   
+m211926@usna.edu   
+Shiyuan Duan∗   
+Department of Computer Science   
+University of Maryland   
+sduan1@umd.edu
+
+John Dickerson Department of Computer Science University of Maryland john@cs.umd.edu
+
+Gavin Taylor   
+Department of Computer Science   
+US Naval Academy   
+taylor@usna.edu
+
+Tom Goldstein Department of Computer Science University of Maryland tomg@cs.umd.edu
+
+# ABSTRACT
+
+Facial recognition systems are increasingly deployed by private corporations, government agencies, and contractors for consumer services and mass surveillance programs alike. These systems are typically built by scraping social media profiles for user images. Adversarial perturbations have been proposed for bypassing facial recognition systems. However, existing methods fail on full-scale systems and commercial APIs. We develop our own adversarial filter that accounts for the entire image processing pipeline and is demonstrably effective against industrial-grade pipelines that include face detection and large scale databases. Additionally, we release an easy-to-use webtool that significantly degrades the accuracy of Amazon Rekognition and the Microsoft Azure Face Recognition API, reducing the accuracy of each to below $1 \%$ .
+
+# 1 INTRODUCTION
+
+Facial recognition systems (FR) are widely deployed for mass surveillance by government agencies, government contractors, and private companies alike on massive databases of images belonging to private individuals (Hartzog, 2020; Derringer, 2019; Weise & Singer, 2020). Recently, these systems have been thrust into the limelight in the midst of outrage over invasion into personal life and concerns regarding fairness (Singer, 2018; Lohr, 2018; Cherepanova et al., 2021). Practitioners populate their databases by hoarding publicly available images from social media outlets, and so users are forced to choose between keeping their images outside of public view or taking their chances with mass surveillance.
+
+We develop a tool, LowKey, for protecting users from unauthorized surveillance by leveraging methods from the adversarial attack literature, and make it available to the public as a webtool.
+
+![](images/a346e274e56b271a637b350791be3a6a07a832f3ce2439284095e282da8421d8.jpg)  
+Figure 1: Top: original images, Bottom: protected by LowKey.
+
+LowKey is the first such evasion tool that is effective against commercial facial recognition APIs. Our system pre-processes user images before they are made publicly available on social media outlets so they cannot be used by a third party for facial recognition purposes. We establish the effectiveness of LowKey throughout this work.
+
+Our contributions can be summarized as follows:
+
+• We design a black-box adversarial attack on facial recognition models. Our algorithm moves the feature space representations of gallery faces so that they do not match corresponding probe images while preserving image quality.   
+• We interrogate the performance of our method on commercial black-box APIs, including Amazon Rekognition and Microsoft Azure Face, whose inner workings are not publicly known. We provide comprehensive comparisons with the existing data poisoning alternative, Fawkes (Shan et al., 2020), and we find that while Fawkes is ineffective in every experiment, our method consistently prevents facial recognition.   
+• We release an easy-to-use webtool, LowKey, so that social media users are no longer confronted with a choice between withdrawing their social media presence from public view and risking the repercussions of being surveilled.
+
+# 2 RELATED WORK
+
+Neural networks are known to be vulnerable to adversarial attacks, small perturbations to inputs that do not change semantic content, and yet cause the network to misbehave (Goodfellow et al., 2014). The adversarial attack literature has largely focused on developing new algorithms that, in simulations, are able to fool neural networks (Carlini & Wagner, 2017; Chiang et al., 2020). Most works to date focus on the idea of physical world attacks, in which the attacker places adversarial patterns on an object in hopes that the adversarial properties transfer to an image of the object. Such attacks do not succeed reliably because the adversarial perturbation must survive imaging under various lighting conditions, object orientations, and occlusions (Kurakin et al., 2016). While researchers have succeeded in crafting such attacks against realistic systems, these attacks do not work consistently across environments (Wu et al., 2019; Xu et al., 2019; Goldblum et al., 2020). In facial recognition, attacks have largely focused on physical backdoor threat models, evasion attacks on verification (Wenger et al., 2020; Zhong & Deng, 2020) and attacks on face detection (Pedraza et al., 2018). Unlike these physical threat models, the setting in which we operate is purely digital, meaning that we can manipulate the contents of digital media at the bit level, and then hand manipulated data directly to a machine learning system. The ability to digitally manipulate media greatly simplifies the task of attacking a system, and has been shown to enhance transferability to black box industrial systems for applications like copyright detection (Saadatpanah et al., 2020) and financial time series analysis (Goldblum et al., 2020).
+
+Recently, the Fawkes algorithm was developed for preventing social media images from being used by unauthorized facial recognition systems (Shan et al., 2020). However, Fawkes, along with the experimental setup on which it is evaluated in the original work, suffers from critical problems. First, Fawkes assumes that facial recognition practitioners train their models on each individual’s data.
+
+However, high-performance FR systems instead harness large pre-trained Siamese networks (Liu et al., 2017; Deng et al., 2019). Second, the authors primarily use image classifiers. In contrast, commercial systems are trained with FR-specific heads and loss functions, as opposed to the standard cross-entropy loss used by classifiers. Third, the authors perform evaluations on very small datasets. Specifically, they test Fawkes against commercial APIs with a gallery containing only 50 images. Fourth, the system was only evaluated using top-1 accuracy, but FR users such as police departments often compile a list of suspects rather than a single individual. As a result, other metrics like top-50 accuracy are often used in facial recognition, and are a more realistic metric for when a system has been successfully suppressed. Fifth, while the original work portrays Fawkes’ perturbations are undetectable by the human eye, experience with the codebase suggests the opposite (indeed, a New York Times journalist likewise noted that the Fawkes images she was shown during a demonstration were visibly heavily distorted). Finally, Fawkes has not yet released an app or a webtool, and regular social media users are unlikely to make use of git repositories. Our attack avoids the aforementioned limitations, and we perform thorough evaluations on a large collection of images and identities. When comparing with Fawkes, we use the authors’ own implementation in order to make sure that all evaluations are fair. Furthermore, we use Fawkes’ highest protection setting to make sure that LowKey performs better than Fawkes’ best attack. Another work uses targeted adversarial attack on probe images for facial recognition systems so that they cannot be matched with images in a database (Yang et al., 2020).
+
+# 3 THE LOWKEY ATTACK ON MASS SURVEILLANCE
+
+![](images/8bda533542dd9c8688ace3b8e37721f1adf73d359cdb70ba0f55672c72ff6fed.jpg)  
+Figure 2: The LowKey pipeline. When users protect their publicly available images with LowKey, facial recognition systems cannot match these harvested images with new images of the user, for example from surveillance cameras.
+
+# 3.1 PROBLEM SETUP
+
+To help make our work more widely accessible, we begin by introducing common facial recognition terms.
+
+Gallery images are database images with known identities. These often originate from such sources as passport photos and social media profiles. The gallery is used as a reference for comparing new images.
+
+Probe images are new photos whose subject the FR system user wants to identify. For example, probe images may be extracted from video surveillance footage. The extracted images are then fed into the FR system, and matches to gallery images with known identities.
+
+Identification is the task of answering the question, “who is this person?” Identification entails comparing a probe image to gallery images in order to find potential matches. In contrast, verification answers the question, “is this person who they say they are?”, or equivalently “are these two photos of the same person?” Verification is used, for example, to unlock phones.
+
+In our work, we focus on identification, which can be used for mass surveillance. State-of-the-art facial recognition systems first detect and align faces before extracting facial features from the probe image using a neural network. These systems then find gallery images with the closest feature vectors using a $k$ -nearest neighbors search. The matched gallery images are then considered as likely identities corresponding to the person in the probe photo. LowKey applies a filter to user images which may end up in an organization’s database of gallery images. The result is to corrupt the gallery feature vectors so that they will not match feature vectors corresponding to the user’s probe images. A visual depiction of the LowKey pipeline can be found in Figure 2.
+
+# 3.2 THE LOWKEY ATTACK
+
+LowKey manipulates potential gallery images so that they do not match probe images of the same person. LowKey does this by generating a perturbed image whose feature vector lies far away from the original image, while simultaneously minimizing a perceptual similarity loss between the original and perturbed image. Maximizing the distance in feature space prevents the image from matching other images of the individual, while the perceptual similarity loss prevents the image quality from degrading. In this section, we formulate the optimization problem, and describe a number of important details.
+
+LowKey is designed to evade proprietary FR systems that contain pre-processing steps and neural network backbones that are not publicly known. In order to improve the transferability of our attack to unknown facial recognition systems, LowKey simultaneously attacks an ensemble of models with various backbone architectures that are produced using different training algorithms. Additionally, for each model in the ensemble, the objective function considers the locations of feature vectors of the attacked image both with and without a Gaussian blur. We find that this technique improves both the appearance and transferability of attacked images. Experiments and ablations concerning ensembling and Gaussian smoothing can be found in Section 6. For perceptual similarity loss, we use LPIPS, a metric based on $\ell _ { 2 }$ distance in the feature space of an ImageNet-trained feature extractor (Zhang et al., 2018). LPIPS has been used effectively in the image classification setting to improve the image quality of adversarial examples (Laidlaw et al., 2020).
+
+Formally, the optimization problem we solve is
+
+$$
+\operatorname* { m a x } _ { x ^ { \prime } } \frac { 1 } { 2 n } \sum _ { i = 1 } ^ { n } \widetilde { \frac { \| f _ { i } ( A ( x ) ) - f _ { i } ( A ( x ^ { \prime } ) ) \| _ { 2 } ^ { 2 } } { \| f _ { i } ( A ( x ) ) \| _ { 2 } } } + \widetilde { \| f _ { i } ( A ( x ) ) - f _ { i } ( A ( G ( x ^ { \prime } ) ) ) \| _ { 2 } ^ { 2 } } - \alpha \underbrace { \mathrm { L P I P S } ( x , x ^ { \prime } ) } _ { \mathrm { n e c e a n n a l 1 o s } } ,
+$$
+
+where $x$ is the original image, $x ^ { \prime }$ is the perturbed image, $f _ { i }$ denotes the $i ^ { t h }$ model in our ensemble, $G$ is the Gaussian smoothing function with fixed parameters, and $A$ denotes face detection and extraction followed by $1 1 2 \times 1 1 2$ resizing and alignment. The face detection step is an important part of the LowKey objective function, as commercial systems rely on face detection and extraction because probe images often contain a scene much larger than a face, or else contain a face who’s alignment is not compatible with the face recognition system.
+
+We solve this maximization problem iteratively with signed gradient ascent, which is known to be highly effective for breaking common image classification systems (Madry et al., 2017). Namely, we iteratively update $x ^ { \prime }$ by adding the sign of the gradient of the maximization objective (1) with respect to $x ^ { \prime }$ . By doing this, we move $x ^ { \prime }$ and $G ( x ^ { \prime } )$ far away from the original image $x$ in the feature spaces of models $f _ { i }$ used in the LowKey ensemble. The ensemble contains four feature extractors, IR-152 and ResNet-152 backbones trained with ArcFace and CosFace heads. More details can be found in the next section.
+
+Additional details concerning attack hyperparameters can be found in Appendix 8.1.
+
+# 4 EXPERIMENTAL DESIGN
+
+Our ensemble of models contains ArcFace and CosFace facial recognition systems (Deng et al., 2019; Wang et al., 2018). For each of these systems, we train ResNet-50, ResNet-152, IR-50, and IR-152 backbones on the MS-Celeb-1M dataset, which contains over five million images from over 85,000 identities (He et al., 2016; Deng et al., 2019; Guo et al., 2016). We use these models both in our ensemble to generate attacks and to perform controlled experiments in Section 6. Additional details on our models and their training routines can be found in Appendix 8.1.
+
+We primarily test our attacks on the FaceScrub dataset, a standard identification benchmark from the MegaFace challenge, which contains over 100,000 images from 530 known identities as well as one million distractor images (Kemelmacher-Shlizerman et al., 2016). We discard near-duplicate images from the dataset as is common practice in the facial recognition literature (Zhang et al., 2020). We also perform experiments on the UMDFaces dataset, which can be found in Appendix 8.3 (Bansal et al., 2017). We treat one tenth of each identity’s images as probe images, and we insert the remaining images into the gallery. We randomly select 100 identities and apply LowKey to each of their gallery images. This setting simulates a small pool of LowKey users among a larger population of non-users. Then, in order to perform a single evaluation trial of identification, we randomly sample one probe image from a known identity and find its closest matches within the remainder of the FaceScrub dataset, according to the facial recognition model. Distance is measured in feature space of the model. If the FR model selects a match from the same identity, then the trial is a success.
+
+Note 1 (Rank- $k$ Accuracy). For each probe image, we consider the model successful in the rank- $k$ setting if the correct identity appears among the k closest gallery images in the model’s feature space. To test the transferability of our attack we compute rank-1 and rank-50 accuracy for attack, and test feature extractors from our set of trained FR models.
+
+# 5 BREAKING COMMERCIAL BLACK-BOX APIS
+
+The ultimate test for our protection tool is against commercial systems. These systems are proprietary, and their exact specifications are not publicly available. We test LowKey in the black-box setting using two commercial facial recognition APIs: Amazon Rekognition and Microsoft Azure Face. We also compare against Fawkes. We generate Fawkes images using the authors’ own code and hyperparameters to ensure a fair comparison, and we use the highest protection setting their code offers.
+
+Amazon Rekognition Amazon Rekognition is a commercial tool for detecting and recognizing faces in photos. Rekognition works by matching probe images with uploaded gallery images that have known labels. Amazon does not describe how their algorithm works, but their approach seemingly does not involve training a model on uploaded images (at least not in a supervised manner). We test the Rekognition API using the FaceScrub dataset (including distractors) where 100 randomly selected identities have their images attacked as described in Section 4. We observe that LowKey is highly effective, and even in the setting of rank-50 accuracy, Rekognition can only recognize $2 . 4 \%$ of probe images belonging to users protected with LowKey. In contrast, Fawkes fails, with $7 7 . 5 \%$ of probe images belonging to its users recognized correctly in the rank-1 setting and $9 4 . 9 \%$ of these images recognized correctly when the 50 closest matches are considered. This is close to the performance of Amazon Rekognition on clean images.
+
+<table><tr><td colspan="2">Amazon rank-1</td><td>Amazon rank-50</td><td>Microsoft rank-1</td></tr><tr><td>Clean -</td><td>93.7%</td><td>95.4%</td><td>90.5%</td></tr><tr><td>Fawkes -</td><td>77.5%</td><td>94.9%</td><td>74.2%</td></tr><tr><td>LowKey-</td><td>0.6%</td><td>2.4%</td><td>0.1%</td></tr></table>
+
+Table 1: An evaluation of Amazon Rekognition and Microsoft Azure Face on FaceScrub data with LowKey and Fawkes protection (a small number, and lighter color, indicates a successful attack). LowKey consistently achieves virtually flawless protection, while Fawkes provides little protection.
+
+Microsoft Azure Face We repeat a similar experiment on the Microsoft Azure Facial Recognition API. In contrast to Amazon’s API, Microsoft updates their model on the uploaded gallery of images. Therefore, only known identities can be used, so we only include images corresponding to the 530 known identities from FaceScrub and no distractors. The Azure system recognizes only $0 . 1 \%$ of probe images whose gallery images are under the protection of LowKey. Even though Fawkes is designed to perform data poisoning, and authors claim it is especially well suited to Microsoft Azure Face, in our experiments, Azure is still able to recognize more than $74 \%$ of probe images uploaded by users who employ Fawkes.
+
+We conclude from these experiments that LowKey is both highly effective and transferable to even state-of-the-art industrial facial recognition systems. In the next section, we explore several components of our attack in order to uncover the tools of its success.
+
+# 6 ADDITIONAL EXPERIMENTS
+
+The effectiveness of our protection tool hinges on several properties:
+
+1. The attack must transfer effectively to unseen models.   
+2. Images must look acceptable to users.   
+3. LowKey must run sufficiently fast so that run-time does not outweigh its protective benefits.   
+4. Attacked images must remain effective after being saved in PNG and JPG formats.   
+5. The algorithm must scale to images of any size.
+
+We conduct extensive experiments in this section with a variety of facial recognition systems to interrogate these properties of LowKey.
+
+# 6.1 ENSEMBLES AND TRANSFERABILITY
+
+In developing the ensemble of models used to compute our attack, we examine the extent to which attacks generated by one model are effective against another. By including an eclectic mix of models in our ensemble, we are able to ensure that LowKey produces images that fool a wide variety of facial recognition systems. To this end, we evaluate attacks on all pairs of source and victim models with ResNet-50, ResNet-152, IR-50, and IR-152 backbones, and both ArcFace and CosFace heads. For each victim model, we additionally measure performance on clean images, our ensembled attack, and Fawkes. See Table 2 for a comparison of the rank-50 performance of these combinations. Additional evaluations in the rank-1 setting and on the UMDFaces dataset can be found in Appendix 8.2 and 8.3 respectively. Note that entries for which the attacker and defender models are identical depict white-box performance, while entries for which these model differ depict black-box transferability.
+
+We observe in these experiments that adversarial attacks generated by IR architectures transfer better to IR-based facial recognition systems, while attacks generated by ResNet architectures transfer better to other ResNet systems. In general, attacks computed on 152-layer backbones are more effective than attacks computed on 50-layer backbones, and deeper networks are also more difficult to fool. Moreover, attacks transfer better between models trained with the same head. An ensemble of models of all combinations of ResNet-152 and IR-152 backbones as well as ArcFace and CosFace heads generates attacks that transfer effectively to all models and fool models at only a slightly lower rate than white-box attacks.
+
+# 6.2 GAUSSIAN SMOOTHING
+
+We incorporate Gaussian smoothing as a pre-processing step in our objective function (1) to make our perturbations smoother and more robust. Intuitively, this promotes the effectiveness of the attacked image even when a denoising filter is applied. The presence of blur forces the adversarial perturbation to rely on smoother/low-frequency image modifications rather than adversarial “noise.” Empirically, we find that attacks computed with this procedure produce slightly smoother and more aesthetically pleasing perturbations without sharp lines and high-frequency oscillations. See Figure 3 for a visual comparison of images produced with and without Gaussian smoothing in the LowKey pipeline.
+
+<table><tr><td></td><td rowspan=1 colspan=1>96.8%</td><td rowspan=1 colspan=1>96.8%</td><td rowspan=1 colspan=1>96.7%</td><td rowspan=1 colspan=4>96.8%  96.8%  96.8%  96.7%</td><td rowspan=1 colspan=1>96.7%</td></tr><tr><td></td><td rowspan=1 colspan=1>96.6%</td><td rowspan=1 colspan=1>96.7%</td><td rowspan=1 colspan=1>96.7%</td><td rowspan=1 colspan=1>96.7%</td><td rowspan=1 colspan=1>96.7%</td><td rowspan=1 colspan=1>96.5%</td><td rowspan=1 colspan=1>96.6%</td><td rowspan=1 colspan=1>96.6%</td></tr><tr><td></td><td rowspan=1 colspan=1>0.4%</td><td rowspan=1 colspan=1>22.2%</td><td rowspan=1 colspan=1>11.9%</td><td rowspan=1 colspan=1>35.2%</td><td rowspan=1 colspan=1>33.6%</td><td rowspan=1 colspan=1>46.4%</td><td rowspan=1 colspan=1>45.7%</td><td rowspan=1 colspan=1>53.0%</td></tr><tr><td></td><td rowspan=1 colspan=1>4.9%</td><td rowspan=1 colspan=1>0.3%</td><td rowspan=1 colspan=1>4.1%</td><td rowspan=1 colspan=1>8.0%</td><td rowspan=1 colspan=1>23.1%</td><td rowspan=1 colspan=1>25.9%</td><td rowspan=1 colspan=1>31.4%</td><td rowspan=1 colspan=1>28.6%</td></tr><tr><td></td><td rowspan=1 colspan=1>9.9%</td><td rowspan=1 colspan=1>18.3%</td><td rowspan=1 colspan=1>0.1%</td><td rowspan=1 colspan=1>26.1%</td><td rowspan=1 colspan=1>41.6%</td><td rowspan=1 colspan=1>46.2%</td><td rowspan=1 colspan=1>49.6%</td><td rowspan=1 colspan=1>48.9%</td></tr><tr><td></td><td rowspan=1 colspan=1>2.8%</td><td rowspan=1 colspan=1>1.6%</td><td rowspan=1 colspan=1>1.5%</td><td rowspan=1 colspan=1>0.5%</td><td rowspan=1 colspan=1>11.9%</td><td rowspan=1 colspan=1>13.9%</td><td rowspan=1 colspan=1>18.8%</td><td rowspan=1 colspan=1>16.3%</td></tr><tr><td></td><td rowspan=1 colspan=1>26.4%</td><td rowspan=1 colspan=1>35.7%</td><td rowspan=1 colspan=1>36.3%</td><td rowspan=1 colspan=1>43.0%</td><td rowspan=1 colspan=1>0.9%</td><td rowspan=1 colspan=1>13.3%</td><td rowspan=1 colspan=1>17.4%</td><td rowspan=1 colspan=1>24.2%</td></tr><tr><td></td><td rowspan=1 colspan=1>33.8%</td><td rowspan=1 colspan=1>36.5%</td><td rowspan=1 colspan=1>41.1%</td><td rowspan=1 colspan=1>42.9%</td><td rowspan=1 colspan=1>9.9%</td><td rowspan=1 colspan=1>0.2%</td><td rowspan=1 colspan=1>17.9%</td><td rowspan=1 colspan=1>21.1%</td></tr><tr><td></td><td rowspan=1 colspan=1>16.8%</td><td rowspan=1 colspan=1>22.0%</td><td rowspan=1 colspan=1>21.1%</td><td rowspan=1 colspan=1>28.2%</td><td rowspan=1 colspan=1>5.2%</td><td rowspan=1 colspan=1>8.8%</td><td rowspan=1 colspan=1>0.3%</td><td rowspan=1 colspan=1>7.6%</td></tr><tr><td rowspan=2 colspan=1>RN-152C-Ensemble</td><td rowspan=1 colspan=1>14.8%</td><td rowspan=1 colspan=1>19.2%</td><td rowspan=1 colspan=1>19.9%</td><td rowspan=1 colspan=1>24.3%</td><td rowspan=1 colspan=1>6.7%</td><td rowspan=1 colspan=1>6.9%</td><td rowspan=1 colspan=1>7.1%</td><td rowspan=1 colspan=1>0.5%</td></tr><tr><td rowspan=1 colspan=1> 3.0%</td><td rowspan=1 colspan=1>2.4%</td><td rowspan=1 colspan=1>2.1%</td><td rowspan=1 colspan=1>0.6%</td><td rowspan=1 colspan=1> 3.1%</td><td rowspan=1 colspan=1> 4.2%</td><td rowspan=1 colspan=1> 5.5%</td><td rowspan=1 colspan=1>0.9%</td></tr></table>
+
+Table 2: Rank-50 accuracy of the LowKey and Fawkes attacks. After the first two rows, each row represents LowKey attacks generated from the same model. Each column represents inference on a single model. The first two letters in the model’s name denote the type of backbone: IR or ResNet (RN). The last letter in the model’s name indicates the type of head; “A” denotes ArcFace, and “C” denotes CosFace. Smaller numbers, and lighter colors, indicate more successful attacks.
+
+We additionally produce images both with and without smoothing in the attack pipeline. Before feeding them into facial recognition systems, we defend the system against our attacks by applying a Gaussian smoothing pre-processing step just before inference.
+
+We find that facial recognition systems which use this pre-processing step perform equally well on rank-50 (but not rank-1) accuracy compared to performance without smoothing, and they are also able to defeat attacks which are not computed with Gaussian smoothing. On the other hand, attacks computed using Gaussian smoothing are able to counteract this defense and fool the facial recognition system (see Table 3). This suggests that attacks that use Gaussian smoothing in their pipeline are more robust and harder to defend against. See Appendix 8.6 for details regarding Gaussian smoothing hyperparameters.
+
+# 6.3 RUN-TIME
+
+In order for users to be willing to use our tool, LowKey must run fast enough that it is not an inconvenience to use. Computing adversarial attacks is a computationally expensive task. We compare run-time to Fawkes as a baseline and test both attacks on a single NVIDIA GeForce RTX 2080 TI GPU. We attack one image at a time with no batching for fair comparison, and we average over runs on every full-size gallery image from each of five randomly selected identities from FaceScrub. While Fawkes averages 54 seconds per image, LowKey only averages 32 seconds per image. In addition to providing far superior protection, LowKey runs significantly faster than the existing method, providing users a smoother and more convenient experience.
+
+<table><tr><td colspan="10">Defender IR-50A IR-50C</td></tr><tr><td></td><td>Clean</td><td>96.7% 96.8%</td><td>IR-152A 96.6%</td><td></td><td>IR-152C 96.9%</td><td>RN-50A 96.7%</td><td>96.7%</td><td>RN-50C RN-152A RN-152C 96.7%</td><td>96.7%</td></tr><tr><td>AAreeet Without GS </td><td>78.6%</td><td>74.0%</td><td>74.4%</td><td>64.6%</td><td>75.5%</td><td>76.0%</td><td>77.8%</td><td>74.2%</td></tr><tr><td>With GS</td><td>4.2%</td><td>4.8%</td><td>4.4%</td><td>2.8%</td><td>7.9%</td><td>7.1%</td><td>9.6%</td><td>3.2%</td></tr></table>
+
+Table 3: Rank-50 accuracy of FR models tested on blurred LowKey images computed with/without Gaussian smoothing.
+
+![](images/9269723de086f2ad1a2c16403f94f956472db7a3f092652514c49a9e95d8d810.jpg)  
+Figure 3: LowKey attacked images computed without (above) and with (below) Gaussian smoothing.
+
+# 6.4 ROBUSTNESS TO IMAGE COMPRESSION
+
+Since users may save their images in various formats after passing them through LowKey, the images we produce must provide protection even after being saved in common formats. Our baseline tests are conducted with images saved in uncompressed PNG format. To test performance under compression, we convert protected images to JPEG format and repeat our experiments on commercial APIs. While compression very slightly decreases performance, the attack is still very effective: Microsoft Azure Face is now able to recognize $0 . 2 \%$ of images compared to $0 . 1 \%$ when saved in the PNG format. Likewise, Amazon Rekognition now recognizes $3 . 8 \%$ of probe images compared to $2 . 4 \%$ previously.
+
+# 6.5 SCALABILITY TO ALL IMAGE SIZES (DISCLAIMER)
+
+Many tools in deep learning require that inputs be of particular dimensions, but user images on social media sites come in all shapes and sizes. Therefore, LowKey must be flexible. Since the detection and alignment pipeline in our attack resizes images in a differentiable fashion, we can attack images of any size and aspect ratio. Additionally, we apply the LPIPS penalty to the entire original image, which prevents box-shaped artifacts from developing on the boundaries of the rectangle containing the face. Since LowKey does not have a fixed attack budget, perturbations may have different magnitudes on different images. Figure 4 shows the variability of LowKey perturbations on very large images; the image of Tom Hanks (first column) is one of the best looking examples of LowKey on large images, while the image of Tina Fey (last column) is one of the worst looking examples. Protecting very large images is a more challenging task than protecting small images because of the black-box detection, alignment, and re-scaling used in APIs which affect large images more significantly. These experiments indicate that users will receive stronger protection if they use LowKey on smaller images.
+
+We test the effectiveness of LowKey on large images by protecting gallery images of 10 identities from Facescrub (with 17 images in the gallery on average) and using 20 probe images per person. We also vary the magnitude of the perturbation to find the smallest perturbation that is sufficient to protect images (Table 4). In this way, we find that users may trade off some protection in exchange for better looking images at their own discretion. Additionally, we find that LowKey works much better with smaller gallery sizes; when only 5 gallery images are used, the performance of Amazon Rekognition drops from $3 2 . 5 \%$ to $11 \%$ in the rank-50 setting. This observation suggests that users can upload new profile pictures less frequently in order to decrease the number of gallery images corresponding to their identity and thus enhance their protection. Finally, the quality of probe images is also important; when small probe images are used, like those which would occur in low resolution security camera footage, the accuracy of Amazon Rekognition drops from $3 2 . 5 \%$ to $19 \%$ .
+
+# 7 DISCUSSION
+
+In this work, we develop a tool for protecting users from unauthorized facial recognition. Our tool adversarially pre-processes user images before they are uploaded to social media. These pre-processed images are useless for third-party organizations who collect them for facial recognition. While we have shown that LowKey is highly effective against commercial black-box APIs, it does not protect users $100 \%$ of the time and may be circumvented by specially engineered robust systems. Thus, we hope that users will still remain cautious about publicly revealing personal information. One interesting future direction is to produce adversarial filters that are more aesthetically pleasing in order to promote wider use of this tool. However, it may be that there is no free lunch, and one cannot fool state-of-the-art facial recognition systems without visible perturbations. Facial recognition systems are not fragile, and other attacks that have attempted to break them have failed. Finally, we note that one of our goals in making this tool widely available is to promote broader awareness of facial recognition and the ethical issues it raises. Our webtool can be found at lowkey.umiacs.umd.edu.
+
+![](images/b7f3e5b3bb1f2b492b0e8ca24ca7ff45f66fd286889e5f16f576def2574e3088.jpg)  
+Figure 4: First row: Original large images, Second row: Images protected with LowKey (medium magnitude), Third row: Images protected with LowKey (large magnitude).
+
+Table 4: Evaluation of LowKey on full-size images. Rows indicate levels of magnitude of LowKey (denoted by the number of attack steps).   
+
+<table><tr><td colspan="2">Amazon rank-1</td><td>Amazon rank-50</td><td>Microsoft rank-1</td></tr><tr><td>Clean </td><td>89.0%</td><td>98.5%</td><td>86.0%</td></tr><tr><td>LowKey 10</td><td>63.0%</td><td>94.5%</td><td>75.5%</td></tr><tr><td>LowKey 20-</td><td>34.0%</td><td>59.5%</td><td>30.5%</td></tr><tr><td>LowKey 30 -</td><td>20.5%</td><td>36.5%</td><td>12.7%</td></tr><tr><td>LowKey 40 -</td><td>14.5%</td><td>36.0%</td><td>3.0%</td></tr><tr><td>LowKey 50</td><td>11.0%</td><td>32.5%</td><td>0.0%</td></tr></table>
+
+# ACKNOWLEDGMENTS
+
+This work was supported by the DARPA GARD and DARPA QED programs. Further support was provided by the AFOSR MURI program, and the National Science Foundation’s DMS division. Computation resources were funded by the Sloan Foundation.
+
+# REFERENCES
+
+Ankan Bansal, Anirudh Nanduri, Carlos D Castillo, Rajeev Ranjan, and Rama Chellappa. Umdfaces: An annotated face dataset for training deep networks. In 2017 IEEE International Joint Conference on Biometrics (IJCB), pp. 464–473. IEEE, 2017.
+
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In 2017 ieee symposium on security and privacy (sp), pp. 39–57. IEEE, 2017.
+
+Valeriia Cherepanova, Vedant Nanda, Micah Goldblum, John P Dickerson, and Tom Goldstein. Technical challenges for training fair neural networks. arXiv preprint arXiv:2102.06764, 2021.
+
+Ping-Yeh Chiang, Jonas Geiping, Micah Goldblum, Tom Goldstein, Renkun Ni, Steven Reich, and Ali Shafahi. Witchcraft: Efficient pgd attacks with random step size. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 3747–3751. IEEE, 2020.
+
+Jiankang Deng, Jia Guo, Niannan Xue, and Stefanos Zafeiriou. Arcface: Additive angular margin loss for deep face recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4690–4699, 2019.
+
+William Derringer. A surveillance net blankets china’s cities, giving police vast powers. The New York Times, Dec. 17 2019. URL https://www.nytimes.com/2019/12/17/technology/ china-surveillance.html.
+
+Micah Goldblum, Avi Schwarzschild, Naftali Cohen, Tucker Balch, Ankit B Patel, and Tom Goldstein. Adversarial attacks on machine learning systems for high-frequency trading. arXiv preprint arXiv:2002.09565, 2020.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.
+
+Yandong Guo, Lei Zhang, Yuxiao Hu, Xiaodong He, and Jianfeng Gao. Ms-celeb-1m: A dataset and benchmark for large-scale face recognition. In European conference on computer vision, pp. 87–102. Springer, 2016.
+
+Woodrow Hartzog. The secretive company that might end privacy as we know it. The New York Times, Jan. 18 2020. URL https://www.nytimes.com/2020/01/18/technology/ clearview-privacy-facial-recognition.html.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Ira Kemelmacher-Shlizerman, Steven M Seitz, Daniel Miller, and Evan Brossard. The megaface benchmark: 1 million faces for recognition at scale. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4873–4882, 2016.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016.
+
+Cassidy Laidlaw, Sahil Singla, and Soheil Feizi. Perceptual adversarial robustness: Defense against unseen threat models. arXiv preprint arXiv:2006.12655, 2020.
+
+Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollar. Focal loss for dense object ´ detection. In Proceedings of the IEEE international conference on computer vision, pp. 2980–2988, 2017.
+
+Weiyang Liu, Yandong Wen, Zhiding Yu, Ming Li, Bhiksha Raj, and Le Song. Sphereface: Deep hypersphere embedding for face recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 212–220, 2017.
+
+Steve Lohr. Facial recognition is accurate, if you’re a white guy. New York Times, 9, 2018.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017.
+
+Daniel Pedraza, Dhaval Adjodah, Gretchen Greene, Josh Joseph, Thom Miano, and Francisco. Equalais. https://equalais.media.mit.edu/, 2018.
+
+Parsa Saadatpanah, Ali Shafahi, and Tom Goldstein. Adversarial attacks on copyright detection systems. In International Conference on Machine Learning, pp. 8307–8315. PMLR, 2020.
+
+Shawn Shan, Emily Wenger, Jiayun Zhang, Huiying Li, Haitao Zheng, and Ben Y Zhao. Fawkes: Protecting privacy against unauthorized deep learning models. In 29th {USENIX} Security Symposium ({USENIX} Security 20), pp. 1589–1604, 2020.
+
+Natasha Singer. Microsoft urges congress to regulate use of facial recognition. The New York Times, 2018.
+
+Hao Wang, Yitong Wang, Zheng Zhou, Xing Ji, Dihong Gong, Jingchao Zhou, Zhifeng Li, and Wei Liu. Cosface: Large margin cosine loss for deep face recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5265–5274, 2018.
+
+Karen Weise and Natasha Singer. Amazon pauses police use of its facial recognition software. The New York Times, Jul. 10 2020. URL https://www.nytimes.com/2020/06/10/ technology/amazon-facial-recognition-backlash.html.
+
+Emily Wenger, Josephine Passananti, Yuanshun Yao, Haitao Zheng, and Ben Y Zhao. Backdoor attacks on facial recognition in the physical world. arXiv preprint arXiv:2006.14580, 2020.
+
+Zuxuan Wu, Ser-Nam Lim, Larry Davis, and Tom Goldstein. Making an invisibility cloak: Real world adversarial attacks on object detectors. arXiv preprint arXiv:1910.14667, 2019.
+
+Kaidi Xu, Gaoyuan Zhang, Sijia Liu, Quanfu Fan, Mengshu Sun, Hongge Chen, Pin-Yu Chen, Yanzhi Wang, and Xue Lin. Adversarial t-shirt! evading person detectors in a physical world. arXiv, pp. arXiv–1910, 2019.
+
+Xiao Yang, Yinpeng Dong, Tianyu Pang, Jun Zhu, and Hang Su. Towards privacy protection by generating adversarial identity masks. arXiv preprint arXiv:2003.06814, 2020.
+
+Kai Zhang, V´ıtor Albiero, and Kevin W Bowyer. A method for curation of web-scraped face image datasets. In 2020 8th International Workshop on Biometrics and Forensics (IWBF), pp. 1–6. IEEE, 2020.
+
+Richard Zhang, Phillip Isola, Alexei A Efros, Eli Shechtman, and Oliver Wang. The unreasonable effectiveness of deep features as a perceptual metric. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 586–595, 2018.
+
+Jian Zhao. face.evolve: High-performance face recognition library based on pytorch. https: //github.com/ZhaoJ9014/face.evoLVe.PyTorch, 2020.
+
+Yaoyao Zhong and Weihong Deng. Towards transferable adversarial attack against deep face recognition. arXiv preprint arXiv:2004.05790, 2020.
+
+# 8 APPENDIX
+
+# 8.1 IMPLEMENTATION DETAILS
+
+We train all of our feature extractors using focal loss (Lin et al., 2017) with a batch size of 512 for 120 epochs. We use an initial learning rate of 0.1 and decrease it by a factor of 10 at epochs 35, 65 and 95. For the optimizer, we use SGD with a momentum of 0.9 and weight decay of 5e-4.
+
+For our adversarial attacks, we use 0.05 for the perceptual similarity penalty, $\sigma = 3$ and window size 7 for the Gaussian smoothing term. Attacks are computed using signed SGD for 50 epochs with a learning rate of 0.0025.
+
+For face detection and aligning models as well as for training routines, we use the face.evoLVe.PyTorch github repository (Zhao, 2020).
+
+# 8.2 RANK-1 ACCURACY ON FACESCRUB DATA
+
+See Table 5.
+
+<table><tr><td rowspan=2 colspan=9>DefenderIR-50A IR-50CIR-152AIR-152C RN-50ARN-50C RN-152A RN-152CClean 95.6%  96.1%  96.0%  96.2%  95.8%  95.9%  95.9%  96.0%</td></tr><tr><td rowspan=1 colspan=1>95.6%</td><td rowspan=1 colspan=2>96.1%  96.0%</td><td rowspan=1 colspan=1>96.2%</td><td rowspan=1 colspan=1>95.8%</td><td rowspan=1 colspan=2>95.9%  95.9%</td><td rowspan=1 colspan=1>96.0%</td></tr><tr><td rowspan=5 colspan=1>Fawkes IR-50AIR-50CAAreeet IR-152AIR-152C-</td><td rowspan=1 colspan=1>71.2%</td><td rowspan=1 colspan=1>76.2%</td><td rowspan=1 colspan=1>74.4%</td><td rowspan=1 colspan=1>78.2%</td><td rowspan=1 colspan=1>73.9%</td><td rowspan=1 colspan=2>76.0%  76.0%</td><td rowspan=1 colspan=1>71.2%</td></tr><tr><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>3.5%</td><td rowspan=1 colspan=1>0.5%</td><td rowspan=1 colspan=1>6.4%</td><td rowspan=1 colspan=1>5.0%</td><td rowspan=1 colspan=2>8.2%   8.7%</td><td rowspan=1 colspan=1>12.4%</td></tr><tr><td rowspan=1 colspan=1>0.1%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>0.1%</td><td rowspan=1 colspan=1>9.0%</td><td rowspan=1 colspan=1>3.3%</td><td rowspan=1 colspan=2>3.3%   3.6%</td><td rowspan=1 colspan=1> 5.3%</td></tr><tr><td rowspan=1 colspan=1>0.3%</td><td rowspan=1 colspan=1>1.8%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>4.2%</td><td rowspan=1 colspan=1>6.8%</td><td rowspan=1 colspan=1>8.9%</td><td rowspan=1 colspan=1>9.4%</td><td rowspan=1 colspan=1>10.8%</td></tr><tr><td rowspan=1 colspan=1>0.1%</td><td rowspan=1 colspan=1>0.1%</td><td rowspan=1 colspan=1>0.1%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>1.0%</td><td rowspan=1 colspan=1>1.4%</td><td rowspan=1 colspan=1>2.2%</td><td rowspan=1 colspan=1>2.9%</td></tr><tr><td rowspan=1 colspan=1>RN-50A-</td><td rowspan=1 colspan=1>3.8%</td><td rowspan=1 colspan=1>7.0%</td><td rowspan=1 colspan=1>6.8%</td><td rowspan=1 colspan=1>8.3%</td><td rowspan=1 colspan=1>0.9%</td><td rowspan=1 colspan=1>2.0%</td><td rowspan=1 colspan=1>2.8%</td><td rowspan=1 colspan=1>4.6%</td></tr><tr><td rowspan=1 colspan=1>RN-50C-</td><td rowspan=1 colspan=1>3.1%</td><td rowspan=1 colspan=1> 5.7%</td><td rowspan=1 colspan=1>5.6%</td><td rowspan=1 colspan=1>7.9%</td><td rowspan=1 colspan=1>1.2%</td><td rowspan=1 colspan=1>0.1%</td><td rowspan=1 colspan=1>2.0%</td><td rowspan=1 colspan=1> 3.5%</td></tr><tr><td rowspan=1 colspan=1>RN-152A</td><td rowspan=1 colspan=1>1.5%</td><td rowspan=1 colspan=1>3.1%</td><td rowspan=1 colspan=1>2.7%</td><td rowspan=1 colspan=1>4.9%</td><td rowspan=1 colspan=1>0.3%</td><td rowspan=1 colspan=1>0.5%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>0.4%</td></tr><tr><td rowspan=2 colspan=1>RN-152CEnsemble</td><td rowspan=1 colspan=1>1.7%</td><td rowspan=1 colspan=1>2.6%</td><td rowspan=1 colspan=1>3.1%</td><td rowspan=1 colspan=1>3.9%</td><td rowspan=1 colspan=1>0.8%</td><td rowspan=1 colspan=1>0.8%</td><td rowspan=1 colspan=1>0.5%</td><td rowspan=1 colspan=1>0.0%</td></tr><tr><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=2>0.0%   0.1%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>0.2%</td><td rowspan=1 colspan=2>0.4%   0.6%</td><td rowspan=1 colspan=1>0.1%</td></tr></table>
+
+Table 5: Rank-1 accuracy of the LowKey and Fawkes attacks on the FaceScrub dataset. After the first two rows, each row represents LowKey attacks generated from the same model. Each column represents inference on a single model. The first two letters in the model’s name denote the type of backbone: IR or ResNet (RN). The last letter in the model’s name indicates the type of head; “A” denotes ArcFace, and “C” denotes CosFace. Smaller numbers, and lighter colors, indicate more successful attacks.
+
+# 8.3 RESULTS ON UMDFACES DATASET
+
+We repeat controlled experiments on the UMDFaces dataset which contains over 367,000 photos of 8,277 identities. For UMDFaces, we also choose 100 identities at random and attack their gallery images while keeping one-tenth of each identity’s photos as probe images. Experimental results are reported in Tables 6 and 7. It can be seen that the effectiveness of LowKey attacks on the UMDFaces dataset is slightly lower, which is likely a result of the much smaller gallery.
+
+# 8.4 CAN WE REDUCE THE SIZE OF OUR ATTACK?
+
+In order to make our attacks more aesthetically pleasing, we try to reduce the size of perturbation by increasing the perceptual similarity penalty from 0.05 to 0.08. This attack is depicted in Figure 5 as a ”LowKey small attack”. Unfortunately, even a small decrease in the perturbation size results in a huge decrease in efficiency of the attack. In the rank-50 setting Amazon Rekognition is able to recognize $1 7 . 2 \%$ of probe images belonging to users protected with a LowKey small attack. Similarly, Microsoft
+
+<table><tr><td></td><td rowspan=1 colspan=1>98.6%</td><td rowspan=1 colspan=1>98.3%</td><td rowspan=1 colspan=1>98.6%</td><td rowspan=1 colspan=2>98.6%  98.3%</td><td rowspan=1 colspan=2>98.3%  98.6%</td><td rowspan=1 colspan=1>98.6%</td></tr><tr><td></td><td rowspan=1 colspan=1>0.3%</td><td rowspan=1 colspan=1>38.9%</td><td rowspan=1 colspan=1>25.9%</td><td rowspan=1 colspan=1>48.6%</td><td rowspan=1 colspan=1>47.7%</td><td rowspan=1 colspan=1>55.7%</td><td rowspan=1 colspan=1>57.1%</td><td rowspan=1 colspan=1>62.2%</td></tr><tr><td></td><td rowspan=1 colspan=1>13.6%</td><td rowspan=1 colspan=1>0.3%</td><td rowspan=1 colspan=1>16.5%</td><td rowspan=1 colspan=1>17.6%</td><td rowspan=1 colspan=1>37.5%</td><td rowspan=1 colspan=1>39.2%</td><td rowspan=1 colspan=1>51.4%</td><td rowspan=1 colspan=1>46.3%</td></tr><tr><td></td><td rowspan=1 colspan=1>23.0%</td><td rowspan=1 colspan=1>32.1%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>36.4%</td><td rowspan=1 colspan=1>52.8%</td><td rowspan=1 colspan=1>56.5%</td><td rowspan=1 colspan=1>58.2%</td><td rowspan=1 colspan=1>58.5%</td></tr><tr><td></td><td rowspan=1 colspan=1>8.8%</td><td rowspan=1 colspan=1>8.8%</td><td rowspan=1 colspan=1>9.1%</td><td rowspan=1 colspan=1>1.1%</td><td rowspan=1 colspan=1>26.7%</td><td rowspan=1 colspan=1>28.1%</td><td rowspan=1 colspan=1>34.9%</td><td rowspan=1 colspan=1>31.8%</td></tr><tr><td rowspan=5 colspan=1>Aareeet RN-50A-RN-50C-RN-152A -RN-152C-Ensemble-</td><td rowspan=1 colspan=1>51.4%</td><td rowspan=1 colspan=1>56.3%</td><td rowspan=1 colspan=1>47.2%</td><td rowspan=1 colspan=1>53.1%</td><td rowspan=1 colspan=1>0.3%</td><td rowspan=1 colspan=1>30.7%</td><td rowspan=1 colspan=1>38.4%</td><td rowspan=1 colspan=1>43.2%</td></tr><tr><td rowspan=1 colspan=1>49.4%</td><td rowspan=1 colspan=1>48.3%</td><td rowspan=1 colspan=1>55.1%</td><td rowspan=1 colspan=1>54.0%</td><td rowspan=1 colspan=1>23.0%</td><td rowspan=1 colspan=1>1.1%</td><td rowspan=1 colspan=1>37.2%</td><td rowspan=1 colspan=1>36.4%</td></tr><tr><td rowspan=1 colspan=1>30.4%</td><td rowspan=1 colspan=1>38.1%</td><td rowspan=1 colspan=1>39.8%</td><td rowspan=1 colspan=1>43.8%</td><td rowspan=1 colspan=1>18.8%</td><td rowspan=1 colspan=1>22.2%</td><td rowspan=1 colspan=1>3.4%</td><td rowspan=1 colspan=1>25.9%</td></tr><tr><td rowspan=1 colspan=1>26.4%</td><td rowspan=1 colspan=1>33.8%</td><td rowspan=1 colspan=1>35.5%</td><td rowspan=1 colspan=1>37.8%</td><td rowspan=1 colspan=1>17.3%</td><td rowspan=1 colspan=1>18.2%</td><td rowspan=1 colspan=1>16.8%</td><td rowspan=1 colspan=1> 3.4%</td></tr><tr><td rowspan=1 colspan=1>10.5%</td><td rowspan=1 colspan=1>4.5%</td><td rowspan=1 colspan=1>9.7%</td><td rowspan=1 colspan=1>8.8%</td><td rowspan=1 colspan=1>15.1%</td><td rowspan=1 colspan=1> 6.5%</td><td rowspan=1 colspan=1>12.8%</td><td rowspan=1 colspan=1>13.6%</td></tr></table>
+
+Table 6: Rank-50 accuracy of LowKey attacks on the UMDFaces dataset. After the first row, each row represents LowKey attacks generated from the same model. Each column represents inference on a single model. The first two letters in the model’s name denote the type of backbone: IR or ResNet (RN). The last letter in the model’s name indicates the type of head; “A” denotes ArcFace, and “C” denotes CosFace. Smaller numbers, and lighter colors, indicate more successful attacks.
+
+<table><tr><td></td><td rowspan=1 colspan=1>96.0%</td><td rowspan=1 colspan=1>97.2%</td><td rowspan=1 colspan=1>96.9%</td><td rowspan=1 colspan=2>96.9%  96.3%</td><td rowspan=1 colspan=2>96.6%  97.2%</td><td rowspan=1 colspan=1>96.3%</td></tr><tr><td></td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>12.2%</td><td rowspan=1 colspan=1>6.3%</td><td rowspan=1 colspan=1>18.2%</td><td rowspan=1 colspan=1>17.6%</td><td rowspan=1 colspan=1>25.9%</td><td rowspan=1 colspan=1>28.1%</td><td rowspan=1 colspan=1>31.3%</td></tr><tr><td></td><td rowspan=1 colspan=1>1.7%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>2.6%</td><td rowspan=1 colspan=1>4.3%</td><td rowspan=1 colspan=1>11.6%</td><td rowspan=1 colspan=1>13.9%</td><td rowspan=1 colspan=1>17.3%</td><td rowspan=1 colspan=1>21.0%</td></tr><tr><td></td><td rowspan=1 colspan=1>4.3%</td><td rowspan=1 colspan=1>12.8%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>14.5%</td><td rowspan=1 colspan=1>22.4%</td><td rowspan=1 colspan=1>25.6%</td><td rowspan=1 colspan=1>29.5%</td><td rowspan=1 colspan=1>30.1%</td></tr><tr><td></td><td rowspan=1 colspan=1>1.7%</td><td rowspan=1 colspan=1>2.0%</td><td rowspan=1 colspan=1>2.6%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>6.8%</td><td rowspan=1 colspan=1>9.7%</td><td rowspan=1 colspan=1>13.6%</td><td rowspan=1 colspan=1>11.4%</td></tr><tr><td></td><td rowspan=1 colspan=1>26.4%</td><td rowspan=1 colspan=1>31.0%</td><td rowspan=1 colspan=1>13.9%</td><td rowspan=1 colspan=1>26.4%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>9.4%</td><td rowspan=1 colspan=1>15.1%</td><td rowspan=1 colspan=1>19.0%</td></tr><tr><td rowspan=4 colspan=1>RN-50C-RN-152A -RN-152C-Ensemble </td><td rowspan=1 colspan=1>14.5%</td><td rowspan=1 colspan=1>21.3%</td><td rowspan=1 colspan=1>20.7%</td><td rowspan=1 colspan=1>25.3%</td><td rowspan=1 colspan=1>6.5%</td><td rowspan=1 colspan=1>0.6%</td><td rowspan=1 colspan=1>12.8%</td><td rowspan=1 colspan=1>14.8%</td></tr><tr><td rowspan=1 colspan=1>9.7%</td><td rowspan=1 colspan=1>16.2%</td><td rowspan=1 colspan=1>16.8%</td><td rowspan=1 colspan=1>17.9%</td><td rowspan=1 colspan=1> 5.1%</td><td rowspan=1 colspan=1>7.1%</td><td rowspan=1 colspan=1>0.3%</td><td rowspan=1 colspan=1> 7.4%</td></tr><tr><td rowspan=1 colspan=1>7.4%</td><td rowspan=1 colspan=1>10.2%</td><td rowspan=1 colspan=1>11.9%</td><td rowspan=1 colspan=1>13.1%</td><td rowspan=1 colspan=1>3.1%</td><td rowspan=1 colspan=1> 4.5%</td><td rowspan=1 colspan=1> 5.4%</td><td rowspan=1 colspan=1>0.9%</td></tr><tr><td rowspan=1 colspan=1>2.8%</td><td rowspan=1 colspan=1>1.7%</td><td rowspan=1 colspan=1>2.6%</td><td rowspan=1 colspan=1>3.1%</td><td rowspan=1 colspan=1> 5.1%</td><td rowspan=1 colspan=1>2.0%</td><td rowspan=1 colspan=1>3.1%</td><td rowspan=1 colspan=1>4.0%</td></tr></table>
+
+Table 7: Rank-1 accuracy of LowKey attack attacks on the UMDFaces dataset. After the first row, each row represents LowKey attacks generated from the same model. Each column represents inference on a single model. The first two letters in the model’s name denote the type of backbone: IR or ResNet (RN). The last letter in the model’s name indicates the type of head; “A” denotes ArcFace, and “C” denotes CosFace. Smaller numbers, and lighter colors, indicate more successful attacks.
+
+Azure Face recognizes $5 . 5 \%$ of probe images. Results of controlled experiments are reported in Tables 8 and 9.
+
+# 8.5 COMPARISON WITH FAWKES
+
+By comparing a set of images protected with LowKey and Fawkes tools, we can see that both attacks are noticeable, but distort images in different ways. While Fawkes adds conspicuous artifacts on the face (such as mustaches or lines on the nose), LowKey attack mostly changes the textures and adds spots on a person’s skin. See Figure 5 for a visual comparison.
+
+<table><tr><td></td><td rowspan=1 colspan=1>96.8%</td><td rowspan=1 colspan=1>96.8%</td><td rowspan=1 colspan=1>96.7%</td><td rowspan=1 colspan=1>96.8%</td><td rowspan=1 colspan=1>96.8%</td><td rowspan=1 colspan=2>96.8%  96.7%</td><td rowspan=1 colspan=1>96.7%</td></tr><tr><td></td><td rowspan=1 colspan=1>1.0%</td><td rowspan=1 colspan=1>41.1%</td><td rowspan=1 colspan=1>24.7%</td><td rowspan=1 colspan=1>55.2%</td><td rowspan=1 colspan=1>49.7%</td><td rowspan=1 colspan=1>65.0%</td><td rowspan=1 colspan=1>64.2%</td><td rowspan=1 colspan=1>68.8%</td></tr><tr><td></td><td rowspan=1 colspan=1>17.4%</td><td rowspan=1 colspan=1>2.6%</td><td rowspan=1 colspan=1>20.4%</td><td rowspan=1 colspan=1>30.2%</td><td rowspan=1 colspan=1>47.0%</td><td rowspan=1 colspan=1>49.0%</td><td rowspan=1 colspan=1>56.2%</td><td rowspan=1 colspan=1>55.6%</td></tr><tr><td></td><td rowspan=1 colspan=1>28.8%</td><td rowspan=1 colspan=1>38.6%</td><td rowspan=1 colspan=1>0.3%</td><td rowspan=1 colspan=1>49.8%</td><td rowspan=1 colspan=1>61.2%</td><td rowspan=1 colspan=1>66.6%</td><td rowspan=1 colspan=1>69.8%</td><td rowspan=1 colspan=1>70.7%</td></tr><tr><td></td><td rowspan=1 colspan=1>14.2%</td><td rowspan=1 colspan=1>14.0%</td><td rowspan=1 colspan=1>16.2%</td><td rowspan=1 colspan=1>2.7%</td><td rowspan=1 colspan=1>37.0%</td><td rowspan=1 colspan=1>38.6%</td><td rowspan=1 colspan=1>44.4%</td><td rowspan=1 colspan=1>42.9%</td></tr><tr><td rowspan=5 colspan=1>Aareeet RN-50A-RN-50C-RN-152A -RN-152C-Ensemble -</td><td rowspan=1 colspan=1>49.3%</td><td rowspan=1 colspan=1>62.3%</td><td rowspan=1 colspan=1>64.1%</td><td rowspan=1 colspan=1>68.0%</td><td rowspan=1 colspan=1>1.5%</td><td rowspan=1 colspan=1>35.9%</td><td rowspan=1 colspan=1>41.8%</td><td rowspan=1 colspan=1>49.3%</td></tr><tr><td rowspan=1 colspan=1> 57.4%</td><td rowspan=1 colspan=1>59.9%</td><td rowspan=1 colspan=1>62.1%</td><td rowspan=1 colspan=1>64.4%</td><td rowspan=1 colspan=1>31.1%</td><td rowspan=1 colspan=1>3.6%</td><td rowspan=1 colspan=1>46.8%</td><td rowspan=1 colspan=1>48.6%</td></tr><tr><td rowspan=1 colspan=1>42.9%</td><td rowspan=1 colspan=1>51.3%</td><td rowspan=1 colspan=1>52.3%</td><td rowspan=1 colspan=1>55.0%</td><td rowspan=1 colspan=1>25.6%</td><td rowspan=1 colspan=1>32.9%</td><td rowspan=1 colspan=1>5.6%</td><td rowspan=1 colspan=1>35.0%</td></tr><tr><td rowspan=1 colspan=1>41.8%</td><td rowspan=1 colspan=1>48.9%</td><td rowspan=1 colspan=1>47.9%</td><td rowspan=1 colspan=1>52.7%</td><td rowspan=1 colspan=1>28.2%</td><td rowspan=1 colspan=1>29.2%</td><td rowspan=1 colspan=1>30.4%</td><td rowspan=1 colspan=1>8.5%</td></tr><tr><td rowspan=1 colspan=1>18.0%</td><td rowspan=1 colspan=1>21.8%</td><td rowspan=1 colspan=1>19.4%</td><td rowspan=1 colspan=1>12.2%</td><td rowspan=1 colspan=1>23.1%</td><td rowspan=1 colspan=1>24.3%</td><td rowspan=1 colspan=1>27.0%</td><td rowspan=1 colspan=1>14.1%</td></tr></table>
+
+Table 8: Rank-50 accuracy of LowKey small attacks on the UMDFaces dataset. After the first row, each row represents LowKey small attacks generated from the same model. Each column represents inference on a single model. The first two letters in the model’s name denote the type of backbone: IR or ResNet (RN). The last letter in the model’s name indicates the type of head; “A” denotes ArcFace, and “C” denotes CosFace. Smaller numbers, and lighter colors, indicate more successful attacks.
+
+<table><tr><td></td><td rowspan=1 colspan=1>95.6%</td><td rowspan=1 colspan=1>96.1%</td><td rowspan=1 colspan=1>96.0%</td><td rowspan=1 colspan=1>96.2%</td><td rowspan=1 colspan=4>95.8% 95.9%  95.9%  96.0%</td></tr><tr><td></td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>6.1%</td><td rowspan=1 colspan=1>2.2%</td><td rowspan=1 colspan=1>10.5%</td><td rowspan=1 colspan=1>9.7%</td><td rowspan=1 colspan=1>14.4%</td><td rowspan=1 colspan=1>16.9%</td><td rowspan=1 colspan=1>19.5%</td></tr><tr><td></td><td rowspan=1 colspan=1>1.6%</td><td rowspan=1 colspan=1>0.2%</td><td rowspan=1 colspan=1>2.5%</td><td rowspan=1 colspan=1>5.8%</td><td rowspan=1 colspan=1>9.3%</td><td rowspan=1 colspan=1>11.1%</td><td rowspan=1 colspan=1>14.0%</td><td rowspan=1 colspan=1>14.5%</td></tr><tr><td></td><td rowspan=1 colspan=1>2.2%</td><td rowspan=1 colspan=1>5.6%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>9.6%</td><td rowspan=1 colspan=1>14.0%</td><td rowspan=1 colspan=1>17.4%</td><td rowspan=1 colspan=1>19.2%</td><td rowspan=1 colspan=1>20.7%</td></tr><tr><td></td><td rowspan=1 colspan=1>1.3%</td><td rowspan=1 colspan=1>1.7%</td><td rowspan=1 colspan=1>2.2%</td><td rowspan=1 colspan=1>0.4%</td><td rowspan=1 colspan=1> 5.1%</td><td rowspan=1 colspan=1> 7.5%</td><td rowspan=1 colspan=1>9.6%</td><td rowspan=1 colspan=1> 9.7%</td></tr><tr><td rowspan=5 colspan=1>AAraret RN-50ARN-50CRN-152A-RN-152C-Ensemble</td><td rowspan=1 colspan=1>8.7%</td><td rowspan=1 colspan=1>14.9%</td><td rowspan=1 colspan=1>14.8%</td><td rowspan=1 colspan=1>17.1%</td><td rowspan=1 colspan=1>0.2%</td><td rowspan=1 colspan=1>7.6%</td><td rowspan=1 colspan=1>7.8%</td><td rowspan=1 colspan=1>12.5%</td></tr><tr><td rowspan=1 colspan=1>9.9%</td><td rowspan=1 colspan=1>14.6%</td><td rowspan=1 colspan=1>15.6%</td><td rowspan=1 colspan=1>17.2%</td><td rowspan=1 colspan=1>5.6%</td><td rowspan=1 colspan=1>0.6%</td><td rowspan=1 colspan=1>8.8%</td><td rowspan=1 colspan=1>11.6%</td></tr><tr><td rowspan=1 colspan=1>9.2%</td><td rowspan=1 colspan=1>13.5%</td><td rowspan=1 colspan=1>12.2%</td><td rowspan=1 colspan=1>14.8%</td><td rowspan=1 colspan=1>5.7%</td><td rowspan=1 colspan=1>7.9%</td><td rowspan=1 colspan=1>0.8%</td><td rowspan=1 colspan=1>8.5%</td></tr><tr><td rowspan=1 colspan=1>6.9%</td><td rowspan=1 colspan=1>11.3%</td><td rowspan=1 colspan=1>11.8%</td><td rowspan=1 colspan=1>12.2%</td><td rowspan=1 colspan=1>4.8%</td><td rowspan=1 colspan=1> 5.3%</td><td rowspan=1 colspan=1>6.0%</td><td rowspan=1 colspan=1>1.3%</td></tr><tr><td rowspan=1 colspan=1>2.6%</td><td rowspan=1 colspan=1>3.6%</td><td rowspan=1 colspan=1>3.5%</td><td rowspan=1 colspan=1>2.9%</td><td rowspan=1 colspan=1>4.0%</td><td rowspan=1 colspan=1>4.7%</td><td rowspan=1 colspan=1> 5.4%</td><td rowspan=1 colspan=1>3.9%</td></tr></table>
+
+Table 9: Rank-1 accuracy of LowKey small attacks on the UMDFaces dataset. After the first row, each row represents LowKey small attacks generated from the same model. Each column represents inference on a single model. The first two letters in the model’s name denote the type of backbone: IR or ResNet (RN). The last letter in the model’s name indicates the type of head; “A” denotes ArcFace, and “C” denotes CosFace. Smaller numbers, and lighter colors, indicate more successful attacks.
+
+# 8.6 GAUSSIAN SMOOTHING IN LOWKEY
+
+For the parameters of the Gaussian smoothing term in the optimization problem (1), we use 3 for $\sigma$ and 7 for window size. For the defensive Gaussian blur, we use $\sigma = 2$ and no window size.
+
+![](images/f96629cc280e06dd4286556160bdc259fd2bc6656c04a9b70ee142678fa2910c.jpg)  
+Figure 5: Panel of different attacks. First row: original images, second row: Fawkes attack, third row: LowKey small attack, last row: LowKey attack.
+
+Defender IR-50A IR-50C IR-152A IR-152C RN-50A RN-50C RN-152A RN-152C   
+
+<table><tr><td rowspan="2">Clean </td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>84.4%</td><td>85.3%</td><td>84.7%</td><td>86.1%</td><td>86.7%</td><td>87.9%</td><td>88.5%</td><td>89.6%</td></tr><tr><td>Aareeet Without GS</td><td>13.3%</td><td>17.9%</td><td>15.8%</td><td>13.7%</td><td>18.9%</td><td>20.4%</td><td>23.2%</td><td>20.6%</td></tr><tr><td>With GS</td><td>0.3%</td><td>0.3%</td><td>0.1%</td><td>0.0%</td><td>1.0%</td><td>0.9%</td><td>0.6%</td><td>0.6%</td></tr></table>
+
+Table 10: Rank-1 accuracy of FR models tested on blurred images attacked without and with the Gaussian smoothing term. The first two letters in the model’s name denote the type of backbone: IR or ResNet (RN). The last letter in the model’s name indicates the type of head; “A” denotes ArcFace, and “C” denotes CosFace. Smaller numbers, and lighter colors, indicate more successful attacks.

parse/train/hJmtwocEqzc/hJmtwocEqzc_content_list.json

@@ -0,0 +1,1623 @@
+[
+    {
+        "type": "text",
+        "text": "LOWKEY: LEVERAGING ADVERSARIAL ATTACKS TO PROTECT SOCIAL MEDIA USERS FROM FACIAL RECOGNITION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            825,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Valeriia Cherepanova Department of Mathematics University of Maryland vcherepa@umd.edu ",
+        "bbox": [
+            184,
+            195,
+            369,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Micah Goldblum Department of Computer Science University of Maryland goldblum@umd.edu ",
+        "bbox": [
+            589,
+            195,
+            810,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Harrison Foley∗   \nDepartment of Computer Science   \nUS Naval Academy   \nm211926@usna.edu   \nShiyuan Duan∗   \nDepartment of Computer Science   \nUniversity of Maryland   \nsduan1@umd.edu ",
+        "bbox": [
+            184,
+            272,
+            405,
+            328
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            593,
+            272,
+            813,
+            328
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "John Dickerson Department of Computer Science University of Maryland john@cs.umd.edu ",
+        "bbox": [
+            184,
+            349,
+            405,
+            405
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Gavin Taylor   \nDepartment of Computer Science   \nUS Naval Academy   \ntaylor@usna.edu ",
+        "bbox": [
+            593,
+            349,
+            813,
+            405
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tom Goldstein Department of Computer Science University of Maryland tomg@cs.umd.edu ",
+        "bbox": [
+            184,
+            428,
+            405,
+            482
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            520,
+            544,
+            535
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Facial recognition systems are increasingly deployed by private corporations, government agencies, and contractors for consumer services and mass surveillance programs alike. These systems are typically built by scraping social media profiles for user images. Adversarial perturbations have been proposed for bypassing facial recognition systems. However, existing methods fail on full-scale systems and commercial APIs. We develop our own adversarial filter that accounts for the entire image processing pipeline and is demonstrably effective against industrial-grade pipelines that include face detection and large scale databases. Additionally, we release an easy-to-use webtool that significantly degrades the accuracy of Amazon Rekognition and the Microsoft Azure Face Recognition API, reducing the accuracy of each to below $1 \\%$ . ",
+        "bbox": [
+            233,
+            547,
+            766,
+            700
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            726,
+            336,
+            742
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Facial recognition systems (FR) are widely deployed for mass surveillance by government agencies, government contractors, and private companies alike on massive databases of images belonging to private individuals (Hartzog, 2020; Derringer, 2019; Weise & Singer, 2020). Recently, these systems have been thrust into the limelight in the midst of outrage over invasion into personal life and concerns regarding fairness (Singer, 2018; Lohr, 2018; Cherepanova et al., 2021). Practitioners populate their databases by hoarding publicly available images from social media outlets, and so users are forced to choose between keeping their images outside of public view or taking their chances with mass surveillance. ",
+        "bbox": [
+            174,
+            756,
+            825,
+            867
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We develop a tool, LowKey, for protecting users from unauthorized surveillance by leveraging methods from the adversarial attack literature, and make it available to the public as a webtool. ",
+        "bbox": [
+            176,
+            875,
+            825,
+            902
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/a346e274e56b271a637b350791be3a6a07a832f3ce2439284095e282da8421d8.jpg",
+        "image_caption": [
+            "Figure 1: Top: original images, Bottom: protected by LowKey. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            101,
+            802,
+            253
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "LowKey is the first such evasion tool that is effective against commercial facial recognition APIs. Our system pre-processes user images before they are made publicly available on social media outlets so they cannot be used by a third party for facial recognition purposes. We establish the effectiveness of LowKey throughout this work. ",
+        "bbox": [
+            174,
+            305,
+            825,
+            361
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our contributions can be summarized as follows: ",
+        "bbox": [
+            173,
+            368,
+            495,
+            382
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We design a black-box adversarial attack on facial recognition models. Our algorithm moves the feature space representations of gallery faces so that they do not match corresponding probe images while preserving image quality.   \n• We interrogate the performance of our method on commercial black-box APIs, including Amazon Rekognition and Microsoft Azure Face, whose inner workings are not publicly known. We provide comprehensive comparisons with the existing data poisoning alternative, Fawkes (Shan et al., 2020), and we find that while Fawkes is ineffective in every experiment, our method consistently prevents facial recognition.   \n• We release an easy-to-use webtool, LowKey, so that social media users are no longer confronted with a choice between withdrawing their social media presence from public view and risking the repercussions of being surveilled. ",
+        "bbox": [
+            217,
+            395,
+            825,
+            559
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            579,
+            344,
+            594
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Neural networks are known to be vulnerable to adversarial attacks, small perturbations to inputs that do not change semantic content, and yet cause the network to misbehave (Goodfellow et al., 2014). The adversarial attack literature has largely focused on developing new algorithms that, in simulations, are able to fool neural networks (Carlini & Wagner, 2017; Chiang et al., 2020). Most works to date focus on the idea of physical world attacks, in which the attacker places adversarial patterns on an object in hopes that the adversarial properties transfer to an image of the object. Such attacks do not succeed reliably because the adversarial perturbation must survive imaging under various lighting conditions, object orientations, and occlusions (Kurakin et al., 2016). While researchers have succeeded in crafting such attacks against realistic systems, these attacks do not work consistently across environments (Wu et al., 2019; Xu et al., 2019; Goldblum et al., 2020). In facial recognition, attacks have largely focused on physical backdoor threat models, evasion attacks on verification (Wenger et al., 2020; Zhong & Deng, 2020) and attacks on face detection (Pedraza et al., 2018). Unlike these physical threat models, the setting in which we operate is purely digital, meaning that we can manipulate the contents of digital media at the bit level, and then hand manipulated data directly to a machine learning system. The ability to digitally manipulate media greatly simplifies the task of attacking a system, and has been shown to enhance transferability to black box industrial systems for applications like copyright detection (Saadatpanah et al., 2020) and financial time series analysis (Goldblum et al., 2020). ",
+        "bbox": [
+            174,
+            611,
+            826,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recently, the Fawkes algorithm was developed for preventing social media images from being used by unauthorized facial recognition systems (Shan et al., 2020). However, Fawkes, along with the experimental setup on which it is evaluated in the original work, suffers from critical problems. First, Fawkes assumes that facial recognition practitioners train their models on each individual’s data. ",
+        "bbox": [
+            176,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "However, high-performance FR systems instead harness large pre-trained Siamese networks (Liu et al., 2017; Deng et al., 2019). Second, the authors primarily use image classifiers. In contrast, commercial systems are trained with FR-specific heads and loss functions, as opposed to the standard cross-entropy loss used by classifiers. Third, the authors perform evaluations on very small datasets. Specifically, they test Fawkes against commercial APIs with a gallery containing only 50 images. Fourth, the system was only evaluated using top-1 accuracy, but FR users such as police departments often compile a list of suspects rather than a single individual. As a result, other metrics like top-50 accuracy are often used in facial recognition, and are a more realistic metric for when a system has been successfully suppressed. Fifth, while the original work portrays Fawkes’ perturbations are undetectable by the human eye, experience with the codebase suggests the opposite (indeed, a New York Times journalist likewise noted that the Fawkes images she was shown during a demonstration were visibly heavily distorted). Finally, Fawkes has not yet released an app or a webtool, and regular social media users are unlikely to make use of git repositories. Our attack avoids the aforementioned limitations, and we perform thorough evaluations on a large collection of images and identities. When comparing with Fawkes, we use the authors’ own implementation in order to make sure that all evaluations are fair. Furthermore, we use Fawkes’ highest protection setting to make sure that LowKey performs better than Fawkes’ best attack. Another work uses targeted adversarial attack on probe images for facial recognition systems so that they cannot be matched with images in a database (Yang et al., 2020). ",
+        "bbox": [
+            173,
+            103,
+            826,
+            367
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 THE LOWKEY ATTACK ON MASS SURVEILLANCE ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            392,
+            617,
+            409
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/8bda533542dd9c8688ace3b8e37721f1adf73d359cdb70ba0f55672c72ff6fed.jpg",
+        "image_caption": [
+            "Figure 2: The LowKey pipeline. When users protect their publicly available images with LowKey, facial recognition systems cannot match these harvested images with new images of the user, for example from surveillance cameras. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            433,
+            787,
+            675
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 PROBLEM SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            768,
+            333,
+            784
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To help make our work more widely accessible, we begin by introducing common facial recognition terms. ",
+        "bbox": [
+            174,
+            796,
+            823,
+            825
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Gallery images are database images with known identities. These often originate from such sources as passport photos and social media profiles. The gallery is used as a reference for comparing new images. ",
+        "bbox": [
+            174,
+            832,
+            825,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Probe images are new photos whose subject the FR system user wants to identify. For example, probe images may be extracted from video surveillance footage. The extracted images are then fed into the FR system, and matches to gallery images with known identities. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Identification is the task of answering the question, “who is this person?” Identification entails comparing a probe image to gallery images in order to find potential matches. In contrast, verification answers the question, “is this person who they say they are?”, or equivalently “are these two photos of the same person?” Verification is used, for example, to unlock phones. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In our work, we focus on identification, which can be used for mass surveillance. State-of-the-art facial recognition systems first detect and align faces before extracting facial features from the probe image using a neural network. These systems then find gallery images with the closest feature vectors using a $k$ -nearest neighbors search. The matched gallery images are then considered as likely identities corresponding to the person in the probe photo. LowKey applies a filter to user images which may end up in an organization’s database of gallery images. The result is to corrupt the gallery feature vectors so that they will not match feature vectors corresponding to the user’s probe images. A visual depiction of the LowKey pipeline can be found in Figure 2. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            279
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 THE LOWKEY ATTACK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            303,
+            372,
+            318
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "LowKey manipulates potential gallery images so that they do not match probe images of the same person. LowKey does this by generating a perturbed image whose feature vector lies far away from the original image, while simultaneously minimizing a perceptual similarity loss between the original and perturbed image. Maximizing the distance in feature space prevents the image from matching other images of the individual, while the perceptual similarity loss prevents the image quality from degrading. In this section, we formulate the optimization problem, and describe a number of important details. ",
+        "bbox": [
+            174,
+            332,
+            825,
+            430
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "LowKey is designed to evade proprietary FR systems that contain pre-processing steps and neural network backbones that are not publicly known. In order to improve the transferability of our attack to unknown facial recognition systems, LowKey simultaneously attacks an ensemble of models with various backbone architectures that are produced using different training algorithms. Additionally, for each model in the ensemble, the objective function considers the locations of feature vectors of the attacked image both with and without a Gaussian blur. We find that this technique improves both the appearance and transferability of attacked images. Experiments and ablations concerning ensembling and Gaussian smoothing can be found in Section 6. For perceptual similarity loss, we use LPIPS, a metric based on $\\ell _ { 2 }$ distance in the feature space of an ImageNet-trained feature extractor (Zhang et al., 2018). LPIPS has been used effectively in the image classification setting to improve the image quality of adversarial examples (Laidlaw et al., 2020). ",
+        "bbox": [
+            174,
+            436,
+            825,
+            590
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Formally, the optimization problem we solve is ",
+        "bbox": [
+            174,
+            597,
+            483,
+            611
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bfbf77cb69fbfb59f7fec9c5f47900818729c702fe750a436a3a8f0beebf4ecd.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { x ^ { \\prime } } \\frac { 1 } { 2 n } \\sum _ { i = 1 } ^ { n } \\widetilde { \\frac { \\| f _ { i } ( A ( x ) ) - f _ { i } ( A ( x ^ { \\prime } ) ) \\| _ { 2 } ^ { 2 } } { \\| f _ { i } ( A ( x ) ) \\| _ { 2 } } } + \\widetilde { \\| f _ { i } ( A ( x ) ) - f _ { i } ( A ( G ( x ^ { \\prime } ) ) ) \\| _ { 2 } ^ { 2 } } - \\alpha \\underbrace { \\mathrm { L P I P S } ( x , x ^ { \\prime } ) } _ { \\mathrm { n e c e a n n a l 1 o s } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            191,
+            638,
+            789,
+            685
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $x$ is the original image, $x ^ { \\prime }$ is the perturbed image, $f _ { i }$ denotes the $i ^ { t h }$ model in our ensemble, $G$ is the Gaussian smoothing function with fixed parameters, and $A$ denotes face detection and extraction followed by $1 1 2 \\times 1 1 2$ resizing and alignment. The face detection step is an important part of the LowKey objective function, as commercial systems rely on face detection and extraction because probe images often contain a scene much larger than a face, or else contain a face who’s alignment is not compatible with the face recognition system. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            797
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We solve this maximization problem iteratively with signed gradient ascent, which is known to be highly effective for breaking common image classification systems (Madry et al., 2017). Namely, we iteratively update $x ^ { \\prime }$ by adding the sign of the gradient of the maximization objective (1) with respect to $x ^ { \\prime }$ . By doing this, we move $x ^ { \\prime }$ and $G ( x ^ { \\prime } )$ far away from the original image $x$ in the feature spaces of models $f _ { i }$ used in the LowKey ensemble. The ensemble contains four feature extractors, IR-152 and ResNet-152 backbones trained with ArcFace and CosFace heads. More details can be found in the next section. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            901
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Additional details concerning attack hyperparameters can be found in Appendix 8.1. ",
+        "bbox": [
+            173,
+            909,
+            723,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL DESIGN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            408,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our ensemble of models contains ArcFace and CosFace facial recognition systems (Deng et al., 2019; Wang et al., 2018). For each of these systems, we train ResNet-50, ResNet-152, IR-50, and IR-152 backbones on the MS-Celeb-1M dataset, which contains over five million images from over 85,000 identities (He et al., 2016; Deng et al., 2019; Guo et al., 2016). We use these models both in our ensemble to generate attacks and to perform controlled experiments in Section 6. Additional details on our models and their training routines can be found in Appendix 8.1. ",
+        "bbox": [
+            174,
+            136,
+            825,
+            219
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We primarily test our attacks on the FaceScrub dataset, a standard identification benchmark from the MegaFace challenge, which contains over 100,000 images from 530 known identities as well as one million distractor images (Kemelmacher-Shlizerman et al., 2016). We discard near-duplicate images from the dataset as is common practice in the facial recognition literature (Zhang et al., 2020). We also perform experiments on the UMDFaces dataset, which can be found in Appendix 8.3 (Bansal et al., 2017). We treat one tenth of each identity’s images as probe images, and we insert the remaining images into the gallery. We randomly select 100 identities and apply LowKey to each of their gallery images. This setting simulates a small pool of LowKey users among a larger population of non-users. Then, in order to perform a single evaluation trial of identification, we randomly sample one probe image from a known identity and find its closest matches within the remainder of the FaceScrub dataset, according to the facial recognition model. Distance is measured in feature space of the model. If the FR model selects a match from the same identity, then the trial is a success. ",
+        "bbox": [
+            173,
+            227,
+            825,
+            393
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note 1 (Rank- $k$ Accuracy). For each probe image, we consider the model successful in the rank- $k$ setting if the correct identity appears among the k closest gallery images in the model’s feature space. To test the transferability of our attack we compute rank-1 and rank-50 accuracy for attack, and test feature extractors from our set of trained FR models. ",
+        "bbox": [
+            173,
+            400,
+            825,
+            457
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 BREAKING COMMERCIAL BLACK-BOX APIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            481,
+            580,
+            497
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The ultimate test for our protection tool is against commercial systems. These systems are proprietary, and their exact specifications are not publicly available. We test LowKey in the black-box setting using two commercial facial recognition APIs: Amazon Rekognition and Microsoft Azure Face. We also compare against Fawkes. We generate Fawkes images using the authors’ own code and hyperparameters to ensure a fair comparison, and we use the highest protection setting their code offers. ",
+        "bbox": [
+            173,
+            515,
+            825,
+            598
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Amazon Rekognition Amazon Rekognition is a commercial tool for detecting and recognizing faces in photos. Rekognition works by matching probe images with uploaded gallery images that have known labels. Amazon does not describe how their algorithm works, but their approach seemingly does not involve training a model on uploaded images (at least not in a supervised manner). We test the Rekognition API using the FaceScrub dataset (including distractors) where 100 randomly selected identities have their images attacked as described in Section 4. We observe that LowKey is highly effective, and even in the setting of rank-50 accuracy, Rekognition can only recognize $2 . 4 \\%$ of probe images belonging to users protected with LowKey. In contrast, Fawkes fails, with $7 7 . 5 \\%$ of probe images belonging to its users recognized correctly in the rank-1 setting and $9 4 . 9 \\%$ of these images recognized correctly when the 50 closest matches are considered. This is close to the performance of Amazon Rekognition on clean images. ",
+        "bbox": [
+            173,
+            606,
+            825,
+            758
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/7ca12fba23fefb5998f13d0f2442fc584fad8a5b6d1b23bb5265854965019c5b.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Amazon rank-1</td><td>Amazon rank-50</td><td>Microsoft rank-1</td></tr><tr><td>Clean -</td><td>93.7%</td><td>95.4%</td><td>90.5%</td></tr><tr><td>Fawkes -</td><td>77.5%</td><td>94.9%</td><td>74.2%</td></tr><tr><td>LowKey-</td><td>0.6%</td><td>2.4%</td><td>0.1%</td></tr></table>",
+        "bbox": [
+            235,
+            784,
+            759,
+            864
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 1: An evaluation of Amazon Rekognition and Microsoft Azure Face on FaceScrub data with LowKey and Fawkes protection (a small number, and lighter color, indicates a successful attack). LowKey consistently achieves virtually flawless protection, while Fawkes provides little protection. ",
+        "bbox": [
+            173,
+            878,
+            826,
+            921
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Microsoft Azure Face We repeat a similar experiment on the Microsoft Azure Facial Recognition API. In contrast to Amazon’s API, Microsoft updates their model on the uploaded gallery of images. Therefore, only known identities can be used, so we only include images corresponding to the 530 known identities from FaceScrub and no distractors. The Azure system recognizes only $0 . 1 \\%$ of probe images whose gallery images are under the protection of LowKey. Even though Fawkes is designed to perform data poisoning, and authors claim it is especially well suited to Microsoft Azure Face, in our experiments, Azure is still able to recognize more than $74 \\%$ of probe images uploaded by users who employ Fawkes. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We conclude from these experiments that LowKey is both highly effective and transferable to even state-of-the-art industrial facial recognition systems. In the next section, we explore several components of our attack in order to uncover the tools of its success. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            263
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 ADDITIONAL EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            285,
+            439,
+            301
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The effectiveness of our protection tool hinges on several properties: ",
+        "bbox": [
+            173,
+            318,
+            622,
+            333
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1. The attack must transfer effectively to unseen models.   \n2. Images must look acceptable to users.   \n3. LowKey must run sufficiently fast so that run-time does not outweigh its protective benefits.   \n4. Attacked images must remain effective after being saved in PNG and JPG formats.   \n5. The algorithm must scale to images of any size. ",
+        "bbox": [
+            210,
+            344,
+            826,
+            440
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We conduct extensive experiments in this section with a variety of facial recognition systems to interrogate these properties of LowKey. ",
+        "bbox": [
+            174,
+            452,
+            825,
+            479
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6.1 ENSEMBLES AND TRANSFERABILITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            497,
+            470,
+            512
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In developing the ensemble of models used to compute our attack, we examine the extent to which attacks generated by one model are effective against another. By including an eclectic mix of models in our ensemble, we are able to ensure that LowKey produces images that fool a wide variety of facial recognition systems. To this end, we evaluate attacks on all pairs of source and victim models with ResNet-50, ResNet-152, IR-50, and IR-152 backbones, and both ArcFace and CosFace heads. For each victim model, we additionally measure performance on clean images, our ensembled attack, and Fawkes. See Table 2 for a comparison of the rank-50 performance of these combinations. Additional evaluations in the rank-1 setting and on the UMDFaces dataset can be found in Appendix 8.2 and 8.3 respectively. Note that entries for which the attacker and defender models are identical depict white-box performance, while entries for which these model differ depict black-box transferability. ",
+        "bbox": [
+            174,
+            523,
+            825,
+            662
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We observe in these experiments that adversarial attacks generated by IR architectures transfer better to IR-based facial recognition systems, while attacks generated by ResNet architectures transfer better to other ResNet systems. In general, attacks computed on 152-layer backbones are more effective than attacks computed on 50-layer backbones, and deeper networks are also more difficult to fool. Moreover, attacks transfer better between models trained with the same head. An ensemble of models of all combinations of ResNet-152 and IR-152 backbones as well as ArcFace and CosFace heads generates attacks that transfer effectively to all models and fool models at only a slightly lower rate than white-box attacks. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            781
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6.2 GAUSSIAN SMOOTHING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            799,
+            380,
+            814
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We incorporate Gaussian smoothing as a pre-processing step in our objective function (1) to make our perturbations smoother and more robust. Intuitively, this promotes the effectiveness of the attacked image even when a denoising filter is applied. The presence of blur forces the adversarial perturbation to rely on smoother/low-frequency image modifications rather than adversarial “noise.” Empirically, we find that attacks computed with this procedure produce slightly smoother and more aesthetically pleasing perturbations without sharp lines and high-frequency oscillations. See Figure 3 for a visual comparison of images produced with and without Gaussian smoothing in the LowKey pipeline. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/0d3ebd799e6f63e2c952a22614ec963a5d9fca54b650dcb6979979dd8043323c.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td rowspan=1 colspan=1>96.8%</td><td rowspan=1 colspan=1>96.8%</td><td rowspan=1 colspan=1>96.7%</td><td rowspan=1 colspan=4>96.8%  96.8%  96.8%  96.7%</td><td rowspan=1 colspan=1>96.7%</td></tr><tr><td></td><td rowspan=1 colspan=1>96.6%</td><td rowspan=1 colspan=1>96.7%</td><td rowspan=1 colspan=1>96.7%</td><td rowspan=1 colspan=1>96.7%</td><td rowspan=1 colspan=1>96.7%</td><td rowspan=1 colspan=1>96.5%</td><td rowspan=1 colspan=1>96.6%</td><td rowspan=1 colspan=1>96.6%</td></tr><tr><td></td><td rowspan=1 colspan=1>0.4%</td><td rowspan=1 colspan=1>22.2%</td><td rowspan=1 colspan=1>11.9%</td><td rowspan=1 colspan=1>35.2%</td><td rowspan=1 colspan=1>33.6%</td><td rowspan=1 colspan=1>46.4%</td><td rowspan=1 colspan=1>45.7%</td><td rowspan=1 colspan=1>53.0%</td></tr><tr><td></td><td rowspan=1 colspan=1>4.9%</td><td rowspan=1 colspan=1>0.3%</td><td rowspan=1 colspan=1>4.1%</td><td rowspan=1 colspan=1>8.0%</td><td rowspan=1 colspan=1>23.1%</td><td rowspan=1 colspan=1>25.9%</td><td rowspan=1 colspan=1>31.4%</td><td rowspan=1 colspan=1>28.6%</td></tr><tr><td></td><td rowspan=1 colspan=1>9.9%</td><td rowspan=1 colspan=1>18.3%</td><td rowspan=1 colspan=1>0.1%</td><td rowspan=1 colspan=1>26.1%</td><td rowspan=1 colspan=1>41.6%</td><td rowspan=1 colspan=1>46.2%</td><td rowspan=1 colspan=1>49.6%</td><td rowspan=1 colspan=1>48.9%</td></tr><tr><td></td><td rowspan=1 colspan=1>2.8%</td><td rowspan=1 colspan=1>1.6%</td><td rowspan=1 colspan=1>1.5%</td><td rowspan=1 colspan=1>0.5%</td><td rowspan=1 colspan=1>11.9%</td><td rowspan=1 colspan=1>13.9%</td><td rowspan=1 colspan=1>18.8%</td><td rowspan=1 colspan=1>16.3%</td></tr><tr><td></td><td rowspan=1 colspan=1>26.4%</td><td rowspan=1 colspan=1>35.7%</td><td rowspan=1 colspan=1>36.3%</td><td rowspan=1 colspan=1>43.0%</td><td rowspan=1 colspan=1>0.9%</td><td rowspan=1 colspan=1>13.3%</td><td rowspan=1 colspan=1>17.4%</td><td rowspan=1 colspan=1>24.2%</td></tr><tr><td></td><td rowspan=1 colspan=1>33.8%</td><td rowspan=1 colspan=1>36.5%</td><td rowspan=1 colspan=1>41.1%</td><td rowspan=1 colspan=1>42.9%</td><td rowspan=1 colspan=1>9.9%</td><td rowspan=1 colspan=1>0.2%</td><td rowspan=1 colspan=1>17.9%</td><td rowspan=1 colspan=1>21.1%</td></tr><tr><td></td><td rowspan=1 colspan=1>16.8%</td><td rowspan=1 colspan=1>22.0%</td><td rowspan=1 colspan=1>21.1%</td><td rowspan=1 colspan=1>28.2%</td><td rowspan=1 colspan=1>5.2%</td><td rowspan=1 colspan=1>8.8%</td><td rowspan=1 colspan=1>0.3%</td><td rowspan=1 colspan=1>7.6%</td></tr><tr><td rowspan=2 colspan=1>RN-152C-Ensemble</td><td rowspan=1 colspan=1>14.8%</td><td rowspan=1 colspan=1>19.2%</td><td rowspan=1 colspan=1>19.9%</td><td rowspan=1 colspan=1>24.3%</td><td rowspan=1 colspan=1>6.7%</td><td rowspan=1 colspan=1>6.9%</td><td rowspan=1 colspan=1>7.1%</td><td rowspan=1 colspan=1>0.5%</td></tr><tr><td rowspan=1 colspan=1> 3.0%</td><td rowspan=1 colspan=1>2.4%</td><td rowspan=1 colspan=1>2.1%</td><td rowspan=1 colspan=1>0.6%</td><td rowspan=1 colspan=1> 3.1%</td><td rowspan=1 colspan=1> 4.2%</td><td rowspan=1 colspan=1> 5.5%</td><td rowspan=1 colspan=1>0.9%</td></tr></table>",
+        "bbox": [
+            202,
+            99,
+            792,
+            324
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Rank-50 accuracy of the LowKey and Fawkes attacks. After the first two rows, each row represents LowKey attacks generated from the same model. Each column represents inference on a single model. The first two letters in the model’s name denote the type of backbone: IR or ResNet (RN). The last letter in the model’s name indicates the type of head; “A” denotes ArcFace, and “C” denotes CosFace. Smaller numbers, and lighter colors, indicate more successful attacks. ",
+        "bbox": [
+            173,
+            338,
+            826,
+            409
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We additionally produce images both with and without smoothing in the attack pipeline. Before feeding them into facial recognition systems, we defend the system against our attacks by applying a Gaussian smoothing pre-processing step just before inference. ",
+        "bbox": [
+            174,
+            440,
+            823,
+            483
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We find that facial recognition systems which use this pre-processing step perform equally well on rank-50 (but not rank-1) accuracy compared to performance without smoothing, and they are also able to defeat attacks which are not computed with Gaussian smoothing. On the other hand, attacks computed using Gaussian smoothing are able to counteract this defense and fool the facial recognition system (see Table 3). This suggests that attacks that use Gaussian smoothing in their pipeline are more robust and harder to defend against. See Appendix 8.6 for details regarding Gaussian smoothing hyperparameters. ",
+        "bbox": [
+            173,
+            491,
+            825,
+            588
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.3 RUN-TIME ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            613,
+            289,
+            627
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In order for users to be willing to use our tool, LowKey must run fast enough that it is not an inconvenience to use. Computing adversarial attacks is a computationally expensive task. We compare run-time to Fawkes as a baseline and test both attacks on a single NVIDIA GeForce RTX 2080 TI GPU. We attack one image at a time with no batching for fair comparison, and we average over runs on every full-size gallery image from each of five randomly selected identities from FaceScrub. While Fawkes averages 54 seconds per image, LowKey only averages 32 seconds per image. In addition to providing far superior protection, LowKey runs significantly faster than the existing method, providing users a smoother and more convenient experience. ",
+        "bbox": [
+            173,
+            642,
+            825,
+            753
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/8e04471b0215a801dcb12a49f292ac22c6de6d479188c0a674ed9c6f770524f8.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"10\">Defender IR-50A IR-50C</td></tr><tr><td></td><td>Clean</td><td>96.7% 96.8%</td><td>IR-152A 96.6%</td><td></td><td>IR-152C 96.9%</td><td>RN-50A 96.7%</td><td>96.7%</td><td>RN-50C RN-152A RN-152C 96.7%</td><td>96.7%</td></tr><tr><td>AAreeet Without GS </td><td>78.6%</td><td>74.0%</td><td>74.4%</td><td>64.6%</td><td>75.5%</td><td>76.0%</td><td>77.8%</td><td>74.2%</td></tr><tr><td>With GS</td><td>4.2%</td><td>4.8%</td><td>4.4%</td><td>2.8%</td><td>7.9%</td><td>7.1%</td><td>9.6%</td><td>3.2%</td></tr></table>",
+        "bbox": [
+            202,
+            782,
+            794,
+            880
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Rank-50 accuracy of FR models tested on blurred LowKey images computed with/without Gaussian smoothing. ",
+        "bbox": [
+            174,
+            892,
+            825,
+            921
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/9269723de086f2ad1a2c16403f94f956472db7a3f092652514c49a9e95d8d810.jpg",
+        "image_caption": [
+            "Figure 3: LowKey attacked images computed without (above) and with (below) Gaussian smoothing. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            297,
+            101,
+            699,
+            253
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.4 ROBUSTNESS TO IMAGE COMPRESSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            306,
+            486,
+            319
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Since users may save their images in various formats after passing them through LowKey, the images we produce must provide protection even after being saved in common formats. Our baseline tests are conducted with images saved in uncompressed PNG format. To test performance under compression, we convert protected images to JPEG format and repeat our experiments on commercial APIs. While compression very slightly decreases performance, the attack is still very effective: Microsoft Azure Face is now able to recognize $0 . 2 \\%$ of images compared to $0 . 1 \\%$ when saved in the PNG format. Likewise, Amazon Rekognition now recognizes $3 . 8 \\%$ of probe images compared to $2 . 4 \\%$ previously. ",
+        "bbox": [
+            174,
+            332,
+            825,
+            430
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.5 SCALABILITY TO ALL IMAGE SIZES (DISCLAIMER) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            448,
+            571,
+            462
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Many tools in deep learning require that inputs be of particular dimensions, but user images on social media sites come in all shapes and sizes. Therefore, LowKey must be flexible. Since the detection and alignment pipeline in our attack resizes images in a differentiable fashion, we can attack images of any size and aspect ratio. Additionally, we apply the LPIPS penalty to the entire original image, which prevents box-shaped artifacts from developing on the boundaries of the rectangle containing the face. Since LowKey does not have a fixed attack budget, perturbations may have different magnitudes on different images. Figure 4 shows the variability of LowKey perturbations on very large images; the image of Tom Hanks (first column) is one of the best looking examples of LowKey on large images, while the image of Tina Fey (last column) is one of the worst looking examples. Protecting very large images is a more challenging task than protecting small images because of the black-box detection, alignment, and re-scaling used in APIs which affect large images more significantly. These experiments indicate that users will receive stronger protection if they use LowKey on smaller images. ",
+        "bbox": [
+            174,
+            473,
+            825,
+            640
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We test the effectiveness of LowKey on large images by protecting gallery images of 10 identities from Facescrub (with 17 images in the gallery on average) and using 20 probe images per person. We also vary the magnitude of the perturbation to find the smallest perturbation that is sufficient to protect images (Table 4). In this way, we find that users may trade off some protection in exchange for better looking images at their own discretion. Additionally, we find that LowKey works much better with smaller gallery sizes; when only 5 gallery images are used, the performance of Amazon Rekognition drops from $3 2 . 5 \\%$ to $11 \\%$ in the rank-50 setting. This observation suggests that users can upload new profile pictures less frequently in order to decrease the number of gallery images corresponding to their identity and thus enhance their protection. Finally, the quality of probe images is also important; when small probe images are used, like those which would occur in low resolution security camera footage, the accuracy of Amazon Rekognition drops from $3 2 . 5 \\%$ to $19 \\%$ . ",
+        "bbox": [
+            174,
+            647,
+            825,
+            800
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            821,
+            310,
+            838
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this work, we develop a tool for protecting users from unauthorized facial recognition. Our tool adversarially pre-processes user images before they are uploaded to social media. These pre-processed images are useless for third-party organizations who collect them for facial recognition. While we have shown that LowKey is highly effective against commercial black-box APIs, it does not protect users $100 \\%$ of the time and may be circumvented by specially engineered robust systems. Thus, we hope that users will still remain cautious about publicly revealing personal information. One interesting future direction is to produce adversarial filters that are more aesthetically pleasing in order to promote wider use of this tool. However, it may be that there is no free lunch, and one cannot fool state-of-the-art facial recognition systems without visible perturbations. Facial recognition systems are not fragile, and other attacks that have attempted to break them have failed. Finally, we note that one of our goals in making this tool widely available is to promote broader awareness of facial recognition and the ethical issues it raises. Our webtool can be found at lowkey.umiacs.umd.edu. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/b7f3e5b3bb1f2b492b0e8ca24ca7ff45f66fd286889e5f16f576def2574e3088.jpg",
+        "image_caption": [
+            "Figure 4: First row: Original large images, Second row: Images protected with LowKey (medium magnitude), Third row: Images protected with LowKey (large magnitude). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            101,
+            818,
+            558
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/c4dfc8e7ebebe64246fae893deb2af1698c8038c6e60815e4895cf0de8f52bda.jpg",
+        "table_caption": [
+            "Table 4: Evaluation of LowKey on full-size images. Rows indicate levels of magnitude of LowKey (denoted by the number of attack steps). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Amazon rank-1</td><td>Amazon rank-50</td><td>Microsoft rank-1</td></tr><tr><td>Clean </td><td>89.0%</td><td>98.5%</td><td>86.0%</td></tr><tr><td>LowKey 10</td><td>63.0%</td><td>94.5%</td><td>75.5%</td></tr><tr><td>LowKey 20-</td><td>34.0%</td><td>59.5%</td><td>30.5%</td></tr><tr><td>LowKey 30 -</td><td>20.5%</td><td>36.5%</td><td>12.7%</td></tr><tr><td>LowKey 40 -</td><td>14.5%</td><td>36.0%</td><td>3.0%</td></tr><tr><td>LowKey 50</td><td>11.0%</td><td>32.5%</td><td>0.0%</td></tr></table>",
+        "bbox": [
+            235,
+            614,
+            759,
+            751
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            356,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work was supported by the DARPA GARD and DARPA QED programs. Further support was provided by the AFOSR MURI program, and the National Science Foundation’s DMS division. Computation resources were funded by the Sloan Foundation. ",
+        "bbox": [
+            176,
+            132,
+            826,
+            175
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            195,
+            285,
+            212
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ankan Bansal, Anirudh Nanduri, Carlos D Castillo, Rajeev Ranjan, and Rama Chellappa. Umdfaces: An annotated face dataset for training deep networks. In 2017 IEEE International Joint Conference on Biometrics (IJCB), pp. 464–473. IEEE, 2017. ",
+        "bbox": [
+            174,
+            219,
+            826,
+            262
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In 2017 ieee symposium on security and privacy (sp), pp. 39–57. IEEE, 2017. ",
+        "bbox": [
+            174,
+            270,
+            823,
+            299
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Valeriia Cherepanova, Vedant Nanda, Micah Goldblum, John P Dickerson, and Tom Goldstein. Technical challenges for training fair neural networks. arXiv preprint arXiv:2102.06764, 2021. ",
+        "bbox": [
+            176,
+            308,
+            821,
+            337
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ping-Yeh Chiang, Jonas Geiping, Micah Goldblum, Tom Goldstein, Renkun Ni, Steven Reich, and Ali Shafahi. Witchcraft: Efficient pgd attacks with random step size. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 3747–3751. IEEE, 2020. ",
+        "bbox": [
+            174,
+            344,
+            826,
+            401
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jiankang Deng, Jia Guo, Niannan Xue, and Stefanos Zafeiriou. Arcface: Additive angular margin loss for deep face recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4690–4699, 2019. ",
+        "bbox": [
+            173,
+            410,
+            826,
+            453
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "William Derringer. A surveillance net blankets china’s cities, giving police vast powers. The New York Times, Dec. 17 2019. URL https://www.nytimes.com/2019/12/17/technology/ china-surveillance.html. ",
+        "bbox": [
+            173,
+            462,
+            826,
+            505
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Micah Goldblum, Avi Schwarzschild, Naftali Cohen, Tucker Balch, Ankit B Patel, and Tom Goldstein. Adversarial attacks on machine learning systems for high-frequency trading. arXiv preprint arXiv:2002.09565, 2020. ",
+        "bbox": [
+            173,
+            512,
+            825,
+            555
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014. ",
+        "bbox": [
+            169,
+            564,
+            825,
+            593
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yandong Guo, Lei Zhang, Yuxiao Hu, Xiaodong He, and Jianfeng Gao. Ms-celeb-1m: A dataset and benchmark for large-scale face recognition. In European conference on computer vision, pp. 87–102. Springer, 2016. ",
+        "bbox": [
+            174,
+            602,
+            825,
+            643
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Woodrow Hartzog. The secretive company that might end privacy as we know it. The New York Times, Jan. 18 2020. URL https://www.nytimes.com/2020/01/18/technology/ clearview-privacy-facial-recognition.html. ",
+        "bbox": [
+            176,
+            652,
+            825,
+            695
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            173,
+            703,
+            825,
+            746
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ira Kemelmacher-Shlizerman, Steven M Seitz, Daniel Miller, and Evan Brossard. The megaface benchmark: 1 million faces for recognition at scale. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4873–4882, 2016. ",
+        "bbox": [
+            173,
+            755,
+            825,
+            799
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016. ",
+        "bbox": [
+            171,
+            806,
+            825,
+            835
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Cassidy Laidlaw, Sahil Singla, and Soheil Feizi. Perceptual adversarial robustness: Defense against unseen threat models. arXiv preprint arXiv:2006.12655, 2020. ",
+        "bbox": [
+            171,
+            843,
+            825,
+            873
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollar. Focal loss for dense object ´ detection. In Proceedings of the IEEE international conference on computer vision, pp. 2980–2988, 2017. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Weiyang Liu, Yandong Wen, Zhiding Yu, Ming Li, Bhiksha Raj, and Le Song. Sphereface: Deep hypersphere embedding for face recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 212–220, 2017. ",
+        "bbox": [
+            176,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Steve Lohr. Facial recognition is accurate, if you’re a white guy. New York Times, 9, 2018. ",
+        "bbox": [
+            169,
+            160,
+            764,
+            175
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017. ",
+        "bbox": [
+            176,
+            189,
+            826,
+            231
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel Pedraza, Dhaval Adjodah, Gretchen Greene, Josh Joseph, Thom Miano, and Francisco. Equalais. https://equalais.media.mit.edu/, 2018. ",
+        "bbox": [
+            176,
+            246,
+            825,
+            275
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Parsa Saadatpanah, Ali Shafahi, and Tom Goldstein. Adversarial attacks on copyright detection systems. In International Conference on Machine Learning, pp. 8307–8315. PMLR, 2020. ",
+        "bbox": [
+            173,
+            289,
+            825,
+            318
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shawn Shan, Emily Wenger, Jiayun Zhang, Huiying Li, Haitao Zheng, and Ben Y Zhao. Fawkes: Protecting privacy against unauthorized deep learning models. In 29th {USENIX} Security Symposium ({USENIX} Security 20), pp. 1589–1604, 2020. ",
+        "bbox": [
+            174,
+            332,
+            826,
+            375
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Natasha Singer. Microsoft urges congress to regulate use of facial recognition. The New York Times, 2018. ",
+        "bbox": [
+            173,
+            388,
+            825,
+            416
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hao Wang, Yitong Wang, Zheng Zhou, Xing Ji, Dihong Gong, Jingchao Zhou, Zhifeng Li, and Wei Liu. Cosface: Large margin cosine loss for deep face recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5265–5274, 2018. ",
+        "bbox": [
+            174,
+            431,
+            826,
+            474
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karen Weise and Natasha Singer. Amazon pauses police use of its facial recognition software. The New York Times, Jul. 10 2020. URL https://www.nytimes.com/2020/06/10/ technology/amazon-facial-recognition-backlash.html. ",
+        "bbox": [
+            174,
+            488,
+            825,
+            531
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Emily Wenger, Josephine Passananti, Yuanshun Yao, Haitao Zheng, and Ben Y Zhao. Backdoor attacks on facial recognition in the physical world. arXiv preprint arXiv:2006.14580, 2020. ",
+        "bbox": [
+            173,
+            545,
+            823,
+            574
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zuxuan Wu, Ser-Nam Lim, Larry Davis, and Tom Goldstein. Making an invisibility cloak: Real world adversarial attacks on object detectors. arXiv preprint arXiv:1910.14667, 2019. ",
+        "bbox": [
+            171,
+            587,
+            826,
+            616
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaidi Xu, Gaoyuan Zhang, Sijia Liu, Quanfu Fan, Mengshu Sun, Hongge Chen, Pin-Yu Chen, Yanzhi Wang, and Xue Lin. Adversarial t-shirt! evading person detectors in a physical world. arXiv, pp. arXiv–1910, 2019. ",
+        "bbox": [
+            174,
+            631,
+            825,
+            672
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiao Yang, Yinpeng Dong, Tianyu Pang, Jun Zhu, and Hang Su. Towards privacy protection by generating adversarial identity masks. arXiv preprint arXiv:2003.06814, 2020. ",
+        "bbox": [
+            173,
+            686,
+            823,
+            717
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kai Zhang, V´ıtor Albiero, and Kevin W Bowyer. A method for curation of web-scraped face image datasets. In 2020 8th International Workshop on Biometrics and Forensics (IWBF), pp. 1–6. IEEE, 2020. ",
+        "bbox": [
+            174,
+            731,
+            825,
+            772
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard Zhang, Phillip Isola, Alexei A Efros, Eli Shechtman, and Oliver Wang. The unreasonable effectiveness of deep features as a perceptual metric. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 586–595, 2018. ",
+        "bbox": [
+            174,
+            787,
+            825,
+            830
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jian Zhao. face.evolve: High-performance face recognition library based on pytorch. https: //github.com/ZhaoJ9014/face.evoLVe.PyTorch, 2020. ",
+        "bbox": [
+            173,
+            844,
+            825,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yaoyao Zhong and Weihong Deng. Towards transferable adversarial attack against deep face recognition. arXiv preprint arXiv:2004.05790, 2020. ",
+        "bbox": [
+            174,
+            887,
+            823,
+            915
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "8 APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            294,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "8.1 IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            135,
+            406,
+            150
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We train all of our feature extractors using focal loss (Lin et al., 2017) with a batch size of 512 for 120 epochs. We use an initial learning rate of 0.1 and decrease it by a factor of 10 at epochs 35, 65 and 95. For the optimizer, we use SGD with a momentum of 0.9 and weight decay of 5e-4. ",
+        "bbox": [
+            174,
+            161,
+            825,
+            204
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For our adversarial attacks, we use 0.05 for the perceptual similarity penalty, $\\sigma = 3$ and window size 7 for the Gaussian smoothing term. Attacks are computed using signed SGD for 50 epochs with a learning rate of 0.0025. ",
+        "bbox": [
+            174,
+            210,
+            825,
+            252
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For face detection and aligning models as well as for training routines, we use the face.evoLVe.PyTorch github repository (Zhao, 2020). ",
+        "bbox": [
+            174,
+            260,
+            823,
+            287
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "8.2 RANK-1 ACCURACY ON FACESCRUB DATA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            308,
+            508,
+            321
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "See Table 5. ",
+        "bbox": [
+            174,
+            334,
+            254,
+            348
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/69eeac2ed9b89172772c9eb6cfad8d253b3c60756d89fc416490bc2722479464.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=9>DefenderIR-50A IR-50CIR-152AIR-152C RN-50ARN-50C RN-152A RN-152CClean 95.6%  96.1%  96.0%  96.2%  95.8%  95.9%  95.9%  96.0%</td></tr><tr><td rowspan=1 colspan=1>95.6%</td><td rowspan=1 colspan=2>96.1%  96.0%</td><td rowspan=1 colspan=1>96.2%</td><td rowspan=1 colspan=1>95.8%</td><td rowspan=1 colspan=2>95.9%  95.9%</td><td rowspan=1 colspan=1>96.0%</td></tr><tr><td rowspan=5 colspan=1>Fawkes IR-50AIR-50CAAreeet IR-152AIR-152C-</td><td rowspan=1 colspan=1>71.2%</td><td rowspan=1 colspan=1>76.2%</td><td rowspan=1 colspan=1>74.4%</td><td rowspan=1 colspan=1>78.2%</td><td rowspan=1 colspan=1>73.9%</td><td rowspan=1 colspan=2>76.0%  76.0%</td><td rowspan=1 colspan=1>71.2%</td></tr><tr><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>3.5%</td><td rowspan=1 colspan=1>0.5%</td><td rowspan=1 colspan=1>6.4%</td><td rowspan=1 colspan=1>5.0%</td><td rowspan=1 colspan=2>8.2%   8.7%</td><td rowspan=1 colspan=1>12.4%</td></tr><tr><td rowspan=1 colspan=1>0.1%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>0.1%</td><td rowspan=1 colspan=1>9.0%</td><td rowspan=1 colspan=1>3.3%</td><td rowspan=1 colspan=2>3.3%   3.6%</td><td rowspan=1 colspan=1> 5.3%</td></tr><tr><td rowspan=1 colspan=1>0.3%</td><td rowspan=1 colspan=1>1.8%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>4.2%</td><td rowspan=1 colspan=1>6.8%</td><td rowspan=1 colspan=1>8.9%</td><td rowspan=1 colspan=1>9.4%</td><td rowspan=1 colspan=1>10.8%</td></tr><tr><td rowspan=1 colspan=1>0.1%</td><td rowspan=1 colspan=1>0.1%</td><td rowspan=1 colspan=1>0.1%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>1.0%</td><td rowspan=1 colspan=1>1.4%</td><td rowspan=1 colspan=1>2.2%</td><td rowspan=1 colspan=1>2.9%</td></tr><tr><td rowspan=1 colspan=1>RN-50A-</td><td rowspan=1 colspan=1>3.8%</td><td rowspan=1 colspan=1>7.0%</td><td rowspan=1 colspan=1>6.8%</td><td rowspan=1 colspan=1>8.3%</td><td rowspan=1 colspan=1>0.9%</td><td rowspan=1 colspan=1>2.0%</td><td rowspan=1 colspan=1>2.8%</td><td rowspan=1 colspan=1>4.6%</td></tr><tr><td rowspan=1 colspan=1>RN-50C-</td><td rowspan=1 colspan=1>3.1%</td><td rowspan=1 colspan=1> 5.7%</td><td rowspan=1 colspan=1>5.6%</td><td rowspan=1 colspan=1>7.9%</td><td rowspan=1 colspan=1>1.2%</td><td rowspan=1 colspan=1>0.1%</td><td rowspan=1 colspan=1>2.0%</td><td rowspan=1 colspan=1> 3.5%</td></tr><tr><td rowspan=1 colspan=1>RN-152A</td><td rowspan=1 colspan=1>1.5%</td><td rowspan=1 colspan=1>3.1%</td><td rowspan=1 colspan=1>2.7%</td><td rowspan=1 colspan=1>4.9%</td><td rowspan=1 colspan=1>0.3%</td><td rowspan=1 colspan=1>0.5%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>0.4%</td></tr><tr><td rowspan=2 colspan=1>RN-152CEnsemble</td><td rowspan=1 colspan=1>1.7%</td><td rowspan=1 colspan=1>2.6%</td><td rowspan=1 colspan=1>3.1%</td><td rowspan=1 colspan=1>3.9%</td><td rowspan=1 colspan=1>0.8%</td><td rowspan=1 colspan=1>0.8%</td><td rowspan=1 colspan=1>0.5%</td><td rowspan=1 colspan=1>0.0%</td></tr><tr><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=2>0.0%   0.1%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>0.2%</td><td rowspan=1 colspan=2>0.4%   0.6%</td><td rowspan=1 colspan=1>0.1%</td></tr></table>",
+        "bbox": [
+            202,
+            359,
+            792,
+            584
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Table 5: Rank-1 accuracy of the LowKey and Fawkes attacks on the FaceScrub dataset. After the first two rows, each row represents LowKey attacks generated from the same model. Each column represents inference on a single model. The first two letters in the model’s name denote the type of backbone: IR or ResNet (RN). The last letter in the model’s name indicates the type of head; “A” denotes ArcFace, and “C” denotes CosFace. Smaller numbers, and lighter colors, indicate more successful attacks. ",
+        "bbox": [
+            173,
+            598,
+            826,
+            683
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "8.3 RESULTS ON UMDFACES DATASET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            710,
+            457,
+            726
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We repeat controlled experiments on the UMDFaces dataset which contains over 367,000 photos of 8,277 identities. For UMDFaces, we also choose 100 identities at random and attack their gallery images while keeping one-tenth of each identity’s photos as probe images. Experimental results are reported in Tables 6 and 7. It can be seen that the effectiveness of LowKey attacks on the UMDFaces dataset is slightly lower, which is likely a result of the much smaller gallery. ",
+        "bbox": [
+            174,
+            737,
+            825,
+            808
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "8.4 CAN WE REDUCE THE SIZE OF OUR ATTACK? ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            827,
+            524,
+            842
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In order to make our attacks more aesthetically pleasing, we try to reduce the size of perturbation by increasing the perceptual similarity penalty from 0.05 to 0.08. This attack is depicted in Figure 5 as a ”LowKey small attack”. Unfortunately, even a small decrease in the perturbation size results in a huge decrease in efficiency of the attack. In the rank-50 setting Amazon Rekognition is able to recognize $1 7 . 2 \\%$ of probe images belonging to users protected with a LowKey small attack. Similarly, Microsoft ",
+        "bbox": [
+            173,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/262a94257929912fc561ba1e775bf1d549df36a529e6f26b97b8d5142d3f0d97.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td rowspan=1 colspan=1>98.6%</td><td rowspan=1 colspan=1>98.3%</td><td rowspan=1 colspan=1>98.6%</td><td rowspan=1 colspan=2>98.6%  98.3%</td><td rowspan=1 colspan=2>98.3%  98.6%</td><td rowspan=1 colspan=1>98.6%</td></tr><tr><td></td><td rowspan=1 colspan=1>0.3%</td><td rowspan=1 colspan=1>38.9%</td><td rowspan=1 colspan=1>25.9%</td><td rowspan=1 colspan=1>48.6%</td><td rowspan=1 colspan=1>47.7%</td><td rowspan=1 colspan=1>55.7%</td><td rowspan=1 colspan=1>57.1%</td><td rowspan=1 colspan=1>62.2%</td></tr><tr><td></td><td rowspan=1 colspan=1>13.6%</td><td rowspan=1 colspan=1>0.3%</td><td rowspan=1 colspan=1>16.5%</td><td rowspan=1 colspan=1>17.6%</td><td rowspan=1 colspan=1>37.5%</td><td rowspan=1 colspan=1>39.2%</td><td rowspan=1 colspan=1>51.4%</td><td rowspan=1 colspan=1>46.3%</td></tr><tr><td></td><td rowspan=1 colspan=1>23.0%</td><td rowspan=1 colspan=1>32.1%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>36.4%</td><td rowspan=1 colspan=1>52.8%</td><td rowspan=1 colspan=1>56.5%</td><td rowspan=1 colspan=1>58.2%</td><td rowspan=1 colspan=1>58.5%</td></tr><tr><td></td><td rowspan=1 colspan=1>8.8%</td><td rowspan=1 colspan=1>8.8%</td><td rowspan=1 colspan=1>9.1%</td><td rowspan=1 colspan=1>1.1%</td><td rowspan=1 colspan=1>26.7%</td><td rowspan=1 colspan=1>28.1%</td><td rowspan=1 colspan=1>34.9%</td><td rowspan=1 colspan=1>31.8%</td></tr><tr><td rowspan=5 colspan=1>Aareeet RN-50A-RN-50C-RN-152A -RN-152C-Ensemble-</td><td rowspan=1 colspan=1>51.4%</td><td rowspan=1 colspan=1>56.3%</td><td rowspan=1 colspan=1>47.2%</td><td rowspan=1 colspan=1>53.1%</td><td rowspan=1 colspan=1>0.3%</td><td rowspan=1 colspan=1>30.7%</td><td rowspan=1 colspan=1>38.4%</td><td rowspan=1 colspan=1>43.2%</td></tr><tr><td rowspan=1 colspan=1>49.4%</td><td rowspan=1 colspan=1>48.3%</td><td rowspan=1 colspan=1>55.1%</td><td rowspan=1 colspan=1>54.0%</td><td rowspan=1 colspan=1>23.0%</td><td rowspan=1 colspan=1>1.1%</td><td rowspan=1 colspan=1>37.2%</td><td rowspan=1 colspan=1>36.4%</td></tr><tr><td rowspan=1 colspan=1>30.4%</td><td rowspan=1 colspan=1>38.1%</td><td rowspan=1 colspan=1>39.8%</td><td rowspan=1 colspan=1>43.8%</td><td rowspan=1 colspan=1>18.8%</td><td rowspan=1 colspan=1>22.2%</td><td rowspan=1 colspan=1>3.4%</td><td rowspan=1 colspan=1>25.9%</td></tr><tr><td rowspan=1 colspan=1>26.4%</td><td rowspan=1 colspan=1>33.8%</td><td rowspan=1 colspan=1>35.5%</td><td rowspan=1 colspan=1>37.8%</td><td rowspan=1 colspan=1>17.3%</td><td rowspan=1 colspan=1>18.2%</td><td rowspan=1 colspan=1>16.8%</td><td rowspan=1 colspan=1> 3.4%</td></tr><tr><td rowspan=1 colspan=1>10.5%</td><td rowspan=1 colspan=1>4.5%</td><td rowspan=1 colspan=1>9.7%</td><td rowspan=1 colspan=1>8.8%</td><td rowspan=1 colspan=1>15.1%</td><td rowspan=1 colspan=1> 6.5%</td><td rowspan=1 colspan=1>12.8%</td><td rowspan=1 colspan=1>13.6%</td></tr></table>",
+        "bbox": [
+            202,
+            99,
+            792,
+            324
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 6: Rank-50 accuracy of LowKey attacks on the UMDFaces dataset. After the first row, each row represents LowKey attacks generated from the same model. Each column represents inference on a single model. The first two letters in the model’s name denote the type of backbone: IR or ResNet (RN). The last letter in the model’s name indicates the type of head; “A” denotes ArcFace, and “C” denotes CosFace. Smaller numbers, and lighter colors, indicate more successful attacks. ",
+        "bbox": [
+            173,
+            338,
+            826,
+            409
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/697fa1ac972fca8cb17f97967299352ade592039db31220a7b076daca109d29c.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td rowspan=1 colspan=1>96.0%</td><td rowspan=1 colspan=1>97.2%</td><td rowspan=1 colspan=1>96.9%</td><td rowspan=1 colspan=2>96.9%  96.3%</td><td rowspan=1 colspan=2>96.6%  97.2%</td><td rowspan=1 colspan=1>96.3%</td></tr><tr><td></td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>12.2%</td><td rowspan=1 colspan=1>6.3%</td><td rowspan=1 colspan=1>18.2%</td><td rowspan=1 colspan=1>17.6%</td><td rowspan=1 colspan=1>25.9%</td><td rowspan=1 colspan=1>28.1%</td><td rowspan=1 colspan=1>31.3%</td></tr><tr><td></td><td rowspan=1 colspan=1>1.7%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>2.6%</td><td rowspan=1 colspan=1>4.3%</td><td rowspan=1 colspan=1>11.6%</td><td rowspan=1 colspan=1>13.9%</td><td rowspan=1 colspan=1>17.3%</td><td rowspan=1 colspan=1>21.0%</td></tr><tr><td></td><td rowspan=1 colspan=1>4.3%</td><td rowspan=1 colspan=1>12.8%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>14.5%</td><td rowspan=1 colspan=1>22.4%</td><td rowspan=1 colspan=1>25.6%</td><td rowspan=1 colspan=1>29.5%</td><td rowspan=1 colspan=1>30.1%</td></tr><tr><td></td><td rowspan=1 colspan=1>1.7%</td><td rowspan=1 colspan=1>2.0%</td><td rowspan=1 colspan=1>2.6%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>6.8%</td><td rowspan=1 colspan=1>9.7%</td><td rowspan=1 colspan=1>13.6%</td><td rowspan=1 colspan=1>11.4%</td></tr><tr><td></td><td rowspan=1 colspan=1>26.4%</td><td rowspan=1 colspan=1>31.0%</td><td rowspan=1 colspan=1>13.9%</td><td rowspan=1 colspan=1>26.4%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>9.4%</td><td rowspan=1 colspan=1>15.1%</td><td rowspan=1 colspan=1>19.0%</td></tr><tr><td rowspan=4 colspan=1>RN-50C-RN-152A -RN-152C-Ensemble </td><td rowspan=1 colspan=1>14.5%</td><td rowspan=1 colspan=1>21.3%</td><td rowspan=1 colspan=1>20.7%</td><td rowspan=1 colspan=1>25.3%</td><td rowspan=1 colspan=1>6.5%</td><td rowspan=1 colspan=1>0.6%</td><td rowspan=1 colspan=1>12.8%</td><td rowspan=1 colspan=1>14.8%</td></tr><tr><td rowspan=1 colspan=1>9.7%</td><td rowspan=1 colspan=1>16.2%</td><td rowspan=1 colspan=1>16.8%</td><td rowspan=1 colspan=1>17.9%</td><td rowspan=1 colspan=1> 5.1%</td><td rowspan=1 colspan=1>7.1%</td><td rowspan=1 colspan=1>0.3%</td><td rowspan=1 colspan=1> 7.4%</td></tr><tr><td rowspan=1 colspan=1>7.4%</td><td rowspan=1 colspan=1>10.2%</td><td rowspan=1 colspan=1>11.9%</td><td rowspan=1 colspan=1>13.1%</td><td rowspan=1 colspan=1>3.1%</td><td rowspan=1 colspan=1> 4.5%</td><td rowspan=1 colspan=1> 5.4%</td><td rowspan=1 colspan=1>0.9%</td></tr><tr><td rowspan=1 colspan=1>2.8%</td><td rowspan=1 colspan=1>1.7%</td><td rowspan=1 colspan=1>2.6%</td><td rowspan=1 colspan=1>3.1%</td><td rowspan=1 colspan=1> 5.1%</td><td rowspan=1 colspan=1>2.0%</td><td rowspan=1 colspan=1>3.1%</td><td rowspan=1 colspan=1>4.0%</td></tr></table>",
+        "bbox": [
+            202,
+            431,
+            792,
+            656
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 7: Rank-1 accuracy of LowKey attack attacks on the UMDFaces dataset. After the first row, each row represents LowKey attacks generated from the same model. Each column represents inference on a single model. The first two letters in the model’s name denote the type of backbone: IR or ResNet (RN). The last letter in the model’s name indicates the type of head; “A” denotes ArcFace, and “C” denotes CosFace. Smaller numbers, and lighter colors, indicate more successful attacks. ",
+        "bbox": [
+            173,
+            670,
+            826,
+            741
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Azure Face recognizes $5 . 5 \\%$ of probe images. Results of controlled experiments are reported in Tables 8 and 9. ",
+        "bbox": [
+            174,
+            777,
+            823,
+            806
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "8.5 COMPARISON WITH FAWKES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            835,
+            411,
+            851
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "By comparing a set of images protected with LowKey and Fawkes tools, we can see that both attacks are noticeable, but distort images in different ways. While Fawkes adds conspicuous artifacts on the face (such as mustaches or lines on the nose), LowKey attack mostly changes the textures and adds spots on a person’s skin. See Figure 5 for a visual comparison. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/1ff73a84f6cd5e80501726627faee14f64d2eb8194ba08858fee03533dff836b.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td rowspan=1 colspan=1>96.8%</td><td rowspan=1 colspan=1>96.8%</td><td rowspan=1 colspan=1>96.7%</td><td rowspan=1 colspan=1>96.8%</td><td rowspan=1 colspan=1>96.8%</td><td rowspan=1 colspan=2>96.8%  96.7%</td><td rowspan=1 colspan=1>96.7%</td></tr><tr><td></td><td rowspan=1 colspan=1>1.0%</td><td rowspan=1 colspan=1>41.1%</td><td rowspan=1 colspan=1>24.7%</td><td rowspan=1 colspan=1>55.2%</td><td rowspan=1 colspan=1>49.7%</td><td rowspan=1 colspan=1>65.0%</td><td rowspan=1 colspan=1>64.2%</td><td rowspan=1 colspan=1>68.8%</td></tr><tr><td></td><td rowspan=1 colspan=1>17.4%</td><td rowspan=1 colspan=1>2.6%</td><td rowspan=1 colspan=1>20.4%</td><td rowspan=1 colspan=1>30.2%</td><td rowspan=1 colspan=1>47.0%</td><td rowspan=1 colspan=1>49.0%</td><td rowspan=1 colspan=1>56.2%</td><td rowspan=1 colspan=1>55.6%</td></tr><tr><td></td><td rowspan=1 colspan=1>28.8%</td><td rowspan=1 colspan=1>38.6%</td><td rowspan=1 colspan=1>0.3%</td><td rowspan=1 colspan=1>49.8%</td><td rowspan=1 colspan=1>61.2%</td><td rowspan=1 colspan=1>66.6%</td><td rowspan=1 colspan=1>69.8%</td><td rowspan=1 colspan=1>70.7%</td></tr><tr><td></td><td rowspan=1 colspan=1>14.2%</td><td rowspan=1 colspan=1>14.0%</td><td rowspan=1 colspan=1>16.2%</td><td rowspan=1 colspan=1>2.7%</td><td rowspan=1 colspan=1>37.0%</td><td rowspan=1 colspan=1>38.6%</td><td rowspan=1 colspan=1>44.4%</td><td rowspan=1 colspan=1>42.9%</td></tr><tr><td rowspan=5 colspan=1>Aareeet RN-50A-RN-50C-RN-152A -RN-152C-Ensemble -</td><td rowspan=1 colspan=1>49.3%</td><td rowspan=1 colspan=1>62.3%</td><td rowspan=1 colspan=1>64.1%</td><td rowspan=1 colspan=1>68.0%</td><td rowspan=1 colspan=1>1.5%</td><td rowspan=1 colspan=1>35.9%</td><td rowspan=1 colspan=1>41.8%</td><td rowspan=1 colspan=1>49.3%</td></tr><tr><td rowspan=1 colspan=1> 57.4%</td><td rowspan=1 colspan=1>59.9%</td><td rowspan=1 colspan=1>62.1%</td><td rowspan=1 colspan=1>64.4%</td><td rowspan=1 colspan=1>31.1%</td><td rowspan=1 colspan=1>3.6%</td><td rowspan=1 colspan=1>46.8%</td><td rowspan=1 colspan=1>48.6%</td></tr><tr><td rowspan=1 colspan=1>42.9%</td><td rowspan=1 colspan=1>51.3%</td><td rowspan=1 colspan=1>52.3%</td><td rowspan=1 colspan=1>55.0%</td><td rowspan=1 colspan=1>25.6%</td><td rowspan=1 colspan=1>32.9%</td><td rowspan=1 colspan=1>5.6%</td><td rowspan=1 colspan=1>35.0%</td></tr><tr><td rowspan=1 colspan=1>41.8%</td><td rowspan=1 colspan=1>48.9%</td><td rowspan=1 colspan=1>47.9%</td><td rowspan=1 colspan=1>52.7%</td><td rowspan=1 colspan=1>28.2%</td><td rowspan=1 colspan=1>29.2%</td><td rowspan=1 colspan=1>30.4%</td><td rowspan=1 colspan=1>8.5%</td></tr><tr><td rowspan=1 colspan=1>18.0%</td><td rowspan=1 colspan=1>21.8%</td><td rowspan=1 colspan=1>19.4%</td><td rowspan=1 colspan=1>12.2%</td><td rowspan=1 colspan=1>23.1%</td><td rowspan=1 colspan=1>24.3%</td><td rowspan=1 colspan=1>27.0%</td><td rowspan=1 colspan=1>14.1%</td></tr></table>",
+        "bbox": [
+            202,
+            99,
+            792,
+            324
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 8: Rank-50 accuracy of LowKey small attacks on the UMDFaces dataset. After the first row, each row represents LowKey small attacks generated from the same model. Each column represents inference on a single model. The first two letters in the model’s name denote the type of backbone: IR or ResNet (RN). The last letter in the model’s name indicates the type of head; “A” denotes ArcFace, and “C” denotes CosFace. Smaller numbers, and lighter colors, indicate more successful attacks. ",
+        "bbox": [
+            173,
+            338,
+            828,
+            409
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/cae3c3665771745577d81ef7de3d440c66dcf0a0744bbd95d1ee6f29ed9c59cd.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td rowspan=1 colspan=1>95.6%</td><td rowspan=1 colspan=1>96.1%</td><td rowspan=1 colspan=1>96.0%</td><td rowspan=1 colspan=1>96.2%</td><td rowspan=1 colspan=4>95.8% 95.9%  95.9%  96.0%</td></tr><tr><td></td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>6.1%</td><td rowspan=1 colspan=1>2.2%</td><td rowspan=1 colspan=1>10.5%</td><td rowspan=1 colspan=1>9.7%</td><td rowspan=1 colspan=1>14.4%</td><td rowspan=1 colspan=1>16.9%</td><td rowspan=1 colspan=1>19.5%</td></tr><tr><td></td><td rowspan=1 colspan=1>1.6%</td><td rowspan=1 colspan=1>0.2%</td><td rowspan=1 colspan=1>2.5%</td><td rowspan=1 colspan=1>5.8%</td><td rowspan=1 colspan=1>9.3%</td><td rowspan=1 colspan=1>11.1%</td><td rowspan=1 colspan=1>14.0%</td><td rowspan=1 colspan=1>14.5%</td></tr><tr><td></td><td rowspan=1 colspan=1>2.2%</td><td rowspan=1 colspan=1>5.6%</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>9.6%</td><td rowspan=1 colspan=1>14.0%</td><td rowspan=1 colspan=1>17.4%</td><td rowspan=1 colspan=1>19.2%</td><td rowspan=1 colspan=1>20.7%</td></tr><tr><td></td><td rowspan=1 colspan=1>1.3%</td><td rowspan=1 colspan=1>1.7%</td><td rowspan=1 colspan=1>2.2%</td><td rowspan=1 colspan=1>0.4%</td><td rowspan=1 colspan=1> 5.1%</td><td rowspan=1 colspan=1> 7.5%</td><td rowspan=1 colspan=1>9.6%</td><td rowspan=1 colspan=1> 9.7%</td></tr><tr><td rowspan=5 colspan=1>AAraret RN-50ARN-50CRN-152A-RN-152C-Ensemble</td><td rowspan=1 colspan=1>8.7%</td><td rowspan=1 colspan=1>14.9%</td><td rowspan=1 colspan=1>14.8%</td><td rowspan=1 colspan=1>17.1%</td><td rowspan=1 colspan=1>0.2%</td><td rowspan=1 colspan=1>7.6%</td><td rowspan=1 colspan=1>7.8%</td><td rowspan=1 colspan=1>12.5%</td></tr><tr><td rowspan=1 colspan=1>9.9%</td><td rowspan=1 colspan=1>14.6%</td><td rowspan=1 colspan=1>15.6%</td><td rowspan=1 colspan=1>17.2%</td><td rowspan=1 colspan=1>5.6%</td><td rowspan=1 colspan=1>0.6%</td><td rowspan=1 colspan=1>8.8%</td><td rowspan=1 colspan=1>11.6%</td></tr><tr><td rowspan=1 colspan=1>9.2%</td><td rowspan=1 colspan=1>13.5%</td><td rowspan=1 colspan=1>12.2%</td><td rowspan=1 colspan=1>14.8%</td><td rowspan=1 colspan=1>5.7%</td><td rowspan=1 colspan=1>7.9%</td><td rowspan=1 colspan=1>0.8%</td><td rowspan=1 colspan=1>8.5%</td></tr><tr><td rowspan=1 colspan=1>6.9%</td><td rowspan=1 colspan=1>11.3%</td><td rowspan=1 colspan=1>11.8%</td><td rowspan=1 colspan=1>12.2%</td><td rowspan=1 colspan=1>4.8%</td><td rowspan=1 colspan=1> 5.3%</td><td rowspan=1 colspan=1>6.0%</td><td rowspan=1 colspan=1>1.3%</td></tr><tr><td rowspan=1 colspan=1>2.6%</td><td rowspan=1 colspan=1>3.6%</td><td rowspan=1 colspan=1>3.5%</td><td rowspan=1 colspan=1>2.9%</td><td rowspan=1 colspan=1>4.0%</td><td rowspan=1 colspan=1>4.7%</td><td rowspan=1 colspan=1> 5.4%</td><td rowspan=1 colspan=1>3.9%</td></tr></table>",
+        "bbox": [
+            202,
+            420,
+            792,
+            645
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 9: Rank-1 accuracy of LowKey small attacks on the UMDFaces dataset. After the first row, each row represents LowKey small attacks generated from the same model. Each column represents inference on a single model. The first two letters in the model’s name denote the type of backbone: IR or ResNet (RN). The last letter in the model’s name indicates the type of head; “A” denotes ArcFace, and “C” denotes CosFace. Smaller numbers, and lighter colors, indicate more successful attacks. ",
+        "bbox": [
+            173,
+            657,
+            826,
+            729
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "8.6 GAUSSIAN SMOOTHING IN LOWKEY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            753,
+            467,
+            768
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For the parameters of the Gaussian smoothing term in the optimization problem (1), we use 3 for $\\sigma$ and 7 for window size. For the defensive Gaussian blur, we use $\\sigma = 2$ and no window size. ",
+        "bbox": [
+            173,
+            780,
+            823,
+            809
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/f96629cc280e06dd4286556160bdc259fd2bc6656c04a9b70ee142678fa2910c.jpg",
+        "image_caption": [
+            "Figure 5: Panel of different attacks. First row: original images, second row: Fawkes attack, third row: LowKey small attack, last row: LowKey attack. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            184,
+            807,
+            452
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/d1a9c9128027cee78921bf9e8b9891e71eb0d6e284d64c55813cfd31090583c4.jpg",
+        "table_caption": [
+            "Defender IR-50A IR-50C IR-152A IR-152C RN-50A RN-50C RN-152A RN-152C "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Clean </td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>84.4%</td><td>85.3%</td><td>84.7%</td><td>86.1%</td><td>86.7%</td><td>87.9%</td><td>88.5%</td><td>89.6%</td></tr><tr><td>Aareeet Without GS</td><td>13.3%</td><td>17.9%</td><td>15.8%</td><td>13.7%</td><td>18.9%</td><td>20.4%</td><td>23.2%</td><td>20.6%</td></tr><tr><td>With GS</td><td>0.3%</td><td>0.3%</td><td>0.1%</td><td>0.0%</td><td>1.0%</td><td>0.9%</td><td>0.6%</td><td>0.6%</td></tr></table>",
+        "bbox": [
+            204,
+            696,
+            792,
+            765
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Table 10: Rank-1 accuracy of FR models tested on blurred images attacked without and with the Gaussian smoothing term. The first two letters in the model’s name denote the type of backbone: IR or ResNet (RN). The last letter in the model’s name indicates the type of head; “A” denotes ArcFace, and “C” denotes CosFace. Smaller numbers, and lighter colors, indicate more successful attacks. ",
+        "bbox": [
+            173,
+            779,
+            826,
+            835
+        ],
+        "page_idx": 14
+    }
+]