Add files using upload-large-folder tool

parse/train/BJ5UeU9xx/BJ5UeU9xx.md

@@ -0,0 +1,236 @@
+# VISUALIZING DEEP NEURAL NETWORK DECISIONS: PREDICTION DIFFERENCE ANALYSIS
+
+Luisa M Zintgraf1,3, Taco S Cohen1, Tameem Adel1, Max Welling1,2 1University of Amsterdam, 2Canadian Institute of Advanced Research, 3Vrije Universiteit Brussel {lmzintgraf,tameem.hesham}@gmail.com, {t.s.cohen, m.welling}@uva.nl
+
+# ABSTRACT
+
+This article presents the prediction difference analysis method for visualizing the response of a deep neural network to a specific input. When classifying images, the method highlights areas in a given input image that provide evidence for or against a certain class. It overcomes several shortcoming of previous methods and provides great additional insight into the decision making process of classifiers. Making neural network decisions interpretable through visualization is important both to improve models and to accelerate the adoption of black-box classifiers in application areas such as medicine. We illustrate the method in experiments on natural images (ImageNet data), as well as medical images (MRI brain scans).
+
+# 1 INTRODUCTION
+
+Over the last few years, deep neural networks (DNNs) have emerged as the method of choice for perceptual tasks such as speech recognition and image classification. In essence, a DNN is a highly complex non-linear function, which makes it hard to understand how a particular classification comes about. This lack of transparency is a significant impediment to the adoption of deep learning in areas of industry, government and healthcare where the cost of errors is high.
+
+In order to realize the societal promise of deep learning - e.g., through self-driving cars or personalized medicine - it is imperative that classifiers learn to explain their decisions, whether it is in the lab, the clinic, or the courtroom. In scientific applications, a better understanding of the complex dependencies learned by deep networks could lead to new insights and theories in poorly understood domains.
+
+In this paper, we present a new, probabilistically sound methodology for explaining classification decisions made by deep neural networks. The method can be used to produce a saliency map for each (instance, node) pair that highlights the parts (features) of the input that constitute most evidence for or against the activation of the given (internal or output) node. See figure 1 for an example.
+
+In the following two sections, we review related work and then present our approach. In section 4 we provide several demonstrations of our technique for deep convolutional neural networks (DCNNs) trained on ImageNet data, and further how the method can be applied when classifying MRI brain scans of HIV patients with neurodegenerative disease.
+
+![](images/5ced911aed2598832e28ff23d1a96c2876006712933b86acb08f35ad61dec9e2.jpg)  
+Figure 1: Example of our visualization method: explains why the DCNN (GoogLeNet) predicts "cockatoo". Shown is the evidence for (red) and against (blue) the prediction. We see that the facial features of the cockatoo are most supportive for the decision, and parts of the body seem to constitute evidence against it. In fact, the classifier most likely considers them evidence for the second-highest scoring class, white wolf.
+
+# 2 RELATED WORK
+
+Broadly speaking, there are two approaches for understanding DCNNs through visualization investigated in the literature: find an input image that maximally activates a given unit or class score to visualize what the network is looking for (Erhan et al., 2009; Simonyan et al., 2013; Yosinski et al., 2015), or visualize how the network responds to a specific input image in order to explain a particular classification made by the network. The latter will be the subject of this paper.
+
+One such instance-specific method is class saliency visualization proposed by Simonyan et al. (2013) who measure how sensitive the classification score is to small changes in pixel values, by computing the partial derivative of the class score with respect to the input features using standard backpropagation. They also show that there is a close connection to using deconvolutional networks for visualization, proposed by Zeiler & Fergus (2014). Other methods include Shrikumar et al. (2016), who compare the activation of a unit when a specific input is fed forward through the net to a reference activation for that unit. Zhou et al. (2016) and Bach et al. (2015) also generate interesting visualization results for individual inputs, but are both not as closely related to our method as the two papers mentioned above. The idea of our method is similar to another analysis Zeiler & Fergus (2014) make: they estimate the importance of input pixels by visualizing the probability of the (correct) class as a function of a gray patch occluding parts of the image. In this paper, we take a more rigorous approach at both removing information from the image and evaluating the effect of this.
+
+In the field of medical image classification specifically, a widely used method for visualizing feature importances is to simply plot the weights of a linear classifier (Klöppel et al., 2008; Ecker et al., 2010), or the p-values of these weights (determined by permutation testing) (Mourao-Miranda et al., 2005; Wang et al., 2007). These are independent of the input image, and, as argued by Gaonkar & Davatzikos (2013) and Haufe et al. (2014), interpreting these weights can be misleading in general.
+
+The work presented in this paper is based on an instance-specific method by Robnik-Šikonja & Kononenko (2008), the prediction difference analysis, which is reviewed in the next section. Our main contributions are three substantial improvements of this method: conditional sampling (section 3.1), multivariate analysis (section 3.2), and deep visualization (section 3.3).
+
+# 3 APPROACH
+
+Our method is based on the technique presented by Robnik-Šikonja & Kononenko (2008), which we will now review. For a given prediction, the method assigns a relevance value to each input feature with respect to a class $c$ . The basic idea is that the relevance of a feature $x _ { i }$ can be estimated by measuring how the prediction changes if the feature is unknown, i.e., the difference between $p ( c | \mathbf { x } )$ and $p ( c | \mathbf { x } _ { \backslash i } )$ , where $\mathbf { x } _ { \backslash i }$ denotes the set of all input features except $x _ { i }$ .
+
+To find $p ( c | \mathbf { x } _ { \backslash i } )$ , i.e., evaluate the prediction when a feature is unknown, the authors propose three strategies. The first is to label the feature as unknown (which only few classifiers allow). The second is to re-train the classifier with the feature left out (which is clearly infeasible for DNNs and high-dimensional data like images). The third approach is to simulate the absence of a feature by marginalizing the feature:
+
+$$
+p ( c | \mathbf { x } _ { \backslash i } ) = \sum _ { x _ { i } } p ( x _ { i } | \mathbf { x } _ { \backslash i } ) p ( c | \mathbf { x } _ { \backslash i } , x _ { i } )
+$$
+
+(with the sum running over all possible values for $x _ { i }$ ). However, modeling $p ( x _ { i } | \mathbf { x } _ { \backslash i } )$ can easily become infeasible with a large number of features. Therefore, the authors approximate equation (1) by assuming that feature $x _ { i }$ is independent of the other features, $\mathbf { x } _ { \backslash i }$ :
+
+$$
+p ( c | \mathbf { x } _ { \backslash i } ) \approx \sum _ { x _ { i } } p ( x _ { i } ) p ( c | \mathbf { x } _ { \backslash i } , x _ { i } ) .
+$$
+
+The prior probability $p ( x _ { i } )$ is usually approximated by the empirical distribution for that feature.
+
+Once the class probability $p ( c | \mathbf { x } _ { \backslash i } )$ is estimated, it can be compared to $p ( c | \mathbf { x } )$ . We stick to an evaluation proposed by the authors referred to as weight of evidence, given by
+
+$$
+\begin{array} { r } { \mathbf { W E } _ { i } ( c | \mathbf { x } ) = \log _ { 2 } \left( \operatorname { o d d s } ( c | \mathbf { x } ) \right) - \log _ { 2 } \left( \operatorname { o d d s } ( c | \mathbf { x } _ { \backslash i } ) \right) , } \end{array}
+$$
+
+![](images/2d3615626674c157c6eefb119008f778803ca19b3e3f4b0516ad65688ee3ec04.jpg)  
+Figure 2: Simple illustration of the sampling procedure in algorithm 1. Given the input image $x$ , we select every possible patch $x _ { w }$ (in a sliding window fashion) of size $k \times k$ and place a larger patch $\hat { x } _ { w }$ of size $l \times l$ around it. We can then conditionally sample $x _ { w }$ by conditioning on the surrounding patch $\hat { x } _ { w }$ .
+
+Algorithm 1 Evaluating the prediction difference using conditional and multivariate sampling Input: classifier with outputs $\mathsf { p } ( \mathsf { c } | \mathbf { x } )$ , input image $\mathbf { x }$ of size $n \times n$ , inner patch size $k$ , outer patch size $l > k$ , class of interest $c$ , probabilistic model over patches of size $l \times l$ , number of samples $S$ Initialization: $\mathrm { W E = z e r o s ( n ^ { * } n ) }$ , counts $\mathbf { \mu } _ { \mathrm { : } } = \mathbf { Z } \mathbf { e }$ ros $( \mathfrak { n } ^ { * } \mathfrak { n } )$ for every patch $\mathbf { x } _ { w }$ of size $k \times k$ in $\mathbf { x }$ do $\mathbf { x } ^ { \prime } = { \bar { \mathrm { c o p y } } } ( \mathbf { x } )$ $\mathrm { s u m } _ { w } = 0$ define patch $\hat { \mathbf { x } } _ { w }$ of size $l \times l$ that contains $\mathbf { x } _ { w }$ for $s = 1$ to $S$ do $\mathbf { x } _ { w } ^ { \prime } \gets \mathbf { x } _ { w }$ sampled from $p ( \mathbf { x } _ { w } | \hat { \mathbf { x } } _ { w } \backslash \mathbf { x } _ { w } )$ $\mathrm { s u m } _ { w } \mathrel { + { = } } p ( c | \mathbf { x } ^ { \prime } )$ . evaluate classifier end for $p ( c | \mathbf x \backslash \mathbf x _ { w } ) : = \mathtt { s u m } _ { w } / S$ WE[coordinates of $\mathbf { x } _ { w } ] + = \log _ { 2 } ( \operatorname { o d d s } ( c | \mathbf { x } ) ) - \log _ { 2 } ( \operatorname { o d d s } ( c | \mathbf { x } \backslash \mathbf { x } _ { w } ) )$ counts[coordinates of $\mathbf { x } _ { w } ] + = 1$ end for Output: WE / counts . point-wise division where $\mathrm { o d d s } ( c | \mathbf { x } ) = p ( c | \mathbf { x } ) / ( 1 - p ( c | \mathbf { x } ) )$ . To avoid problems with zero probabilities, Laplace correction $p \gets ( p N + 1 ) / ( N + K )$ is used, where $N$ is the number of training instances and $K$ the number of classes.
+
+The method produces a relevance vector $( \mathrm { W E } _ { i } ) _ { i = 1 \dots m }$ ( $\textbar { m }$ being the number of features) of the same size as the input, which reflects the relative importance of all features. A large prediction difference means that the feature contributed substantially to the classification, whereas a small difference indicates that the feature was not important for the decision. A positive value $\mathrm { W E } _ { i }$ means that the feature has contributed evidence for the class of interest: removing it would decrease the confidence of the classifier in the given class. A negative value on the other hand indicates that the feature displays evidence against the class: removing it also removes potentially conflicting or irritating information and the classifier becomes more certain in the investigated class.
+
+# 3.1 CONDITIONAL SAMPLING
+
+In equation (3), the conditional probability $p ( x _ { i } | \mathbf { x } _ { \backslash i } )$ of a feature $x _ { i }$ is approximated using the marginal distribution $p ( x _ { i } )$ . This is a very crude approximation. In images for example, a pixel’s value is highly dependent on other pixels. We propose a much more accurate approximation, based on the following two observations: a pixel depends most strongly on a small neighborhood around it, and the conditional of a pixel given its neighborhood does not depend on the position of the pixel in the image. For a pixel $x _ { i }$ , we can therefore find a patch $\hat { \mathbf { x } } _ { i }$ of size $l \times l$ that contains $x _ { i }$ , and condition on the remaining pixels in that patch:
+
+$$
+p ( x _ { i } | \mathbf { x } _ { \backslash i } ) \approx p ( x _ { i } | \hat { \mathbf { x } } _ { \backslash i } ) .
+$$
+
+This greatly improves the approximation while remaining completely tractable.
+
+For a feature to become relevant when using conditional sampling, it now has to satisfy two conditions: being relevant to predict the class of interest, and be hard to predict from the neighboring pixels. Relative to the marginal method, we therefore downweight the pixels that can easily be predicted and are thus redundant in this sense.
+
+# 3.2 MULTIVARIATE ANALYSIS
+
+Robnik-Šikonja & Kononenko (2008) take a univariate approach: only one feature at a time is removed. However, we would expect that a neural network is relatively robust to just one feature of a high-dimensional input being unknown, like a pixel in an image. Therefore, we will remove several features at once by again making use of our knowledge about images by strategically choosing these feature sets: patches of connected pixels. Instead of going through all individual pixels, we go through all patches of size $k \times k$ in the image ( $k \times k \times 3$ for RGB images and $k \times k \times k$ for 3D images like MRI scans), implemented in a sliding window fashion. The patches are overlapping, so that ultimately an individual pixel’s relevance is obtained by taking the average relevance obtained from the different patches it was in.
+
+Algorithm 1 and figure 2 illustrate how the method can be implemented, incorporating the proposed improvements.
+
+# 3.3 DEEP VISUALIZATION OF HIDDEN LAYERS
+
+When trying to understand neural networks and how they make decisions, it is not only interesting to analyze the input-output relation of the classifier, but also to look at what is going on inside the hidden layers of the network. We can adapt the method to see how the units of any layer of the network influence a node from a deeper layer. Mathematically, we can formulate this as follows. Let h be the vector representation of the values in a layer $H$ in the network (after forward-propagating the input up to this layer). Further, let $z = z ( \mathbf { h } )$ be the value of a node that depends on $\mathbf { h }$ , i.e., a node in a subsequent layer. Then the analog of equation (2) is given by the expectation:
+
+$$
+g ( z | \mathbf { h } _ { \setminus i } ) \equiv \mathbb { E } _ { p ( h _ { i } | \mathbf { h } _ { \setminus i } ) } \left[ z ( \mathbf { h } ) \right] = \sum _ { h _ { i } } p ( h _ { i } | \mathbf { h } _ { \setminus i } ) z ( \mathbf { h } _ { \setminus i } , h _ { i } ) ,
+$$
+
+which expresses the distribution of $z$ when unit $h _ { i }$ in layer $H$ is unobserved. The equation now works for arbitrary layer/unit combinations, and evaluates to the same as equation (1) when the input-output relation is analyzed. To evaluate the difference between $g ( z | \mathbf { h } )$ and $g ( z | \mathbf { h } _ { \backslash i } )$ , we will in general use the activation difference, $\mathrm { A D } _ { i } ( z | \mathbf { h } ) = g ( z | \mathbf { h } ) - g ( z | \mathbf { h } _ { \backslash i } )$ , for the case when we are not dealing with probabilities (and equation (3) is not applicable).
+
+# 4 EXPERIMENTS
+
+In this section, we illustrate how the proposed visualization method can be applied, on the ImageNet dataset of natural images when using DCNNs (section 4.1), and on a medical imaging dataset of MRI scans when using a logistic regression classifier (section 4.2). For marginal sampling we always use the empirical distribution, i.e., we replace a feature (patch) with samples taken directly from other images, at the same location. For conditional sampling we use a multivariate normal distribution. For both sampling methods we use 10 samples to estimate $p ( c | \mathbf { x } _ { \backslash i } )$ (since no significant difference was observed with more samples). Note that all images are best viewed digital and in color.
+
+Our implementation is available at github.com/lmzintgraf/DeepVis-PredDiff.
+
+# 4.1 IMAGENET: UNDERSTANDING HOW A DCNN MAKES DECISIONS
+
+We use images from the ILSVRC challenge (Russakovsky et al., 2015) (a large dataset of natural images from 1000 categories) and three DCNNs: the AlexNet (Krizhevsky et al., 2012), the GoogLeNet (Szegedy et al., 2015) and the (16-layer) VGG network (Simonyan & Zisserman, 2014). We used the publicly available pre-trained models that were implemented using the deep learning framework caffe (Jia et al., 2014). Analyzing one image took us on average 20, 30 and 70 minutes for the respective classifiers AlexNet, GoogLeNet and VGG (using the GPU implementation of caffe and mini-batches with the standard settings of 10 samples and a window size of $k = 1 0$ ).
+
+The results shown here are chosen from among a small set of images in order to show a range of behavior of the algorithm. The shown images are quite representative of the performance of the method in general. Examples on randomly selected images, including a comparison to the sensitivity analysis of Simonyan et al. (2013), can be seen in appendix A.
+
+![](images/06d03ab00e42b16d0dc1187d88a9d265f3ce56aff123688d917d4d208fc132ae.jpg)  
+Figure 3: Visualization of the effects of marginal versus conditional sampling using the GoogLeNet classifier. The classifier makes correct predictions (ostrich and saxophone), and we show the evidence for (red) and against (blue) this decision at the output layer. We can see that conditional sampling gives more targeted explanations compared to marginal sampling. Also, marginal sampling assigns too much importance on pixels that are easily predictable conditioned on their neighboring pixels.
+
+![](images/6455e925ac116e0d784784daf0f8afd0f43f4ad88880d94d1d98f4fa761d3377.jpg)  
+Figure 4: Visualization of how different window sizes influence the visualization result. We used the conditional sampling method and the AlexNet classifier with $l = k + 4$ and varying $k$ . We can see that even when removing single pixels $k = 1 ,$ ), this has a noticeable effect on the classifier and more important pixels get a higher score. By increasing the window size we can get a more easily interpretable, smooth result until the image gets blurry for very large window sizes.
+
+We start this section by demonstrating our proposed improvements (sections 3.1 - 3.3).
+
+# Marginal vs Conditional Sampling
+
+Figure 3 shows visualizations of the spatial support for the highest scoring class, using marginal and conditional sampling (with $k = 1 0$ and $l = 1 4$ ). We can see that conditional sampling leads to results that are more refined in the sense that they concentrate more around the object. We can also see that marginal sampling leads to pixels being declared as important that are very easily predictable conditioned on their neighboring pixels (like in the saxophone example). Throughout our experiments, we have found that conditional sampling tends to give more specific and fine-grained results than marginal sampling. For the rest of our experiments, we therefore show results using conditional sampling only.
+
+# Multivariate Analysis
+
+For ImageNet data, we have observed that setting $k = 1 0$ gives a good trade-off between sharp results and a smooth appearance. Figure 4 shows how different window sizes influence the resolution of the visualization. Surprisingly, removing only one pixel does have a measurable effect on the prediction, and the largest effect comes from sensitive pixels. We expected that removing only one pixel does not have any effect on the classification outcome, but apparently the classifier is sensitive even to these small changes. However when using such a small window size, it is difficult to make sense of the sign information in the visualization. If we want to get a good impression of which parts in the image are evidence for/against a class, it is therefore better to use larger windows. If $k$ is chosen too large however, the results tend to get blurry. Note that these results are not just simple averages of one another, but a multivariate approach is indeed necessary to observe the presented results.
+
+# Deep Visualization of Hidden Network Layers
+
+Our third main contribution is the extension of the method to neural networks; to understand the role of hidden layers in a DNN. Figure 5 shows how different feature maps in three different layers of the GoogLeNet react to the input of a tabby cat (see figure 6, middle image). For each feature map in a convolutional layer, we first compute the relevance of the input image for each hidden unit in that map. To estimate what the feature map as a whole is doing, we show the average of the relevance vectors over all units in that feature map. The first convolutional layer works with different types of simple image filters (e.g., edge detectors), and what we see is which parts of the input image respond positively or negatively to these filters. The layer we picked from somewhere in the middle of the network is specialized to higher level features (like facial features of the cat). The activations of the last convolutional layer are very sparse across feature channels, indicating that these units are highly specialized.
+
+![](images/9aa2911fd8a20fff6a6cd4bba440ba720e6df920436632ccf296d971d05fc662.jpg)  
+Figure 5: Visualization of feature maps from thee different layers of the GoogLeNet (l.t.r.: ”conv $1 / 7 \mathrm { x } 7 \_ \mathrm { s } 2 ^ { \cdot \prime }$ , ”inception_3a/output”, ”inception_5b/output”), using conditional sampling and patch sizes $k = 1 0$ and $l = 1 4$ (see alg. 1). For each feature map in the convolutional layer, we first evaluate the relevance for every single unit, and then average the results over all the units in one feature map to get a sense of what the unit is doing as a whole. Red pixels activate a unit, blue pixels decreased the activation.
+
+![](images/fcc833d94084792a985ed7f2b47caa4c514cc946c9f6110859c390c1249dbbb6.jpg)  
+Figure 6: Visualization of three different feature maps, taken from the ”inception_ $3 \mathrm { a } I$ output” layer of the GoogLeNet (from the middle of the network). Shown is the average relevance of the input features over all activations of the feature map. We used patch sizes $k = 1 0$ and $l = 1 4$ (see alg. 1). Red pixels activate a unit, blue pixels decreased the activation.
+
+To get a sense of what single feature maps in convolutional layers are doing, we can look at their visualization for different input images and look for patterns in their behavior. Figure 6 shows this for four different feature maps from a layer from the middle of the GoogLeNet network. We can directly see which kind of features the model has learned at this stage in the network. For example, one feature map is mostly activated by the eyes of animals (third row), and another is looking mostly at the background (last row).
+
+# Penultimate vs Output Layer
+
+If we visualize the influence of the input features on the penultimate (pre-softmax) layer, we show only the evidence for/against this particular class, without taking other classes into consideration. After the softmax operation however, the values of the nodes are all interdependent: a drop in the probability for one class could be due to less evidence for it, or because a different class becomes more likely. Figure 7 compares visualizations for the last two layers. By looking at the top three scoring classes, we can see that the visualizations in the penultimate layer look very similar if the classes are similar (like different dog breeds). When looking at the output layer however, they look rather different. Consider the case of the elephants: the top three classes are different elephant subspecies, and the visualizations of the penultimate layer look similar since every subspecies can be identified by similar characteristics. But in the output layer, we can see how the classifier decides for one of the three types of elephants and against the others: the ears in this case are the crucial difference.
+
+![](images/482164df5c34ceee133e9014c442da8bd23bc4dbcb0b6b265127f97c1db9629a.jpg)  
+Figure 7: Visualization of the support for the top-three scoring classes in the penultimate- and output layer. Next to the input image, the first row shows the results with respect to the penultimate layer; the second row with respect to the output layer. For each image, we additionally report the values of the units. We used the AlexNet with conditional sampling and patch sizes $k = 1 0$ and $l = 1 4$ (see alg. 1). Red pixels are evidence for a class, and blue against it.
+
+![](images/b8082c60373251d3deb98376d94efd6c054cce69550e78b6f91354800c5bb442.jpg)  
+Figure 8: Comparison of the prediction visualization of different DCNN architectures. For two input images, we show the results of the prediction difference analysis when using different neural networks - the AlexNet, GoogLeNet and VGG network.
+
+# Network Comparison
+
+When analyzing how neural networks make decisions, we can also compare how different network architectures influence the visualization. Here, we tested our method on the AlexNet, the GoogLeNet and the VGG network. Figure 8 shows the results for the three different networks, on two input images. The AlexNet seems to more on contextual information (the sky in the balloon image), which could be attributed to it having the least complex architecture compared to the other two networks. It is also interesting to see that the VGG network deems the basket of the balloon as very important compared to all other pixels. The second highest scoring class in this case was a parachute - presumably, the network learned to not confuse a balloon with a parachute by detecting a square basket (and not a human).
+
+# 4.2 MRI DATA: EXPLAINING CLASSIFIER DECISIONS IN MEDICAL IMAGING
+
+To illustrate how our visualization method can also be useful in a medical domain, we show some experimental results on an MRI dataset of HIV and healthy patients. In such settings, it is crucial that the practitioner has some insight into the algorithm’s decision when classifying a patient, to weigh this information and incorporate it in the overall diagnosis process.
+
+The dataset used here is referred to as the COBRA dataset. It contains 3D MRIs from $1 0 0 \ \mathrm { H I V }$ patients and 70 healthy individuals, included in the Academic Medical Center (AMC) in Amsterdam, The Netherlands. Of these subjects, diffusion weighted MRI data were acquired. Preprocessing of the data was performed with software developed in-house, using the HPCN-UvA Neuroscience Gateway and using resources of the Dutch e-Science Grid Shahand et al. (2015). As a result, Fractional Anisotropy (FA) maps were computed. FA is sensitive to microstructural damage and therefore expected to be, on average, decreased in patients. Subjects were scanned on two 3.0 Tesla scanner systems, 121 subjects on a Philips Intera system and 39 on a Philips Ingenia system. Patients and controls were evenly distributed. FA images were spatially normalized to standard space Andersson et al. (2007), resulting in volumes with $9 1 \times 1 0 9 \times 9 1 = 9 0 2 , 6 2 9$ voxels.
+
+We trained an L2-regularized Logistic Regression classifier on a subset of the MRI slices (slices 29-40 along the first axis) and on a balanced version of the dataset (by taking the first 70 samples of the HIV class) to achieve an accuracy of $6 9 . 3 \%$ in a 10-fold cross-validation test. Analyzing one image took around half an hour (on a CPU, with $k = 3$ and $l = 7$ , see algorithm 1). For conditional sampling, we also tried adding location information in equation (2), i.e., we split up the 3D image into a $2 0 \times 2 0 \times 2 0$ grid and also condition on the index in that grid. We found that this slightly improved the interpretability of the results, since the pixel values in the special case of MRI scans does depend on spacial location as well.
+
+Figure 9 (first row) shows one way via which the prediction difference results could be presented to a physician, for an HIV sample. By overlapping the prediction difference and the MRI image, the exact regions can be pointed out that are evidence for (red parts) or against (blue parts) the classifier’s decision. The second row shows the results using the weights of the logistic regression classifier, which is a commonly used method in neuroscientific literature. We can see that they are considerably noisier (in the sense that, compared to our method, the voxels relevant for the classification decisions are more scattered), and also, they are not specific to the given image. Figure 10 shows the visualization results for four healthy, and four HIV samples. We can clearly see that the patterns for the two classes are distinct, and there is some pattern to the decision of the classifier, but which is still specific to the input image. Figure 11 shows the same (HIV) sample as in figure 9 along different axes, and figure 12 shows how the visualization changes with different patch sizes. We believe that both varying the slice and patch size can give different insights to a clinician, and in clinical practice, a 3D animation where these parameters can be adjusted would be very useful for analyzing the visualization result.
+
+In general we can assume that the better the classifier, the closer the explanations for its decisions are to the true class difference. For clinical practice it is therefore crucial to have very good classifiers. This will increase computation time, but in many medical settings, longer waiting times for test results are common and worth the wait if the patient is not in an acute life threatening condition (e.g., when predicting HIV or Alzheimer from MRI scans, or the field of cancer diagnosis and detection). The presented results here are for demonstration purposes of the visualization method, and we claim no medical validity. A thorough qualitative analysis incorporating expert knowledge was outside the scope of this paper.
+
+# 5 FUTURE WORK
+
+In our experiments, we used a simple multivariate normal distribution for conditional sampling. We can imagine that using more sophisticated generative models will lead to better results: pixels that are easily predictable by their surrounding are downweighted even more. However this will also significantly increase the computational resources needed to produce the explanations. Similarly, we could try to modify equation (4) to get an even better approximation by using a conditional distribution that takes more information about the whole image into account (like adding spatial information for the MRI scans).
+
+To make the method applicable for clinical analysis and practice, a better classification algorithm is required. Also, software that visualizes the results as an interactive 3D model will improve the usability of the system.
+
+# 6 CONCLUSION
+
+We presented a new method for visualizing deep neural networks that improves on previous methods by using a more powerful conditional, multivariate model. The visualization method shows which pixels of a specific input image are evidence for or against a node in the network. The signed information offers new insights - for research on the networks, as well as the acceptance and usability in domains like healthcare. While our method requires significant computational resources, real-time 3D visualization is possible when visualizations are pre-computed. With further optimization and powerful GPUs, pre-computation time can be reduced a lot further. In our experiments, we have presented several ways in which the visualization method can be put into use for analyzing how DCNNs make decisions.
+
+![](images/a85509f7394141043b2a833c061d51d93e6f419f4ea44470573238dd279a77ee.jpg)  
+Figure 9: Visualization of the support for the correct classification ”HIV”, using the Prediction Difference method and Logistic Regression Weights. For an HIV sample, we show the results with the prediction difference (first row), and using the weights of the logistic regression classifier (second row), for slices 29 and 40 (along the first axis). Red are positive values, and blue negative. For each slice, the left image shows the original image, overlaid with the relevance values. The right image shows the original image with reversed colors and the relevance values. Relevance values are shown only for voxels with (absolute) relevance value above $1 5 \%$ of the (absolute) maximum value.
+
+![](images/95924f4010f91217380b1bc9eb550b78acaba90e69477baca5ed190bd7d9cf28.jpg)  
+Figure 10: Prediction difference visualization for different samples. The first four samples are of the class ”healthy”; the last four of the class ”HIV”. All images show slice 39 (along the first axis). All samples are correctly classified, and the results show evidence for (red) and against (blue) this decision. Prediction differences are shown only for voxels with (absolute) relevance value above $1 5 \%$ of the (absolute) maximum value.
+
+![](images/20456acef76521d1fe14e977d7395f11d399ffa099efda55adcbe4c412677c10.jpg)  
+Figure 11: Visualization results across different slices of the MRI image, using the same input image as shown in 9. Prediction differences are shown only for voxels with (absolute) relevance value above $1 5 \%$ of the (absolute) maximum value.
+
+![](images/58c146db5b6150e3d5cdfc12aaa56836d4ba0d268953eea18fd7e26b54b572a3.jpg)  
+Figure 12: How the patch size influences the visualization. For the input image (HIV sample, slice 39 along the first axis) we show the visualization with different patch sizes $k$ in alg. 1). Prediction differences are shown only for voxels with (absolute) relevance value above $1 5 \%$ of the (absolute) maximum (for $k = 2$ it is $10 \%$ ).
+
+# ACKNOWLEDGMENTS
+
+This work was supported by AWS in Education Grant award. We thank Facebook and Google for financial support, and our reviewers for their time and valuable, constructive feedback.
+
+This work was also in part supported by: Innoviris, the Brussels Institute for Research and Innovation, Brussels, Belgium; the Nuts-OHRA Foundation (grant no. 1003-026), Amsterdam, The Netherlands; The Netherlands Organization for Health Research and Development (ZonMW) together with AIDS Fonds (grant no 300020007 and 2009063). Additional unrestricted scientific grants were received from Gilead Sciences, ViiV Healthcare, Janssen Pharmaceutica N.V., Bristol-Myers Squibb, Boehringer Ingelheim, and Merck&Co.
+
+We thank Barbara Elsenga, Jane Berkel, Sandra Moll, Maja Totté, and Marjolein Martens for running the AGEhIV study program and capturing our data with such care and passion. We thank Yolanda Ruijs-Tiggelman, Lia Veenenberg-Benschop, Sima Zaheri, and Mariska Hillebregt at the HIV Monitoring Foundation for their contributions to data management. We thank Aafien Henderiks and Hans-Erik Nobel for their advice on logistics and organization at the Academic Medical Center. We thank all HIV-physicians and HIV-nurses at the Academic Medical Center for their efforts to include the HIV-infected participants into the AGEhIV Cohort Study, and the Municipal Health Service Amsterdam personnel for their efforts to include the HIV-uninfected participants into the AGEhIV Cohort Study. We thank all study participants without whom this research would not be possible.
+
+AGEhIV Cohort Study Group. Scientific oversight and coordination: P. Reiss (principal investigator), F.W.N.M. Wit, M. van der Valk, J. Schouten, K.W. Kooij, R.A. van Zoest, E. Verheij, B.C. Elsenga (Academic Medical Center (AMC), Department of Global Health and Amsterdam Institute for Global Health and Development (AIGHD)). M. Prins (co-principal investigator), M.F. Schim van der Loeff, M. Martens, S. Moll, J. Berkel, M. Totté, G.R. Visser, L. May, S. Kovalev, A. Newsum, M. Dijkstra (Public Health Service of Amsterdam, Department of Infectious Diseases). Datamanagement: S. Zaheri, M.M.J. Hillebregt, Y.M.C. Ruijs, D.P. Benschop, A. el Berkaoui (HIV Monitoring Foundation). Central laboratory support: N.A. Kootstra, A.M. Harskamp-Holwerda, I. Maurer, T. Booiman, M.M. Mangas Ruiz, A.F. Girigorie, B. Boeser-Nunnink (AMC, Laboratory for Viral Immune Pathogenesis and Department of Experimental Immunology). Project management and administrative support: W. Zikkenheiner, F.R. Janssen (AIGHD). Participating HIV physicians and nurses: S.E. Geerlings, M.H. Godfried, A. Goorhuis, J.W.R. Hovius, J.T.M. van der Meer, F.J.B. Nellen, T. van der Poll, J.M. Prins, P. Reiss, M. van der Valk, W.J. Wiersinga, M. van Vugt, G. de Bree, F.W.N.M. Wit; J. van Eden, A.M.H. van Hes, M. Mutschelknauss , H.E. Nobel, F.J.J. Pijnappel, M. Bijsterveld, A. Weijsenfeld, S. Smalhout (AMC, Division of Infectious Diseases). Other collaborators: J. de Jong, P.G. Postema (AMC, Department of Cardiology); P.H.L.T. Bisschop, M.J.M. Serlie (AMC, Division of Endocrinology and Metabolism); P. Lips (Free University Medical Center Amsterdam); E. Dekker (AMC, Department of Gastroenterology); N. van der Velde (AMC, Division of Geriatric Medicine); J.M.R. Willemsen, L. Vogt (AMC, Division of Nephrology); J. Schouten, P. Portegies, B.A. Schmand, G.J. Geurtsen (AMC, Department of Neurology); F.D. Verbraak, N. Demirkaya (AMC, Department of Ophthalmology); I. Visser (AMC, Department of Psychiatry); A. Schadé (Free University Medical Center Amsterdam, Department of Psychiatry); P.T. Nieuwkerk, N. Langebeek (AMC, Department of Medical Psychology); R.P. van Steenwijk, E. Dijkers (AMC, Department of Pulmonary medicine); C.B.L.M. Majoie, M.W.A. Caan, T. Su (AMC, Department of Radiology); H.W. van Lunsen, M.A.F. Nievaard (AMC, Department of Gynaecology); B.J.H. van den Born, E.S.G. Stroes, (AMC, Division of Vascular Medicine); W.M.C. Mulder (HIV Vereniging Nederland).
+
+# REFERENCES
+
+Jesper LR Andersson, Mark Jenkinson, and Stephen Smith. Non-linear optimisation. fmrib technical report tr07ja1. University of Oxford FMRIB Centre: Oxford, UK, 2007.
+
+Sebastian Bach, Alexander Binder, Grégoire Montavon, Frederick Klauschen, Klaus-Robert Müller, and Wojciech Samek. On pixel-wise explanations for non-linear classifier decisions by layer-wise relevance propagation. PloS one, 10(7):e0130140, 2015.
+
+Christine Ecker, Andre Marquand, Janaina Mourão-Miranda, Patrick Johnston, Eileen M Daly, Michael J Brammer, Stefanos Maltezos, Clodagh M Murphy, Dene Robertson, Steven C Williams, et al. Describing the brain in autism in five dimensions—magnetic resonance imaging-assisted diagnosis of autism spectrum disorder using a multiparameter classification approach. The Journal of Neuroscience, 30(32):10612–10623, 2010.
+
+Dumitru Erhan, Yoshua Bengio, Aaron Courville, and Pascal Vincent. Visualizing higher-layer features of a deep network. Dept. IRO, Université de Montréal, Tech. Rep, 4323, 2009.
+
+Bilwaj Gaonkar and Christos Davatzikos. Analytic estimation of statistical significance maps for support vector machine based multi-variate image analysis and classification. NeuroImage, 78:270–283, 2013.
+
+Stefan Haufe, Frank Meinecke, Kai Görgen, Sven Dähne, John-Dylan Haynes, Benjamin Blankertz, and Felix Bießmann. On the interpretation of weight vectors of linear models in multivariate neuroimaging. Neuroimage, 87:96–110, 2014.
+
+Yangqing Jia, Evan Shelhamer, Jeff Donahue, Sergey Karayev, Jonathan Long, Ross Girshick, Sergio Guadarrama, and Trevor Darrell. Caffe: Convolutional architecture for fast feature embedding. arXiv preprint arXiv:1408.5093, 2014.
+
+Stefan Klöppel, Cynthia M Stonnington, Carlton Chu, Bogdan Draganski, Rachael I Scahill, Jonathan D Rohrer, Nick C Fox, Clifford R Jack, John Ashburner, and Richard SJ Frackowiak. Automatic classification of mr scans in alzheimer’s disease. Brain, 131(3):681–689, 2008.
+
+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.
+
+Janaina Mourao-Miranda, Arun LW Bokde, Christine Born, Harald Hampel, and Martin Stetter. Classifying brain states and determining the discriminating activation patterns: Support vector machine on functional mri data. NeuroImage, 28(4):980–995, 2005.
+
+Marko Robnik-Šikonja and Igor Kononenko. Explaining classifications for individual instances. Knowledge and Data Engineering, IEEE Transactions on, 20(5):589–600, 2008.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. ImageNet Large Scale Visual Recognition Challenge. International Journal of Computer Vision (IJCV), 115(3):211–252, 2015. doi: 10.1007/s11263-015-0816-y.
+
+Shayan Shahand, Ammar Benabdelkader, Mohammad Mahdi Jaghoori, Mostapha al Mourabit, Jordi Huguet, Matthan WA Caan, Antoine HC Kampen, and Sílvia D Olabarriaga. A data-centric neuroscience gateway: design, implementation, and experiences. Concurrency and Computation: Practice and Experience, 27(2): 489–506, 2015.
+
+Avanti Shrikumar, Peyton Greenside, Anna Shcherbina, and Anshul Kundaje. Not just a black box: Learning important features through propagating activation differences. arXiv preprint arXiv:1605.01713, 2016.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. arXiv preprint arXiv:1312.6034, 2013.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1–9, 2015.
+
+Ze Wang, Anna R Childress, Jiongjiong Wang, and John A Detre. Support vector machine learning-based fmri data group analysis. NeuroImage, 36(4):1139–1151, 2007.
+
+Jason Yosinski, Jeff Clune, Anh Nguyen, Thomas Fuchs, and Hod Lipson. Understanding neural networks through deep visualization. arXiv preprint arXiv:1506.06579, 2015.
+
+Matthew D Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In Computer vision–ECCV 2014, pp. 818–833. Springer, 2014.
+
+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, 2016.
+
+# A RANDOM RESULTS
+
+![](images/56046904ef7dc7617dbe0e10eb3d4bc0cf57ee2e68dd29905815aada30679ce8.jpg)  
+Figure 13: Results on 34 randomly chosen ImageNet images. Middle columns: original image; left columns: sensitivity maps (Simonyan et al., 2013) where the red pixels indicate high sensitivity, and white pixels mean no sensitivity (note that we show the absolute values of the partial derivatives, since the sign cannot be interpreted like in our method); right columns: results from our method. For both methods, we visualize the results with respect to the correct class which is given above the image. In brackets we see how the classifier ranks this class, i.e., a (1) means it was correctly classified, whereas a (4) means that it was misclassified, and the correct class was ranked fourth. For our method, red areas show evidence for the correct class, and blue areas show evidence against the class (e.g., the scuba diver looks more like a tea pot to the classifier).

parse/train/BJuysoFeg/BJuysoFeg.md

@@ -0,0 +1,240 @@
+# REVISITING BATCH NORMALIZATION FORPRACTICAL DOMAIN ADAPTATION
+
+Yanghao $\mathbf { L i } ^ { \dagger }$ , Naiyan Wang‡, Jianping $\mathbf { S h i } ^ { \circ }$ , Jiaying $\mathbf { L } \mathbf { i } \mathbf { u } ^ { \dagger }$ , Xiaodi Hou‡
+
+† Institute of Computer Science and Technology, Peking University   
+‡ TuSimple  SenseTime   
+lyttonhao@pku.edu.cn winsty@gmail.com shijianping5000@gmail.com   
+liujiaying@pku.edu.cn xiaodi.hou@gmail.com
+
+# ABSTRACT
+
+Deep neural networks (DNN) have shown unprecedented success in various computer vision applications such as image classification and object detection. However, it is still a common annoyance during the training phase, that one has to prepare at least thousands of labeled images to fine-tune a network to a specific domain. Recent study (Tommasi et al., 2015) shows that a DNN has strong dependency towards the training dataset, and the learned features cannot be easily transferred to a different but relevant task without fine-tuning. In this paper, we propose a simple yet powerful remedy, called Adaptive Batch Normalization (AdaBN) to increase the generalization ability of a DNN. By modulating the statistics from the source domain to the target domain in all Batch Normalization layers across the network, our approach achieves deep adaptation effect for domain adaptation tasks. In contrary to other deep learning domain adaptation methods, our method does not require additional components, and is parameter-free. It archives stateof-the-art performance despite its surprising simplicity. Furthermore, we demonstrate that our method is complementary with other existing methods. Combining AdaBN with existing domain adaptation treatments may further improve model performance.
+
+# 1 INTRODUCTION
+
+Training a DNN for a new image recognition task is expensive. It requires a large amount of labeled training images that are not easy to obtain. One common practice is to use labeled data from other related source such as a different public dataset, or harvesting images by keywords from a search engine. Because 1) the distributions of the source domains (third party datasets or Internet images) are often different from the target domain (testing images); and 2) DNN is particularly good at capturing dataset bias in its internal representation (Torralba & Efros, 2011), which eventually leads to overfitting, imperfectly paired training and testing sets usually leads to inferior performance.
+
+Known as domain adaptation, the effort to bridge the gap between training and testing data distributions has been discussed several times under the context of deep learning (Tzeng et al., 2014; Long et al., 2015; Tzeng et al., 2015; Ganin & Lempitsky, 2015). To make the connection between the domain of training and the domain of testing, most of these methods require additional optimization steps and extra parameters. Such additional computational burden could greatly complicate the training of a DNN which is already intimidating enough for most people.
+
+In this paper, we propose a simple yet effective approach called AdaBN for batch normalized DNN domain adaptation. We hypothesize that the label related knowledge is stored in the weight matrix of each layer, whereas domain related knowledge is represented by the statistics of the Batch Normalization (BN) (Ioffe & Szegedy, 2015) layer. Therefore, we can easily transfer the trained model to a new domain by modulating the statistics in the BN layer. This approach is straightforward to implement, has zero parameter to tune, and requires minimal computational resources. Moreover, our AdaBN is ready to be extended to more sophisticated scenarios such as multi-source domain adaptation and semi-supervised settings. Fig. 1 illustrates the flowchart of AdaBN. To summarize, our contributions are as follows:
+
+![](images/fb3bd16dd2ead98b3b1710a9d87b797a6dd41fd7ffe45f68b0b0df6a8ca63bb9.jpg)  
+Figure 1: Illustration of the proposed method. For each convolutional or fully connected layer, we use different bias/variance terms to perform batch normalization for the training domain and the test domain. The domain specific normalization mitigates the domain shift issue.
+
+1. We propose a novel domain adaptation technique called Adaptive Batch Normalization (AdaBN). We show that AdaBN can naturally dissociate bias and variance of a dataset, which is ideal for domain adaptation tasks.   
+2. We validate the effectiveness of our approach on standard benchmarks for both single source and multi-source domain adaptation. Our method outperforms the state-of-the-art methods.   
+3. We conduct experiments on the cloud detection for remote sensing images to further demonstrate the effectiveness of our approach in practical use.
+
+# 2 RELATED WORK
+
+Domain transfer in visual recognition tasks has gained increasing attention in recent literature (Beijbom, 2012; Patel et al., 2015). Often referred to as covariate shift (Shimodaira, 2000) or dataset bias (Torralba & Efros, 2011), this problem poses a great challenge to the generalization ability of a learned model. One key component of domain transfer is to model the difference between source and target distributions. In Khosla et al. (2012), the authors assign each dataset with an explicit bias vector, and train one discriminative model to handle multiple classification problems with different bias terms. A more explicit way to compute dataset difference is based on Maximum Mean Discrepancy (MMD) (Gretton et al., 2012). This approach projects each data sample into a Reproducing Kernel Hilbert Space, and then computes the difference of sample means. To reduce dataset discrepancies, many methods are proposed, including sample selections (Huang et al., 2006; Gong et al., 2013), explicit projection learning (Pan et al., 2011; Gopalan et al., 2011; Baktashmotlagh et al., 2013) and principal axes alignment (Fernando et al., 2013; Gong et al., 2012; Aljundi et al., 2015).
+
+All of these methods face the same challenge of constructing the domain transfer function – a highdimensional non-linear function. Due to computational constraints, most of the proposed transfer functions are in the category of simple shallow projections, which are typically composed of kernel transformations and linear mapping functions.
+
+In the field of deep learning, feature transferability across different domains is a tantalizing yet generally unsolved topic (Yosinski et al., 2014; Tommasi et al., 2015). To transfer the learned representations to a new dataset, pre-training plus fine-tuning (Donahue et al., 2014) have become de facto procedures. However, adaptation by fine-tuning is far from perfect. It requires a considerable amount of labeled data from the target domain, and non-negligible computational resources to retrain the whole network.
+
+A series of progress has been made in DNN to facilitate domain transfer. Early works of domain adaptation either focus on reordering fine-tuning samples (Chopra et al., 2013), or regularizing MMD (Gretton et al., 2012) in a shallow network (Ghifary et al., 2014). It is only until recently that the problem is directly attacked under the setting of classification of unlabeled target domain using modern convolutional neural network (CNN) architecture. DDC (Tzeng et al., 2014) used the classical MMD loss to regularize the representation in the last layer of CNN. DAN (Long et al., 2015) further extended the method to multiple kernel MMD and multiple layer adaptation. Besides adapting features using MMD, RTN (Long et al., 2016) also added a gated residual layer for classifier adaptation. RevGrad (Ganin & Lempitsky, 2015) devised a gradient reversal layer to compensate the back-propagated gradients that are domain specific. Recently, by explicitly modeling both private and shared components of the domain representations in the network, Bousmalis et al. (2016) proposed a Domain Separation Network to extract better domain-invariant features.
+
+Another related work is CORAL (Sun et al., 2016). This model focuses on the last layer of CNN. CORAL whitens the data in source domain, and then re-correlates the source domain features to target domain. This operation aligns the second order statistics of source domain and target domain distributions. Surprisingly, such simple approach yields state-of-the-arts results in various text classification and visual recognition tasks. Recently, Deep CORAL (Sun & Saenko, 2016) also extends the method into DNN by incorporating a CORAL loss.
+
+# 2.1 BATCH NORMALIZATION
+
+In this section, we briefly review Batch Normalization (BN) (Ioffe & Szegedy, 2015) which is closely related to our AdaBN. The BN layer is originally designed to alleviate the issue of internal covariate shifting – a common problem while training a very deep neural network. It first standardizes each feature in a mini-batch, and then learns a common slope and bias for each mini-batch. Formally, given the input to a BN layer $\mathbf { X } \in \mathbb { R } ^ { n \times p }$ , where $n$ denotes the batch size, and $p$ is the feature dimension, BN layer transforms a feature $j \in \{ 1 \ldots p \}$ into:
+
+$$
+\begin{array} { r l } & { \hat { x } _ { j } = \frac { x _ { j } - \mathbb { E } \left[ \mathbf { X } _ { \cdot j } \right] } { \sqrt { \operatorname { V a r } [ \mathbf { X } _ { \cdot j } ] } } , } \\ & { y _ { j } = \gamma _ { j } \hat { x } _ { j } + \beta _ { j } , } \end{array}
+$$
+
+where $x _ { j }$ and $y _ { j }$ are the input/output scalars of one neuron response in one data sample; $\mathbf { X } _ { \cdot j }$ denotes the $j ^ { t h }$ column of the input data; and $\gamma _ { j }$ and $\beta _ { j }$ are parameters to be learned. This transformation guarantees that the input distribution of each layer remains unchanged across different mini-batches. For Stochastic Gradient Descent (SGD) optimization, a stable input distribution could greatly facilitate model convergence, leading to much faster training speed for CNN. Moreover, if training data are shuffled at each epoch, the same training sample will be applied with different transformations, or in other words, more comprehensively augmented throughout the training. During the testing phase, the global statistics of all training samples is used to normalize every mini-batch of test data.
+
+Extensive experiments have shown that Batch Normalization significantly reduces the number of iteration to converge, and improves the final performance at the same time. BN layer has become a standard component in recent top-performing CNN architectures, such as deep residual network (He et al., 2016), and Inception V3 (Szegedy et al., 2015).
+
+# 3 THE MODEL
+
+In Sec. 3.1, we first analyze the domain shift in deep neural network, and reveal two key observations. Then in Sec. 3.2, we introduce our Adaptive Batch Normalization (AdaBN) method based on these observations.
+
+# 3.1 A PILOT EXPERIMENT
+
+The Batch Normalization (BN) technique is originally proposed to help SGD optimization by aligning the distribution of training data. From this perspective, it is interesting to examine the BN parameters (batch-wise mean and variance) over different dataset at different layers of the network.
+
+In this pilot experiment, we use MXNet implementation (Chen et al., 2016b) of the Inception-BN model (Ioffe & Szegedy, 2015) pre-trained on ImageNet classification task (Russakovsky et al., 2015) as our baseline DNN model. Our image data are drawn from (Bergamo & Torresani, 2010), which contains the same classes of images from both Caltech-256 dataset (Griffin et al., 2007) and Bing image search results. For each mini-batch sampled from one dataset, we concatenate the mean and variance of all neurons from one layer to form a feature vector. Using linear SVM, we can almost perfectly classify whether the mini-batch feature vector is from Caltech-256 or Bing dataset. Fig. 2 visualizes the distributions of mini-batch feature vectors from two datasets in 2D. It is clear that BN statistics from different domains are separated into clusters.
+
+![](images/8b54780b4e6ce548bc8d94465b49fff9fe6bc3aabb422481c6a6d0103c5b24d7.jpg)  
+(a) Shallow layer distributions
+
+![](images/e8e71c21882fe636329b7efe3cc59f5ab6d48265cdca17c5b9fcc74c721044ce.jpg)  
+(b) Deep layer distributions   
+Figure 2: t-SNE (Van der Maaten & Hinton, 2008) visualization of the mini-batch BN feature vector distributions in both shallow and deep layers, across different datasets. Each point represents the BN statistics in one mini-batch. Red dots come from Bing domain, while the blue ones are from Caltech-256 domain. The size of each mini-batch is 64.
+
+This pilot experiment suggests:
+
+1. Both shallow layers and deep layers of the DNN are influenced by domain shift. Domain adaptation by manipulating the output layer alone is not enough.   
+2. The statistics of BN layer contain the traits of the data domain.
+
+Both observations motivate us to adapt the representation across different domains by BN layer.
+
+# 3.2 ADAPTIVE BATCH NORMALIZATION
+
+Given the pre-trained DNN model and a target domain, our Adaptive Batch Normalization algorithm is as follows1:
+
+<table><tr><td>Algorithm1 Adaptive Batch Normalization (AdaBN)</td></tr><tr><td>for neuron jinDNN do Concatenate neuron responses on all images of tar-</td></tr><tr><td>get domain t: xj =[...,xj(m),...] Compute the mean and variance of the target do-</td></tr><tr><td>main: μ =E(x)，=√Var(x).</td></tr><tr><td>end for</td></tr><tr><td>for neuron j in DNN, testing image m in target domain do</td></tr><tr><td>(aj(m)-μ) Compute BN output yj(m) := γj +βj</td></tr><tr><td>g end for</td></tr></table>
+
+The intuition behind our method is straightforward: The standardization of each layer by domain ensures that each layer receives data from a similar distribution, no matter it comes from the source domain or the target domain. Although modulating statistics in one BN layer by AdaBN is a simple translation and scaling operation, such linear transformation in one layer can achieve a highly nonlinear transformation through the whole deep CNN architecture. Thus, we believe this AdaBN process could approximate the intrinsically non-linear domain transfer function.
+
+For $K$ domain adaptation where $K > 2$ , we standardize each sample by the statistics in its own domain. During training, the statistics are calculated for every mini-batch, the only thing that we need to make sure is that the samples in every mini-batch are from the same domain. For (semi)supervised domain adaptation, we may use the labeled data to fine-tune the weights as well. As a result, our method could fit in all different settings of domain adaptation with minimal effort.
+
+Compared with CORAL (Sun et al., 2016), one natural question is why we transform the neuron responses independently, not decorrelate and then re-correlate the responses together as suggested in Sun et al. (2016). Under certain conditions, decorrelation could improve the performance. However, in CNN, the mini-batch size is usually smaller than the feature dimension, leading to singular covariance matrices that is hard to be inversed. As a result, the covariance matrix is always singular. In addition, decorrelation requires to compute the inverse of the covariance matrix which is computationally intensive, especially if we plan to apply AdaBN to all layers of the network.
+
+# 4 EXPERIMENTS
+
+In this section, we demonstrate the effectiveness of AdaBN on standard domain adaptation datasets, and empirically analyze our AdaBN model. We also evaluation our method on a practical application with remote sensing images.
+
+# 4.1 EXPERIMENTAL SETTINGS
+
+We first introduce our experiments on two standard datasets: Office (Saenko et al., 2010) and Caltech-Bing (Bergamo & Torresani, 2010).
+
+Office (Saenko et al., 2010) is a standard benchmark for domain adaptation, which is a collection of 4652 images in 31 classes from three different domains: Amazon $\mathbf { \Pi } ^ { ( \mathbf { A } ) }$ , $D S R L ( \mathbf { D } )$ and Webcam(W). Similar to (Tzeng et al., 2014; Sun et al., 2016; Long et al., 2015), we evaluate the pairwise domain adaption performance of AdaBN on all six pairs of domains. For the multi-source setting, we evaluate our method on three transfer tasks $\{ \mathbf { A } , \bar { \mathbf { W } } \} \to \mathbf { D }$ , $\{ \mathbf { A } , \mathbf { D } \} \to \mathbf { W }$ , $\{ \mathbf { D } , \mathbf { W } \}  \mathbf { A }$ .
+
+Caltech-Bing (Bergamo & Torresani, 2010) is a much larger domain adaptation dataset, which contains 30,607 and 121,730 images in 256 categories from two domains Caltech-256(C) and Bing(B). The images in the Bing set are collected from Bing image search engine by keyword search. Apparently Bing data contains noise, and its data distribution is dramatically different from that of Caltech-256.
+
+We compare our approach with a variety of methods, including four shallow methods: SA (Fernando et al., 2013), LSSA (Aljundi et al., 2015), GFK (Gong et al., 2012), CORAL (Sun et al., 2016), and four deep methods: DDC (Tzeng et al., 2014), DAN (Long et al., 2015), RevGrad (Ganin & Lempitsky, 2015), Deep CORAL (Sun & Saenko, 2016). Specifically, GFK models domain shift by integrating an infinite number of subspaces that characterize changes in statistical properties from the source to the target domain. SA, LSSA and CORAL align the source and target subspaces by explicit feature space transformations that would map source distribution into the target one. DDC and DAN are deep learning based methods which maximize domain invariance by adding to AlexNet one or several adaptation layers using MMD. RevGrad incorporates a gradient reversal layer in the deep model to encourage learning domain-invariant features. Deep CORAL extends CORAL to perform end-to-end adaptation in DNN. It should be noted that these deep learning methods have the adaptation layers on top of the output layers of DNNs, which is a sharp contrast to our method that delves into early convolution layers as well with the help of BN layers.
+
+We follow the full protocol (Donahue et al., 2014) for the single source setting; while for multiple sources setting, we use all the samples in the source domains as training data, and use all the samples in the target domain as testing data. We fine-tune the Inception-BN (Ioffe & Szegedy, 2015) model on source domain in each task for 100 epochs. The learning rate is set to 0.01 initially, and then is dropped by a factor 0.1 every 40 epochs. Since the office dataset is quite small, following the best practice in Long et al. (2015), we freeze the first three groups of Inception modules, and set the learning rate of fourth and fifth group one tenth of the base learning rate to avoid overfitting. For Caltech-Bing dataset, we fine-tune the whole model with the same base learning rate.
+
+Table 1: Single source domain adaptation results on Office-31 (Saenko et al., 2010) dataset with standard unsupervised adaptation protocol.   
+
+<table><tr><td colspan="7">Method A→W D→W W→D A→D D→A W→A Avg</td></tr><tr><td>AlexNet (Krizhevsky et al.,2012)</td><td>61.6</td><td>95.4</td><td>99.0</td><td>63.8</td><td>51.1</td><td>49.8 70.1</td></tr><tr><td>DDC (Tzeng et al., 2014)</td><td>61.8</td><td>95.0</td><td>98.5</td><td>64.4 52.1</td><td>52.2</td><td>70.6</td></tr><tr><td>DAN (Long et al., 2015)</td><td>68.5</td><td>96.0</td><td>99.0</td><td>67.0 54.0</td><td>53.1</td><td>72.9</td></tr><tr><td>Deep CORAL (Sun &amp; Saenko, 2016)</td><td>66.4</td><td>95.7</td><td>99.2</td><td>66.8</td><td>52.8 51.5</td><td>72.1</td></tr><tr><td>RevGrad (Ganin &amp; Lempitsky,2015)</td><td>73.0</td><td>96.4</td><td>99.2</td><td>1 1</td><td>1</td><td>1</td></tr><tr><td>Inception BN (Ioffe &amp; Szegedy, 2015)</td><td>70.3</td><td>94.3</td><td>100</td><td>70.5</td><td>60.1 57.9</td><td>75.5</td></tr><tr><td>SA (Fernando et al., 2013)</td><td>69.8</td><td>95.5</td><td>99.0</td><td>71.3</td><td>59.4 56.9</td><td>75.3</td></tr><tr><td>GFK (Gong et al., 2012)</td><td>66.7</td><td>97.0</td><td>99.4</td><td>70.1</td><td>58.0 56.9</td><td>74.7</td></tr><tr><td>LSSA (Aljundi et al., 2015)</td><td>67.7</td><td>96.1</td><td>98.4</td><td>71.3</td><td>57.8 57.8</td><td>74.9</td></tr><tr><td>CORAL (Sun et al., 2016)</td><td>70.9</td><td>95.7</td><td>99.8</td><td>71.9</td><td>59.0 60.2</td><td>76.3</td></tr><tr><td>AdaBN</td><td>74.2</td><td>95.7</td><td>99.8</td><td>73.1</td><td>59.8 57.4</td><td>76.7</td></tr><tr><td> AdaBN + CORAL</td><td>75.4</td><td>96.2</td><td>99.6</td><td>72.7</td><td>59.0 60.5</td><td>77.2</td></tr></table>
+
+# 4.2 RESULTS
+
+# 4.2.1 OFFICE DATASET
+
+Our results on Office dataset is reported in Table 1 and Table 2 for single/multi source(s), respectively. Note that the first 5 models of the Table 1 are pre-trained on AlexNet (Krizhevsky et al., 2012) instead of the Inception-BN (Ioffe & Szegedy, 2015) model, due to the lack of publicly available pre-trained Inception BN model in Caffe (Jia et al., 2014). Thus, the relative improvements over the baseline (AlexNet/Inception BN) make more sense than the absolute numbers of each algorithm.
+
+From Table 1, we first notice that the Inception-BN indeed improves over the AlexNet on average, which means that the CNN pre-trained on ImageNet has learned general features, the improvements on ImageNet can be transferred to new tasks. Among the methods based on Inception-BN features, our method improves the most over the baseline. Moreover, since our method is complementary to other methods, we can simply apply CORAL on the top of AdaBN. Not surprisingly, this simple combination exhibits $0 . 5 \%$ increase in performance. This preliminary test reveals further potential of AdaBN if combined with other advanced domain adaptation methods. Finally, we could improve $1 . 7 \%$ over the baseline, and advance the state-of-the-art results for this dataset.
+
+None of the compared methods has reported their performance on multi-source domain adaptation. To demonstrate the capacity of AdaBN under multi-domain settings, we compare it against CORAL, which is the best performing algorithm in the single source setting. The result is reported in Table 2. We find that simply combining two domains does not lead to better performance. The result is generally worse compared to the best performing single domain between the two. This phenomenon suggests that if we cannot properly cope with domain bias, the increase of training samples may be reversely affect to the testing performance. This result confirms the necessity of domain adaptation. In this more challenging setting, AdaBN still outperforms the baseline and CORAL on average. Again, when combined with CORAL, our method demonstrates further improvements. At last, our method archives $2 . 3 \%$ gain over the baseline.
+
+<table><tr><td>Method</td><td>A,D→WA,W→D D,W→A</td><td></td><td></td><td>Avg</td></tr><tr><td>Inception BN (Ioffe &amp; Szegedy,2015)</td><td>90.8</td><td>95.4</td><td>60.2</td><td>82.1</td></tr><tr><td>CORAL (Sun et al., 2016)</td><td>92.1</td><td>96.4</td><td>61.4</td><td>83.3</td></tr><tr><td>AdaBN</td><td>94.2</td><td>97.2</td><td>59.3</td><td>83.6</td></tr><tr><td>AdaBN + CORAL</td><td>95.0</td><td>97.8</td><td>60.5</td><td>84.4</td></tr></table>
+
+Table 2: Multi-source domain adaptation results on Office-31 (Saenko et al., 2010) dataset with standard unsupervised adaptation protocol.
+
+# 4.2.2 CALTECH-BING DATASET
+
+To further evaluate our method on the large-scale dataset, we show our results on Caltech-Bing Dataset in Table 3. Compared with CORAL, AdaBN achieves better performance, which improves $1 . 8 \%$ over the baseline. Note that all the domain adaptation methods show minor improvements over the baseline in the task $\mathbf { C }  \mathbf { B }$ . One of the hypotheses to this relatively small improvement is that the images in Bing dataset are collected from Internet, which are more diverse and noisier (Bergamo & Torresani, 2010). Thus, it is not easy to adapt on the Bing dataset from the relatively clean dataset Caltech-256. Combining CORAL with our method does not offer further improvements. This might be explained by the noise of the Bing dataset and the imbalance of the number of images in the two domains.
+
+Table 3: Single source domain adaptation results on Caltech-Bing (Bergamo & Torresani, 2010) dataset.   
+
+<table><tr><td>Method</td><td>C→B B→C Avg</td><td></td><td></td></tr><tr><td>Inception BN (Ioffe&amp; Szegedy,2015)35.1</td><td></td><td>64.6</td><td>49.9</td></tr><tr><td>CORAL (Sun et al., 2016)</td><td>35.3</td><td>67.2 </td><td> 51.3</td></tr><tr><td>AdaBN</td><td>35.2</td><td>68.1</td><td>51.7</td></tr><tr><td> AdaBN + CORAL</td><td>35.0</td><td>67.551.2</td><td></td></tr></table>
+
+# 4.3 EMPIRICAL ANALYSIS
+
+In this section, we investigate the influence of the number of samples in target domain to the performance and empirically analyze the adaptation effect of different BN layers.
+
+# 4.3.1 SENSITIVITY TO TARGET DOMAIN SIZE.
+
+Since the key of our method is to calculate the mean and variance of the target domain on different BN layers, it is very natural to ask how many target images is necessary to obtain stable statistics. In this experiment, we randomly select a subset of images in target domain to calculate the statistics and then evaluate the performance on the whole target set. Fig. 3 illustrates the effect of using different number of batches. The results demonstrate that our method can obtain good results when using only a small part of the target examples. It should also be noted that in the extremal case of one batch of target images, our method still achieves better results than the baseline. This is valuable in practical use since a large number of target images are often not available.
+
+![](images/496f3f9cc7373771a6785c1983a9a46a95324b04f4a9fb6a0c2342e83b75e6af.jpg)  
+Figure 3: Accuracy when varying the number of mini-batches used for calculating the statistics of BN layers in $\mathbf A \to \mathbf W$ and $\mathbf { B }  \mathbf { C }$ , respectively. For $\mathbf B \to \mathbf C$ , we only show the results of using less than 100 batches, since the results are very stable when adding more examples. The batch size is 64 in this experiment. For even smaller number of examples, the performance may be not consistent and drop behind the baseline (e.g. 0.652 with 16 samples, 0.661 with 32 samples).
+
+![](images/ae6f16be07fe0af154144a608f7cb13eb98945cd3405d52036b5bc9286acf302.jpg)  
+Figure 4: Accuracy when adapting with different BN blocks in $\mathbf B \to \mathbf C$ . $x = 0$ corresponds to the result with non-adapt method, and 1, 2, 3a, $_ { 3 b }$ , 4a, $4 b$ , 4c, 5a, $5 b$ correspond to the nine different blocks in Inception-BN network..
+
+# 4.3.2 ADAPTATION EFFECT FOR DIFFERENT BN LAYERS.
+
+In this experiment, we analyze the effect of adapting on different BN layers with our AdaBN method. According to the structure of Inception-BN network Ioffe & Szegedy (2015), we categorize the BN layers into 9 blocks: 1, 2, 3a, 3b, 4a, 4b, 4c, 5a, 5b. Since the back BN layers are influenced by the outputs of previous BN layers, when adapting a specific block we adapted all the blocks before it. Fig. 4 illustrates the adaptation effect for different BN layers. It shows that adapting BN layers consistently improves the results over the baseline method in most cases. Specifically, when incorporating more BN layers in the adaptation, we could achiever better transfer results.
+
+# 4.4 PRACTICAL APPLICATION FOR CLOUD DETECTION IN REMOTE SENSING IMAGES
+
+In this section, we further demonstrate the effectiveness of AdaBN on a practical problem: Cloud Detection in Remote Sensing Images. Since remote sensing images are taken by different satellites with different sensors and resolutions, the captured images are visually different in texture, color, and value range distributions, as shown in Fig. 5. How to adapt a model trained on one satellite to another satellite images is naturally a domain adaptation problem.
+
+Our task here is to identify cloud from the remote sensing images, which can be regarded as a semantic segmentation task. The experiment is taken under a self-collected dataset, which includes three image sets, from GF2, GF1 and Tianhui satellites. Each image set contains 635, 324 and 113 images with resolution over $6 0 0 0 { \times } 6 0 0 0$ pixels respectively. We name the three different datasets following the satellite names. GF2 dataset is used as the training dataset while GF1 and Tianhui datasets are for testing. We use a state-of-art semantic segmentation method (Chen et al., 2016a) as our baseline model.
+
+<table><tr><td>Method</td><td>GF1</td><td>Tianhui</td></tr><tr><td>Baseline</td><td>38.95%</td><td>14.54%</td></tr><tr><td> AdaBN</td><td>64.50%</td><td>29.66%</td></tr></table>
+
+Table 4: Domain adaptation results (mIOU) on GF1 and Tianhui datasets training on GF2 datasets.
+
+The results on GF1 and Tianhui datasets are shown in Table 4. The relatively low results of the baseline method indicate that there exists large distribution disparity among images from different satellites. Thus, the significant improvement after applying AdaBN reveals the effectiveness of our method. Some of the visual results are shown in Fig. 6. Since other domain adaptation methods require either additional optimization steps and extra components (e.g. MMD) or post-processing distribution alignment (like CORAL), it is very hard to apply these methods from image classification to this large-size $( 6 0 0 0 \times 6 0 0 0 )$ segmentation problem. Comparatively, besides the effective performance, our method needs no extra parameters and very few computations over the whole adaptation process.
+
+![](images/f297e25a4dfe06baa9619e485ecd47aef546efbc1802ef59bdb62cce63c4fb42.jpg)  
+Figure 5: Remote sensing images in different domains.
+
+![](images/f0e93f1f24071fb5ac37bd0c96690996da8f1c1d75523e251fd7caed483d04b1.jpg)  
+Figure 6: Visual cloud detection results on GF1 dataset. White pixels in (b) and (c) represent the detected cloud regions.
+
+# 5 CONCLUSION AND FUTURE WORKS
+
+In this paper, we have introduced a simple yet effective approach for domain adaptation on batch normalized neural networks. Besides its original uses, we have exploited another functionality of Batch Normalization (BN) layer: domain adaptation. The main idea is to replace the statistics of each BN layer in source domain with those in target domain. The proposed method is easy to implement and parameter-free, and it takes almost no effort to extend to multiple source domains and semi-supervised settings. Our method established new state-of-the-art results on both single and multiple source(s) domain adaptation settings on standard benchmarks. At last, the experiments on cloud detection for large-size remote sensing images further demonstrate the effectiveness of our method in practical use. We believe our method opens up a new direction for domain adaptation.
+
+In contrary to other methods that use Maximum Mean Discrepancy (MMD) or domain confusion loss to update the weights in CNN for domain adaptation, our method only modifies the statistics of BN layer. Therefore, our method is fully complementary to other existing deep learning based methods. It is interesting to see how these different methods can be unified under one framework.
+
+# REFERENCES
+
+Rahaf Aljundi, Remi Emonet, Damien Muselet, and Marc Sebban. Landmarks-based kernelized ´ subspace alignment for unsupervised domain adaptation. In CVPR, 2015.   
+Mahsa Baktashmotlagh, Mehrtash Harandi, Brian Lovell, and Mathieu Salzmann. Unsupervised domain adaptation by domain invariant projection. In ICCV, pp. 769–776, 2013.   
+Oscar Beijbom. Domain adaptations for computer vision applications. arXiv preprint arXiv:1211.4860, 2012.   
+Alessandro Bergamo and Lorenzo Torresani. Exploiting weakly-labeled web images to improve object classification: a domain adaptation approach. In NIPS, pp. 181–189, 2010.   
+Konstantinos Bousmalis, George Trigeorgis, Nathan Silberman, Dilip Krishnan, and Dumitru Erhan. Domain separation networks. NIPS, 2016.   
+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. arXiv preprint arXiv:1606.00915, 2016a.   
+Tianqi Chen, Mu Li, Yutian Li, Min Lin, Naiyan Wang, Minjie Wang, Tianjun Xiao, Bing Xu, Chiyuan Zhang, and Zheng Zhang. MXNet: A flexible and efficient machine learning library for heterogeneous distributed systems. NIPS Workshop on Machine Learning Systems, 2016b.   
+Sumit Chopra, Suhrid Balakrishnan, and Raghuraman Gopalan. DLID: Deep learning for domain adaptation by interpolating between domains. In ICML Workshop on Challenges in Representation Learning, volume 2, 2013.   
+Jeff Donahue, Yangqing Jia, Oriol Vinyals, Judy Hoffman, Ning Zhang, Eric Tzeng, and Trevor Darrell. DeCAF: A deep convolutional activation feature for generic visual recognition. In ICML, pp. 647–655, 2014.   
+E Knuth Donald. The art of computer programming. Sorting and searching, 3:426–458, 1999.   
+Basura Fernando, Amaury Habrard, Marc Sebban, and Tinne Tuytelaars. Unsupervised visual domain adaptation using subspace alignment. In ICCV, pp. 2960–2967, 2013.   
+Yaroslav Ganin and Victor Lempitsky. Unsupervised domain adaptation by backpropagation. In ICML, pp. 1180–1189, 2015.   
+Muhammad Ghifary, W Bastiaan Kleijn, and Mengjie Zhang. Domain adaptive neural networks for object recognition. In PRICAI: Trends in Artificial Intelligence, pp. 898–904. 2014.   
+Boqing Gong, Yuan Shi, Fei Sha, and Kristen Grauman. Geodesic flow kernel for unsupervised domain adaptation. In CVPR, pp. 2066–2073, 2012.
+
+Boqing Gong, Kristen Grauman, and Fei Sha. Connecting the dots with landmarks: Discriminatively learning domain-invariant features for unsupervised domain adaptation. In ICML, pp. 222–230, 2013.
+
+Raghuraman Gopalan, Ruonan Li, and Rama Chellappa. Domain adaptation for object recognition: An unsupervised approach. In ICCV, pp. 999–1006, 2011.
+
+Arthur Gretton, Karsten M Borgwardt, Malte J Rasch, Bernhard Scholkopf, and Alexander Smola. ¨ A kernel two-sample test. The Journal of Machine Learning Research, 13(1):723–773, 2012.
+
+Gregory Griffin, Alex Holub, and Pietro Perona. Caltech-256 object category dataset. 2007.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CVPR, 2016.
+
+Jiayuan Huang, Arthur Gretton, Karsten M Borgwardt, Bernhard Scholkopf, and Alex J Smola. ¨ Correcting sample selection bias by unlabeled data. In NIPS, pp. 601–608, 2006.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, pp. 448–456, 2015.
+
+Yangqing Jia, Evan Shelhamer, Jeff Donahue, Sergey Karayev, Jonathan Long, Ross Girshick, Sergio Guadarrama, and Trevor Darrell. Caffe: Convolutional architecture for fast feature embedding. In ACM MM, pp. 675–678, 2014.
+
+Aditya Khosla, Tinghui Zhou, Tomasz Malisiewicz, Alexei A Efros, and Antonio Torralba. Undoing the damage of dataset bias. In ECCV, pp. 158–171. 2012.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, pp. 1097–1105, 2012.
+
+Mingsheng Long, Yue Cao, Jianmin Wang, and Michael Jordan. Learning transferable features with deep adaptation networks. In ICML, pp. 97–105, 2015.
+
+Mingsheng Long, Jianmin Wang, and Michael I Jordan. Unsupervised domain adaptation with residual transfer networks. In NIPS, 2016.
+
+Sinno Jialin Pan, Ivor W Tsang, James T Kwok, and Qiang Yang. Domain adaptation via transfer component analysis. IEEE Transactions on Neural Networks, 22(2):199–210, 2011.
+
+Vishal M Patel, Raghuraman Gopalan, Ruonan Li, and Rama Chellappa. Visual domain adaptation: A survey of recent advances. IEEE Signal Processing Magazine, 32(3):53–69, 2015.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. ImageNet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015.
+
+Kate Saenko, Brian Kulis, Mario Fritz, and Trevor Darrell. Adapting visual category models to new domains. In ECCV, pp. 213–226. 2010.
+
+Hidetoshi Shimodaira. Improving predictive inference under covariate shift by weighting the loglikelihood function. Journal of statistical planning and inference, 90(2):227–244, 2000.
+
+Baochen Sun and Kate Saenko. Deep coral: Correlation alignment for deep domain adaptation. arXiv preprint arXiv:1607.01719, 2016.
+
+Baochen Sun, Jiashi Feng, and Kate Saenko. Return of frustratingly easy domain adaptation. AAAI, 2016.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. arXiv preprint arXiv:1512.00567, 2015.
+
+Tatiana Tommasi, Novi Patricia, Barbara Caputo, and Tinne Tuytelaars. A deeper look at dataset bias. German Conference on Pattern Recognition, 2015.
+
+Antonio Torralba and Alexei A Efros. Unbiased look at dataset bias. In CVPR, pp. 1521–1528, 2011.
+
+Eric Tzeng, Judy Hoffman, Ning Zhang, Kate Saenko, and Trevor Darrell. Deep domain confusion: Maximizing for domain invariance. arXiv preprint arXiv:1412.3474, 2014.
+
+Eric Tzeng, Judy Hoffman, Trevor Darrell, and Kate Saenko. Simultaneous deep transfer across domains and tasks. In ICCV, pp. 4068–4076, 2015.
+
+Laurens Van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of Machine Learning Research, 9(2579-2605):85, 2008.
+
+Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In NIPS, pp. 3320–3328, 2014.

parse/train/BJuysoFeg/BJuysoFeg_content_list.json

@@ -0,0 +1,1228 @@
+[
+    {
+        "type": "text",
+        "text": "REVISITING BATCH NORMALIZATION FORPRACTICAL DOMAIN ADAPTATION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            684,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yanghao $\\mathbf { L i } ^ { \\dagger }$ , Naiyan Wang‡, Jianping $\\mathbf { S h i } ^ { \\circ }$ , Jiaying $\\mathbf { L } \\mathbf { i } \\mathbf { u } ^ { \\dagger }$ , Xiaodi Hou‡ ",
+        "bbox": [
+            186,
+            169,
+            673,
+            185
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "† Institute of Computer Science and Technology, Peking University   \n‡ TuSimple \u0005 SenseTime   \nlyttonhao@pku.edu.cn winsty@gmail.com shijianping5000@gmail.com   \nliujiaying@pku.edu.cn xiaodi.hou@gmail.com ",
+        "bbox": [
+            184,
+            186,
+            743,
+            241
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            279,
+            544,
+            294
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks (DNN) have shown unprecedented success in various computer vision applications such as image classification and object detection. However, it is still a common annoyance during the training phase, that one has to prepare at least thousands of labeled images to fine-tune a network to a specific domain. Recent study (Tommasi et al., 2015) shows that a DNN has strong dependency towards the training dataset, and the learned features cannot be easily transferred to a different but relevant task without fine-tuning. In this paper, we propose a simple yet powerful remedy, called Adaptive Batch Normalization (AdaBN) to increase the generalization ability of a DNN. By modulating the statistics from the source domain to the target domain in all Batch Normalization layers across the network, our approach achieves deep adaptation effect for domain adaptation tasks. In contrary to other deep learning domain adaptation methods, our method does not require additional components, and is parameter-free. It archives stateof-the-art performance despite its surprising simplicity. Furthermore, we demonstrate that our method is complementary with other existing methods. Combining AdaBN with existing domain adaptation treatments may further improve model performance. ",
+        "bbox": [
+            233,
+            309,
+            764,
+            545
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            571,
+            336,
+            588
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Training a DNN for a new image recognition task is expensive. It requires a large amount of labeled training images that are not easy to obtain. One common practice is to use labeled data from other related source such as a different public dataset, or harvesting images by keywords from a search engine. Because 1) the distributions of the source domains (third party datasets or Internet images) are often different from the target domain (testing images); and 2) DNN is particularly good at capturing dataset bias in its internal representation (Torralba & Efros, 2011), which eventually leads to overfitting, imperfectly paired training and testing sets usually leads to inferior performance. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            702
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Known as domain adaptation, the effort to bridge the gap between training and testing data distributions has been discussed several times under the context of deep learning (Tzeng et al., 2014; Long et al., 2015; Tzeng et al., 2015; Ganin & Lempitsky, 2015). To make the connection between the domain of training and the domain of testing, most of these methods require additional optimization steps and extra parameters. Such additional computational burden could greatly complicate the training of a DNN which is already intimidating enough for most people. ",
+        "bbox": [
+            174,
+            708,
+            823,
+            791
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a simple yet effective approach called AdaBN for batch normalized DNN domain adaptation. We hypothesize that the label related knowledge is stored in the weight matrix of each layer, whereas domain related knowledge is represented by the statistics of the Batch Normalization (BN) (Ioffe & Szegedy, 2015) layer. Therefore, we can easily transfer the trained model to a new domain by modulating the statistics in the BN layer. This approach is straightforward to implement, has zero parameter to tune, and requires minimal computational resources. Moreover, our AdaBN is ready to be extended to more sophisticated scenarios such as multi-source domain adaptation and semi-supervised settings. Fig. 1 illustrates the flowchart of AdaBN. To summarize, our contributions are as follows: ",
+        "bbox": [
+            174,
+            799,
+            825,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/fb3bd16dd2ead98b3b1710a9d87b797a6dd41fd7ffe45f68b0b0df6a8ca63bb9.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of the proposed method. For each convolutional or fully connected layer, we use different bias/variance terms to perform batch normalization for the training domain and the test domain. The domain specific normalization mitigates the domain shift issue. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            274,
+            99,
+            722,
+            315
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. We propose a novel domain adaptation technique called Adaptive Batch Normalization (AdaBN). We show that AdaBN can naturally dissociate bias and variance of a dataset, which is ideal for domain adaptation tasks.   \n2. We validate the effectiveness of our approach on standard benchmarks for both single source and multi-source domain adaptation. Our method outperforms the state-of-the-art methods.   \n3. We conduct experiments on the cloud detection for remote sensing images to further demonstrate the effectiveness of our approach in practical use. ",
+        "bbox": [
+            209,
+            406,
+            825,
+            541
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            568,
+            344,
+            583
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Domain transfer in visual recognition tasks has gained increasing attention in recent literature (Beijbom, 2012; Patel et al., 2015). Often referred to as covariate shift (Shimodaira, 2000) or dataset bias (Torralba & Efros, 2011), this problem poses a great challenge to the generalization ability of a learned model. One key component of domain transfer is to model the difference between source and target distributions. In Khosla et al. (2012), the authors assign each dataset with an explicit bias vector, and train one discriminative model to handle multiple classification problems with different bias terms. A more explicit way to compute dataset difference is based on Maximum Mean Discrepancy (MMD) (Gretton et al., 2012). This approach projects each data sample into a Reproducing Kernel Hilbert Space, and then computes the difference of sample means. To reduce dataset discrepancies, many methods are proposed, including sample selections (Huang et al., 2006; Gong et al., 2013), explicit projection learning (Pan et al., 2011; Gopalan et al., 2011; Baktashmotlagh et al., 2013) and principal axes alignment (Fernando et al., 2013; Gong et al., 2012; Aljundi et al., 2015). ",
+        "bbox": [
+            173,
+            603,
+            825,
+            770
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "All of these methods face the same challenge of constructing the domain transfer function – a highdimensional non-linear function. Due to computational constraints, most of the proposed transfer functions are in the category of simple shallow projections, which are typically composed of kernel transformations and linear mapping functions. ",
+        "bbox": [
+            174,
+            777,
+            823,
+            833
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the field of deep learning, feature transferability across different domains is a tantalizing yet generally unsolved topic (Yosinski et al., 2014; Tommasi et al., 2015). To transfer the learned representations to a new dataset, pre-training plus fine-tuning (Donahue et al., 2014) have become de facto procedures. However, adaptation by fine-tuning is far from perfect. It requires a considerable amount of labeled data from the target domain, and non-negligible computational resources to retrain the whole network. ",
+        "bbox": [
+            173,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A series of progress has been made in DNN to facilitate domain transfer. Early works of domain adaptation either focus on reordering fine-tuning samples (Chopra et al., 2013), or regularizing MMD (Gretton et al., 2012) in a shallow network (Ghifary et al., 2014). It is only until recently that the problem is directly attacked under the setting of classification of unlabeled target domain using modern convolutional neural network (CNN) architecture. DDC (Tzeng et al., 2014) used the classical MMD loss to regularize the representation in the last layer of CNN. DAN (Long et al., 2015) further extended the method to multiple kernel MMD and multiple layer adaptation. Besides adapting features using MMD, RTN (Long et al., 2016) also added a gated residual layer for classifier adaptation. RevGrad (Ganin & Lempitsky, 2015) devised a gradient reversal layer to compensate the back-propagated gradients that are domain specific. Recently, by explicitly modeling both private and shared components of the domain representations in the network, Bousmalis et al. (2016) proposed a Domain Separation Network to extract better domain-invariant features. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            270
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Another related work is CORAL (Sun et al., 2016). This model focuses on the last layer of CNN. CORAL whitens the data in source domain, and then re-correlates the source domain features to target domain. This operation aligns the second order statistics of source domain and target domain distributions. Surprisingly, such simple approach yields state-of-the-arts results in various text classification and visual recognition tasks. Recently, Deep CORAL (Sun & Saenko, 2016) also extends the method into DNN by incorporating a CORAL loss. ",
+        "bbox": [
+            174,
+            276,
+            825,
+            361
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 BATCH NORMALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            378,
+            388,
+            393
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we briefly review Batch Normalization (BN) (Ioffe & Szegedy, 2015) which is closely related to our AdaBN. The BN layer is originally designed to alleviate the issue of internal covariate shifting – a common problem while training a very deep neural network. It first standardizes each feature in a mini-batch, and then learns a common slope and bias for each mini-batch. Formally, given the input to a BN layer $\\mathbf { X } \\in \\mathbb { R } ^ { n \\times p }$ , where $n$ denotes the batch size, and $p$ is the feature dimension, BN layer transforms a feature $j \\in \\{ 1 \\ldots p \\}$ into: ",
+        "bbox": [
+            174,
+            405,
+            825,
+            489
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9bee7c5a7947c3a06acadc8dd3d12b62c4daac585a33b6a1cd525c6f6dc0d57d.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\hat { x } _ { j } = \\frac { x _ { j } - \\mathbb { E } \\left[ \\mathbf { X } _ { \\cdot j } \\right] } { \\sqrt { \\operatorname { V a r } [ \\mathbf { X } _ { \\cdot j } ] } } , } \\\\ & { y _ { j } = \\gamma _ { j } \\hat { x } _ { j } + \\beta _ { j } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            434,
+            506,
+            565,
+            564
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $x _ { j }$ and $y _ { j }$ are the input/output scalars of one neuron response in one data sample; $\\mathbf { X } _ { \\cdot j }$ denotes the $j ^ { t h }$ column of the input data; and $\\gamma _ { j }$ and $\\beta _ { j }$ are parameters to be learned. This transformation guarantees that the input distribution of each layer remains unchanged across different mini-batches. For Stochastic Gradient Descent (SGD) optimization, a stable input distribution could greatly facilitate model convergence, leading to much faster training speed for CNN. Moreover, if training data are shuffled at each epoch, the same training sample will be applied with different transformations, or in other words, more comprehensively augmented throughout the training. During the testing phase, the global statistics of all training samples is used to normalize every mini-batch of test data. ",
+        "bbox": [
+            173,
+            565,
+            825,
+            679
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Extensive experiments have shown that Batch Normalization significantly reduces the number of iteration to converge, and improves the final performance at the same time. BN layer has become a standard component in recent top-performing CNN architectures, such as deep residual network (He et al., 2016), and Inception V3 (Szegedy et al., 2015). ",
+        "bbox": [
+            174,
+            685,
+            825,
+            742
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 THE MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            762,
+            310,
+            779
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In Sec. 3.1, we first analyze the domain shift in deep neural network, and reveal two key observations. Then in Sec. 3.2, we introduce our Adaptive Batch Normalization (AdaBN) method based on these observations. ",
+        "bbox": [
+            174,
+            795,
+            823,
+            837
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 A PILOT EXPERIMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            854,
+            370,
+            869
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The Batch Normalization (BN) technique is originally proposed to help SGD optimization by aligning the distribution of training data. From this perspective, it is interesting to examine the BN parameters (batch-wise mean and variance) over different dataset at different layers of the network. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this pilot experiment, we use MXNet implementation (Chen et al., 2016b) of the Inception-BN model (Ioffe & Szegedy, 2015) pre-trained on ImageNet classification task (Russakovsky et al., 2015) as our baseline DNN model. Our image data are drawn from (Bergamo & Torresani, 2010), which contains the same classes of images from both Caltech-256 dataset (Griffin et al., 2007) and Bing image search results. For each mini-batch sampled from one dataset, we concatenate the mean and variance of all neurons from one layer to form a feature vector. Using linear SVM, we can almost perfectly classify whether the mini-batch feature vector is from Caltech-256 or Bing dataset. Fig. 2 visualizes the distributions of mini-batch feature vectors from two datasets in 2D. It is clear that BN statistics from different domains are separated into clusters. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/8b54780b4e6ce548bc8d94465b49fff9fe6bc3aabb422481c6a6d0103c5b24d7.jpg",
+        "image_caption": [
+            "(a) Shallow layer distributions "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            279,
+            250,
+            460,
+            363
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/e8e71c21882fe636329b7efe3cc59f5ab6d48265cdca17c5b9fcc74c721044ce.jpg",
+        "image_caption": [
+            "(b) Deep layer distributions ",
+            "Figure 2: t-SNE (Van der Maaten & Hinton, 2008) visualization of the mini-batch BN feature vector distributions in both shallow and deep layers, across different datasets. Each point represents the BN statistics in one mini-batch. Red dots come from Bing domain, while the blue ones are from Caltech-256 domain. The size of each mini-batch is 64. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            532,
+            251,
+            723,
+            361
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This pilot experiment suggests: ",
+        "bbox": [
+            176,
+            469,
+            380,
+            484
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. Both shallow layers and deep layers of the DNN are influenced by domain shift. Domain adaptation by manipulating the output layer alone is not enough.   \n2. The statistics of BN layer contain the traits of the data domain. ",
+        "bbox": [
+            212,
+            496,
+            825,
+            544
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Both observations motivate us to adapt the representation across different domains by BN layer. ",
+        "bbox": [
+            171,
+            554,
+            800,
+            570
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 ADAPTIVE BATCH NORMALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            585,
+            465,
+            601
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given the pre-trained DNN model and a target domain, our Adaptive Batch Normalization algorithm is as follows1: ",
+        "bbox": [
+            176,
+            612,
+            823,
+            640
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/447d6254c781efb66fdf3fe0356f3b3e181bb0c0994eda2a5da5e6354af8428b.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm1 Adaptive Batch Normalization (AdaBN)</td></tr><tr><td>for neuron jinDNN do Concatenate neuron responses on all images of tar-</td></tr><tr><td>get domain t: xj =[...,xj(m),...] Compute the mean and variance of the target do-</td></tr><tr><td>main: μ =E(x)，=√Var(x).</td></tr><tr><td>end for</td></tr><tr><td>for neuron j in DNN, testing image m in target domain do</td></tr><tr><td>(aj(m)-μ) Compute BN output yj(m) := γj +βj</td></tr><tr><td>g end for</td></tr></table>",
+        "bbox": [
+            310,
+            666,
+            686,
+            848
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The intuition behind our method is straightforward: The standardization of each layer by domain ensures that each layer receives data from a similar distribution, no matter it comes from the source domain or the target domain. Although modulating statistics in one BN layer by AdaBN is a simple translation and scaling operation, such linear transformation in one layer can achieve a highly nonlinear transformation through the whole deep CNN architecture. Thus, we believe this AdaBN process could approximate the intrinsically non-linear domain transfer function. ",
+        "bbox": [
+            176,
+            871,
+            823,
+            900
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For $K$ domain adaptation where $K > 2$ , we standardize each sample by the statistics in its own domain. During training, the statistics are calculated for every mini-batch, the only thing that we need to make sure is that the samples in every mini-batch are from the same domain. For (semi)supervised domain adaptation, we may use the labeled data to fine-tune the weights as well. As a result, our method could fit in all different settings of domain adaptation with minimal effort. ",
+        "bbox": [
+            174,
+            166,
+            823,
+            236
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Compared with CORAL (Sun et al., 2016), one natural question is why we transform the neuron responses independently, not decorrelate and then re-correlate the responses together as suggested in Sun et al. (2016). Under certain conditions, decorrelation could improve the performance. However, in CNN, the mini-batch size is usually smaller than the feature dimension, leading to singular covariance matrices that is hard to be inversed. As a result, the covariance matrix is always singular. In addition, decorrelation requires to compute the inverse of the covariance matrix which is computationally intensive, especially if we plan to apply AdaBN to all layers of the network. ",
+        "bbox": [
+            174,
+            242,
+            825,
+            342
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            361,
+            326,
+            377
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we demonstrate the effectiveness of AdaBN on standard domain adaptation datasets, and empirically analyze our AdaBN model. We also evaluation our method on a practical application with remote sensing images. ",
+        "bbox": [
+            174,
+            392,
+            825,
+            435
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENTAL SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            452,
+            398,
+            465
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We first introduce our experiments on two standard datasets: Office (Saenko et al., 2010) and Caltech-Bing (Bergamo & Torresani, 2010). ",
+        "bbox": [
+            174,
+            478,
+            823,
+            506
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Office (Saenko et al., 2010) is a standard benchmark for domain adaptation, which is a collection of 4652 images in 31 classes from three different domains: Amazon $\\mathbf { \\Pi } ^ { ( \\mathbf { A } ) }$ , $D S R L ( \\mathbf { D } )$ and Webcam(W). Similar to (Tzeng et al., 2014; Sun et al., 2016; Long et al., 2015), we evaluate the pairwise domain adaption performance of AdaBN on all six pairs of domains. For the multi-source setting, we evaluate our method on three transfer tasks $\\{ \\mathbf { A } , \\bar { \\mathbf { W } } \\} \\to \\mathbf { D }$ , $\\{ \\mathbf { A } , \\mathbf { D } \\} \\to \\mathbf { W }$ , $\\{ \\mathbf { D } , \\mathbf { W } \\}  \\mathbf { A }$ . ",
+        "bbox": [
+            174,
+            512,
+            823,
+            583
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Caltech-Bing (Bergamo & Torresani, 2010) is a much larger domain adaptation dataset, which contains 30,607 and 121,730 images in 256 categories from two domains Caltech-256(C) and Bing(B). The images in the Bing set are collected from Bing image search engine by keyword search. Apparently Bing data contains noise, and its data distribution is dramatically different from that of Caltech-256. ",
+        "bbox": [
+            174,
+            589,
+            825,
+            659
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We compare our approach with a variety of methods, including four shallow methods: SA (Fernando et al., 2013), LSSA (Aljundi et al., 2015), GFK (Gong et al., 2012), CORAL (Sun et al., 2016), and four deep methods: DDC (Tzeng et al., 2014), DAN (Long et al., 2015), RevGrad (Ganin & Lempitsky, 2015), Deep CORAL (Sun & Saenko, 2016). Specifically, GFK models domain shift by integrating an infinite number of subspaces that characterize changes in statistical properties from the source to the target domain. SA, LSSA and CORAL align the source and target subspaces by explicit feature space transformations that would map source distribution into the target one. DDC and DAN are deep learning based methods which maximize domain invariance by adding to AlexNet one or several adaptation layers using MMD. RevGrad incorporates a gradient reversal layer in the deep model to encourage learning domain-invariant features. Deep CORAL extends CORAL to perform end-to-end adaptation in DNN. It should be noted that these deep learning methods have the adaptation layers on top of the output layers of DNNs, which is a sharp contrast to our method that delves into early convolution layers as well with the help of BN layers. ",
+        "bbox": [
+            173,
+            666,
+            825,
+            847
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We follow the full protocol (Donahue et al., 2014) for the single source setting; while for multiple sources setting, we use all the samples in the source domains as training data, and use all the samples in the target domain as testing data. We fine-tune the Inception-BN (Ioffe & Szegedy, 2015) model on source domain in each task for 100 epochs. The learning rate is set to 0.01 initially, and then is dropped by a factor 0.1 every 40 epochs. Since the office dataset is quite small, following the best practice in Long et al. (2015), we freeze the first three groups of Inception modules, and set the learning rate of fourth and fifth group one tenth of the base learning rate to avoid overfitting. For Caltech-Bing dataset, we fine-tune the whole model with the same base learning rate. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/6e600c0b36e3de5e0145d3ee023360c3649ac29743ea18d60c28df3d7165a665.jpg",
+        "table_caption": [
+            "Table 1: Single source domain adaptation results on Office-31 (Saenko et al., 2010) dataset with standard unsupervised adaptation protocol. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"7\">Method A→W D→W W→D A→D D→A W→A Avg</td></tr><tr><td>AlexNet (Krizhevsky et al.,2012)</td><td>61.6</td><td>95.4</td><td>99.0</td><td>63.8</td><td>51.1</td><td>49.8 70.1</td></tr><tr><td>DDC (Tzeng et al., 2014)</td><td>61.8</td><td>95.0</td><td>98.5</td><td>64.4 52.1</td><td>52.2</td><td>70.6</td></tr><tr><td>DAN (Long et al., 2015)</td><td>68.5</td><td>96.0</td><td>99.0</td><td>67.0 54.0</td><td>53.1</td><td>72.9</td></tr><tr><td>Deep CORAL (Sun &amp; Saenko, 2016)</td><td>66.4</td><td>95.7</td><td>99.2</td><td>66.8</td><td>52.8 51.5</td><td>72.1</td></tr><tr><td>RevGrad (Ganin &amp; Lempitsky,2015)</td><td>73.0</td><td>96.4</td><td>99.2</td><td>1 1</td><td>1</td><td>1</td></tr><tr><td>Inception BN (Ioffe &amp; Szegedy, 2015)</td><td>70.3</td><td>94.3</td><td>100</td><td>70.5</td><td>60.1 57.9</td><td>75.5</td></tr><tr><td>SA (Fernando et al., 2013)</td><td>69.8</td><td>95.5</td><td>99.0</td><td>71.3</td><td>59.4 56.9</td><td>75.3</td></tr><tr><td>GFK (Gong et al., 2012)</td><td>66.7</td><td>97.0</td><td>99.4</td><td>70.1</td><td>58.0 56.9</td><td>74.7</td></tr><tr><td>LSSA (Aljundi et al., 2015)</td><td>67.7</td><td>96.1</td><td>98.4</td><td>71.3</td><td>57.8 57.8</td><td>74.9</td></tr><tr><td>CORAL (Sun et al., 2016)</td><td>70.9</td><td>95.7</td><td>99.8</td><td>71.9</td><td>59.0 60.2</td><td>76.3</td></tr><tr><td>AdaBN</td><td>74.2</td><td>95.7</td><td>99.8</td><td>73.1</td><td>59.8 57.4</td><td>76.7</td></tr><tr><td> AdaBN + CORAL</td><td>75.4</td><td>96.2</td><td>99.6</td><td>72.7</td><td>59.0 60.5</td><td>77.2</td></tr></table>",
+        "bbox": [
+            194,
+            99,
+            803,
+            272
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            343,
+            825,
+            385
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            402,
+            277,
+            417
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2.1 OFFICE DATASET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            429,
+            346,
+            443
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our results on Office dataset is reported in Table 1 and Table 2 for single/multi source(s), respectively. Note that the first 5 models of the Table 1 are pre-trained on AlexNet (Krizhevsky et al., 2012) instead of the Inception-BN (Ioffe & Szegedy, 2015) model, due to the lack of publicly available pre-trained Inception BN model in Caffe (Jia et al., 2014). Thus, the relative improvements over the baseline (AlexNet/Inception BN) make more sense than the absolute numbers of each algorithm. ",
+        "bbox": [
+            174,
+            453,
+            825,
+            523
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "From Table 1, we first notice that the Inception-BN indeed improves over the AlexNet on average, which means that the CNN pre-trained on ImageNet has learned general features, the improvements on ImageNet can be transferred to new tasks. Among the methods based on Inception-BN features, our method improves the most over the baseline. Moreover, since our method is complementary to other methods, we can simply apply CORAL on the top of AdaBN. Not surprisingly, this simple combination exhibits $0 . 5 \\%$ increase in performance. This preliminary test reveals further potential of AdaBN if combined with other advanced domain adaptation methods. Finally, we could improve $1 . 7 \\%$ over the baseline, and advance the state-of-the-art results for this dataset. ",
+        "bbox": [
+            173,
+            530,
+            825,
+            642
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "None of the compared methods has reported their performance on multi-source domain adaptation. To demonstrate the capacity of AdaBN under multi-domain settings, we compare it against CORAL, which is the best performing algorithm in the single source setting. The result is reported in Table 2. We find that simply combining two domains does not lead to better performance. The result is generally worse compared to the best performing single domain between the two. This phenomenon suggests that if we cannot properly cope with domain bias, the increase of training samples may be reversely affect to the testing performance. This result confirms the necessity of domain adaptation. In this more challenging setting, AdaBN still outperforms the baseline and CORAL on average. Again, when combined with CORAL, our method demonstrates further improvements. At last, our method archives $2 . 3 \\%$ gain over the baseline. ",
+        "bbox": [
+            174,
+            648,
+            825,
+            787
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/14f09452940f1e2eedaf885e078a19007f83629209d32577d41000c2e8ae57b3.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 2: Multi-source domain adaptation results on Office-31 (Saenko et al., 2010) dataset with standard unsupervised adaptation protocol. "
+        ],
+        "table_body": "<table><tr><td>Method</td><td>A,D→WA,W→D D,W→A</td><td></td><td></td><td>Avg</td></tr><tr><td>Inception BN (Ioffe &amp; Szegedy,2015)</td><td>90.8</td><td>95.4</td><td>60.2</td><td>82.1</td></tr><tr><td>CORAL (Sun et al., 2016)</td><td>92.1</td><td>96.4</td><td>61.4</td><td>83.3</td></tr><tr><td>AdaBN</td><td>94.2</td><td>97.2</td><td>59.3</td><td>83.6</td></tr><tr><td>AdaBN + CORAL</td><td>95.0</td><td>97.8</td><td>60.5</td><td>84.4</td></tr></table>",
+        "bbox": [
+            225,
+            800,
+            772,
+            868
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2.2 CALTECH-BING DATASET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            406,
+            117
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To further evaluate our method on the large-scale dataset, we show our results on Caltech-Bing Dataset in Table 3. Compared with CORAL, AdaBN achieves better performance, which improves $1 . 8 \\%$ over the baseline. Note that all the domain adaptation methods show minor improvements over the baseline in the task $\\mathbf { C }  \\mathbf { B }$ . One of the hypotheses to this relatively small improvement is that the images in Bing dataset are collected from Internet, which are more diverse and noisier (Bergamo & Torresani, 2010). Thus, it is not easy to adapt on the Bing dataset from the relatively clean dataset Caltech-256. Combining CORAL with our method does not offer further improvements. This might be explained by the noise of the Bing dataset and the imbalance of the number of images in the two domains. ",
+        "bbox": [
+            173,
+            131,
+            826,
+            256
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/177ee646441394b2fffdb3ddb61b51ec7b250bd6b2a49fde30656c74e24b0f54.jpg",
+        "table_caption": [
+            "Table 3: Single source domain adaptation results on Caltech-Bing (Bergamo & Torresani, 2010) dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>C→B B→C Avg</td><td></td><td></td></tr><tr><td>Inception BN (Ioffe&amp; Szegedy,2015)35.1</td><td></td><td>64.6</td><td>49.9</td></tr><tr><td>CORAL (Sun et al., 2016)</td><td>35.3</td><td>67.2 </td><td> 51.3</td></tr><tr><td>AdaBN</td><td>35.2</td><td>68.1</td><td>51.7</td></tr><tr><td> AdaBN + CORAL</td><td>35.0</td><td>67.551.2</td><td></td></tr></table>",
+        "bbox": [
+            310,
+            272,
+            687,
+            340
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 EMPIRICAL ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            422,
+            370,
+            436
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we investigate the influence of the number of samples in target domain to the performance and empirically analyze the adaptation effect of different BN layers. ",
+        "bbox": [
+            173,
+            450,
+            823,
+            479
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3.1 SENSITIVITY TO TARGET DOMAIN SIZE. ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            501,
+            508,
+            516
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Since the key of our method is to calculate the mean and variance of the target domain on different BN layers, it is very natural to ask how many target images is necessary to obtain stable statistics. In this experiment, we randomly select a subset of images in target domain to calculate the statistics and then evaluate the performance on the whole target set. Fig. 3 illustrates the effect of using different number of batches. The results demonstrate that our method can obtain good results when using only a small part of the target examples. It should also be noted that in the extremal case of one batch of target images, our method still achieves better results than the baseline. This is valuable in practical use since a large number of target images are often not available. ",
+        "bbox": [
+            173,
+            529,
+            825,
+            641
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/496f3f9cc7373771a6785c1983a9a46a95324b04f4a9fb6a0c2342e83b75e6af.jpg",
+        "image_caption": [
+            "Figure 3: Accuracy when varying the number of mini-batches used for calculating the statistics of BN layers in $\\mathbf A \\to \\mathbf W$ and $\\mathbf { B }  \\mathbf { C }$ , respectively. For $\\mathbf B \\to \\mathbf C$ , we only show the results of using less than 100 batches, since the results are very stable when adding more examples. The batch size is 64 in this experiment. For even smaller number of examples, the performance may be not consistent and drop behind the baseline (e.g. 0.652 with 16 samples, 0.661 with 32 samples). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            246,
+            664,
+            745,
+            821
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/ae6f16be07fe0af154144a608f7cb13eb98945cd3405d52036b5bc9286acf302.jpg",
+        "image_caption": [
+            "Figure 4: Accuracy when adapting with different BN blocks in $\\mathbf B \\to \\mathbf C$ . $x = 0$ corresponds to the result with non-adapt method, and 1, 2, 3a, $_ { 3 b }$ , 4a, $4 b$ , 4c, 5a, $5 b$ correspond to the nine different blocks in Inception-BN network.. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            338,
+            98,
+            633,
+            276
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3.2 ADAPTATION EFFECT FOR DIFFERENT BN LAYERS. ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            358,
+            583,
+            372
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, we analyze the effect of adapting on different BN layers with our AdaBN method. According to the structure of Inception-BN network Ioffe & Szegedy (2015), we categorize the BN layers into 9 blocks: 1, 2, 3a, 3b, 4a, 4b, 4c, 5a, 5b. Since the back BN layers are influenced by the outputs of previous BN layers, when adapting a specific block we adapted all the blocks before it. Fig. 4 illustrates the adaptation effect for different BN layers. It shows that adapting BN layers consistently improves the results over the baseline method in most cases. Specifically, when incorporating more BN layers in the adaptation, we could achiever better transfer results. ",
+        "bbox": [
+            173,
+            382,
+            825,
+            479
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 PRACTICAL APPLICATION FOR CLOUD DETECTION IN REMOTE SENSING IMAGES ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            496,
+            777,
+            511
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we further demonstrate the effectiveness of AdaBN on a practical problem: Cloud Detection in Remote Sensing Images. Since remote sensing images are taken by different satellites with different sensors and resolutions, the captured images are visually different in texture, color, and value range distributions, as shown in Fig. 5. How to adapt a model trained on one satellite to another satellite images is naturally a domain adaptation problem. ",
+        "bbox": [
+            174,
+            522,
+            825,
+            592
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our task here is to identify cloud from the remote sensing images, which can be regarded as a semantic segmentation task. The experiment is taken under a self-collected dataset, which includes three image sets, from GF2, GF1 and Tianhui satellites. Each image set contains 635, 324 and 113 images with resolution over $6 0 0 0 { \\times } 6 0 0 0$ pixels respectively. We name the three different datasets following the satellite names. GF2 dataset is used as the training dataset while GF1 and Tianhui datasets are for testing. We use a state-of-art semantic segmentation method (Chen et al., 2016a) as our baseline model. ",
+        "bbox": [
+            173,
+            598,
+            825,
+            696
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/9b02b0259ea825c1ae90342860dd8d730911e725d6e7b8d7099635758c39b467.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>GF1</td><td>Tianhui</td></tr><tr><td>Baseline</td><td>38.95%</td><td>14.54%</td></tr><tr><td> AdaBN</td><td>64.50%</td><td>29.66%</td></tr></table>",
+        "bbox": [
+            400,
+            705,
+            596,
+            752
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Domain adaptation results (mIOU) on GF1 and Tianhui datasets training on GF2 datasets. ",
+        "bbox": [
+            173,
+            762,
+            821,
+            776
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The results on GF1 and Tianhui datasets are shown in Table 4. The relatively low results of the baseline method indicate that there exists large distribution disparity among images from different satellites. Thus, the significant improvement after applying AdaBN reveals the effectiveness of our method. Some of the visual results are shown in Fig. 6. Since other domain adaptation methods require either additional optimization steps and extra components (e.g. MMD) or post-processing distribution alignment (like CORAL), it is very hard to apply these methods from image classification to this large-size $( 6 0 0 0 \\times 6 0 0 0 )$ segmentation problem. Comparatively, besides the effective performance, our method needs no extra parameters and very few computations over the whole adaptation process. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/f297e25a4dfe06baa9619e485ecd47aef546efbc1802ef59bdb62cce63c4fb42.jpg",
+        "image_caption": [
+            "Figure 5: Remote sensing images in different domains. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            223,
+            154,
+            776,
+            318
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/f0e93f1f24071fb5ac37bd0c96690996da8f1c1d75523e251fd7caed483d04b1.jpg",
+        "image_caption": [
+            "Figure 6: Visual cloud detection results on GF1 dataset. White pixels in (b) and (c) represent the detected cloud regions. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            468,
+            795,
+            818
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION AND FUTURE WORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            504,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have introduced a simple yet effective approach for domain adaptation on batch normalized neural networks. Besides its original uses, we have exploited another functionality of Batch Normalization (BN) layer: domain adaptation. The main idea is to replace the statistics of each BN layer in source domain with those in target domain. The proposed method is easy to implement and parameter-free, and it takes almost no effort to extend to multiple source domains and semi-supervised settings. Our method established new state-of-the-art results on both single and multiple source(s) domain adaptation settings on standard benchmarks. At last, the experiments on cloud detection for large-size remote sensing images further demonstrate the effectiveness of our method in practical use. We believe our method opens up a new direction for domain adaptation. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            258
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In contrary to other methods that use Maximum Mean Discrepancy (MMD) or domain confusion loss to update the weights in CNN for domain adaptation, our method only modifies the statistics of BN layer. Therefore, our method is fully complementary to other existing deep learning based methods. It is interesting to see how these different methods can be unified under one framework. ",
+        "bbox": [
+            174,
+            265,
+            825,
+            321
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            343,
+            285,
+            358
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rahaf Aljundi, Remi Emonet, Damien Muselet, and Marc Sebban. Landmarks-based kernelized ´ subspace alignment for unsupervised domain adaptation. In CVPR, 2015.   \nMahsa Baktashmotlagh, Mehrtash Harandi, Brian Lovell, and Mathieu Salzmann. Unsupervised domain adaptation by domain invariant projection. In ICCV, pp. 769–776, 2013.   \nOscar Beijbom. Domain adaptations for computer vision applications. arXiv preprint arXiv:1211.4860, 2012.   \nAlessandro Bergamo and Lorenzo Torresani. Exploiting weakly-labeled web images to improve object classification: a domain adaptation approach. In NIPS, pp. 181–189, 2010.   \nKonstantinos Bousmalis, George Trigeorgis, Nathan Silberman, Dilip Krishnan, and Dumitru Erhan. Domain separation networks. NIPS, 2016.   \nLiang-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. arXiv preprint arXiv:1606.00915, 2016a.   \nTianqi Chen, Mu Li, Yutian Li, Min Lin, Naiyan Wang, Minjie Wang, Tianjun Xiao, Bing Xu, Chiyuan Zhang, and Zheng Zhang. MXNet: A flexible and efficient machine learning library for heterogeneous distributed systems. NIPS Workshop on Machine Learning Systems, 2016b.   \nSumit Chopra, Suhrid Balakrishnan, and Raghuraman Gopalan. DLID: Deep learning for domain adaptation by interpolating between domains. In ICML Workshop on Challenges in Representation Learning, volume 2, 2013.   \nJeff Donahue, Yangqing Jia, Oriol Vinyals, Judy Hoffman, Ning Zhang, Eric Tzeng, and Trevor Darrell. DeCAF: A deep convolutional activation feature for generic visual recognition. In ICML, pp. 647–655, 2014.   \nE Knuth Donald. The art of computer programming. Sorting and searching, 3:426–458, 1999.   \nBasura Fernando, Amaury Habrard, Marc Sebban, and Tinne Tuytelaars. Unsupervised visual domain adaptation using subspace alignment. In ICCV, pp. 2960–2967, 2013.   \nYaroslav Ganin and Victor Lempitsky. Unsupervised domain adaptation by backpropagation. In ICML, pp. 1180–1189, 2015.   \nMuhammad Ghifary, W Bastiaan Kleijn, and Mengjie Zhang. Domain adaptive neural networks for object recognition. In PRICAI: Trends in Artificial Intelligence, pp. 898–904. 2014.   \nBoqing Gong, Yuan Shi, Fei Sha, and Kristen Grauman. Geodesic flow kernel for unsupervised domain adaptation. In CVPR, pp. 2066–2073, 2012. ",
+        "bbox": [
+            171,
+            359,
+            826,
+            928
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Boqing Gong, Kristen Grauman, and Fei Sha. Connecting the dots with landmarks: Discriminatively learning domain-invariant features for unsupervised domain adaptation. In ICML, pp. 222–230, 2013. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Raghuraman Gopalan, Ruonan Li, and Rama Chellappa. Domain adaptation for object recognition: An unsupervised approach. In ICCV, pp. 999–1006, 2011. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Arthur Gretton, Karsten M Borgwardt, Malte J Rasch, Bernhard Scholkopf, and Alexander Smola. ¨ A kernel two-sample test. The Journal of Machine Learning Research, 13(1):723–773, 2012. ",
+        "bbox": [
+            174,
+            193,
+            823,
+            223
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gregory Griffin, Alex Holub, and Pietro Perona. Caltech-256 object category dataset. 2007. ",
+        "bbox": [
+            176,
+            231,
+            777,
+            247
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CVPR, 2016. ",
+        "bbox": [
+            173,
+            256,
+            821,
+            285
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiayuan Huang, Arthur Gretton, Karsten M Borgwardt, Bernhard Scholkopf, and Alex J Smola. ¨ Correcting sample selection bias by unlabeled data. In NIPS, pp. 601–608, 2006. ",
+        "bbox": [
+            176,
+            294,
+            821,
+            324
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, pp. 448–456, 2015. ",
+        "bbox": [
+            174,
+            332,
+            820,
+            362
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yangqing Jia, Evan Shelhamer, Jeff Donahue, Sergey Karayev, Jonathan Long, Ross Girshick, Sergio Guadarrama, and Trevor Darrell. Caffe: Convolutional architecture for fast feature embedding. In ACM MM, pp. 675–678, 2014. ",
+        "bbox": [
+            176,
+            371,
+            821,
+            414
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aditya Khosla, Tinghui Zhou, Tomasz Malisiewicz, Alexei A Efros, and Antonio Torralba. Undoing the damage of dataset bias. In ECCV, pp. 158–171. 2012. ",
+        "bbox": [
+            173,
+            422,
+            823,
+            452
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, pp. 1097–1105, 2012. ",
+        "bbox": [
+            174,
+            460,
+            823,
+            489
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mingsheng Long, Yue Cao, Jianmin Wang, and Michael Jordan. Learning transferable features with deep adaptation networks. In ICML, pp. 97–105, 2015. ",
+        "bbox": [
+            174,
+            500,
+            823,
+            529
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mingsheng Long, Jianmin Wang, and Michael I Jordan. Unsupervised domain adaptation with residual transfer networks. In NIPS, 2016. ",
+        "bbox": [
+            174,
+            536,
+            821,
+            566
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sinno Jialin Pan, Ivor W Tsang, James T Kwok, and Qiang Yang. Domain adaptation via transfer component analysis. IEEE Transactions on Neural Networks, 22(2):199–210, 2011. ",
+        "bbox": [
+            174,
+            575,
+            823,
+            604
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vishal M Patel, Raghuraman Gopalan, Ruonan Li, and Rama Chellappa. Visual domain adaptation: A survey of recent advances. IEEE Signal Processing Magazine, 32(3):53–69, 2015. ",
+        "bbox": [
+            173,
+            613,
+            823,
+            643
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. ImageNet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015. ",
+        "bbox": [
+            178,
+            651,
+            823,
+            695
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kate Saenko, Brian Kulis, Mario Fritz, and Trevor Darrell. Adapting visual category models to new domains. In ECCV, pp. 213–226. 2010. ",
+        "bbox": [
+            173,
+            704,
+            823,
+            733
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hidetoshi Shimodaira. Improving predictive inference under covariate shift by weighting the loglikelihood function. Journal of statistical planning and inference, 90(2):227–244, 2000. ",
+        "bbox": [
+            171,
+            742,
+            821,
+            771
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Baochen Sun and Kate Saenko. Deep coral: Correlation alignment for deep domain adaptation. arXiv preprint arXiv:1607.01719, 2016. ",
+        "bbox": [
+            171,
+            780,
+            821,
+            809
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Baochen Sun, Jiashi Feng, and Kate Saenko. Return of frustratingly easy domain adaptation. AAAI, 2016. ",
+        "bbox": [
+            174,
+            818,
+            823,
+            847
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. arXiv preprint arXiv:1512.00567, 2015. ",
+        "bbox": [
+            173,
+            857,
+            821,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tatiana Tommasi, Novi Patricia, Barbara Caputo, and Tinne Tuytelaars. A deeper look at dataset bias. German Conference on Pattern Recognition, 2015. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Antonio Torralba and Alexei A Efros. Unbiased look at dataset bias. In CVPR, pp. 1521–1528, 2011. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Eric Tzeng, Judy Hoffman, Ning Zhang, Kate Saenko, and Trevor Darrell. Deep domain confusion: Maximizing for domain invariance. arXiv preprint arXiv:1412.3474, 2014. ",
+        "bbox": [
+            176,
+            140,
+            821,
+            170
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Eric Tzeng, Judy Hoffman, Trevor Darrell, and Kate Saenko. Simultaneous deep transfer across domains and tasks. In ICCV, pp. 4068–4076, 2015. ",
+        "bbox": [
+            173,
+            178,
+            823,
+            208
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Laurens Van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of Machine Learning Research, 9(2579-2605):85, 2008. ",
+        "bbox": [
+            171,
+            215,
+            825,
+            246
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In NIPS, pp. 3320–3328, 2014. ",
+        "bbox": [
+            169,
+            253,
+            825,
+            284
+        ],
+        "page_idx": 11
+    }
+]

parse/train/Byg9A24tvB/Byg9A24tvB.md

@@ -0,0 +1,515 @@
+# RETHINKING SOFTMAX CROSS-ENTROPY LOSS FOR ADVERSARIAL ROBUSTNESS
+
+Tianyu Pang, Kun Xu, Yinpeng Dong, Chao Du, Ning Chen, Jun Zhu∗ Dept. of Comp. Sci. & Tech., BNRist Center, Institute for AI, Tsinghua University; RealAI {pty17,xu-k16,dyp17,du-c14}@mails.tsinghua.edu.cn, {ningchen,dcszj}@tsinghua.edu.cn
+
+# ABSTRACT
+
+Previous work shows that adversarially robust generalization requires larger sample complexity, and the same dataset, e.g., CIFAR-10, which enables good standard accuracy may not suffice to train robust models. Since collecting new training data could be costly, we focus on better utilizing the given data by inducing the regions with high sample density in the feature space, which could lead to locally sufficient samples for robust learning. We first formally show that the softmax cross-entropy (SCE) loss and its variants convey inappropriate supervisory signals, which encourage the learned feature points to spread over the space sparsely in training. This inspires us to propose the Max-Mahalanobis center (MMC) loss to explicitly induce dense feature regions in order to benefit robustness. Namely, the MMC loss encourages the model to concentrate on learning ordered and compact representations, which gather around the preset optimal centers for different classes. We empirically demonstrate that applying the MMC loss can significantly improve robustness even under strong adaptive attacks, while keeping high accuracy on clean inputs comparable to the SCE loss with little extra computation.
+
+# 1 INTRODUCTION
+
+The deep neural networks (DNNs) trained by the softmax cross-entropy (SCE) loss have achieved state-of-the-art performance on various tasks (Goodfellow et al., 2016). However, in terms of robustness, the SCE loss is not sufficient to lead to satisfactory performance of the trained models. It has been widely recognized that the DNNs trained by the SCE loss are vulnerable to adversarial attacks (Carlini & Wagner, 2017a; Goodfellow et al., 2015; Kurakin et al., 2017; Moosavi-Dezfooli et al., 2016; Papernot et al., 2016), where human imperceptible perturbations can be crafted to fool a high-performance network. To improve adversarial robustness of classifiers, various kinds of defenses have been proposed, but many of them are quickly shown to be ineffective to the adaptive attacks, which are adapted to the specific details of the proposed defenses (Athalye et al., 2018).
+
+Besides, the methods on verification and training provably robust networks have been proposed (Dvijotham et al., 2018a;b; Hein & Andriushchenko, 2017; Wong & Kolter, 2018). While these methods are exciting, the verification process is often slow and not scalable. Among the previously proposed defenses, the adversarial training (AT) methods can achieve state-of-the-art robustness under different adversarial settings (Madry et al., 2018; Zhang et al., 2019b). These methods either directly impose the AT mechanism on the SCE loss or add additional regularizers. Although the AT methods are relatively strong, they could sacrifice accuracy on clean inputs and are computationally expensive (Xie et al., 2019). Due to the computational obstruction, many recent efforts have been devoted to proposing faster verification methods (Wong et al., 2018; Xiao et al., 2019) and accelerating AT procedures (Shafahi et al., 2019; Zhang et al., 2019a). However, the problem still remains.
+
+Schmidt et al. (2018) show that the sample complexity of robust learning can be significantly larger than that of standard learning. Given the difficulty of training robust classifiers in practice, they further postulate that the difficulty could stem from the insufficiency of training samples in the commonly used datasets, e.g., CIFAR-10 (Krizhevsky & Hinton, 2009). Recent work intends to solve this problem by utilizing extra unlabeled data (Carmon et al., 2019; Stanforth et al., 2019), while we focus on the complementary strategy to exploit the labeled data in hand more efficiently. Note that although the samples in the input space are unchangeable, we could instead manipulate the local sample distribution, i.e., sample density in the feature space via appropriate training objectives. Intuitively, by inducing high-density feature regions, there would be locally sufficient samples to train robust classifiers and return reliable predictions (Schmidt et al., 2018).
+
+Similar to our attempt to induce high-density regions in the feature space, previous work has been proposed to improve intra-class compactness. Contrastive loss (Sun et al., 2014) and triplet loss (Schroff et al., 2015) are two classical objectives for this purpose, but the training iterations will dramatically grow to construct image pairs or triplets, which results in slow convergence and instability. The center loss (Wen et al., 2016) avoids the pair-wise or triplet-wise computation by minimizing the squared distance
+
+![](images/cd21ca49c496b899fcd796cd244157363d97f6d237c3a499c74d82c8e7cc0796.jpg)  
+Figure 1: Intuitive illusion of how training data moves and how sample density varies in a two-dimensional feature space during the training procedure.
+
+between the features and the corresponding class centers. However, since the class centers are updated w.r.t. the learned features during training, the center loss has to be jointly used with the SCE loss to seek for a trade-off between inter-class dispersion and intra-class compactness. Therefore, the center loss cannot concentrate on inducing strong intra-class compactness to construct high-density regions and consequently could not lead to reliable robustness, as shown in our experiments.
+
+In this paper, we first formally analyze the sample density distribution induced by the SCE loss and its other variants (Pang et al., 2018; Wan et al., 2018) in Sec. 3.2, which demonstrates that these previously proposed objectives convey unexpected supervisory signals on the training points, which make the learned features tend to spread over the space sparsely. This undesirable behavior mainly roots from applying the softmax function in training, which makes the loss function only depend on the relative relation among logits and cannot directly supervise on the learned representations.
+
+We further propose a novel training objective which can explicitly induce high-density regions in the feature space and learn more structured representations. To achieve this, we propose the MaxMahalanobis center (MMC) loss (detailed in Eq. (8)) as the substitute of the SCE loss. Specifically, in the MMC loss, we first preset untrainable class centers with optimal inter-class dispersion in the feature space according to Pang et al. (2018), then we encourage the features to gather around the centers by minimizing the squared distance similar with the center loss. The MMC loss can explicitly control the inter-class dispersion by a single hyperparameter, and further concentrate on improving intra-class compactness in the training procedure to induce high-density regions, as intuitively shown in Fig. 1. Behind the simple formula, the MMC loss elegantly combines the favorable merits of the previous methods, which leads to a considerable improvement on the adversarial robustness.
+
+In experiments, we follow the suggestion by Carlini et al. (2019) that we test under different threat models and attacks, including the adaptive attacks (Athalye et al., 2018) on MNIST, CIFAR-10, and CIFAR-100 (Krizhevsky & Hinton, 2009; LeCun et al., 1998). The results demonstrate that our method can lead to reliable robustness of the trained models with little extra computation, while maintaining high clean accuracy with faster convergence rates compared to the SCE loss and its variants. When combined with the existing defense mechanisms, e.g., the AT methods (Madry et al., 2018), the trained models can be further enhanced under the attacks different from the one used to craft adversarial examples for training.
+
+# 2 PRELIMINARIES
+
+This section first provides the notations, then introduces the adversarial attacks and threat models.
+
+# 2.1 NOTATIONS
+
+In this paper, we use the lowercases to denote variables and the uppercases to denote mappings. Let $L$ be the number of classes, we define the softmax function softmax ${ \bf \Phi } : \mathbb { R } ^ { L } \to \dot { \mathbb { R } } ^ { L }$ as so $\mathrm { \ t m a x } ( h ) _ { i } = \exp ( h _ { i } ) / { \sum _ { l = 1 } ^ { L } \exp ( h _ { l } ) } , i \in [ L ]$ , where $[ L ] : = \{ 1 , \cdots , L \}$ and $h$ is termed as logit.
+
+A deep neural network (DNN) learns a non-linear mapping from the input $x \in \mathbb { R } ^ { p }$ to the feature $z = \dot { Z ( x ) } \in \mathbb { R } ^ { d }$ . One common training objective for DNNs is the softmax cross-entropy (SCE) loss:
+
+$$
+\mathcal { L } _ { \mathrm { S C E } } ( Z ( x ) , y ) = - 1 _ { y } ^ { \top } \log { [ \mathrm { s o f t m a x } ( W z + b ) ] } ,
+$$
+
+for a single input-label pair $( x , y )$ , where $1 _ { y }$ is the one-hot encoding of $y$ and the logarithm is defined as element-wise. Here $W$ and $b$ are the weight matrix and bias vector of the SCE loss, respectively.
+
+# 2.2 ADVERSARIAL ATTACKS AND THREAT MODELS
+
+Previous work has shown that adversarial examples can be easily crafted to fool DNNs (Biggio et al., 2013; Nguyen et al., 2015; Szegedy et al., 2014). A large amount of attacking methods on generating adversarial examples have been introduced in recent years (Carlini & Wagner, 2017a; Chen et al., 2017; Dong et al., 2018; Goodfellow et al., 2015; Ilyas et al., 2018; Kurakin et al., 2017; Madry et al., 2018; Moosavi-Dezfooli et al., 2016; Papernot et al., 2016; Uesato et al., 2018). Given the space limit, we try to perform a comprehensive evaluation by considering five different threat models and choosing representative attacks for each threat model following Carlini et al. (2019):
+
+White-box $l _ { \infty }$ distortion attack: We apply the projected gradient descent (PGD) (Madry et al., 2018) method, which is efficient and widely studied in previous work (Pang et al., 2019).
+
+White-box $l _ { 2 }$ distortion attack: We apply the C&W (Carlini & Wagner, 2017a) method, which has a binary search mechanism on its parameters to find the minimal $l _ { 2 }$ distortion for a successful attack.
+
+Black-box transfer-based attack: We use the momentum iterative method (MIM) (Dong et al., 2018) that is effective on boosting adversarial transferability (Kurakin et al., 2018).
+
+Black-box gradient-free attack: We choose SPSA (Uesato et al., 2018) since it has broken many previously proposed defenses. It can still perform well even when the loss is difficult to optimize.
+
+General-purpose attack: We also evaluate the general robustness of models when adding Gaussian noise (Gilmer et al., 2019) or random rotation (Engstrom et al., 2019) on the input images.
+
+Furthermore, to exclude the false robustness caused by, e.g., gradient mask (Athalye et al., 2018), we modify the above attacking methods to be adaptive attacks (Carlini & Wagner, 2017b; Carlini et al., 2019; Herley & Van Oorschot, 2017) when evaluating on the robustness of our method. The adaptive attacks are much more powerful than the non-adaptive ones, as detailed in Sec. 4.2.
+
+# 3 METHODOLOGY
+
+Various theoretical explanations have been developed for adversarial examples (Fawzi et al., 2016; 2018; Ilyas et al., 2019; Papernot et al., 2018). In particular, Schmidt et al. (2018) show that training robust classifiers requires significantly larger sample complexity compared to that of training standard ones, and they further postulate that the difficulty of training robust classifiers stems from, at least partly, the insufficiency of training samples in the common datasets. Recent efforts propose alternatives to benefit training with extra unlabeled data (Carmon et al., 2019; Stanforth et al., 2019), while we explore the complementary way to better use the labeled training samples for robust learning.
+
+Although a given sample is fixed in the input space, we can instead manipulate the local sample distribution, i.e., sample density in the feature space, via designing appropriate training objectives. Intuitively, by inducing high-density regions in the feature space, it can be expected to have locally sufficient samples to train robust models that are able to return reliable predictions. In this section, we first formally define the notion of sample density in the feature space. Then we provide theoretical analyses of the sample density induced by the SCE loss and its variants. Finally, we propose our new Max-Mahalanobis center (MMC) loss and demonstrate its superiority compared to previous losses.
+
+# 3.1 SAMPLE DENSITY IN THE FEATURE SPACE
+
+Given a training dataset $\mathcal { D }$ with $N$ input-label pairs, and the feature mapping $Z$ trained by the objective $\bar { \mathcal { L } } ( Z ( \bar { x } ) , y )$ on this dataset, we define the sample density nearby the feature point $z = Z ( x )$
+
+following the similar definition in physics (Jackson, 1999) as
+
+$$
+\mathbb { S D } ( z ) = \frac { \Delta N } { \mathrm { V o l } ( \Delta B ) } .
+$$
+
+Here $\operatorname { v o l } ( \cdot )$ denotes the volume of the input set, $\Delta B$ is a small neighbourhood containing the feature point $z$ , and $\Delta N = | Z ( \mathcal { D } ) \cap \Delta B |$ is the number of training points in $\Delta B$ , where $Z ( \mathcal { D } )$ is the set of all mapped features for the inputs in $\mathcal { D }$ . Note that the mapped feature $z$ is still of the label $y$ .
+
+In the training procedure, the feature distribution is directly induced by the training loss $\mathcal { L }$ , where minimizing the loss value is the only supervisory signal for the feature points to move (Goodfellow et al., 2016). This means that the sample density varies mainly along the orthogonal direction w.r.t. the loss contours, while the density along a certain contour could be approximately considered as the same. For example, in the right panel of Fig. 1, the sample density induced by our MMC loss (detailed in Sec. 3.3) changes mainly along the radial direction, i.e., the directions of red arrows, where the loss contours are dashed concentric circles. Therefore, supposing $\mathcal { L } ( z , y ) = C$ , we choose $\Delta B = \{ \mathbf { z } \in \mathbb { R } ^ { d } | { \mathcal { L } } ( \mathbf { z } , y ) \in [ C , C + \Delta C ] \}$ , where $\Delta C > 0$ is a small value. Then $\mathrm { V o l } ( \Delta B )$ is the volume between the loss contours of $C$ and $C + \Delta C$ for label $y$ in the feature space.
+
+# 3.2 THE SAMPLE DENSITY INDUCED BY THE GENERALIZED SCE LOSS
+
+Generalized SCE loss. To better understand how the SCE loss and its variants (Pang et al., 2018; Wan et al., 2018) affect the sample density of features, we first generalize the definition in Eq. (1) as:
+
+$$
+\mathcal { L } _ { \mathrm { g - S C E } } ( Z ( x ) , y ) = - 1 _ { y } ^ { \top } \log { [ \mathrm { s o f t m a x } ( h ) ] } ,
+$$
+
+where the logit $h = H ( z ) \in \mathbb { R } ^ { L }$ is a general transformation of the feature $z$ , for example, $h = W z + b$ in the SCE loss. We call this family of losses as the generalized SCE $\scriptstyle ( { \bf g } - { \bf S } { \bf C } { \bf E } )$ loss. Wan et al. (2018) propose the large-margin Gaussian Mixture (L-GM) loss, where $h _ { i } = { \breve { - } } ( z - \mu _ { i } ) ^ { \top } \Sigma _ { i } ( z - \mu _ { i } ) - m \delta _ { i , y }$ under the assumption that the learned features $z$ distribute as a mixture of Gaussian. Here $\mu _ { i }$ and $\Sigma _ { i }$ are extra trainable means and covariance matrices respectively, $m$ is the margin, and $\delta _ { i , y }$ is the indicator function. Pang et al. (2018) propose the Max-Mahalanobis linear discriminant analysis (MMLDA) loss, where $h _ { i } = - \| z - \mu _ { i } ^ { * } \| _ { 2 } ^ { 2 }$ under the similar mixture of Gaussian assumption, but the main difference is that $\mu _ { i } ^ { * }$ are not trainable, but calculated before training with optimal inter-class dispersion. These two losses both fall into the family of the $\mathbf { g }$ -SCE loss with quadratic logits:
+
+$$
+h _ { i } = - ( z - \mu _ { i } ) ^ { \top } \Sigma _ { i } ( z - \mu _ { i } ) + B _ { i } ,
+$$
+
+where $B _ { i }$ are the bias variables. Besides, note that for the SCE loss, there is
+
+$$
+\mathrm { s o f t m a x } ( W z + b ) _ { i } = \frac { \exp ( W _ { i } ^ { \top } z + b _ { i } ) } { \sum _ { l \in [ L ] } \exp ( W _ { l } ^ { \top } z + b _ { l } ) } = \frac { \exp ( - \| z - \frac { 1 } { 2 } W _ { i } \| _ { 2 } ^ { 2 } + b _ { i } + \frac { 1 } { 4 } \| W _ { i } \| _ { 2 } ^ { 2 } ) } { \sum _ { l \in [ L ] } \exp ( - \| z - \frac { 1 } { 2 } W _ { l } \| _ { 2 } ^ { 2 } + b _ { l } + \frac { 1 } { 4 } \| W _ { l } \| _ { 2 } ^ { 2 } ) } .
+$$
+
+According to Eq. (4), the SCE loss can also be regraded as a special case of the $\mathrm { g - S C E }$ loss with quadratic logits, where $\begin{array} { r } { \mu _ { i } = \frac { 1 } { 2 } W _ { i } } \end{array}$ , $\begin{array} { r } { B _ { i } = b _ { i } + \frac 1 4 \| \dot { W _ { i } } \| _ { 2 } ^ { 2 } } \end{array}$ and $\Sigma _ { i } = I$ are identity matrices. Therefore, later when we refer to the g-SCE loss, we assume that the logits are quadratic as in Eq. (4) by default.
+
+The contours of the g-SCE loss. To provide a formal representation of the sample density induced by the $\mathrm { g - S C E }$ loss, we first derive the formula of the contours, i.e., the closed-form solution of $\mathcal { L } _ { \mathrm { g - S C E } } ( Z ( x ) , y ) = C$ in the space of $z$ , where $C \in ( 0 , + \infty )$ is a given constant. Let $C _ { e } = \exp ( C ) \in$ $( 1 , + \infty )$ , from Eq. (3), we can represent the contours as the solution of
+
+$$
+\log \left( 1 + \frac { \sum _ { l \neq y } \exp ( h _ { l } ) } { \exp ( h _ { y } ) } \right) = C \implies h _ { y } = \log \left[ \sum _ { l \neq y } \exp ( h _ { l } ) \right] - \log ( C _ { e } - 1 ) .
+$$
+
+The function in Eq. (5) does not provide an intuitive closed-form solution for the contours, since the existence of the term $\begin{array} { r } { \log \left[ \sum _ { l \neq y } \exp ( h _ { l } ) \right] } \end{array}$ . However, note that this term belongs to the family of Log-Sum-Exp (LSE) function, which is a smooth approximation to the maximum function (Nesterov, 2005; Nielsen & Sun, 2016). Therefore, we can locally approximate the function in Eq. (5) with
+
+$$
+h _ { y } - h _ { \tilde { y } } = - \log ( C _ { e } - 1 ) ,
+$$
+
+![](images/e8eff5603d86340f061e410cce3ffe57b54ed800936ba7ac11e6c26cc797d7d6.jpg)  
+Figure 2: Intuitive illustration on the inherent limitations of the $\mathbf { g } { - } \mathbf { S } \mathbf { C } \mathbf { E }$ loss. Reasonably learned features for a classification task should distribute in clusters, so it is counter-intuitive that the feature points tend to move to infinity to pursue lower loss values when applying the $\mathbf { g }$ -SCE loss. In contrast, MMC induces models to learn more structured and orderly features.
+
+where $\tilde { y } = \mathrm { a r g } \operatorname* { m a x } _ { l \neq y } h _ { l }$ . In the following text, we apply colored characters with tilde like $\tilde { y }$ to better visually distinguish them. According to Eq. (6), we can define $\mathcal { L } _ { y , \tilde { y } } ( z ) = \log [ \exp ( h _ { \tilde { y } } - h _ { y } ) + 1 ]$ as the local approximation of the $\mathrm { g - S C E }$ loss nearby the feature point $z$ , and substitute the neighborhood ∆B by ∆By,y˜ $\Delta \bar { B } _ { y , \mathrm { ~ \scriptsize ~ = ~ } } \{ \mathbf { z } \in \mathbb { R } ^ { d } | \mathcal { L } _ { y , \mathrm { ~ \scriptsize ~ ( ~ \mathbf { z } ) ~ \in ~ } [ C , C \dot { ~ } + \Delta C ] \} }$ . For simplicity, we assume scaled identity covariance matrix in Eq. (4), i.e., $\Sigma _ { i } = \sigma _ { i } I$ , where $\sigma _ { i } > 0$ are scalars. Through simple derivations (detailed in Appendix A.1), we show that if $\sigma _ { y } \neq \sigma$ , the solution of $\mathcal { L } _ { y , \textit { \textbf { ( z ) } } } = C$ is a $( d - 1 )$ - dimensional hypersphere with the center $\mathbf { M } _ { y , \mathbf { \Omega } } = ( \sigma _ { y } - \sigma \mathbf { \Omega } ) ^ { - 1 } ( \sigma _ { y } \mu _ { y } - \sigma \mathbf { \Omega } \mu \mathbf { \Sigma } )$ ; otherwise if $\sigma _ { y } = \sigma$ , the hypersphere-shape contour will degenerate to a hyperplane.
+
+The induced sample density. Since the approximation in Eq. (6) depends on the specific $y$ and $\cdot$ , we define the training subset $\mathcal { D } _ { k , \tilde { k } } = \{ ( x , y ) \in \mathcal { D } | y = k$ , $\tilde { y } = \tilde { k } \}$ and $N _ { k , \tilde { k } } = | \mathcal { D } _ { k , \tilde { k } } |$ . Intuitively, Dk,k˜ includes the data with the true label of class $k$ , while the highest prediction returned by the classifier is class $\tilde { k }$ among other classes. Then we can derive the approximated sample density in the feature space induced by the $\mathbf { g }$ -SCE loss, as stated in the following theorem:
+
+Theorem 1. (Proof in Appendix A.1) Given $( x , y ) \in \mathcal { D } _ { k , \tilde { k } }$ , $z = Z ( x )$ and $\mathcal { L } _ { g - S C E } ( z , y ) = C$ , if there are $\Sigma _ { k } = \sigma _ { k } I$ , $\Sigma _ { \tilde { k } } = \sigma _ { \tilde { k } } I$ , and $\sigma _ { k } \neq \sigma _ { \tilde { k } }$ , then the sample density nearby the feature point $z$ based on the approximation in Eq. (6) is
+
+$$
+\begin{array} { r } { \mathbb { S } \mathbb { D } ( z ) \propto \frac { N _ { k , \tilde { k } } \cdot p _ { k , \tilde { k } } ( C ) } { \left[ \mathbf { B } _ { k , \tilde { k } } + \frac { \log ( C _ { e } - 1 ) } { \sigma _ { k } - \sigma _ { \tilde { k } } } \right] ^ { \frac { d - 1 } { 2 } } } , a n d \mathbf { B } _ { k , \tilde { k } } = \frac { \sigma _ { k } \sigma _ { \tilde { k } } \| \mu _ { k } - \mu _ { \tilde { k } } \| _ { 2 } ^ { 2 } } { ( \sigma _ { k } - \sigma _ { \tilde { k } } ) ^ { 2 } } + \frac { B _ { k } - B _ { \tilde { k } } } { \sigma _ { k } - \sigma _ { \tilde { k } } } , } \end{array}
+$$
+
+where for the input-label pair in $\mathcal { D } _ { k , \tilde { k } }$ , there is $\mathcal { L } _ { g - S C E } \sim p _ { k , \tilde { k } } ( c )$ .
+
+Limitations of the $\mathbf { g }$ -SCE loss. Based on Theorem 1 and the approximation in Eq. (6), let $C ^ { * } =$ $\mathrm { l o g } ( 1 + \exp ( \mathbf { B } _ { k , \tilde { k } } ( \sigma _ { \tilde { k } } - \sigma _ { k } ) ) )$ and $C _ { e } ^ { * } = \exp ( C ^ { * } )$ , such that $\begin{array} { r } { \bar { \mathbf { B } } _ { k , \tilde { k } } + \frac { \log ( C _ { e } ^ { * } - 1 ) } { \sigma _ { k } - \sigma _ { \tilde { k } } } \bar { = } \bar { 0 } } \end{array}$ = 0. According to Appendix A.1, if $\sigma _ { k } > \sigma _ { \tilde { k } }$ , then $C ^ { * }$ will act as a tight lower bound for $C$ , i.e., the solution set of $C < C ^ { * }$ is empty. This will make the training procedure tend to avoid this case since the loss $C$ cannot be further minimized to zero, which will introduce unnecessary biases on the returned predictions. On the other hand, if $\sigma _ { k } < \sigma _ { \tilde { k } }$ , $C$ could be minimized to zero. However, when $C  0$ , the sample density will also tend to zero since there is $\begin{array} { r } { \mathbf { B } _ { k , \tilde { k } } + \frac { \log ( C _ { e } - 1 ) } { \sigma _ { k } - \sigma _ { \tilde { k } } }  \infty } \end{array}$ , which means the feature point will be encouraged to go further and further from the hypersphere center $\mathbf { M } _ { k , \tilde { k } }$ only to make the loss value $C$ be lower, as intuitively illustrated in Fig. 2(a).
+
+This counter-intuitive behavior mainly roots from applying the softmax function in training. Namely, the softmax normalization makes the loss value only depend on the relative relation among logits. This causes indirect and unexpected supervisory signals on the learned features, such that the points with low loss values tend to spread over the space sparsely. Fortunately, in practice, the feature point will not really move to infinity, since the existence of batch normalization layers (Ioffe & Szegedy, 2015), and the squared radius from the center $\mathbf { M } _ { k , \tilde { k } }$ increases as $\mathcal { O } ( | \log C | )$ when minimizing the loss $C$ These theoretical conclusions are consistent with the empirical observations on the two-dimensional features in previous work (cf. Fig. 1 in Wan et al. (2018)).
+
+Another limitation of the $\mathbf { g }$ -SCE loss is that the sample density is proportional to $N _ { k , \tilde { k } }$ , which is on average $N / L ^ { 2 }$ . For example, there are around 1.3 million training data in ImageNet (Deng et al., 2009), but with a large number of classes $L = 1 , 0 0 0$ , there are averagely less than two samples in each $\mathcal { D } _ { k , \tilde { k } }$ . These limitations inspire us to design the new training loss as in Sec 3.3.
+
+Remark 1. If $\sigma _ { k } = \sigma _ { \tilde { k } }$ (e.g., as in the SCE loss), the features with loss values in $[ C , C + \Delta C ]$ will be encouraged to locate between two hyperplane contours without further supervision, and consequently there will not be explicit supervision on the sample density as shown in the left panel of Fig. 1.
+
+Remark 2. Except for the $\mathbf { g }$ -SCE loss, Wen et al. (2016) propose the center loss in order to improve the intra-class compactness of learned features, formulated as $\begin{array} { r } { \mathcal { L } _ { \mathrm { C e n t e r } } ( Z ( x ) , y ) = \frac { 1 } { 2 } \| z - \mu _ { y } \| _ { 2 } ^ { 2 } } \end{array}$ . Here the center $\mu _ { y }$ is updated based on a mini-batch of learned features with label $y$ in each training iteration. The center loss has to be jointly used with the SCE loss as $\mathcal { L } _ { \mathrm { S C E } } + \lambda \mathcal { L } _ { \mathrm { C e n t e r } } ,$ , since simply supervise the DNNs with the center loss term will cause the learned features and centers to degrade to zeros (Wen et al., 2016). This makes it difficult to derive a closed-form formula for the induced sample density. Besides, the center loss method cannot concentrate on improving intra-class compactness, since it has to seek for a trade-off between inter-class dispersion and intra-class compactness.
+
+# 3.3 MAX-MAHALANOBIS CENTER LOSS
+
+Inspired by the above analyses, we propose the Max-Mahalanobis center (MMC) loss to explicitly learn more structured representations and induce high-density regions in the feature space. The MMC loss is defined in a regression form without the softmax function as
+
+$$
+\mathcal { L } _ { \mathrm { M M C } } ( Z ( x ) , y ) = \frac { 1 } { 2 } \| z - \mu _ { y } ^ { * } \| _ { 2 } ^ { 2 } .
+$$
+
+Here $\mu ^ { * } = \{ \mu _ { l } ^ { * } \} _ { l \in [ L ] }$ are the centers of the Max-Mahalanobis distribution (MMD) (Pang et al., 2018). The MMD is a mixture of Gaussian distribution with identity covariance matrix and preset centers $\mu ^ { * }$ , where $\| \mu _ { l } ^ { * } \| _ { 2 } = C _ { \mathrm { M M } }$ for any $l \in [ L ]$ , and $C _ { \mathrm { M M } }$ is a hyperparameter. These MMD centers are invariable during training, which are crafted according to the criterion: $\begin{array} { r } { \mu ^ { * } = \arg \operatorname* { m i n } _ { \mu } \operatorname* { m a x } _ { i \neq j } \langle \mu _ { i } , \mu _ { j } \rangle } \end{array}$ . Intuitively, this criterion is to maximize the minimal angle between any two centers, which can provide optimal inter-class dispersion as shown in Pang et al. (2018). In Appendix B.1, we provide the generation algorithm for $\mu ^ { * }$ in MMC. We derive the sample density induced by the MMC loss in the feature space, as stated in Theorem 2. Similar to the previously introduced notations, here we define the subset $\mathcal { D } _ { k } = \{ ( x , y ) \in \mathcal { D } | y = k \}$ and $N _ { k } = | \mathcal { D } _ { k } |$ .
+
+Theorem 2. (Proof in Appendix A.2) Given $( x , y ) \in \mathcal { D } _ { k }$ , $z = Z ( x )$ and $\mathcal { L } _ { M M C } ( z , y ) = C$ , the sample density nearby the feature point $z$ is
+
+$$
+\mathbb { S D } ( z ) \propto \frac { N _ { k } \cdot p _ { k } ( C ) } { C ^ { \frac { d - 1 } { 2 } } } ,
+$$
+
+where for the input-label pair in $\mathcal { D } _ { k }$ , there is $\mathcal { L } _ { M M C } \sim p _ { k } ( c )$
+
+According to Theorem 2, there are several attractive merits of the MMC loss, as described below.
+
+Inducing higher sample density. Compared to Theorem 1, the sample density induced by MMC is proportional to $N _ { k }$ rather than $N _ { k , \tilde { k } }$ , where $N _ { k }$ is on average $N / L$ . It facilitates producing higher sample density. Furthermore, when the loss value $C$ is minimized to zero, the sample density will exponentially increase according to Eq. (9), as illustrated in Fig. 2(b). The right panel of Fig. 1 also provides an intuitive insight on this property of the MMC loss: since the loss value $C$ is proportional to the squared distance from the preset center $\mu _ { y } ^ { * }$ , the feature points with lower loss values are certain to locate in a smaller volume around the center. Consequently, the feature points of the same class are encouraged to gather around the corresponding center, such that for each sample, there will be locally enough data in its neighborhood for robust learning (Schmidt et al., 2018). The MMC loss value also becomes a reliable metric of the uncertainty on returned predictions.
+
+Better exploiting model capacity. Behind the simple formula, the MMC loss can explicitly monitor inter-class dispersion by the hyperparameter $C _ { \mathrm { M M } }$ , while enabling the network to concentrate on minimizing intra-class compactness in training. Instead of repeatedly searching for an internal tradeoff in training as the center loss, the monotonicity of the supervisory signals induced by MMC can better exploit model capacity and also lead to faster convergence, as empirically shown in Fig. 3(a).
+
+![](images/deb36c75e4c426d6fca32c84344f3da984c10ed3738d645212bd66306431ea0d.jpg)  
+Figure 3: (a) Test error rates on clean images w.r.t training time on CIFAR-10. Here AT refers to 10-steps targeted PGD adversarial training, i.e., $\mathsf { A T } _ { 1 0 } ^ { \mathsf { t a r } }$ . (b) Two-dimensional visualization of the attacks on trained MMC networks in the feature space of MNIST. For each attack there is $\epsilon = 0 . 3$ with step size of 0.01. The total number of iteration steps is 50, where Iter- indicates the perturbed features at -th iteration step.
+
+Avoiding the degradation problem. The MMC loss can naturally avoid the degradation problem encountered in Wen et al. (2016) when the center loss is not jointly used with the SCE loss, since the preset centers $\mu ^ { * }$ for MMC are untrainable. In the test phase, the network trained by MMC can still return a normalized prediction with the softmax function. More details about the empirical superiorities of the MMC loss over other previous losses are demonstrated in Sec. 4.
+
+Remark 3. In Appendix B.2, we discuss on why the squared-error form in Eq. (8) is preferred compared to, e.g., the absolute form or the Huber form in the adversarial setting. We further introduce flexible variants of the MMC loss in Appendix B.3, which can better adapt to various tasks.
+
+Remark 4. Pang et al. (2018) propose a Max-Mahalanobis linear discriminant analysis (MMLDA) method, which assumes the features to distribute as an MMD. Due to the Gaussian mixture assumption, the training loss for the MMLDA method is obtained by the Bayes’ theorem as
+
+$$
+{ \mathcal { L } } _ { \mathrm { M M L D A } } ( Z ( x ) , y ) = - \log \left[ \frac { \exp ( - \frac { \| z - \mu _ { y } ^ { * } \| _ { 2 } ^ { 2 } } { 2 } ) } { \sum _ { l \in [ L ] } \exp ( - \frac { \| z - \mu _ { l } ^ { * } \| _ { 2 } ^ { 2 } } { 2 } ) } \right] = - \log \left[ \frac { \exp ( z ^ { \top } \mu _ { y } ^ { * } ) } { \sum _ { l \in [ L ] } \exp ( z ^ { \top } \mu _ { l } ^ { * } ) } \right] .
+$$
+
+Note that there is $\Sigma _ { i } = { \textstyle { \frac { 1 } { 2 } } } I$ in Eq. (4) for the MMLDA loss, similar with the SCE loss. Thus the MMLDA method cannot explicitly supervise on the sample density and induce high-density regions in the feature space, as analyzed in Sec. 3.2. Compared to the MMLDA method, the MMC loss introduces extra supervision on intra-class compactness, which facilitates better robustness.
+
+# 4 EXPERIMENTS
+
+In this section, we empirically demonstrate several attractive merits of applying the MMC loss. We experiment on the widely used MNIST, CIFAR-10, and CIFAR-100 datasets (Krizhevsky & Hinton, 2009; LeCun et al., 1998). The main baselines for the MMC loss are SCE (He et al., 2016), Center loss (Wen et al., 2016), MMLDA (Pang et al., 2018), and L-GM (Wan et al., 2018). The codes are provided in https://github.com/P2333/Max-Mahalanobis-Training.
+
+# 4.1 PERFORMANCE ON THE CLEAN INPUTS
+
+The network architecture applied is ResNet-32 with five core layer blocks (He et al., 2016). Here we use MMC-10 to indicate the MMC loss with $C _ { \mathrm { M M } } = 1 0$ , where $C _ { \mathrm { M M } }$ is assigned based on the cross-validation results in Pang et al. (2018). The hyperparameters for the center loss, L-GM loss and the MMLDA method all follow the settings in the original papers (Pang et al., 2018; Wan et al., 2018; Wen et al., 2016). The pixel values are scaled to the interval $[ 0 , 1 ]$ . For each training loss with or without the AT mechanism, we apply the momentum SGD (Qian, 1999) optimizer with the initial learning rate of 0.01, and train for 40 epochs on MNIST, 200 epochs on CIFAR-10 and CIFAR-100. The learning rate decays with a factor of 0.1 at 100 and 150 epochs, respectively.
+
+![](images/e6b6d6470ddff993a11f795965a5941102ba2c93b6e9021a09ce2e30fab9d9af.jpg)  
+Figure 4: Classification accuracy under the black-box transfer-based attacks on the test set of CIFAR-10. The substitute model one used to craft adversarial examples, and the target model is the one that an adversary actually intends to fool. Here AT refers to $\mathbf { A T _ { 1 0 } ^ { t a r } }$ to the.
+
+When applying the AT mechanism (Madry et al., 2018), the adversarial examples for training are crafted by 10-steps targeted or untargeted PGD with $\epsilon = 8 / 2 5 5$ . In Fig. 3(a), we provide the curves of the test error rate w.r.t. the training time. Note that the MMC loss induces faster convergence rate and requires little extra computation compared to the SCE loss and its variants, while keeping comparable performance on the clean images. In comparison, implementing the AT mechanism is computationally expensive in training and will sacrifice the accuracy on the clean images.
+
+# 4.2 ADAPTIVE ATTACKS FOR THE MMC LOSS
+
+As stated in Athalye et al. (2018), only applying the existing attacks with default hyperparameters is not sufficient to claim reliable robustness. Thus, we apply the adaptive versions of existing attacks when evading the networks trained by the MMC loss (detailed in Appendix B.4). For instance, the non-adaptive objectives for PGD are variants of the SCE loss (Madry et al., 2018), while the adaptive objectives are $- \mathcal { L } _ { \mathrm { M M C } } ( z , y )$ and $\mathcal { L } _ { \mathrm { M M C } } ( z , y _ { t } )$ in the untargeted and targeted modes for PGD, respectively. Here $y _ { t }$ is the target label. To verify that the adaptive attacks are more effective than the non-adaptive ones, we modify the network architecture with a two-dimensional feature layer and visualize the PGD attacking procedure in Fig. 3(b). The two panels separately correspond to two randomly selected clean inputs indicated by black stars. The ten colored clusters in each panel consist of the features of all the 10,000 test samples in MNIST, where each color corresponds to one class. We can see that the adaptive attacks are indeed much more efficient than the non-adaptive one.
+
+# 4.3 PERFORMANCE UNDER THE WHITE-BOX ATTACKS
+
+We first investigate the white-box $l _ { \infty }$ distortion setting using the PGD attack, and report the results in Table 1. According to Carlini et al. (2019), we evaluate under different combinations of the attacking parameters: the perturbation $\epsilon$ , iteration steps, and the attack mode, i.e., targeted or untargeted.
+
+Table 2: Experiments on CIFAR-10. Part I: Averaged $l _ { 2 }$ distortion of the white-box adversarial examples crafted by C&W with 1,000 iteration steps. Part II: Classification accuracy $( \% )$ under the block-box SPSA attack. Part III: Classification accuracy $( \% )$ under general transformations. The standard deviation $\sigma$ for the Gaussian noise is 0.05, the degree range is $\pm 3 0 ^ { \circ }$ for random rotation.   
+
+<table><tr><td rowspan=1 colspan=3>Methods</td><td rowspan=1 colspan=2>Part IC&amp; Wtar  C&amp; Wun</td><td rowspan=1 colspan=2>Part II (ε=8/255)SPSA10 SPSA10</td><td rowspan=1 colspan=2>Part II (e=16/255)SPSA10  SPSA10</td><td rowspan=1 colspan=2>Part IIINoise  Rotation</td></tr><tr><td rowspan=7 colspan=3>SCECenter lossMMLDAL-GMMMC-10</td><td rowspan=1 colspan=1>0.12</td><td rowspan=1 colspan=1>0.07</td><td rowspan=1 colspan=1>12.3</td><td rowspan=1 colspan=1>1.2</td><td rowspan=1 colspan=1>5.1</td><td rowspan=1 colspan=1>≤1</td><td rowspan=1 colspan=1>52.0</td><td rowspan=1 colspan=1>83.5</td></tr><tr><td rowspan=3 colspan=2>S</td><td rowspan=3 colspan=1>0.13</td><td rowspan=3 colspan=1>0.07</td><td rowspan=3 colspan=1>21.2</td><td rowspan=3 colspan=1>6.0</td><td></td><td></td><td></td><td></td></tr><tr><td rowspan=2 colspan=1></td><td></td><td></td><td></td><td></td></tr><tr><td rowspan=1 colspan=1>10.6</td><td rowspan=1 colspan=1>2.0</td><td rowspan=1 colspan=1>55.4</td><td rowspan=1 colspan=1>84.9</td></tr><tr><td rowspan=1 colspan=1>0.17</td><td rowspan=1 colspan=1>0.10</td><td rowspan=1 colspan=1>25.6</td><td rowspan=1 colspan=1>13.2</td><td rowspan=1 colspan=1>11.3</td><td rowspan=1 colspan=1>5.7</td><td rowspan=1 colspan=1>57.9</td><td rowspan=1 colspan=1>84.8</td></tr><tr><td rowspan=1 colspan=1>0.23</td><td rowspan=1 colspan=1>0.12</td><td rowspan=1 colspan=1>61.9</td><td rowspan=1 colspan=1>45.9</td><td rowspan=1 colspan=1>46.1</td><td rowspan=1 colspan=1>28.2</td><td rowspan=1 colspan=1>59.2</td><td rowspan=1 colspan=1>82.4</td></tr><tr><td rowspan=1 colspan=1>0.34</td><td rowspan=1 colspan=1>0.17</td><td rowspan=1 colspan=1>69.5</td><td rowspan=1 colspan=1>56.9</td><td rowspan=1 colspan=1>57.2</td><td rowspan=1 colspan=1>41.5</td><td rowspan=1 colspan=1>69.3</td><td rowspan=1 colspan=1>87.2</td></tr><tr><td rowspan=2 colspan=3>AT10 (SCE)AT10 (MMC-10)</td><td rowspan=2 colspan=1>1.191.91</td><td rowspan=1 colspan=1>0.63</td><td rowspan=1 colspan=1>81.1</td><td rowspan=1 colspan=1>67.8</td><td rowspan=1 colspan=1>77.9</td><td rowspan=1 colspan=1>59.4</td><td rowspan=2 colspan=1>82.283.5</td><td rowspan=1 colspan=1>76.0</td></tr><tr><td rowspan=1 colspan=1>0.85</td><td rowspan=1 colspan=1>79.1</td><td rowspan=1 colspan=1>69.2</td><td rowspan=1 colspan=1>74.5</td><td rowspan=1 colspan=1>62.7</td><td rowspan=1 colspan=1>75.2</td></tr><tr><td rowspan=2 colspan=3>AT10 (SCE)AT10(MMC-10)</td><td rowspan=1 colspan=1>1.26</td><td rowspan=1 colspan=1>0.68</td><td rowspan=1 colspan=1>78.8</td><td rowspan=1 colspan=1>67.0</td><td rowspan=1 colspan=1>73.7</td><td rowspan=1 colspan=1>60.3</td><td rowspan=1 colspan=1>78.9</td><td rowspan=1 colspan=1>73.7</td></tr><tr><td rowspan=1 colspan=1>1.55</td><td rowspan=1 colspan=1>0.73</td><td rowspan=1 colspan=1>80.4</td><td rowspan=1 colspan=1>69.6</td><td rowspan=1 colspan=1>74.6</td><td rowspan=1 colspan=1>62.4</td><td rowspan=1 colspan=1>80.3</td><td rowspan=1 colspan=1>75.8</td></tr></table>
+
+Following the setting in Madry et al. (2018), we choose the perturbation $\epsilon = 8 / 2 5 5$ and 16/255, with the step size be $2 / 2 5 5$ . We have also run PGD-100 and PGD-200 attacks, and find that the accuracy converges compared to PGD-50. In each PGD experiment, we ran several times with different random restarts to guarantee the reliability of the reported results.
+
+Ablation study. To investigate the effect on robustness induced by high sample density in MMC, we substitute uniformly sampled center set (Liu et al., 2018; Duan et al., 2019), i.e., $\mu ^ { r } = \{ \mu _ { l } ^ { r } \} _ { l \in [ L ] }$ for the MM center set $\mu ^ { * }$ , and name the resulted method as "MMC-10 (rand)" as shown in Table 1. There is also $\| \mu _ { l } ^ { r } \| _ { 2 } = C _ { \mathrm { M M } }$ , but $\mu ^ { r }$ is no longer the solution of the min-max problem in Sec. 3.3.
+
+From the results in Table 1, we can see that higher sample density alone in "MMC-10 (rand)" can already lead to much better robustness than other baseline methods even under the adaptive attacks, while using the optimal center set $\mu ^ { * }$ as in "MMC-10" can further improve performance. When combining with the AT mechanism, the trained models have better performance under the attacks different from the one used to craft adversarial examples for training, e.g, $\mathrm { P G D } _ { 5 0 } ^ { \mathbf { u n } }$ with $\epsilon = 1 6 / 2 5 5$ .
+
+Then we investigate the white-box $l _ { 2 }$ distortion setting. We apply the C&W attack, where it has a binary search mechanism to find the minimal distortion to successfully mislead the classifier under the untargeted mode, or lead the classifier to predict the target label in the targeted mode. Following the suggestion in Carlini & Wagner (2017a), we set the binary search steps to be 9 with the initial constant $c = 0 . 0 1$ . The iteration steps for each value of $c$ are set to be 1,000 with the learning rate of 0.005. In the Part I of Table 2, we report the minimal distortions found by the C&W attack. As expected, it requires much larger distortions to successfully evade the networks trained by MMC.
+
+# 4.4 PERFORMANCE UNDER THE BLACK-BOX ATTACKS
+
+Table 3: Accuracy $( \% )$ of MMC-10 under SPSA with different batch sizes.   
+
+<table><tr><td rowspan=2 colspan=3>CIFAR-10Batch SPSA10 SPSA</td></tr><tr><td rowspan=1 colspan=1>Batch</td><td rowspan=1 colspan=1>SPSA10</td></tr><tr><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>57.0</td><td rowspan=1 colspan=1>69.0</td></tr><tr><td rowspan=1 colspan=1>4096</td><td rowspan=1 colspan=1>41.0</td><td rowspan=1 colspan=1>52.0</td></tr><tr><td rowspan=1 colspan=1>8192</td><td rowspan=1 colspan=1>37.0</td><td rowspan=1 colspan=1>49.0</td></tr></table>
+
+As suggested in Carlini et al. (2019), providing evidence of being robust against the black-box attacks is critical to claim reliable robustness. We first perform the transfer-based attacks using PGD and MIM. Since the targeted attacks usually have poor transferability (Kurakin et al., 2018), we only focus on the untargeted mode in this case, and the results are shown in Fig. 4. We further perform the gradient-free attacks using the SPSA method and report the results in the Part II of Table 2. To perform numerical approximations on gradients in SPSA, we set the batch size to be 128, the learning rate is 0.01, and the step size of the finite difference is $\delta = 0 . 0 1$ , as suggested by Uesato et al. (2018). We also evaluate under stronger
+
+SPSA attacks with batch size to be 4096 and 8192 in Table 3, where the $\epsilon = 8 / 2 5 5$ . With larger batch sizes, we can find that the accuracy under the black-box SPSA attacks converges to it under the white-box PGD attacks. These results indicate that training with the MMC loss also leads to robustness under the black-box attacks, which verifies that our method can induce reliable robustness, rather than the false one caused by, e.g., gradient mask (Athalye et al., 2018).
+
+Table 4: Experiments on CIFAR-100. Part I: Classification accuracy $( \% )$ on the clean test samples. Part II: Classification accuracy $( \% )$ under the white-box PGD attacks and the block-box SPSA attack. The attacks are adaptive for MMC. Here the batch size for SPSA is 128. Part III: Averaged $l _ { 2 }$ distortion of the white-box adversarial examples crafted by C&W with 1,000 iteration steps and 9 binary search epochs.   
+
+<table><tr><td rowspan="2">Methods</td><td rowspan="2">Part I Clean</td><td colspan="4">Part II(ε = 8/255)</td><td colspan="2">Part I</td></tr><tr><td>PGD</td><td>PGD10</td><td>SPSA</td><td>SPSA10</td><td>C&amp;Wtar</td><td>C&amp;Wun</td></tr><tr><td>SCE</td><td>72.9</td><td>≤1</td><td>8.0</td><td>14.0</td><td>1.9</td><td>0.16</td><td>0.047</td></tr><tr><td>Center</td><td>72.8</td><td>≤1</td><td>10.2</td><td>14.7</td><td>2.3</td><td>0.18</td><td>0.048</td></tr><tr><td>MMLDA</td><td>72.2</td><td>≤1</td><td>13.9</td><td>18.5</td><td>5.6</td><td>0.21</td><td>0.050</td></tr><tr><td>L-GM</td><td>71.3</td><td>15.8</td><td>15.3</td><td>22.8</td><td>7.6</td><td>0.31</td><td>0.063</td></tr><tr><td>MMC-10</td><td>71.9</td><td>23.9</td><td>23.4</td><td>33.4</td><td>15.8</td><td>0.37</td><td>0.085</td></tr></table>
+
+# 4.5 PERFORMANCE UNDER THE GENERAL-PURPOSE ATTACKS
+
+To show that our method is generally robust, we further test under the general-purpose attacks (Carlini et al., 2019). We apply the Gaussian noise (Fawzi et al., 2016; Gilmer et al., 2019) and rotation transformation (Engstrom et al., 2019), which are not included in the data augmentation for training. The results are given in the Part III of Table 2. Note that the AT methods are less robust to simple transformations like rotation, as also observed in previous work (Engstrom et al., 2019). In comparison, the models trained by the MMC loss are still robust to these easy-to-apply attacks.
+
+# 4.6 EXPERIMENTS ON CIFAR-100
+
+In Table 4 and Table 5, we provide the results on CIFAR-100 under the white-box PGD and C&W attacks, and the black-box gradient-free SPSA attack. The hyperparameter setting for each attack is the same as it on CIFAR-10. Compared to previous defense strategies which also evaluate on CIFAR-100 (Pang et al., 2019; Mustafa et al., 2019), MMC can improve robustness more significantly, while keeping better performance on the clean inputs. Compared to the results on CIFAR-10, the averaged distortion of C&W on CIFAR-100 is larger for a successful targeted attack and is much smaller for a successful untargeted attack. This is because when only the number of classes increases, e.g., from 10 to 100, it is easier to achieve a coarse untargeted attack, but harder to make a subtle targeted attack. Note that in Table 5, we also train on the ResNet-110 model with eighteen core block layers except for the ResNet-32 model. The results show that MMC can further benefit from deep network architectures and better exploit model capacity to improve robustness. Similar properties are also observed in previous work when applying the AT methods (Madry et al., 2018). In contrast, as shown in Table 5, the models trained by SCE are comparably sensitive to adversarial perturbations for different architectures, which demonstrates that SCE cannot take full advantage of the model capacity to improve robustness. This verifies that MMC provides effective robustness promoting mechanism like the AT methods, with much less computational cost.
+
+# 5 CONCLUSION
+
+In this paper, we formally demonstrate that applying the softmax function in training could potentially lead to unexpected supervisory signals. To solve this problem, we propose the MMC loss to learn more structured representations and induce high-density regions in the feature space. In our experiments, we empirically demonstrate several favorable merits of our method: (i) Lead to reliable robustness even under strong adaptive attacks in different threat models; (ii) Keep high performance on clean inputs comparable to SCE; (iii) Introduce little extra computation compared to the SCE loss; (iv) Compatible with the existing defense mechanisms, e.g., the AT methods. Our analyses in this paper also provide useful insights for future work on designing new objectives beyond the SCE framework.
+
+# ACKNOWLEDGEMENTS
+
+This work was supported by the National Key Research and Development Program of China (No. 2017YFA0700904), NSFC Projects (Nos. 61620106010, U19B2034, U1811461), Beijing NSF Project (No. L172037), Beijing Academy of Artificial Intelligence (BAAI), Tsinghua-Huawei Joint Research Program, a grant from Tsinghua Institute for Guo Qiang, Tiangong Institute for Intelligent Computing, the JP Morgan Faculty Research Program and the NVIDIA NVAIL Program with GPU/DGX Acceleration.
+
+# REFERENCES
+
+Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. In International Conference on Machine Learning (ICML), 2018.
+
+Battista Biggio, Igino Corona, Davide Maiorca, Blaine Nelson, Nedim Šrndic, Pavel Laskov, Giorgio ´ 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 (S&P), 2017a.
+
+Nicholas Carlini and David Wagner. Adversarial examples are not easily detected: Bypassing ten detection methods. In ACM Workshop on Artificial Intelligence and Security (AISec), 2017b.
+
+Nicholas Carlini, Anish Athalye, Nicolas Papernot, Wieland Brendel, Jonas Rauber, Dimitris Tsipras, Ian Goodfellow, Aleksander Madry, and Alexey Kurakin. On evaluating adversarial robustness. arXiv preprint arXiv:1902.06705, 2019.
+
+Yair Carmon, Aditi Raghunathan, Ludwig Schmidt, Percy Liang, and John C Duchi. Unlabeled data improves adversarial robustness. In Advances in Neural Information Processing Systems (NeurIPS), 2019.
+
+Pin-Yu Chen, Huan Zhang, Yash Sharma, Jinfeng Yi, and Cho-Jui Hsieh. Zoo: Zeroth order optimization based black-box attacks to deep neural networks without training substitute models. In Proceedings of the 10th ACM Workshop on Artificial Intelligence and Security (AISec), pp. 15–26. ACM, 2017.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 248–255. IEEE, 2009.
+
+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 (CVPR), pp. 4690–4699, 2019.
+
+Yinpeng Dong, Fangzhou Liao, Tianyu Pang, Hang Su, Jun Zhu, Xiaolin Hu, and Jianguo Li. Boosting adversarial attacks with momentum. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2018.
+
+Yueqi Duan, Jiwen Lu, and Jie Zhou. Uniformface: Learning deep equidistributed representation for face recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 3415–3424, 2019.
+
+Krishnamurthy Dvijotham, Sven Gowal, Robert Stanforth, Relja Arandjelovic, Brendan O’Donoghue, Jonathan Uesato, and Pushmeet Kohli. Training verified learners with learned verifiers. arXiv preprint arXiv:1805.10265, 2018a.
+
+Krishnamurthy Dvijotham, Robert Stanforth, Sven Gowal, Timothy Mann, and Pushmeet Kohli. A dual approach to scalable verification of deep networks. In Annual Conference on Uncertainty in Artificial Intelligence (UAI), 2018b.
+
+Logan Engstrom, Brandon Tran, Dimitris Tsipras, Ludwig Schmidt, and Aleksander Madry. A rotation and a translation suffice: Fooling cnns with simple transformations. In International Conference on Machine Learning (ICML), 2019.
+
+Alhussein Fawzi, Seyed-Mohsen Moosavi-Dezfooli, and Pascal Frossard. Robustness of classifiers: from adversarial to random noise. In Advances in Neural Information Processing Systems (NeurIPS), pp. 1632–1640, 2016.
+
+Alhussein Fawzi, Hamza Fawzi, and Omar Fawzi. Adversarial vulnerability for any classifier. In Advances in Neural Information Processing Systems (NeurIPS), 2018.
+
+Jerome Friedman, Trevor Hastie, and Robert Tibshirani. The elements of statistical learning, volume 1. Springer series in statistics New York, 2001.
+
+Justin Gilmer, Nicolas Ford, Nicolas Carlini, and Ekin Cubuk. Adversarial examples are a natural consequence of test error in noise. In International Conference on Machine Learning (ICML), 2019.
+
+Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep Learning. MIT Press, 2016. http: //www.deeplearningbook.org.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In International Conference on Learning Representations (ICLR), 2015.
+
+Yandong Guo and Lei Zhang. One-shot face recognition by promoting underrepresented classes. arXiv preprint arXiv:1707.05574, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In European Conference on Computer Vision (ECCV), pp. 630–645. Springer, 2016.
+
+Matthias Hein and Maksym Andriushchenko. Formal guarantees on the robustness of a classifier against adversarial manipulation. In Advances in Neural Information Processing Systems (NeurIPS), pp. 2266–2276, 2017.
+
+Cormac Herley and Paul C Van Oorschot. Sok: Science, security and the elusive goal of security as a scientific pursuit. In 2017 IEEE Symposium on Security and Privacy (S&P), pp. 99–120. IEEE, 2017.
+
+Andrew Ilyas, Logan Engstrom, Anish Athalye, and Jessy Lin. Black-box adversarial attacks with limited queries and information. In International Conference on Machine Learning (ICML), 2018.
+
+Andrew Ilyas, Shibani Santurkar, Dimitris Tsipras, Logan Engstrom, Brandon Anish Athalye, Tran, and Aleksander Madry. Adversarial examples are not bugs, they are features. In Advances in Neural Information Processing Systems (NeurIPS), 2019.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning (ICML), pp. 448–456, 2015.
+
+John David Jackson. Classical electrodynamics. American Journal of Physics, 1999.
+
+Harini Kannan, Alexey Kurakin, and Ian Goodfellow. Adversarial logit pairing. arXiv preprint arXiv:1803.06373, 2018.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. In The International Conference on Learning Representations (ICLR) Workshops, 2017.
+
+Alexey Kurakin, Ian Goodfellow, Samy Bengio, Yinpeng Dong, Fangzhou Liao, Ming Liang, Tianyu Pang, Jun Zhu, Xiaolin Hu, Cihang Xie, et al. Adversarial attacks and defences competition. arXiv preprint arXiv:1804.00097, 2018.
+
+Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Xuezhi Liang, Xiaobo Wang, Zhen Lei, Shengcai Liao, and Stan Z Li. Soft-margin softmax for deep classification. In International Conference on Neural Information Processing (ICNIP), pp. 413–421. Springer, 2017.
+
+Weiyang Liu, Yandong Wen, Zhiding Yu, and Meng Yang. Large-margin softmax loss for convolutional neural networks. In International Conference on Machine Learning (ICML), 2016.
+
+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 (CVPR), pp. 212–220, 2017.
+
+Weiyang Liu, Rongmei Lin, Zhen Liu, Lixin Liu, Zhiding Yu, Bo Dai, and Le Song. Learning towards minimum hyperspherical energy. In Advances in Neural Information Processing Systems (NeurIPS), pp. 6222–6233, 2018.
+
+Pavel Loskot and Norman C. Beaulieu. On monotonicity of the hypersphere volume and area. Journal of Geometry, 2007.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In International Conference on Learning Representations (ICLR), 2018.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 2574–2582, 2016.
+
+Aamir Mustafa, Salman Khan, Munawar Hayat, Roland Goecke, Jianging Shen, and Ling Shao. Adversarial defense by restricting the hidden space of deep neural networks. In International Conference on Computer Vision (ICCV), 2019.
+
+Yu Nesterov. Smooth minimization of non-smooth functions. Mathematical programming, 103(1): 127–152, 2005.
+
+Anh Nguyen, Jason Yosinski, and Jeff Clune. Deep neural networks are easily fooled: High confidence predictions for unrecognizable images. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 427–436, 2015.
+
+Frank Nielsen and Ke Sun. Guaranteed bounds on the kullback–leibler divergence of univariate mixtures. IEEE Signal Processing Letters, 23(11):1543–1546, 2016.
+
+Tianyu Pang, Chao Du, and Jun Zhu. Max-mahalanobis linear discriminant analysis networks. In International Conference on Machine Learning (ICML), 2018.
+
+Tianyu Pang, Kun Xu, Chao Du, Ning Chen, and Jun Zhu. Improving adversarial robustness via promoting ensemble diversity. In International Conference on Machine Learning (ICML), 2019.
+
+Nicolas Papernot, Patrick McDaniel, Somesh Jha, Matt Fredrikson, Z Berkay Celik, and Ananthram Swami. The limitations of deep learning in adversarial settings. In IEEE European Symposium on Security and Privacy (EuroS&P), pp. 372–387. IEEE, 2016.
+
+Nicolas Papernot, Patrick McDaniel, Arunesh Sinha, and Michael Wellman. Towards the science of security and privacy in machine learning. In European Symposium on Security and Privacy (EuroS&P), 2018.
+
+Xianbiao Qi and Lei Zhang. Face recognition via centralized coordinate learning. arXiv preprint arXiv:1801.05678, 2018.
+
+Ning Qian. On the momentum term in gradient descent learning algorithms. Neural networks, 12(1): 145–151, 1999.
+
+Ludwig Schmidt, Shibani Santurkar, Dimitris Tsipras, Kunal Talwar, and Aleksander Madry. Adversarially robust generalization requires more data. In Advances in Neural Information Processing Systems (NeurIPS), pp. 5019–5031, 2018.
+
+Florian Schroff, Dmitry Kalenichenko, and James Philbin. Facenet: A unified embedding for face recognition and clustering. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 815–823, 2015.
+
+Ali Shafahi, Mahyar Najibi, Amin Ghiasi, Zheng Xu, John Dickerson, Christoph Studer, Larry S Davis, Gavin Taylor, and Tom Goldstein. Adversarial training for free! In Advances in Neural Information Processing Systems (NeurIPS), 2019.
+
+Robert Stanforth, Alhussein Fawzi, Pushmeet Kohli, et al. Are labels required for improving adversarial robustness? In Advances in Neural Information Processing Systems (NeurIPS), 2019.
+
+Yi Sun, Yuheng Chen, Xiaogang Wang, and Xiaoou Tang. Deep learning face representation by joint identification-verification. In Advances in Neural Information Processing Systems (NeurIPS), pp. 1988–1996, 2014.
+
+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 (ICLR), 2014.
+
+Jonathan Uesato, Brendan O’Donoghue, Aaron van den Oord, and Pushmeet Kohli. Adversarial risk and the dangers of evaluating against weak attacks. In International Conference on Machine Learning (ICML), 2018.
+
+Weitao Wan, Yuanyi Zhong, Tianpeng Li, and Jiansheng Chen. Rethinking feature distribution for loss functions in image classification. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 9117–9126, 2018.
+
+Feng Wang, Xiang Xiang, Jian Cheng, and Alan Loddon Yuille. Normface: l 2 hypersphere embedding for face verification. In Proceedings of the 25th ACM international conference on Multimedia (ACM MM), pp. 1041–1049. ACM, 2017.
+
+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 (CVPR), pp. 5265–5274, 2018.
+
+Yandong Wen, Kaipeng Zhang, Zhifeng Li, and Yu Qiao. A discriminative feature learning approach for deep face recognition. In European Conference on Computer Vision (ECCV), pp. 499–515. Springer, 2016.
+
+Eric Wong and Zico Kolter. Provable defenses against adversarial examples via the convex outer adversarial polytope. In International Conference on Machine Learning (ICML), pp. 5283–5292, 2018.
+
+Eric Wong, Frank Schmidt, Jan Hendrik Metzen, and J Zico Kolter. Scaling provable adversarial defenses. In Advances in Neural Information Processing Systems (NeurIPS), pp. 8400–8409, 2018.
+
+Kai Y Xiao, Vincent Tjeng, Nur Muhammad Shafiullah, and Aleksander Madry. Training for faster adversarial robustness verification via inducing relu stability. In International Conference on Learning Representations (ICLR), 2019.
+
+Cihang Xie, Yuxin Wu, Laurens van der Maaten, Alan Yuille, and Kaiming He. Feature denoising for improving adversarial robustness. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019.
+
+Dinghuai Zhang, Tianyuan Zhang, Yiping Lu, Zhanxing Zhu, and Bin Dong. You only propagate once: Accelerating adversarial training via maximal principle. In Advances in Neural Information Processing Systems (NeurIPS), 2019a.
+
+Hongyang Zhang, Yaodong Yu, Jiantao Jiao, Eric P Xing, Laurent El Ghaoui, and Michael I Jordan. Theoretically principled trade-off between robustness and accuracy. In International Conference on Machine Learning (ICML), 2019b.
+
+# A PROOF
+
+In this section, we provide the proof of the theorems proposed in the paper.
+
+A.1 PROOF OF THEOREM 1
+
+According to the definition of sample density
+
+$$
+\mathbb { S D } ( z ) = \frac { \Delta N } { \mathrm { V o l } ( \Delta B ) } ,
+$$
+
+we separately calculate $\Delta N$ and $\mathrm { V o l } ( \Delta B )$ . Since $\mathcal { L } _ { \mathrm { g - S C E } } \sim p _ { k , \tilde { k } } ( c )$ for the data points in $\mathcal { D } _ { k , \tilde { k } }$ , recall that $\Delta B = \{ z \in \mathbb { R } ^ { d } | { \mathcal { L } } _ { \mathrm { g - S C E } } \in [ C , C + \Delta C ] \}$ , then there is
+
+$$
+\begin{array} { r l } & { \Delta N = | Z ( \mathcal { D } _ { k , \tilde { k } } ) \cap \Delta B | } \\ & { \qquad = N _ { k , \tilde { k } } \cdot p _ { k , \tilde { k } } ( C ) \cdot \Delta C . } \end{array}
+$$
+
+Now we calculate $\mathrm { V o l } ( \Delta B )$ by approximating it with $\mathrm { V o l } ( \Delta B _ { y , \tilde { y } } )$ . We first derive the solution of $\begin{array} { r l } { \mathcal { L } _ { y , } } & { { } = ~ C } \end{array}$ . For simplicity, we assume scaled identity covariance matrix, i.e., $\Sigma _ { i } = \sigma _ { i } I $ , where $\sigma _ { i } > 0$ are scalars. Then $\forall i , j \in [ L ]$ , $c$ is any constant, if $\sigma _ { i } \neq \sigma _ { j }$ , the solution of $h _ { i } - h _ { j } = c$ is a $( d \mathrm { - } 1 )$ -dimensional hypersphere embedded in the $d$ -dimensional space of the feature $z$ :
+
+$$
+\| z - \mathbf { M } _ { i , j } \| _ { 2 } ^ { 2 } = \mathbf { B } _ { i , j } - { \frac { c } { \sigma _ { i } - \sigma _ { j } } } , { \mathrm { w h e r e } } \mathbf { M } _ { i , j } = { \frac { \sigma _ { i } \mu _ { i } - \sigma _ { j } \mu _ { j } } { \sigma _ { i } - \sigma _ { j } } } , \ \mathbf { B } _ { i , j } = { \frac { \sigma _ { i } \sigma _ { j } \| \mu _ { i } - \mu _ { j } \| _ { 2 } ^ { 2 } } { ( \sigma _ { i } - \sigma _ { j } ) ^ { 2 } } } + { \frac { B _ { i } - B _ { j } } { \sigma _ { i } - \sigma _ { j } } } .
+$$
+
+Note that each value of $c$ corresponds to a specific contour, where $\mathbf { M } _ { i , j }$ and $\mathbf { B } _ { i , j }$ can be regraded as constant w.r.t. $c$ . When $\mathbf { B } _ { i , j } < ( \sigma _ { i } - \sigma _ { j } ) ^ { - 1 } c$ , the solution set becomes empty. Specially, if $\sigma _ { i } = \sigma _ { j } = \sigma$ , the hypersphere-shape contour will degenerate to a hyperplane: $z ^ { \top } ( \mu _ { i } - \mu _ { j } ) =$ $\begin{array} { r } { \frac { 1 } { 2 } \left[ \| \mu _ { i } \| _ { 2 } ^ { 2 } - \| \mu _ { j } \| _ { 2 } ^ { 2 } + \sigma ^ { - 1 } ( B _ { j } - B _ { i } + c ) \right] } \end{array}$ . For example, for the SCE loss, the solution of the contour is $z ^ { \top } ( W _ { i } - W _ { j } ) = b _ { j } - b _ { i } + c$ . For more general $\Sigma _ { i }$ , the conclusions are similar, e.g., the solution in Eq. (12) will become a hyperellipse. Now it easy to show that the solution of $\begin{array} { r l } { \mathcal { L } _ { y , } } & { { } = C } \end{array}$ when $y = k , \tilde { y } = \tilde { k }$ is the hypersphere:
+
+$$
+\| z - \mathbf { M } _ { k , \tilde { k } } \| _ { 2 } ^ { 2 } = \mathbf { B } _ { k , \tilde { k } } + \frac { \log ( C _ { e } - 1 ) } { \sigma _ { k } - \sigma _ { \tilde { k } } } .
+$$
+
+According to the formula of the hypersphere surface area (Loskot & Beaulieu, 2007), the volume of $\Delta B _ { y , }$ is
+
+$$
+\mathrm { V o l } ( \Delta B _ { y , \tilde { y } } ) = \frac { 2 \pi ^ { \frac { d } { 2 } } } { \Gamma ( \frac { d } { 2 } ) } \left( \mathbf { B } _ { k , \tilde { k } } + \frac { \log ( C _ { e } - 1 ) } { \sigma _ { k } - \sigma _ { \tilde { k } } } \right) ^ { \frac { d - 1 } { 2 } } \cdot \Delta C ,
+$$
+
+where $\Gamma ( \cdot )$ is the gamma function. Finally we can approximate the sample density as
+
+$$
+\begin{array} { l } { \displaystyle \mathbb { S } \mathbb { D } ( z ) \approx \frac { \Delta N } { \Delta B _ { y , } } } \\ { \displaystyle \propto \frac { N _ { k , \tilde { k } } \cdot p _ { k , \tilde { k } } ( C ) } { \left[ \mathbf { B } _ { k , \tilde { k } } + \frac { \log ( C _ { e } - 1 ) } { \sigma _ { k } - \sigma _ { \tilde { k } } } \right] ^ { \frac { d - 1 } { 2 } } } . } \end{array}
+$$
+
+# A.2 PROOF OF THEOREM 2
+
+Similar to the proof of Theorem 1, there is
+
+$$
+\begin{array} { r l } { \Delta N = | Z ( \mathcal { D } _ { k } ) \cap \Delta B | } & { } \\ { = N _ { k } \cdot p _ { k } ( C ) \cdot \Delta C . } \end{array}
+$$
+
+Unlike for the $\mathbf { g }$ -SCE, we can exactly calculate $\mathrm { V o l } ( \Delta B )$ for the MMC loss. Note that the solution of $\mathcal { L } _ { \mathrm { M M C } } = C$ is the hypersphere:
+
+$$
+\| z - \mu _ { y } ^ { * } \| _ { 2 } ^ { 2 } = 2 C .
+$$
+
+![](images/fc359600e0ce617edfc8fda9b8b820f6b274065866c605fee7023165506c1f86.jpg)  
+Figure 5: Intuitive illustration of the Max-Mahalanobis centers in the cases of $L = 2 , 3 , 4$ .
+
+According to the formula of the hypersphere surface area (Loskot & Beaulieu, 2007), we have
+
+$$
+\operatorname { V o l } ( \Delta B ) = { \frac { 2 ^ { \frac { d + 1 } { 2 } } \pi ^ { \frac { d } { 2 } } C ^ { \frac { d - 1 } { 2 } } } { \Gamma ( { \frac { d } { 2 } } ) } } \cdot \Delta C ,
+$$
+
+where $\Gamma ( \cdot )$ is the gamma function. Finally we can obtain the sample density as
+
+$$
+\begin{array} { l } { \displaystyle \mathbb { S D } ( z ) = \frac { \Delta N } { \Delta B } } \\ { \displaystyle \propto \frac { N _ { k } \cdot p _ { k } ( C ) } { C ^ { \frac { d - 1 } { 2 } } } . } \end{array}
+$$
+
+# B TECHNICAL DETAILS
+
+In this section, we provide more technical details we applied in our paper. Most of our experiments are conducted on the NVIDIA DGX-1 server with eight Tesla P100 GPUs.
+
+# B.1 GENERATION ALGORITHM FOR THE MAX-MAHALANOBIS CENTERS
+
+We give the generation algorithm for crafting the Max-Mahalanobis Centers in Algorithm 1, proposed by Pang et al. (2018). Note that there are two minor differences from the originally proposed algorithm. First is that in Pang et al. (2018) they use $C = \| \mu _ { i } \| _ { 2 } ^ { 2 }$ , while we use $C _ { \bf M M } = \| \mu _ { i } \| _ { 2 }$ . Second is that we denote the feature $z \in \mathbb { R } ^ { d }$ , while they denote $z \in \mathbb { R } ^ { p }$ . The Max-Mahalanobis centers generated in the low-dimensional cases are quite intuitive and comprehensible as shown in Fig. 5. For examples, when $L = 2$ , the Max-Mahalanobis centers are the two vertexes of a line segment; when $L = 3$ , they are the three vertexes of an equilateral triangle; when $L = 4$ , they are the four vertexes of a regular tetrahedron.
+
+# Algorithm 1 GenerateMMcenters
+
+<table><tr><td></td><td>Input: The constant CMm,the dimension of vectors d and the number of classes L.(L ≤d +1) Initialization: Let the L mean vectors be μ* = e1 and μ* = Od,i ÷ 1. Here e1 and Od separately</td><td></td><td></td><td></td></tr><tr><td>denote the first unit basis vector and the zero vector in Rd. fori=2 toL do</td><td></td><td></td><td></td><td></td></tr><tr><td>for j=1 toi-1 do</td><td>μ*(j)=-[1+(μ*,μ&gt;·(L-1)]/[μ(j)·(L-1)]</td><td></td><td></td><td></td></tr><tr><td>end for</td><td></td><td></td><td></td><td></td></tr><tr><td>H（i=√1-1*12</td><td></td><td></td><td></td><td></td></tr><tr><td>end for</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td>for k = 1 to L do</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td>H=CMM·μ</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td>end for</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Return: The optimal mean vectors μ*,i ∈ [L].</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+# B.2 WHY THE SQUARED-ERROR FORM IS PREFERRED
+
+In the feature space, penalizing the distance between the features and the prefixed centers can be regarded as a regression problem. In the MMC loss, we apply the squared-error form as $\| \boldsymbol { z } - \boldsymbol { \mu } _ { y } ^ { * } \| _ { 2 } ^ { 2 }$ Other substitutes could be the absolute form $\lVert \boldsymbol { z } - \boldsymbol { \mu } _ { y } ^ { * } \rVert _ { 2 }$ or the Huber form. As stated in Friedman et al. (2001), the absolute form and the Huber form are more resistant to the noisy data (outliers) or the misspecification of the class labels, especially in the data mining applications. However, in the classification tasks that we focus on in this paper, the training data is clean and reliable. Thus the squared-error form can lead to high accuracy with faster convergence rate compared to other forms. Furthermore, in the adversarial setting, the adversarial examples have similar properties as the outliers. When we apply the AT mechanism in the training procedure, we expect the classifiers to pay more attention to the adversarial examples, i.e., the outliers. Note that this goal is the opposite of it in the data mining applications, where outliers are intended to be ignored. Therefore, due to the sensitivity to the outliers, the squared-error form can better collaborate with the AT mechanism to improve robustness.
+
+Besides, the MMC loss can naturally perform stronger AT mechanism without additional regularizer term. Specifically, let $x$ be the clean input, $x ^ { * }$ be the adversarial example crafted based on $x$ , then in the adversarial logit pairing (ALP) method (Kannan et al., 2018), there is an extra regularizer except for SCE as:
+
+$$
+\| z ( x ) - z ( x ^ { * } ) \| _ { 2 } ^ { 2 } .
+$$
+
+When adding $x ^ { * }$ as an extra training point for MMC, then the MMC loss will minimize $\| z ( x ) - \mu _ { y } ^ { * } \| _ { 2 } ^ { 2 } +$ $\| z ( x ^ { * } ) - \mu _ { y } ^ { * } \| _ { 2 } ^ { 2 }$ , which is an upper bound for $\begin{array} { r } { \frac { 1 } { 2 } \| z ( x ) - z ( x ^ { * } ) \| _ { 2 } ^ { 2 } } \end{array}$ . Thus performing naive adversarial training (Goodfellow et al., 2015; Madry et al., 2018) with MMC is equivalent to performing stronger adversarial training variants like ALP. As analyzed above, the squared-error form in the MMC loss can accelerate the convergence of the AT mechanism, since the objective is sensitive to the crafted adversarial examples.
+
+# B.3 VARIANTS OF THE MMC LOSS
+
+In the MMC loss, we encourage the features to gather around the preset Max-Mahalanobis (MM) centers $\mu ^ { * } = \{ \mu _ { l } ^ { * } \} _ { l \in [ L ] }$ , which leads to many attractive properties. However, this ’hard’ supervision, which induces quite an orderly feature distribution may beyond the reach of the model capability, especially when the classification tasks themselves are already challenging to learn, e.g., ImageNet (Deng et al., 2009). Therefore, we propose potential variants of the MMC loss that could probably solve the problem and make our method more adaptable. We leave the experimental investigations as future work.
+
+Note that the MMC loss can be regarded as minimizing the negative log likelihood (NLL) of $- \log ( P ( z | y ) )$ , where the conditional feature distribution is modeled as $\mathsf { \bar { z } } | y \sim \mathcal N ( \mu _ { y } ^ { * } , I )$ . As described above, this distribution model may not be easy to learn by the DNNs in some cases. Thus, we construct a softer model: $z | y , \mu _ { y } \sim \mathcal { N } ( \mu _ { y } , I )$ and $\mu _ { y } \sim \mathcal { N } ( \mu _ { y } ^ { * } , \alpha I )$ , where $\alpha > 0$ is a scalar. Here we give the feature center $\mu _ { y }$ a prior distribution, while the prior is centered at $\mu _ { y } ^ { * }$ . Intuitively, we relax the constraint that the features have to gather around $\mu _ { y } ^ { * }$ . Instead, we encourage the features to gather around a substitute $\mu _ { y }$ , while $\mu _ { y }$ should be in the vicinity of $\mu _ { y } ^ { * }$ . In the training, we minimize the joint NLL of $- \log ( P ( z , \mu _ { y } | y ) ) = - \log ( P ( z | y , \mu _ { y } ) ) - \log ( \tilde { P ( \mu _ { y } ) } )$ , which is equivalent to minimize the what we call elastic Max-Mahalanobis center (EMC) loss as:
+
+$$
+\mathcal { L } _ { \mathrm { E M C } } ( Z ( x ) , y ) = \frac { 1 } { 2 } \| z - \mu _ { y } \| ^ { 2 } + \frac { 1 } { 2 \alpha } \| \mu _ { y } - \mu _ { y } ^ { * } \| ^ { 2 } .
+$$
+
+Here $\mu = \{ \mu _ { l } \} _ { l \in [ L ] }$ are simply extra trainable parameters, the prior variance $\alpha$ is a hyperparameter. When $\alpha  0$ , the EMC loss degenerates to the MMC loss. Note that although $\mu _ { l } ^ { * }$ are all on the hypersphere $\{ \mathbf { z } \in \mathbb { R } ^ { d } | \| \mathbf { z } \| = C _ { \mathrm { M M } } \}$ , the support sets of $\mu _ { l }$ are the entire feature space $\mathbb { R } ^ { d }$ .
+
+Further improvement can be made w.r.t. the MM centers $\mu ^ { * }$ . An implicit assumption behind the generation process of $\mu ^ { * }$ is that any two classes are mutually independent. This assumption could be approximately true for MNIST and CIFAR-10, but for more complex datasets, e.g., CIFAR-100 or ImageNet, this assumption may not be appropriate since there are structures in the relation among classes. These structures can usually be visualized by a tree. To solve this problem, we introduce the hierarchical Max-Mahalanobis (HM) centers $\mu ^ { \mathrm { H } } = \{ \mu _ { l } ^ { \mathrm { H } } \} _ { l \in [ L ] }$ , which adaptively craft the centers according to the tree structure. Specifically, we first assign a virtual center (i.e., the origin) to the root node. For any child node $n _ { c }$ in the tree, we denote its parent node as $n _ { p }$ , and the number of its brother nodes as $L _ { c }$ . We locally generate a set of MM centers as $\mu ^ { ( s , L _ { c } ) } =$ GenerateMMcenters $\left( C ^ { s } , d , L _ { c } \right)$ , where $s$ is the depth of the child node $n _ { c }$ , $C ^ { s }$ is a constant with smaller values for larger $s$ . Then we assign the virtual center to each child node of $n _ { p }$ from $\mu _ { n _ { p } } + \mu ^ { ( s , L _ { c } ) }$ , i.e., a shifted set of crafted MM centers, where $\mu _ { n _ { p } }$ is the virtual center assigned to $n _ { p }$ . If the child node $n _ { c }$ is a leaf node, i.e., it correspond to a class label $l$ , then there is $\mu _ { l } ^ { \mathrm { H } } = \mu _ { n _ { c } }$ . For example, in the CIFAR-100 dataset, there are 20 superclasses, with 5 classes in each superclass. We first craft $2 0 ~ \mathrm { M M }$ centers as $\mu ^ { ( 1 , 2 0 ) } =$ GenerateMMcenters $( C ^ { 1 } , d , 2 0 )$ and 5 MM centers as $\mu ^ { ( 2 , 5 ) } =$ GenerateMMcenters $( C ^ { 2 } , d , 5 )$ , where $C ^ { 2 } \ll C ^ { 1 }$ . Note that $\mu ^ { ( 2 , 5 ) }$ could be different for each superclass, e.g., by a rotation transformation. Then if the label $l$ is the $j$ -th class in the $i$ -th superclass, there is $\mu _ { l } ^ { \mathrm { H } } = \mu _ { i } ^ { ( 1 , 2 0 ) } + \mu _ { j } ^ { ( 2 , 5 ) }$
+
+![](images/12115ca27ef382b159499c70ff9ac449304cf0ff874ada634c975c571f3793f7.jpg)  
+Figure 6: Intuitive demonstration of the attacking mechanisms under different adaptive objectives. Here $_ y$ is the original label, $\begin{array} { r l } { \tilde { y } } & { { } = } \end{array}$ arg $\operatorname* { m a x } _ { l \neq y } h _ { l }$ is the label of the nearest other decision region w.r.t. the feature $_ z$ , and $y _ { t }$ is the target label of targeted attacks.
+
+# B.4 ADAPTIVE OBJECTIVES AND THE INDUCED ATTACKING MECHANISMS
+
+We apply the adaptive versions of existing attacks when evading the networks trained by the MMC loss. Wmode: $\mathcal { L } _ { \mathrm { A d a } } ^ { \bf u \bar { n } , 1 } = - \dot { \mathcal { L } } _ { \mathrm { M M C } } ( z , y )$ a; $\mathcal { L } _ { \mathrm { A d a } } ^ { \bar { \bf u n } , 2 } = \mathcal { L } _ { \mathrm { M M C } } ( z , \tilde { y } ) - \mathcal { L } _ { \mathrm { M M C } } ( z , y )$ $\mathcal { L } _ { \mathrm { { A d a } } }$ o minimize under the untargeted, and under the targeted mode: $\mathcal { L } _ { \mathrm { A d a } } ^ { \mathrm { t a r } , 1 } { = } \mathcal { L } _ { \mathrm { M M C } } ( z , y _ { t } )$ ; $\mathcal { L } _ { \mathrm { A d a } } ^ { \mathrm { t a r } , 2 } = \mathcal { L } _ { \mathrm { M M C } } ( z , y _ { t } ) { - \mathcal { L } _ { \mathrm { M M C } } ( z , y ) }$ , where $y _ { t }$ is the targeted label, $\tilde { y }$ is generally the highest predicted label except for by Carlini & Wagner (2017a;b). Spe $y$ as defined in Sec. 3.2. These ofically, the adaptive objectives ves rand previous workare used in the $\bar { \mathcal { L } } _ { \mathrm { A d a } } ^ { \mathrm { t a r } , 1 }$ $\mathcal { L } _ { \mathrm { A d a } } ^ { \mathbf { u n } , 1 }$ PGD, MIM and SPSA attacks, while the objectives Ltar,2Ada and $\mathcal { L } _ { \mathrm { A d a } } ^ { \mathbf { u n } , 2 }$ Ada Ada are used in the C&W attacks.
+
+In Fig. 6, we demonstrate the attacking mechanisms induced by different adaptive adversarial objectives. Note that we only focus on the gradients and ignore the specific method which implements the attack. Different adaptive objectives are preferred under different adversarial goals. For examples, when decreasing the confidence of the true label is the goal, $\mathcal { L } _ { \mathrm { A d a } } ^ { \mathbf { u n } , 1 }$ is the optimal choice; in order to mislead the classifier to predict an untrue label or the target label, $\mathcal { L } _ { \mathrm { A d a } } ^ { \mathbf { u n } , 2 }$ and $ { \mathcal { L } } _ { \mathrm { A d a } } ^ { \mathrm { t a r } , 2 }$ are the optimal choices, respectively. Sometimes there are additional detectors, then the adversarial examples generated by $\mathcal { L } _ { \mathrm { A d a } } ^ { \mathrm { t a r } , 1 }$ could be assigned to the target label with high confidence by the classifiers.
+
+# B.5 RELATED WORK IN THE FACE RECOGNITION AREA
+
+There are many previous work in the face recognition area that focus on angular margin-based softmax (AMS) losses (Liu et al., 2016; 2017; Liang et al., 2017; Wang et al., 2018; Deng et al., 2019). They mainly exploit three basic operations: weight normalization (WN), feature normalization (FN), and angular margin (AN). It has been empirically shown that WN can benefit the cases with unbalanced data (Guo & Zhang, 2017); FN can encourage the models to focus more on hard examples (Wang et al., 2017); AN can induce larger inter-class margins and lead to better generalization in different facial tasks (Wang et al., 2018; Deng et al., 2019). However, there are two critical differences between our MMC loss and these AMS losses:
+
+Table 5: Classification accuracy $( \% )$ on the white-box adversarial examples crafted on the test set of CIFAR-10 and CIFAR-100. The results w.r.t the MMC loss are reported under the adaptive versions of different attacks. MMC can better exploit deep architectures, while SCE cannot.   
+
+<table><tr><td rowspan="2">Methods</td><td rowspan="2">Cle.</td><td colspan="4">Perturbation ε = 8/255</td><td colspan="4">Perturbation ε = 16/255</td></tr><tr><td>PGD</td><td>PGD1</td><td>PGD5</td><td>PGD50</td><td>PGD</td><td>PGD</td><td>PGD5</td><td>PGD3</td></tr><tr><td colspan="9">CIFAR-10</td></tr><tr><td>SCE (Res.32)</td><td>93.6</td><td>&lt;1</td><td>3.7</td><td>&lt;1</td><td>3.6</td><td>&lt;1</td><td>2.7</td><td>&lt;1</td><td>2.9</td></tr><tr><td>MMC (Res.32)</td><td>92.7</td><td>48.7</td><td>36.0</td><td>26.6</td><td>24.8</td><td>36.1</td><td>25.2</td><td>13.4</td><td>17.5</td></tr><tr><td>SCE (Res.110) MMC (Res.110)</td><td>94.7 93.6</td><td>≤1 54.7</td><td>3.0 46.0</td><td>≤1 34.4</td><td>2.9 31.4</td><td>&lt;1 41.0</td><td>2.1 30.7</td><td>≤1 16.2</td><td>2.0 21.6</td></tr><tr><td colspan="10">CIFAR-100</td></tr><tr><td>SCE (Res.32)</td><td>72.3</td><td>&lt;1</td><td>7.8</td><td>&lt;1</td><td>7.4</td><td>&lt;1</td><td>4.8</td><td>&lt;1</td><td>4.7</td></tr><tr><td>MMC (Res.32)</td><td>71.9</td><td>23.9</td><td>23.4</td><td>15.1</td><td>21.9</td><td>16.4</td><td>16.7</td><td>8.0</td><td>15.7</td></tr><tr><td>SCE (Res.110)</td><td>74.8</td><td>≤1</td><td>7.5</td><td>≤1</td><td>7.3</td><td>≤1</td><td>4.7</td><td>≤1</td><td>4.5</td></tr><tr><td>MMC (Res.110)</td><td>73.2</td><td>34.6</td><td>22.4</td><td>23.7</td><td>16.5</td><td>24.1</td><td>14.9</td><td>13.9</td><td>10.5</td></tr></table>
+
+# Difference one: The inter-class margin
+
+• The AMS losses induce the inter-class margins mainly by encouraging the intra-class compactness, while the weights are not explicitly forced to have large margins (Qi & Zhang, 2018).
+
+• The MMC loss simultaneously fixes the class centers to be optimally dispersed and encourages the intra-class distribution to be compact. Note that both of the two mechanisms can induce inter-class margins, which can finally lead to larger inter-class margins compared to the AMS losses.
+
+# Difference two: The normalization
+
+• The AMS losses use both WN and FN to exploit the angular metric, which makes the normalized features distribute on hyperspheres. The good properties of the AMS losses are at the cost of abandoning the radial degree of freedom, which may reduce the capability of models.
+
+• In the MMC loss, there is only WN on the class centers, i.e., $\| \mu _ { y } ^ { * } \| = C _ { \mathrm { M M } }$ , and we leave the degree of freedom in the radial direction for the features to keep model capacity. However, note that the MMC loss $\| z - \mu _ { y } ^ { * } \| _ { 2 } ^ { 2 } \geq ( \| z \| _ { 2 } - C _ { \mathrm { M M } } ) ^ { 2 }$ is a natural penalty term on the feature norm, which encourage $\left. z \right. _ { 2 }$ to not be far from $C _ { \mathrm { M M } }$ . This prevents models from increasing feature norms for easy examples and ignoring hard examples, just similar to the effect caused by FN but more flexible.

parse/train/g11CZSghXyY/g11CZSghXyY.md

@@ -0,0 +1,380 @@
+# COMBINING ENSEMBLES AND DATA AUGMENTATION CAN HARM YOUR CALIBRATION
+
+Yeming Wen∗1, Ghassen Jerfel∗2, Rafael Muller2, Michael W. Dusenberry2, Jasper Snoek2, Balaji Lakshminarayanan2 & Dustin Tran2 ∗ Equal contribution, 1University of Texas, Austin, 2Google Brain
+
+# ABSTRACT
+
+Ensemble methods which average over multiple neural network predictions are a simple approach to improve a model’s calibration and robustness. Similarly, data augmentation techniques, which encode prior information in the form of invariant feature transformations, are effective for improving calibration and robustness. In this paper, we show a surprising pathology: combining ensembles and data augmentation can harm model calibration. This leads to a trade-off in practice, whereby improved accuracy by combining the two techniques comes at the expense of calibration. On the other hand, selecting only one of the techniques ensures good uncertainty estimates at the expense of accuracy. We investigate this pathology and identify a compounding under-confidence among methods which marginalize over sets of weights and data augmentation techniques which soften labels. Finally, we propose a simple correction, achieving the best of both worlds with significant accuracy and calibration gains over using only ensembles or data augmentation individually. Applying the correction produces new state-of-the art in uncertainty calibration across CIFAR-10, CIFAR-100, and ImageNet.1
+
+# 1 INTRODUCTION
+
+Many success stories in deep learning (Krizhevsky et al., 2012; Sutskever et al., 2014) are in restricted settings where predictions are only made for inputs similar to the training distribution. In real-world scenarios, neural networks can face truly novel data points during inference, and in these settings it can be valuable to have good estimates of the model’s uncertainty. For example, in healthcare, reliable uncertainty estimates can prevent over-confident decisions for rare or novel patient conditions (Dusenberry et al., 2019). We highlight two recent trends obtaining state-of-the-art in uncertainty and robustness benchmarks.
+
+Ensemble methods are a simple approach to improve a model’s calibration and robustness (Lakshminarayanan et al., 2017). The same network architecture but optimized with different initializations can converge to different functional solutions, leading to decorrelated prediction errors. By averaging predictions, ensembles can rule out individual mistakes (Lakshminarayanan et al., 2017; Ovadia et al., 2019). Additional work has gone into efficient ensembles such as MC-dropout (Gal and Ghahramani, 2016), BatchEnsemble, and its variants (Wen et al., 2020; Dusenberry et al., 2020; Wenzel et al., 2020). These methods significantly improve calibration and robustness while adding few parameters to the original model.
+
+Data augmentation is an approach which is orthogonal to ensembles in principle, encoding additional priors in the form of invariant feature transformations. Intuitively, data augmentation enables the model to train on more data, encouraging the model to capture certain invariances with respect to its inputs and outputs; data augmentation may also produce data that may be closer to an out-ofdistribution target task. It has been a key factor driving state-of-the-art: for example, Mixup (Zhang et al., 2018; Thulasidasan et al., 2019a), AugMix (Hendrycks et al., 2020), and test-time data augmentation (Ashukha et al., 2020).
+
+A common wisdom in the community suggests that ensembles and data augmentation should naturally combine. For example, the majority of uncertainty models in vision with strong performance are built upon baselines leveraging standard data augmentation (He et al., 2016; Hendrycks et al., 2020) (e.g., random flips, cropping); Hafner et al. (2018) cast data augmentation as an explicit prior for Bayesian neural networks, treating it as beneficial when ensembling; and Hendrycks et al. (2020) highlights further improved results in AugMix when combined with Deep Ensembles (Hansen and Salamon, 1990; Krogh and Vedelsby, 1995). However, we find the complementary benefits between data augmentations and ensembels are not universally true. Section 3.1 illustrates the poor calibration of combining ensembles (MC-dropout, BatchEnsemble and Deep Ensembles) and Mixup on CIFAR: the model outputs excessive low confidence. Motivated by this pathology, in this paper, we investigate in more detail why this happens and propose a method to resolve it.
+
+Contributions. In contrast to prior work, which finds individually that ensembles and Mixup improve calibration, we find that combining ensembles and Mixup consistently degrades calibration performance across three ensembling techniques. From a detailed analysis, we identify a compounding under-confidence, where the soft labels in Mixup introduce a negative confidence bias that hinders its combination with ensembles. We further find this to be true for other label-based strategies such as label smoothing. Finally, we propose CAMixup to correct this bias, pairing well with ensembles. CAMixup produces new state-of-the-art calibration on both CIFAR-10/100 (e.g., $0 . 4 \%$ and $2 . 3 \%$ on CIFAR-10 and CIFAR-10C), building on Wide ResNet 28-10 for competitive accuracy (e.g., $9 7 . 5 \%$ and $8 9 . 8 \%$ ) and on ImageNet $( 1 . 5 \% )$ , building on ResNet-50 for competitive accuracy $( 7 7 . 4 \% )$ .
+
+2 BACKGROUND ON CALIBRATION, ENSEMBLES AND DATA AUGMENTATION
+
+# 2.1 CALIBRATION
+
+Uncertainty estimation is critical but ground truth is difficult to obtain for measuring performance. Fortunately, calibration error, which assesses how well a model reliably forecasts its predictions over a population, helps address this. Let $( \hat { Y } , \hat { P } )$ denote the class prediction and associated confidence (predicted probability) of a classifier.
+
+Expected Calibration Error(ECE): One notion of miscalibration is the expected difference between confidence and accuracy (Naeini et al., 2015): $E _ { \hat { P } } [ | \mathbb { P } ( \hat { Y } = Y | \hat { P } = p ) - p | ]$ . ECE approximates this by binning the predictions in $[ 0 , 1 ]$ under $M$ equally-spaced intervals, and then taking a weighted average of each bins’ accuracy/confidence difference. Let $B _ { m }$ be the set of examples in the $m ^ { \tilde { t } h }$ bin whose predicted confidence falls into interval $\textstyle { \bigl ( } { \frac { m - 1 } { M } } , { \frac { m } { M } } { \bigr ] }$ . The bin $B _ { m }$ ’s accuracy and confidence are:
+
+$$
+\mathrm { A c c } ( B _ { m } ) = \frac { 1 } { | B _ { m } | } \sum _ { x _ { i } \in B _ { m } } \mathbb { 1 } ( \hat { y } _ { i } = y _ { i } ) , \quad \mathrm { C o n f } ( B _ { m } ) = \frac { 1 } { | B _ { m } | } \sum _ { x _ { i } \in B _ { m } } \hat { p } _ { i } ,
+$$
+
+where $\hat { y } _ { i }$ and $y _ { i }$ are the predicted and true labels and $\hat { p _ { i } }$ is the confidence for example $x _ { i }$ . Given $n$ examples, ECE is $\begin{array} { r } { \sum _ { m = 1 } ^ { M ^ { - } } \frac { | B _ { m } | } { n } \bigg | \operatorname { A c c } ( B _ { m } ) - \operatorname { C o n f } ( B _ { m } ) \bigg | } \end{array}$ .
+
+# 2.2 ENSEMBLES
+
+Aggregating the predictions of multiple models into an ensemble is a well-established strategy to improve generalization (Hansen and Salamon, 1990; Perrone and Cooper, 1992; Dietterich, 2000).
+
+BatchEnsemble: BatchEnsemble takes a network architecture and shares its parameters across ensemble members, adding only a rank-1 perturbation for each layer in order to decorrelate member predictions (Wen et al., 2020). For a given layer, define the shared weight matrix among $K$ ensemble members as $\mathbf { W } \in \mathbb { R } ^ { m \times d }$ . A tuple of trainable vectors $\mathbf { r } _ { k } \in \mathbb { R } ^ { m }$ and $\mathbf { s } _ { k } \in \mathbb { R } ^ { n }$ are associated with each ensemble member $k$ . The new weight matrix for each ensemble member in BatchEnsemble is
+
+$$
+\mathbf { W } _ { k } ^ { \prime } = \mathbf { W } \circ \mathbf { F } _ { k } , { \mathrm { ~ w h e r e ~ } } \mathbf { F } _ { k } = \mathbf { r } _ { k } \mathbf { s } _ { k } ^ { \top } \in \mathbb { R } ^ { m \times d } ,
+$$
+
+where $\circ$ denotes the element-wise product. Applying rank-1 perturbations via $\mathbf { r }$ and s adds few additional parameters to the overall model. We use an ensemble size of 4 in all experiments.
+
+MC-Dropout: Gal and Ghahramani (2016) interpret Dropout (Srivastava et al., 2014) as an ensemble model, leading to its application for uncertainty estimates by sampling multiple dropout masks at test time in order to ensemble its predictions. We use an ensemble size of 20 in all experiments.
+
+Deep Ensembles: Composing an ensemble of models, each trained with a different random initialization, provides diverse predictions (Fort et al., 2019) which have been shown to outperform strong baselines on uncertainty estimation tasks (Lakshminarayanan et al., 2017). We use an ensemble size of 4 in all experiments.
+
+In this work, we focus on the interaction between data augmentation strategies and BatchEnsemble, MC-Dropout, and deep ensembles. Other popular ensembling approaches leverage weight averaging such as Polyak-Ruppert (Ruppert, 1988), checkpointing (Huang et al., 2017), and stochastic weight averaging (Izmailov et al., 2018) to collect multiple sets of weights during training and aggregate them to make predictions with only a single set.
+
+# 2.3 DATA AUGMENTATION
+
+Data augmentation encourages a model to make invariant predictions under desired transformations which can greatly improve generalization performance. For example, in computer vision, random leftright flipping and cropping are de-facto approaches (He et al., 2016). We highlight two state-of-the-art techniques which we study.
+
+Mixup: Mixup (Zhang et al., 2018) manipulates both the features and the labels in order to encourage linearly interpolating predictions. Given an example $( x _ { i } , y _ { i } )$ , Mixup applies
+
+$$
+\tilde { x } _ { i } = \lambda x _ { i } + ( 1 - \lambda ) x _ { j } , \quad \tilde { y } _ { i } = \lambda y _ { i } + ( 1 - \lambda ) y _ { j } .
+$$
+
+Here, $x _ { j }$ is sampled from the training dataset (taken from the minibatch), and $\lambda \sim \operatorname { B e t a } ( a , a )$ for a fixed hyperparameter $a > 0$ .
+
+Mixup was shown to be effective for generalization and calibration of deep neural networks (Zhang et al., 2018; Thulasidasan et al., 2019b). Recent work has investigated why Mixup improves generalization (Guo et al., 2018; Shimada et al., 2019) and adversarial robustness (Beckham et al., 2019; Pang et al., 2020; Mangla et al., 2020). Given Mixup’s simplicity, many extensions have been proposed with further improvements (Yun et al., 2019; Berthelot et al., 2019; Verma et al., 2019; Roady et al., 2020; Chou et al., 2020).
+
+AugMix: Searching or sampling over a set of data augmentation operations can lead to significant improvement on both generalization error and calibration (Cubuk et al., 2019b;a). AugMix (Hendrycks et al., 2020) applies a sum of augmentations, each with random weighting, with a Jensen-Shannon consistency loss to encourage similarity across the augmentations. AugMix achieves state-of-the-art calibration across in- and out-of-distribution tasks. Let $\mathcal { O }$ be the set of data augmentation operations and $k$ be the number of AugMix iterations. AugMix samples $w _ { 1 } , \dots , w _ { k } \sim { \mathrm { D i r i c h l e t } } ( a , \dots , a )$ for a fixed hyperparameter $a > 0$ and $\boldsymbol { \mathrm { o p } } _ { 1 } , \ldots , \boldsymbol { \mathrm { o p } } _ { k }$ from $\mathcal { O }$ . Given an interpolation parameter $m$ , sampled from $\mathrm { B e t a } ( a , a )$ , the augmented input $\tilde { x } _ { a u g m i x }$ is:
+
+$$
+\tilde { x } _ { a u g m i x } = m x _ { o r i g } + ( 1 - m ) x _ { a u g } , \qquad x _ { a u g } = \sum _ { i = 1 } ^ { k } w _ { i } \mathrm { o p } _ { i } ( x _ { o r i g } ) .
+$$
+
+# 3 MIXUP-ENSEMBLE PATHOLOGY
+
+We seek to understand the effect of data augmentations on ensembles. In particular, we hope to verify the hypothesis of compounding improvements when combining the seemingly orthogonal techniques of data augmentation and ensembles. To our surprise, we find that augmentation techniques can be detrimental to ensemble calibration.
+
+# 3.1 THE SURPRISING MISCALIBRATION OF ENSEMBLES WITH MIXUP
+
+Ensembles are the most known and simple approaches to improving calibration (Ovadia et al., 2019; Lakshminarayanan et al., 2017), and Thulasidasan et al. (2019b) showed that Mixup improves calibration in a single network. Motivated by this, Fig. 1 applies Mixup to each ensemble member on CIFAR-10/CIFAR-100 with WideResNet 28-10 (Zagoruyko and Komodakis, 2016). Here, we searched over Mixup’s optimal hyperparameter $\alpha$ (Eq. 3) and found that $\alpha = 1$ gives the best result, which corroborates the finding in Zhang et al. (2018). All data points in Fig. 1 are averaged over 5 random seeds.
+
+Figs. 1a and 1b demonstrate improved test accuracy (Red (ensembles without Mixup) to Blue (ensembles with Mixup)). However, if we shift focus to Figs. 1c and 1d’s calibration error, it is evident that combining Mixup with ensembles leads to worse calibration (Red to Blue). This is counterintuitive as we would expect Mixup, which improves calibration of individual models (Thulasidasan et al., 2019a), to also improve the calibration of their ensemble. Fig. 1 confirms this pattern across BatchEnsemble (BE), MC-dropout (MC), and deep ensembles (DE). This pathology also occurs on ImageNet, as seen in Table 1.
+
+![](images/7de16ef0003a45865f116896bc4adabc694829b6b0ca10008acf67cfc5bcbe5e.jpg)  
+Figure 1: WideResNet 28-10 on CIFAR-10/CIFAR-100. Red: Ensembles without Mixup; Blue: Ensembles with Mixup; Orange: Individual models in ensembles without Mixup. (a) & (b): Applying Mixup to different ensemble methods leads to consistent improvement on test accuracy. (c) & (d): Applying Mixup to different ensemble methods harms calibration. Averaged over 5 random seeds.
+
+Why do Mixup ensembles degrade calibration? To investigate this in more detail, Fig. 2 plots a variant of reliability diagrams (DeGroot and Fienberg, 1983) on BatchEnsemble. We bin the predictions into $M = 1 5$ equally spaced intervals based on their confidence (softmax probabilities) and compute the difference between the average confidence and the average accuracy as in Eq. 1 for each bin. Fig. 2 tracks this difference over varying confidence levels. A positive difference (Acc−Conf) implies under-confidence with respect to the true frequencies; negative implies over-confidence; and zero implies perfect calibration.
+
+The backbone model in Fig. 2 is BatchEnsemble with an ensemble size of 4 (we also found this consistent for MC-Dropout and Deep-Ensemble). The figure presents 4 methods: Single: vanilla WideResNet 28-10; MixupSingle: WideResNet 28-10 model trained with Mixup; BatchEnsemble: vanilla BatchEnsemble WideResNet 28-10 model; MixupBE: BatchEnsemble WideResNet 28-10 model trained with Mixup. Fig. 2 shows that only models trained with Mixup have positive $( \operatorname { A c c } - \operatorname { C o n f } )$ values on the test set, which suggests that Mixup encourages under-confidence. Mixup ensemble’s under-confidence is also greater in magnitude than that of the individual Mixup models. This suggests that Mixup ensembles suffer from compounding under-confidence, leading to a worse calibration for the ensemble than the individual Mixup models’ calibration. This is contrary to our intuition that ensembles always improves calibration.
+
+![](images/c2ab4f9142caea72ad8e4cfafd8a5bf0ae7a9877e08d8dcff755f5ba49661364.jpg)  
+Figure 2: Reliability diagrams on CIFAR100 with a WideResNet 28-10.
+
+To further visualize this issue, Appendix C’s Fig. 8 investigates the confidence (softmax probabilities) surface of deep ensembles and Mixup when trained on a toy dataset consisting of 5 clusters, each with a different radius. We ensemble over 4 independently trained copies of 3-layer MLPs. Deep ensemble’s predictive confidence is plotted over the entire input data space in Fig. 8c. The resulting predictions are extremely confident except at the decision boundaries. Deep Ensemble still displays high confidence in the area nearest to the origin which is expected to have lower confidence level. On the other hand, Fig. 8d shows that Mixup-Ensemble is only confident in a very constrained area around the training clusters, leading to an overall under-confident classifier which confirms our postulation of compounding under-confidence.
+
+# 3.2 IS THE PATHOLOGY SPECIFIC TO MIXUP?
+
+At the core of the issue is that Mixup conflates data uncertainty (uncertainty inherent to the data generating process) with model uncertainty. Soft labels can correct for over-confidence in single models which have no other recourse to improve uncertainty estimates. However, when combined with ensembles, which incorporate model uncertainty, this correction may be unnecessary. Because image classification benchmarks tend to be deterministic, soft labels encourage predictions on training data to be less confident about their true targets even if they are correct. We validate this hypothesis by showing it also applies to label smoothing.
+
+Label Smoothing: Like Mixup, label smoothing applies soft labels: it smoothens decision boundaries by multiplying a data point’s true class by $( 1 - \alpha )$ , with probability $\alpha$ spread equally across other classes. Using the same experimental setup as before, we apply increasing levels of label smoothing to ensembles of WideResNet 28-10 models trained on CIFAR-10. Fig. 3 demonstrates the harmful effect of label smoothing on CIFAR-10 ECE, particularly when aggressive (coeff $\geq 0 . 2$ ). In the concurrent work, Qin et al. (2020) found that label smoothing plus ensemble leads to worse calibration. They showed that adjusting model confidence successfully corrects the compounding underconfidence.
+
+![](images/2328151ade7bb16f576d3496a242db1d6119f59bda46bd5b2894e140726a9e82.jpg)  
+Errorand ECE of Label Smoothing on WideResNet 28-10 trained on CIFAR-10   
+Figure 3: ECE and Error on CIFAR-10 with label smoothing on MC Dropout, Deep Ensembles, and BatchEnsemble. ECE degrades with label smoothing, particularly when it is more aggressive $( \geq 0 . 2 )$ .
+
+# 4 CONFIDENCE ADJUSTED MIXUP ENSEMBLES (CAMIXUP)
+
+In this section, we aim to fix the compounding under-confidence issue when combining Mixup and ensembles without sacrificing its improved accuracy on both in- and out-of-distribution data.
+
+# 4.1 CLASS BASED CAMIXUP
+
+Mixup encourages model under-confidence as shown in Fig. 2. Notice that Mixup assigns a uniform hyperparameter $\alpha$ to all examples in the training set. To improve Mixup, we start from the intuition that in classification, some classes are prone to be more difficult than others to predict. This can be confirmed by Fig. 4a, which provides examples of per-class test accuracy. Ideally, we prefer our model to be confident when it is predicting over easy classes such as cars and ships. For harder classes like cats and dogs, the model is encouraged to be less confident to achieve better calibration.
+
+Therefore, instead of a uniform Mixup hyperparameter for all classes, we propose to adjust the Mixup hyperparameter of each class by the difference between its accuracy and confidence. CAMixup’s intuition is that we want to apply Mixup on hard classes on which models tend to be over-confident. On easy examples, we impose the standard data-augmentation without Mixup. This partially prevents Mixup models from being over-confident on difficult classes while maintaining its good calibration on out-of-distribution inputs.2
+
+Denote the accuracy and confidence of class $i$ as $\operatorname { A c c } ( C _ { i } )$ and $\operatorname { C o n f } ( C _ { i } )$ . We adjust Mixup’s $\lambda$ in Eqn. 3 by the sign of $\operatorname { A c c } ( C _ { i } ) - \operatorname { C o n f } ( C _ { i } )$ , which are defined as $\begin{array} { r } { \operatorname { A c c } ( \dot { C } _ { i } ) = \frac { 1 } { | C _ { i } | } \dot { \sum } _ { x _ { j } \in C _ { i } } \mathbb { 1 } \bar { ( y _ { j } = i ) } } \end{array}$ and $\begin{array} { r } { \mathrm { C o n f } ( C _ { i } ) = \frac { 1 } { | C _ { i } | } \sum _ { x _ { j } \in C _ { i } } \hat { p _ { i } } } \end{array}$ .
+
+$$
+\lambda _ { i } = { \left\{ \begin{array} { l l } { 0 } & { \operatorname { A c c } ( C _ { i } ) > \operatorname { C o n f } ( C _ { i } ) } \\ { \lambda } & { \operatorname { A c c } ( C _ { i } ) \leq \operatorname { C o n f } ( C _ { i } ) . } \end{array} \right. }
+$$
+
+![](images/95afc36f6c2c12253cda3c96aa22255d9112dd3f392eab512b9f9ded1ff43870.jpg)  
+Figure 4: Left: An illustration of the proposed CAMixup data augmentation. Selected per-class test accuracies are showed in brown. Overall test accuracy is $9 6 . 2 \%$ on CIFAR-10; Right: Number of epochs (out of 250) where CAMixup enables Mixup for selected classes in BatchEnsemble. CAMixup tends to assign Mixup to hard classes. Counts are accumulated individually for each ensemble member (ensemble size 4).
+
+If the model is already under-confident on class $i$ $( \operatorname { A c c } ( C _ { i } ) > \operatorname { C o n f } ( C _ { i } ) )$ , Mixup is not applied to examples in the class, and $\lambda _ { i } = 0$ . However, if $\operatorname { A c c } ( C _ { i } ) \leq \operatorname { C o n f } ( C _ { i } )$ , the model is over-confident on this class, and Mixup is applied to reduce model confidence. We compute the accuracy and confidence on a validation dataset after each training epoch.
+
+![](images/448a92d6a9ed5defb12abf632c929d52ca4d0d5dfd34a7d32422b6742a648e99.jpg)  
+Figure 5: WideResNet 28-10 on CIFAR-10/CIFAR-100. Red: Ensembles without Mixup; Blue: Ensembles with Mixup; Green: Our proposed CAMixup improves both accuracy & ECE of ensembles.
+
+Notice that $\lambda _ { i }$ is dynamically updated at the end of each epoch. To understand which classes are more often assigned Mixup operation, Fig. 4 calculates the number of times that $\lambda _ { i } > 0$ throughout training. The maximum number of times is the number of total training epochs, which is 250 in the BatchEnsemble model. We find that CAMixup rarely enables Mixup to easy classes such as cars and ships: the number of times is less than $1 0 \%$ of the total epochs. For harder classes like cats and dogs, CAMixup assigns Mixup operation almost every epoch, accounting for more than $8 0 \%$ of total epochs. In summary, Fig. 4 shows that CAMixup reduces model confidence on difficult classes and encourages model confidence on easy classes, leading to better overall calibration. Appendix D.1’s Fig. 9a also shows that CAMixup effectively shifts the confidence to the lower region.
+
+Fig. 5 presents results of CAMixup on CIFAR-10 and CIFAR-100 test set, where we compare the effect of Mixup and CAMixup on different ensembling strategies (BatchEnsemble, MC Dropout, DeepEnsemble). Adding Mixup to ensembles improves accuracy but worsens ECE. Adding CAMixup to ensembles significantly improves accuracy of ensembles in all cases. More importantly, the calibration results in Figs. 5c and 5d show that CAMixup ensembles are significantly better calibrated than Mixup ensembles, for instance, CAMixup reduces ECE by more than 5X for BatchEnsemble over Mixup. We observe a minor decrease in test accuracy (at most $0 . 2 \%$ ) when comparing CAMixup ensembles with Mixup ensembles, but we believe that this is a worthwhile trade-off given the significant improvement in test ECE.
+
+Table 1 presents similar experiments applied to ResNet-50 on ImageNet, using BatchEnsemble as the base ensembling strategy. These results are state of the art to the best of our knowledge: Dusenberry et al. (2020) report $1 . 7 \%$ ECE with Rank-1 Bayesian neural nets and $3 . 0 \%$ with Deep Ensembles; Thulasidasan et al. (2019a) report $3 . 2 \%$ for ResNet-50 with Mixup, $2 . 9 \%$ for ResNet-50 with an entropy-regularized loss, and $1 . 8 \%$ for ResNet-50 with label smoothing.
+
+Table 1: BatchEnsemble with ensemble size 4 on ImageNet.   
+
+<table><tr><td></td><td>ACC</td><td>ECE</td></tr><tr><td>BatchEnsemble</td><td>77.0</td><td>2.0%</td></tr><tr><td>MixupBE</td><td>77.5</td><td>2.1%</td></tr><tr><td>CAMixupBE</td><td>77.4</td><td>1.5%</td></tr></table>
+
+# 4.2 PERFORMANCE UNDER DISTRIBUTION SHIFT
+
+Here, we assess model resilience to covariate shift by evaluating on the CIFAR-10-C and CIFAR-100-C benchmarks (C stands for corruptions) proposed by Hendrycks and Dietterich (2019a), which apply 15 types of corruptions each with 5 levels of intensity. We evaluate the performance of CAMixup vs Mixup when applied to different ensembles, and report average error on ECE across different types of corruptions and intensities.
+
+Fig. 6a shows that Mixup improves accuracy on the corrupted dataset because of its strong regularization effect. However, the models tend to be over-confident as one moves further from the original distribution (higher corruption intensities), so encouraging underconfidence is not an issue. This explains why Mixup ensembles maintain low ECE on out-of-distribution test data in Fig. 6b.
+
+![](images/e247a496dee5a83d0292aa2da827d3c725000b1b3fd45ee5b7e80a9a777da7fe.jpg)  
+Figure 6: WideResNet 28-10 on CIFAR-10-C. Red: Ensembles without Mixup; Blue: Ensembles with Mixup; Green: Ensembles with CAMixup (ours).
+
+Fig. 6b also shows that CAMixup’s calibration on out-of-distribution data (CIFAR-10-C) is also on par with Mixup ensembles. We observe the same result on CIFAR-100-C (Appendix D.1’s Fig. 9). Thus, we successfully improve model calibration on in-distribution datasets without sacrificing its calibration on out-of-distribution datasets.
+
+# 5 COMPOUNDING THE BENEFITS OF CAMIXUP WITH AUGMIX ENSEMBLES
+
+We have investigated why certain data augmentation schemes may not provide complementary benefits to ensembling. We proposed class-adjusted Mixup (CAMixup) which compounds both accuracy and ECE over vanilla ensembles. We believe that the insights from our work will allow the community and practitioners to compound SOTA performance. We provide two concrete examples.
+
+# 5.1 AUGMIX
+
+We show how CAMixup can compound performance over ensembles of models trained with AugMix, which were shown by Hendrycks et al. (2020) to achieve state-of-the-art accuracy and calibration on both clean and corrupted benchmarks. We primarily focus on improving BatchEnsemble and we investigate if adding better data augmentation schemes closes the gap between memory-efficient ensembles (BatchEnsemble) and independent deep ensembles.
+
+As discussed in Section 2.3, AugMix only uses label-preserving transformations. Therefore AugMix provides complementary benefits to ensembles (and CAMixup). This is consistent with calibration improvements in the literature with ensemble methods, which apply standard data augmentation such as random flips, which also do not smoothen labels.
+
+We consider a combination of AugMix and Mixup as it allows the model to encounter both diverse label-preserving augmentations and soft labels under a linearly interpolating regime. The combination
+
+![](images/0a192a9b07380f96c62a6518a30dc271c9cd46cb5426c6368fa6afb30194de5e.jpg)  
+Figure 7: Performance on BatchEnsemble under dataset shift. Mixup and AugMixup improve accuracy and calibration under shift but significantly worsen in-distribution calibration. Our proposed CAMixup and AugCAMixup improve accuracy and calibration.
+
+Table 2: Results for Wide ResNet-28-10 BatchEnsemble on in- and out-of-distribution CIFAR-10/100 with various data augmentations, averaged over 3 seeds. AugMix: AugMix $^ +$ BatchEnsemble; AugMixup: AugMix $^ +$ Mixup BatchEnsemble; AugCAMixup: AugMix $^ +$ CAMixup BatchEnsemble. Adding Mixup to AugMix model increases test accuracy and corrupt accuracy at the cost of calibration decay on testset. CAMixup bridges this gap with only a minor drop in accuracy.   
+
+<table><tr><td rowspan="2">Method/Metric</td><td colspan="3">CIFAR-10</td><td colspan="3">CIFAR-100</td></tr><tr><td>Acc(↑)</td><td>ECE(↓)</td><td>cA/cECE</td><td>Acc(↑)</td><td>ECE(↓)</td><td>cA/cECE</td></tr><tr><td>AugMix BE</td><td>97.36</td><td>1.02%</td><td>89.49/2.6%</td><td>83.57</td><td>2.96%</td><td>67.12/7.1%</td></tr><tr><td>AugMixup BE</td><td>97.52</td><td>1.71%</td><td>90.05/2.8%</td><td>83.77</td><td>4.19%</td><td>69.26/4.8%</td></tr><tr><td>AugCAMixup BE</td><td>97.47</td><td>0.45%</td><td>89.81/2.4%</td><td>83.74</td><td>2.35%</td><td>68.71/4.4%</td></tr></table>
+
+AugMixup (AugMix $^ +$ Mixup) can be written as
+
+$$
+x = \lambda * \operatorname { A u g M i x } ( x _ { 1 } ) + ( 1 - \lambda ) \operatorname { A u g M i x } ( x _ { 2 } ) , \quad y = \lambda * y _ { 1 } + ( 1 - \lambda ) * y _ { 2 } .
+$$
+
+Consistent with earlier results on Mixup, Table 2 shows combining AugMixup with BatchEnsemble improves accuracy but worsens ECE, leading to under-confidence on in-distribution data. (Appendix D.2’s Fig. 10). With our proposed fix CAMixup, the combination AugCAMixup (AugMix $^ +$ CAMixup) improves calibration while retaining the highest accuracy for ensembles. Fig. 7 shows detailed results on CIFAR-10-C and CIFAR-100-C. Similar to Mixup, AugMixup improves calibration under shift but worsens calibration on in-distribution. However, our proposed AugCAMixup improves accuracy and calibration of ensembles on both clean and corrupted data.
+
+To the best of our knowledge, these results are state-of-the-art in the literature: Dusenberry et al. (2020) report $0 . 8 \%$ ECE and $1 . 8 \%$ ECE for CIFAR-10 and CIFAR-100 along with $8 \%$ and ${ \mathrm { { \dot { 1 } } 1 . 7 \% } }$ ECE for corruptions; Guo et al. (2017) report $0 . 5 4 \%$ and $2 . 3 \%$ ECE for the smaller Wide ResNet 32 on CIFAR-10 and CIFAR-100 with temperature scaling $9 3 \%$ and $72 \%$ accuracy), and Ovadia et al. (2019) demonstrated that temperature scaling does not extend to distribution shift.
+
+# 5.2 TEMPERATURE SCALING
+
+In concurrent work, Rahaman and Thiery (2020) consider the interplay between data augmentation and ensembling on calibration. They also find that Mixup ensembles can be under-confident, and propose temperature scaling as a solution. Their core contribution is the same but differ in slight ways: we further this analysis by showing the compounding under-confidence extends to other techniques applying soft labels such as label smoothing, and we propose CAMixup as a solution. Post-hoc calibration techniques like temperature scaling are complementary to our proposal and do not address the core conflation issue with Mixup. Corroborating findings of Ovadia et al. (2019), Appendix G shows combining CAMixup and temperature scaling can further improve test calibration error; it does not improve out-of-distribution calibration. Another concurrent work showed that calibrated ensemble members do not always lead to calibrated ensemble predictions (Anonymous, 2021).
+
+# 6 CONCLUSION
+
+Contrary to existing wisdom in the literature, we find that combining ensembles and Mixup consistently degrades calibration performance across three ensembling techniques. From a detailed analysis, we identify a compounding under-confidence, where Mixup’s soft labels (and more broadly, label-based augmentation strategies) introduce a negative confidence bias that hinders its combination with ensembles. To correct this, we propose CAMixup, which applies Mixup to only those classes on which the model tends to be over-confident, modulated throughout training. CAMixup combines well with state-of-the-art methods. It produces new state-of-the-art calibration across CIFAR-10, CIFAR-100, and ImageNet while obtaining competitive accuracy. Appendix H points out potential future work and limitations of CAMixup.
+
+# REFERENCES
+
+Chirag Agarwal and Sara Hooker. Estimating example difficulty using variance of gradients. arXiv preprint arXiv:2008.11600, 2020.
+
+Anonymous. Should ensemble members be calibrated? In Submitted to International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id $=$ wTWLfuDkvKp. under review.
+
+Arsenii Ashukha, Alexander Lyzhov, Dmitry Molchanov, and Dmitry Vetrov. Pitfalls of in-domain uncertainty estimation and ensembling in deep learning. In International Conference on Learning Representations, 2020.
+
+Christopher Beckham, Sina Honari, Alex Lamb, Vikas Verma, Farnoosh Ghadiri, R. Devon Hjelm, and Christopher Joseph Pal. Adversarial mixup resynthesizers. ArXiv, abs/1903.02709, 2019.
+
+David Berthelot, Nicholas Carlini, Ian Goodfellow, Nicolas Papernot, Avital Oliver, and Colin A Raffel. Mixmatch: A holistic approach to semi-supervised learning. In Advances in Neural Information Processing Systems, pages 5049–5059, 2019.
+
+Hsin-Ping Chou, S. Chang, J. Pan, Wei Wei, and D. Juan. Remix: Rebalanced mixup. ArXiv, abs/2007.03943, 2020.
+
+Ekin D. Cubuk, Barret Zoph, Jonathon Shlens, and Quoc V. Le. Randaugment: Practical automated data augmentation with a reduced search space. arXiv: Computer Vision and Pattern Recognition, 2019a.
+
+Ekin Dogus Cubuk, Barret Zoph, Dandelion Mané, V. Vasudevan, and Quoc V. Le. Autoaugment: Learning augmentation strategies from data. 2019 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 113–123, 2019b.
+
+Morris H. DeGroot and Stephen E. Fienberg. The Comparison and Evaluation of Forecasters. The Statistician, 32(1/2):12, March 1983. ISSN 00390526. doi: 10.2307/2987588. URL https: //www.jstor.org/stable/10.2307/2987588?origin ${ \bf \Phi } = { \bf \Phi }$ crossref.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Fei-Fei Li. Imagenet: A large-scale hierarchical image database. 2009 IEEE Conference on Computer Vision and Pattern Recognition, pages 248–255, 2009.
+
+Thomas G. Dietterich. Ensemble methods in machine learning. In Multiple Classifier Systems, 2000.
+
+Michael W Dusenberry, Dustin Tran, Edward Choi, Jonas Kemp, Jeremy Nixon, Ghassen Jerfel, Katherine Heller, and Andrew M Dai. Analyzing the role of model uncertainty for electronic health records. arXiv preprint arXiv:1906.03842, 2019.
+
+Michael W. Dusenberry, Ghassen Jerfel, Yeming Wen, Yi-an Ma, Jasper Snoek, Katherine Heller, Balaji Lakshminarayanan, and Dustin Tran. Efficient and scalable Bayesian neural nets with rank-1 factors. In ICML, 2020.
+
+Stanislav Fort, Huiyi Hu, and Balaji Lakshminarayanan. Deep Ensembles: A Loss Landscape Perspective. arXiv preprint arXiv:1912.02757, 2019.
+
+Yarin Gal and Zoubin Ghahramani. Dropout as a Bayesian approximation: Representing model uncertainty in deep learning. In International Conference on Machine Learning, 2016.
+
+Chuan Guo, Geoff Pleiss, Yu Sun, and Kilian Q Weinberger. On Calibration of Modern Neural Networks. In International Conference on Machine Learning (ICML), volume cs.LG. Cornell University Library, August 2017. URL http://arxiv.org/abs/1706.04599v2.
+
+Hongyu Guo, Yongyi Mao, and Richong Zhang. Mixup as locally linear out-of-manifold regularization. In AAAI, 2018.
+
+Hongyu Guo, Yongyi Mao, and Richong Zhang. Augmenting data with mixup for sentence classification: An empirical study. arXiv preprint arXiv:1905.08941, 2019.
+
+Danijar Hafner, Dustin Tran, Alex Irpan, Timothy Lillicrap, and James Davidson. Reliable uncertainty estimates in deep neural networks using noise contrastive priors. arXiv preprint arXiv:1807.09289, 2018.
+
+Lars Kai Hansen and Péter Salamon. Neural network ensembles. IEEE Trans. Pattern Anal. Mach. Intell., 12:993–1001, 1990.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Computer Vision and Pattern Recognition, 2016.
+
+Dan Hendrycks and Thomas Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. In International Conference on Learning Representations, 2019a. URL https://openreview.net/forum?id $=$ HJz6tiCqYm.
+
+Dan Hendrycks and Thomas Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. In International Conference on Learning Representations, 2019b.
+
+Dan Hendrycks, Norman Mu, Ekin D. Cubuk, Barret Zoph, Justin Gilmer, and Balaji Lakshminarayanan. Augmix: A simple data processing method to improve robustness and uncertainty. ArXiv, abs/1912.02781, 2020.
+
+Gao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Q. Weinberger. Deep networks with stochastic depth. In ECCV, 2016.
+
+Gao Huang, Yixuan Li, Geoff Pleiss, Zhuang Liu, John E Hopcroft, and Kilian Q Weinberger. Snapshot ensembles: Train 1, get m for free. arXiv preprint arXiv:1704.00109, 2017.
+
+Pavel Izmailov, Dmitrii Podoprikhin, Timur Garipov, Dmitry Vetrov, and Andrew Gordon Wilson. Averaging weights leads to wider optima and better generalization. In Uncertainty in Artificial Intelligence, 2018.
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. 2009.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Neural Information Processing Systems, pages 1097–1105, 2012.
+
+Anders Krogh and Jesper Vedelsby. Neural network ensembles, cross validation, and active learning. In Advances in neural information processing systems, pages 231–238, 1995.
+
+Ananya Kumar, Percy Liang, and Tengyu Ma. Verified uncertainty calibration. ArXiv, abs/1909.10155, 2019.
+
+Balaji Lakshminarayanan, Alexander Pritzel, and Charles Blundell. Simple and scalable predictive uncertainty estimation using deep ensembles. In Neural Information Processing Systems, 2017.
+
+Puneet Mangla, Vedant Singh, Shreyas Jayant Havaldar, and Vineeth N. Balasubramanian. Varmixup: Exploiting the latent space for robust training and inference. ArXiv, abs/2003.06566, 2020.
+
+Mahdi Pakdaman Naeini, Gregory F. Cooper, and Milos Hauskrecht. Obtaining Well Calibrated Probabilities Using Bayesian Binning. In AAAI Conference on Artificial Intelligence, volume 2015, pages 2901–2907, January 2015. URL https://www.ncbi.nlm.nih.gov/pmc/ articles/PMC4410090/pdf/nihms679964.pdf.
+
+Jeremy Nixon, Mike Dusenberry, Linchuan Zhang, Ghassen Jerfel, and Dustin Tran. Measuring Calibration in Deep Learning. arXiv:1904.01685 [cs, stat], April 2019. URL http://arxiv. org/abs/1904.01685.
+
+Yaniv Ovadia, Emily Fertig, Jie Ren, Zachary Nado, D Sculley, Sebastian Nowozin, Joshua V Dillon, Balaji Lakshminarayanan, and Jasper Snoek. Can you trust your model’s uncertainty? Evaluating predictive uncertainty under dataset shift. In Neural Information Processing Systems, 2019.
+
+Tianyu Pang, Kun Xu, and Jun Zhu. Mixup inference: Better exploiting mixup to defend adversarial attacks. ArXiv, abs/1909.11515, 2020.
+
+Michael P. Perrone and Leon N. Cooper. When networks disagree: Ensemble methods for hybrid neural networks. 1992.   
+Yao Qin, Xuezhi Wang, Alex Beutel, and Ed Huai hsin Chi. Improving uncertainty estimates through the relationship with adversarial robustness. ArXiv, abs/2006.16375, 2020.   
+Rahul Rahaman and Alexandre H Thiery. Uncertainty quantification and deep ensembles. arXiv preprint arXiv:2007.08792, 2020.   
+Ryne Roady, T. Hayes, and Christopher Kanan. Improved robustness to open set inputs via tempered mixup. ArXiv, abs/2009.04659, 2020.   
+Alejandro Romero, Nicolas Ballas, Samira Ebrahimi Kahou, Antoine Chassang, Carlo Gatta, and Yoshua Bengio. FitNets: Hints for thin deep nets. CoRR, abs/1412.6550, 2015.   
+David Ruppert. Efficient estimations from a slowly convergent Robbins-Monro process. Technical report, Cornell University Operations Research and Industrial Engineering, 1988.   
+Takuya Shimada, Shoichiro Yamaguchi, Kohei Hayashi, and Sosuke Kobayashi. Data interpolating prediction: Alternative interpretation of mixup. ArXiv, abs/1906.08412, 2019.   
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1):1929–1958, 2014.   
+Rupesh Kumar Srivastava, Klaus Greff, and Jürgen Schmidhuber. Highway networks. CoRR, abs/1505.00387, 2015.   
+Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In Neural Information Processing Systems, 2014.   
+Sunil Thulasidasan, Gopinath Chennupati, Jeff A Bilmes, Tanmoy Bhattacharya, and Sarah Michalak. On mixup training: Improved calibration and predictive uncertainty for deep neural networks. In Advances in Neural Information Processing Systems, pages 13888–13899, 2019a.   
+Sunil Thulasidasan, Gopinath Chennupati, Jeff A. Bilmes, Tanmoy Bhattacharya, and Sarah Ellen Michalak. On mixup training: Improved calibration and predictive uncertainty for deep neural networks. In NeurIPS, 2019b.   
+Mariya Toneva, Alessandro Sordoni, Remi Tachet des Combes, Adam Trischler, Yoshua Bengio, and Geoffrey J Gordon. An empirical study of example forgetting during deep neural network learning. arXiv preprint arXiv:1812.05159, 2018.   
+Juozas Vaicenavicius, D. Widmann, Carl R. Andersson, F. Lindsten, J. Roll, and Thomas Bo Schön. Evaluating model calibration in classification. In AISTATS, 2019.   
+Vikas Verma, Alex Lamb, Christopher Beckham, Amir Najafi, Ioannis Mitliagkas, David Lopez-Paz, and Yoshua Bengio. Manifold mixup: Better representations by interpolating hidden states. In International Conference on Machine Learning, pages 6438–6447. PMLR, 2019.   
+Yeming Wen, Dustin Tran, and Jimmy Ba. BatchEnsemble: An alternative approach to efficient ensemble and lifelong learning. In International Conference on Learning Representations, 2020.   
+Florian Wenzel, Jasper Snoek, Dustin Tran, and Rodolphe Jenatton. Hyperparameter ensembles for robustness and uncertainty quantification. In Neural Information Processing Systems, 2020.   
+D. Widmann, F. Lindsten, and D. Zachariah. Calibration tests in multi-class classification: A unifying framework. ArXiv, abs/1910.11385, 2019.   
+Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, and Youngjoon Yoo. Cutmix: Regularization strategy to train strong classifiers with localizable features. In Proceedings of the IEEE International Conference on Computer Vision, pages 6023–6032, 2019.   
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.   
+Hongyi Zhang, Moustapha Cissé, Yann Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. ArXiv, abs/1710.09412, 2018.
+
+# A DATASET DETAILS
+
+CIFAR & CIFAR-C: We consider two CIFAR datasets, CIFAR-10 and CIFAR-100 (Krizhevsky, 2009). Each consists of a training set of size 50K and a test set of size 10K. They are natural images with $3 2 \mathrm { x } 3 2 $ pixels. Each class has 5,000 training images and 500 training images on CIFAR-10 and CIFAR-100 respectively. In our experiments, we follow the standard data pre-processing schemes including zero-padding with 4 pixels on each sise, random crop and horizon flip (Romero et al., 2015; Huang et al., 2016; Srivastava et al., 2015). If a training method requires validation dataset such as CAMixup, we use separate 2, 500 images from 50K training images as the validation set.
+
+It’s important to test whether models are well calibrated under distribution shift. CIFAR-10 corruption dataset (Hendrycks and Dietterich, 2019a) is designed to accomplish this. The dataset consists of 15 types of corruptions to the images. Each corruption types have 5 intensities. Thus, in total CIFAR-10C has 75 corrupted datasets. Notice that the corrupted dataset is used as a testset without training on it. Ovadia et al. (2019) benchmarked a number of methods on CIFAR-10 corruption. Similarly, we can apply the same corruptions to CIFAR-100 dataset to obtain CIFAR-100C.
+
+ImageNet & ImageNet-C: We used the ILSVRC 2012 classification dataset (Deng et al., 2009) which consists of a total of 1.2 million training images, 50,000 validation images and 150,000 testing images. Images span over 1,000 classes. We follow the data augmentation scheme in He et al. (2016), such as random crop and random flip, to preprocess the training images. During testing time, we apply a $2 2 4 \mathbf { x } 2 2 4$ center crop to images. Similarly to CIFAR-C, we apply 15 corruption types with 5 intensities each to obtain ImageNet-C (Hendrycks and Dietterich, 2019b).
+
+# B HYPERPARAMETERS IN SECTION 3
+
+We kept the same set of hyperparameters as the BatchEnsemble model in Wen et al. (2020). All hyperparameters can be found in Table 3. The most sensitive hyperparameter we found is whether to use ensemble batch norm, which applies a separate batch norm layer for each ensemble member; and the value of random_sign_init, which controls the standard deviation of Gaussian distributed initialization of s and r. We kept BatchEnsemble CIFAR-10 the same as Wen et al. (2020), which does not deploy ensemble batch norm. We enable ensemble batch norm on CIFAR-100 and ImageNet. This allows us to use larger standard deviation in the initialization. The random_sign_init is $- 0 . 5$ on CIFAR-10 and $- 0 . 7 5$ on CIFAR-100 and -0.75 on ImageNet. In the code, we use negative value to denote the standard deviation of Gaussian distribution (positive value instead initializes with a Bernoulli distribution under that probability). In our case, we only use negative random_sign_init, which means we only consider Gaussian distributed initialization in this work.
+
+<table><tr><td>Dataset</td><td>CIFAR-10</td><td>CIFAR-100</td></tr><tr><td>ensemble_size base_learning_rate per_core_batch_size num_cores lr_decay_ratio train_epochs</td><td colspan="2">4 0.1 64 8 0.1 250</td></tr><tr><td>lr_decay_epochs 12</td><td>0.0001</td><td>[80,160,200] 0.0003</td></tr><tr><td>random_sign_init SyncEnsemble_BN</td><td>0.5 False</td><td>0.75 True</td></tr></table>
+
+Table 3: Hyperparameters we used in Section 3 regarding to BatchEnsemble. The difference between CIFAR-10 and CIFAR-100 is l2, random_sign_init and whether to use SyncEnsemble_BN.
+
+# C EXCESSIVE UNDER-CONFIDENCE ON SYNTHETIC DATA
+
+To further understand the confidence surface of Mixup $^ +$ Ensembles, we provided a visualization in Fig. 8. We trained on a synthetic dataset consisting of 5 clusters, each with a different radius. We ensemble over 4 independently trained copies of 3-layer MLPs. We plotted the softmax probabilities surface of Mixup-Single model, Deep-Ensemble and Mixup-Ensemble. The softmax probabilities represent the model confidence. Fig. 8c shows that Deep-Ensemble predictions are extremely confident except at the decision boundaries. Fig. 8b displays a lower confidence than Deep-Ensemble. This is beneficial in the single model context because single deep neural networks tend to be over-confident and Mixup can partially correct this bias. On the other hand, Fig. 8d shows that MixupEnsemble is only confident in a very constrained area around the training clusters, leading to an overall under-confident classifier which confirms our postulation of compounding under-confidence.
+
+![](images/4c21c18d93455688887e0ec4d911ad98c2664f072558ac9645d281177ed2c49b.jpg)  
+Figure 8: Softmax probabilities surface of different ensemble methods (ensemble size 4) in the input space after training on synthetic data. Deep ensemble is over-confident in the area around origin. Mixup-Ensemble leads to gloabl under-confidence.
+
+![](images/7e18c46478f8c1945a9cec0cdf368fafe4410460963629986a99b860c4edb73f.jpg)  
+Figure 9: Left: Reliability diagrams on CIFAR-100 with a WideResNet 28-10. Our proposed CAMixup successfully fixes the under-confidence of Mixup BatchEnsemble, leading to better calibration. (b) & (c): Red: Ensembles without Mixup; Blue: Ensembles with Mixup; Green: Our proposed CAMixup does not harm the out-of-distribution performance.
+
+# D MORE CALIBRATION RESULTS OF MIXUP-BATCHENSEMBLE
+
+In Section 3.1, we demonstrated that combining Mixup and ensembles leads to worse calibration on testset. In this appendix section, we complement the above conclusion with the analysis on corrupted datasets and with data-augmentation techniques like AugMix.
+
+# D.1 SUPPLEMENTARY RESULTS ON CAMIXUP
+
+In this section, we provided supplementary results on CAMixup. Fig. 2 shows that combining Mixup and BatchEnsemble leads to excessive under-confidence. In Fig. 9a, we showed that our proposed CAMixup fixes this issue by correcting the confidence bias. This explains why CAMixup achieves better calibration on in-distribution testset. As demonstrated in Section 4.2, Mixup improves model out-of-distribution performance because of its strong regularization effect. We showed that our proposed CAMixup inherits Mixup’s improvement on CIFAR-10-C. Fig. 9b and Fig. 9c show that this conclusion seamlessly transfers to CIFAR-100-C. We also supplement Fig. 5 with Table 4 and Table 5, illusrating detailed numbers.
+
+![](images/f76a87b2f9497b7fa10e32b6f5cab1e5870f1af219775b2ca07d30be42f73fc2.jpg)  
+Figure 10: Reliability diagrams on CIFAR-10 and CIFAR-100. Both plots show that AugMix does not lead to under-confidence when combined with ensembles. However, if we combine AugMix with Mixup (AugMixup), the compounding under-confidence issue still exists, leading to suboptimal calibration. Our proposed AugCAMixup corrects this underconfidence bias.   
+Table 5: CIFAR-100 results for Wide ResNet-28-10 BatchEnsemble (Wen et al., 2020) (BE), averaged over 5 seeds. This table is used to supplement Fig. 5.
+
+# D.2 SUPPLEMENTARY RESULTS ON AUGMIX
+
+We show that Mixup does not combine with ensembles without sacrificing in-distribution calibration in Section 3.1. As discussed in Section 2.3, AugMix only uses label-preserving transformations and does not modify the labels. Intuitively, it does not reduce model confidence. We support this intuition with Fig. 10. It shows that AugMix does not lead to under-confidence. Therefore it can be combined with ensembles without any calibration issue.
+
+In Table 2, we showed that combining AugMix and Mixup leads to worse calibration due to the under-confidence although AugMix itself does not. To better understand the insights beyond staring at scalars, we provided the reliability diagram analysis as well. In Figure 10, we showed that the underconfidence issue of AugMixup (Augmi $\mathbf { \boldsymbol { x } } + \mathbf { \boldsymbol { M } } \mathbf { \dot { \boldsymbol { i } } } \mathbf { \boldsymbol { x } }$ up) still exists. It suggests that applying CAMixup to Augmix can correct the under-confidence bias as what we showed in Fig. 10a and Fig. 10b. Our proposed CAMixup allows to compound performance of ensembles and data augmentation to achieve the best possible performance.
+
+<table><tr><td rowspan="2">Method/Metric</td><td colspan="3">CIFAR-10</td></tr><tr><td>Ac(↑)</td><td>ECE(↓)</td><td>cA/cE</td></tr><tr><td>BatchEnsemble</td><td>96.22 ±0.07</td><td>1.8 ±0.2 %</td><td>77.5±0.3 /12.9 ±1.2 %</td></tr><tr><td>Mixup BE</td><td>96.98±0.08</td><td>6.4 ±0.4 %</td><td>80.0±0.4 /9.3±0.3 %</td></tr><tr><td>CAMixup BE</td><td>96.94 ±0.10</td><td>1.2 ±0.2 %</td><td>81.1±0.4 /9.7±0.35%</td></tr></table>
+
+Table 4: CIFAR-10 results for Wide ResNet-28-10 BatchEnsemble (Wen et al., 2020) (BE), averaged over 5 seeds. This table is used to supplement Fig. 5.   
+
+<table><tr><td rowspan="2">Method/Metric</td><td colspan="3">CIFAR-100</td></tr><tr><td>Acc(↑)</td><td>ECE(↓)</td><td>cA/cE</td></tr><tr><td>BatchEnsemble</td><td>81.85±0.09</td><td>2.8±0.1%</td><td>54.1±0.3/19.1±0.8%</td></tr><tr><td>Mixup BE</td><td>83.12±0.08</td><td>9.7±0.5 %</td><td>59.3±0.3/8.8±0.4%</td></tr><tr><td>CAMixup BE</td><td>83.02±0.10</td><td>2.3±0.1%</td><td>59.7±0.3/8.9±0.4%</td></tr></table>
+
+<table><tr><td>Dataset</td><td colspan="3">CIFAR-10</td><td colspan="3">CIFAR-100</td></tr><tr><td>Metric</td><td>Acc(↑）</td><td>ECE(↓)</td><td>cA/cE</td><td>Acc(1）</td><td>ECE(↓)</td><td>cA/cE</td></tr><tr><td>Deep Ensembles</td><td>96.66</td><td>0.78%</td><td>76.80/9.8%</td><td>82.7</td><td>2.1%</td><td>54.1/13.8%</td></tr><tr><td>Mixup DE</td><td>97.11</td><td>6.15%</td><td>83.33/8.0%</td><td>83.90</td><td>9.42%</td><td>61.02/8.9%</td></tr><tr><td>CAMixup DE</td><td>96.95</td><td>1.92%</td><td>83.01/4.4%</td><td>83.68</td><td>5.22%</td><td>59.18/8.6%</td></tr><tr><td>AugMix DE</td><td>97.39</td><td>0.59%</td><td>89.50/3.3%</td><td>84.15</td><td>5.13%</td><td>68.21/6.7%</td></tr><tr><td>AugMixup DE</td><td>97.56</td><td>2.71%</td><td>90.03/4.3%</td><td>84.85</td><td>6.86%</td><td>69.31/7.6%</td></tr><tr><td>AugCAMixup DE</td><td>97.48</td><td>1.89%</td><td>89.94/4.7%</td><td>84.64</td><td>5.29%</td><td>69.19/5.9%</td></tr></table>
+
+Table 6: Mixup/AugMix/AugMixup/AugCAMixup on deep ensembles. We can conclude that Mixup worsens ensemble predictions in deep ensembles as well as in BatchEnsemble. This suggests we can use CAMixup on deep ensembles as well. However, the improvement is not as obvious as it is on BatchEnsemble, leading to the fact that AugMix is the most calibrated (in- and out-of-distribution) data augmentation strategy on deep ensembles.
+
+# E DEEP ENSEMBLES WITH MIXUP
+
+We showed that CAMixup improves Mixup BatchEnsemble calibration on testset without undermining its calibration under distribution shift in Section 4. In this section, we show that the improvement can also be observed on deep ensembles. In Fig. 11, we showed the under-confidence bias we observed on Mixup $^ +$ BatchEnsemble also exists on Mixup $^ +$ deep ensembles, with an even more obvious trend. Beyond commonly used ECE measure, we also explore other calibration measures. They further confirmed our under-confidence intuition. We provide some brief explanation on how to calculate ACE, SCE and TACE.
+
+ACE measure is the same as ECE except for the binning scheme. Rather than equally divide the confidence evenly into several bins, ACE choses an adaptive scheme which spaces the bin intervals so that each contains an equal number of predictions. SCE is the same as ECE except that it accounts for all classes into calibration measure rather than just looking at the class with maximum probability. The softmax predictions induce infinitesimal probabilities. These tiny predictions can wash out the calibration score. TACE is proposed to set a threshold to only include predictions with large predictive probability, to address the above issue.
+
+We present the results of Mixup, CAMixup, AugMix, AugMixup and AugCAMixup on deep ensembles in Table 6. We notice that the improvement of CAMixup on deep ensembles is smaller than its improvement on BatchEnsemble. We postulate that this is because Mixup $^ +$ deep ensembles is much badly calibrated than Mixup $^ +$ BatchEnsemble. For example, AugMixup $^ +$ deep ensembles achieve $2 . 7 1 \%$ and $6 . 8 6 \%$ ECE on CIFAR-10 and CIFAR-100. In the meanwhile, AugMixup $^ +$ BatchEnsemble achieve $1 . 7 1 \%$ and $4 . 1 9 \%$ . Thus, even if CAMixup can improve the calibration of Mixup $^ +$ deep ensembles, it still cannot beat AugMix $^ +$ deep ensembles. As a result, when we say we close the calibration gap between BatchEnsemble and deep ensembles, we are comparing AugCAMixup BatchEnsemble (BatchEnsemble $^ +$ CAMi $\mathrm  { a p } + \mathrm  { A u } \{ $ mix) to AugMix deep ensembles. This is because AugMix deep ensembles achieve the best calibration among all variants we tried. How to completely fix the under-confidence in deep ensembles is a natural extension of this work. Since we focus on bridging the calibration gap between BatchEnsemble and deep ensembles, we delegate the complete fix in deep ensembles to the future work.
+
+# F METRICS OTHER THAN ECE
+
+ECE is the standard metric in calibration, but it is a biased estimate of true calibration (Vaicenavicius et al., 2019). Heavily relying on ECE metric might lead to inconsistent conclusion. In this section, we computed the calibration error with recently proposed calibration estimator which reduces bias in ECE, including debiased calibration estimator (Kumar et al., 2019) (DCE) and SKCE (Widmann et al., 2019). fig. 12 shows that our conclusion in the main section are also supported by these two recently proposed calibration estimators. In particular, the improvement of proposed CAMixup over
+
+![](images/633278aee038c021af573c49fd7c50e614b66a15a002152dd564d8d1cf8c29d3.jpg)  
+Figure 11: WideResNet-28-10 Deep Ensembles with Mixup on CIFAR-10. We plotted the reliability diagram of ensemble and individual predictions. Besides ECE, we also plotted other calibration metrics such as ACE, SCE and TACE proposed in Nixon et al. (2019). All metrics verify the conclusion that Mixup $^ +$ Ensembles leads to under-confidence on testset.
+
+Table 7: Results for Wide ResNet-28-10 BatchEnsemble (Wen et al., 2020) and Deep Ensembles on CIFAR-10 and CIFAR-10-C, averaged over 3 seeds. This table is used to supplement Fig. 12   
+
+<table><tr><td rowspan="2">Method/Metric</td><td colspan="3">BatchEnsemble</td><td colspan="3">Deep-Ensembles</td></tr><tr><td>Acc(↑)</td><td>SKCE(↓)</td><td>cA/cSKCE</td><td>Acc(↑)</td><td>SKCE(↓)</td><td>cA/cSKCE</td></tr><tr><td>Vanilla</td><td>96.22</td><td>3.4e-4</td><td>77.5/0.026</td><td>96.66</td><td>3.4e-5</td><td>54.1/0.018</td></tr><tr><td>Mixup</td><td>96.98</td><td>4e-3</td><td>80.0/0.024</td><td>97.11</td><td>4.4e-3</td><td>59.3/0.0068</td></tr><tr><td>CAMixup</td><td>96.94</td><td>1.3e-4</td><td>81.1/0.019</td><td>96.95</td><td>4.3e-4</td><td>59.7/0.0032</td></tr></table>
+
+![](images/c71a903195907a190dcd87a2fc60471bf147b76fe445b996b9cecd42435a586f.jpg)  
+Mixup on testset is even larger than what ECE reflects in Fig. 5. Table 7 demonstrates the specific numbers used in Fig. 12.   
+Figure 12: WideResNet 28-10 on CIFAR-10 and CIFAR-10-C, averaged over 3 random seeds. SKCE: Squared kernel calibration error computed in Widmann et al. (2019). DCE: Debiased calibration error in Kumar et al. (2019). Red: Ensembles without Mixup; Blue: Ensembles with Mixup; Green: Ensembles with CAMixup (ours). Both SKCE and DCE give consistent rankings on calibration error to the ranking in Fig. 5 and Fig. 6. This plot shows that our proposed CAMixup is effective in reducing Mixup calibration error when combined with ensembles.
+
+# G CAMIXUP WITH TEMPERATURE SCALING
+
+See Fig. 13.
+
+# H LIMITATIONS AND FUTURE WORK
+
+We describe limitations of our work, signalling areas for future research. One limitation of CAMixup is that all examples in the same class still share the same Mixup coefficient. This leaves room for developing more fine-grained adaptive Mixup mechanisms, such as adapting the Mixup coefficient per example. This relates to an open research question: how do you measure the training difficulty of a data point given a deep network? (Toneva et al., 2018; Agarwal and Hooker, 2020) Another limitation is we showed that CAMixup still cannot fully fix the miscalibration of Mixup $^ +$ deep ensembles in Appendix E, due to the fact that Mixup $^ +$ deep ensembles leads to even worse calibration than Mixup $^ +$ BatchEnsemble. This raises a harder question which CAMixup cannot completely solve but also leaves more research room to further understand why Mixup is worse on deep ensembles and how to address it. Thus, we leave the question on how to address the above issues to future work. Next, we determine whether to use Mixup based on the reliability (Mean Accuracy - Mean Confidence) of each class on validation set. One concern is that CAMixup does not scale well to a large number of classes. Fortunately, we showed that this works on problems up to 1000 classes (ImageNet). Additionally, Mixup has been most successful in the vision domain, hence our focus; and with preliminary success on tabular data and natural language processing (Zhang et al., 2018; Guo et al., 2019). Assessing whether CAMixup and ensembling techniques translate to text is an interesting area.
+
+We took a first step in developing a more fine-grained adaptive Mixup mechanism. Recall that class based CAMixup calculates the reliability (Accuracy - Confidence) at the end of each epoch, then it decided whether to apply Mixup in each class (illustrated in Fig. 4). This requires extra computation on validation dataset and it assigns uniform Mixup coefficient within one class. By leveraging recently developed forgetting count (Toneva et al., 2018), we can adjust Mixup coefficient for each example based on its forgetting counts. The intuition is if an examples is associated with high forgetting counts, it indicates the model tends to forget this example. To achieve better calibration, we should place low confidence on this example. The algorithm of forgetting counts based CAMixup is presented in Algorithm 1. In summary, we first calculate the forgetting counts for each training example and obtain the median of these counts as the threshold. Then, CAMixup applies Mixup to the training example whose forgetting counts are higher than the median.
+
+We provided a preliminary results on CIFAR-10 in Fig. 14. It demonstrates that forgetting counts based CAMixup outperforms class based CAMixup on most metrics across BatchEnsemble and MC-dropout. One exception is that it underperforms on test calibration on MC-dropout. We could not observe the same improvement on CIFAR-100. We postulate that the reliability of forgetting count on CIFAR-100 is not as good as it is on CIFAR-10, leading to the inconsistent results. We leave the question on how to improve orgeting count based CAMixup on CIFAR-100 into future work.
+
+<table><tr><td>Algorithm CAMixup</td><td>1Forgetting Count Based</td></tr><tr><td>initialize prevacci = O,i ∈ D initialize forgettingT[i]=O,i∈D initialize MixupCoeffli] = 0 while training do ApplyMixup MixupCoeff for example; ∈ B do compute acci end if end for rank = sort(T) threshold = rank[|D|//2] for example; ∈ B do else end if end for</td><td>B ~ D # sample a minibatch onB based if prevacci &gt; acci then T[i]=T[]+1 prevacci = acCi gradient update classifier on B if T[i] &gt;threshold then MixupCoeff[i] = a MixupCoeff[𝑖] = 0</td></tr></table>
+
+![](images/48c4cc653f2fc176ffdc1bad559dbfb22e200b2cf241629db49fa1548ac8506b.jpg)  
+Figure 13: Combining CAMixup and Temperature Scaling further improves test ECE. It does not make further improvements on out-of-distribution calibration however.
+
+![](images/daf9fd143d0db37bed1038611e668ed8c4f6db601d7971c2dd568811b63bea74.jpg)  
+Figure 14: WideResNet 28-10 on CIFAR-10 and CIFAR-10-C. Green: Class based CAMixup. Purple: Forgetting count based CAMixup. Forgetting count based CAMixup outperforms class based Mixup in most metrics across BatchEnsemble and MC-dropout.

parse/train/g11CZSghXyY/g11CZSghXyY_content_list.json

@@ -0,0 +1,1993 @@
+[
+    {
+        "type": "text",
+        "text": "COMBINING ENSEMBLES AND DATA AUGMENTATION CAN HARM YOUR CALIBRATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            820,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yeming Wen∗1, Ghassen Jerfel∗2, Rafael Muller2, Michael W. Dusenberry2, Jasper Snoek2, Balaji Lakshminarayanan2 & Dustin Tran2 ∗ Equal contribution, 1University of Texas, Austin, 2Google Brain ",
+        "bbox": [
+            183,
+            167,
+            714,
+            213
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            250,
+            544,
+            265
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ensemble methods which average over multiple neural network predictions are a simple approach to improve a model’s calibration and robustness. Similarly, data augmentation techniques, which encode prior information in the form of invariant feature transformations, are effective for improving calibration and robustness. In this paper, we show a surprising pathology: combining ensembles and data augmentation can harm model calibration. This leads to a trade-off in practice, whereby improved accuracy by combining the two techniques comes at the expense of calibration. On the other hand, selecting only one of the techniques ensures good uncertainty estimates at the expense of accuracy. We investigate this pathology and identify a compounding under-confidence among methods which marginalize over sets of weights and data augmentation techniques which soften labels. Finally, we propose a simple correction, achieving the best of both worlds with significant accuracy and calibration gains over using only ensembles or data augmentation individually. Applying the correction produces new state-of-the art in uncertainty calibration across CIFAR-10, CIFAR-100, and ImageNet.1 ",
+        "bbox": [
+            233,
+            281,
+            766,
+            488
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            510,
+            336,
+            525
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many success stories in deep learning (Krizhevsky et al., 2012; Sutskever et al., 2014) are in restricted settings where predictions are only made for inputs similar to the training distribution. In real-world scenarios, neural networks can face truly novel data points during inference, and in these settings it can be valuable to have good estimates of the model’s uncertainty. For example, in healthcare, reliable uncertainty estimates can prevent over-confident decisions for rare or novel patient conditions (Dusenberry et al., 2019). We highlight two recent trends obtaining state-of-the-art in uncertainty and robustness benchmarks. ",
+        "bbox": [
+            174,
+            532,
+            825,
+            630
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ensemble methods are a simple approach to improve a model’s calibration and robustness (Lakshminarayanan et al., 2017). The same network architecture but optimized with different initializations can converge to different functional solutions, leading to decorrelated prediction errors. By averaging predictions, ensembles can rule out individual mistakes (Lakshminarayanan et al., 2017; Ovadia et al., 2019). Additional work has gone into efficient ensembles such as MC-dropout (Gal and Ghahramani, 2016), BatchEnsemble, and its variants (Wen et al., 2020; Dusenberry et al., 2020; Wenzel et al., 2020). These methods significantly improve calibration and robustness while adding few parameters to the original model. ",
+        "bbox": [
+            174,
+            637,
+            825,
+            748
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Data augmentation is an approach which is orthogonal to ensembles in principle, encoding additional priors in the form of invariant feature transformations. Intuitively, data augmentation enables the model to train on more data, encouraging the model to capture certain invariances with respect to its inputs and outputs; data augmentation may also produce data that may be closer to an out-ofdistribution target task. It has been a key factor driving state-of-the-art: for example, Mixup (Zhang et al., 2018; Thulasidasan et al., 2019a), AugMix (Hendrycks et al., 2020), and test-time data augmentation (Ashukha et al., 2020). ",
+        "bbox": [
+            174,
+            755,
+            825,
+            853
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A common wisdom in the community suggests that ensembles and data augmentation should naturally combine. For example, the majority of uncertainty models in vision with strong performance are built upon baselines leveraging standard data augmentation (He et al., 2016; Hendrycks et al., 2020) (e.g., random flips, cropping); Hafner et al. (2018) cast data augmentation as an explicit prior for Bayesian neural networks, treating it as beneficial when ensembling; and Hendrycks et al. (2020) highlights further improved results in AugMix when combined with Deep Ensembles (Hansen and Salamon, 1990; Krogh and Vedelsby, 1995). However, we find the complementary benefits between data augmentations and ensembels are not universally true. Section 3.1 illustrates the poor calibration of combining ensembles (MC-dropout, BatchEnsemble and Deep Ensembles) and Mixup on CIFAR: the model outputs excessive low confidence. Motivated by this pathology, in this paper, we investigate in more detail why this happens and propose a method to resolve it. ",
+        "bbox": [
+            174,
+            859,
+            821,
+            887
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contributions. In contrast to prior work, which finds individually that ensembles and Mixup improve calibration, we find that combining ensembles and Mixup consistently degrades calibration performance across three ensembling techniques. From a detailed analysis, we identify a compounding under-confidence, where the soft labels in Mixup introduce a negative confidence bias that hinders its combination with ensembles. We further find this to be true for other label-based strategies such as label smoothing. Finally, we propose CAMixup to correct this bias, pairing well with ensembles. CAMixup produces new state-of-the-art calibration on both CIFAR-10/100 (e.g., $0 . 4 \\%$ and $2 . 3 \\%$ on CIFAR-10 and CIFAR-10C), building on Wide ResNet 28-10 for competitive accuracy (e.g., $9 7 . 5 \\%$ and $8 9 . 8 \\%$ ) and on ImageNet $( 1 . 5 \\% )$ , building on ResNet-50 for competitive accuracy $( 7 7 . 4 \\% )$ . ",
+        "bbox": [
+            174,
+            234,
+            826,
+            361
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ON CALIBRATION, ENSEMBLES AND DATA AUGMENTATION ",
+        "bbox": [
+            174,
+            376,
+            823,
+            392
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 CALIBRATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            400,
+            316,
+            415
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Uncertainty estimation is critical but ground truth is difficult to obtain for measuring performance. Fortunately, calibration error, which assesses how well a model reliably forecasts its predictions over a population, helps address this. Let $( \\hat { Y } , \\hat { P } )$ denote the class prediction and associated confidence (predicted probability) of a classifier. ",
+        "bbox": [
+            173,
+            421,
+            825,
+            481
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Expected Calibration Error(ECE): One notion of miscalibration is the expected difference between confidence and accuracy (Naeini et al., 2015): $E _ { \\hat { P } } [ | \\mathbb { P } ( \\hat { Y } = Y | \\hat { P } = p ) - p | ]$ . ECE approximates this by binning the predictions in $[ 0 , 1 ]$ under $M$ equally-spaced intervals, and then taking a weighted average of each bins’ accuracy/confidence difference. Let $B _ { m }$ be the set of examples in the $m ^ { \\tilde { t } h }$ bin whose predicted confidence falls into interval $\\textstyle { \\bigl ( } { \\frac { m - 1 } { M } } , { \\frac { m } { M } } { \\bigr ] }$ . The bin $B _ { m }$ ’s accuracy and confidence are: ",
+        "bbox": [
+            174,
+            486,
+            825,
+            561
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/486a7f3758227d46d38bac4801267810e86fd8df2cbcaebfc39ad639e90754a3.jpg",
+        "text": "$$\n\\mathrm { A c c } ( B _ { m } ) = \\frac { 1 } { | B _ { m } | } \\sum _ { x _ { i } \\in B _ { m } } \\mathbb { 1 } ( \\hat { y } _ { i } = y _ { i } ) , \\quad \\mathrm { C o n f } ( B _ { m } ) = \\frac { 1 } { | B _ { m } | } \\sum _ { x _ { i } \\in B _ { m } } \\hat { p } _ { i } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            266,
+            565,
+            733,
+            604
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\hat { y } _ { i }$ and $y _ { i }$ are the predicted and true labels and $\\hat { p _ { i } }$ is the confidence for example $x _ { i }$ . Given $n$ examples, ECE is $\\begin{array} { r } { \\sum _ { m = 1 } ^ { M ^ { - } } \\frac { | B _ { m } | } { n } \\bigg | \\operatorname { A c c } ( B _ { m } ) - \\operatorname { C o n f } ( B _ { m } ) \\bigg | } \\end{array}$ . ",
+        "bbox": [
+            176,
+            608,
+            826,
+            647
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 ENSEMBLES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            659,
+            300,
+            672
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Aggregating the predictions of multiple models into an ensemble is a well-established strategy to improve generalization (Hansen and Salamon, 1990; Perrone and Cooper, 1992; Dietterich, 2000). ",
+        "bbox": [
+            174,
+            676,
+            823,
+            705
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "BatchEnsemble: BatchEnsemble takes a network architecture and shares its parameters across ensemble members, adding only a rank-1 perturbation for each layer in order to decorrelate member predictions (Wen et al., 2020). For a given layer, define the shared weight matrix among $K$ ensemble members as $\\mathbf { W } \\in \\mathbb { R } ^ { m \\times d }$ . A tuple of trainable vectors $\\mathbf { r } _ { k } \\in \\mathbb { R } ^ { m }$ and $\\mathbf { s } _ { k } \\in \\mathbb { R } ^ { n }$ are associated with each ensemble member $k$ . The new weight matrix for each ensemble member in BatchEnsemble is ",
+        "bbox": [
+            174,
+            712,
+            825,
+            782
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/aee5bb5fe55fb791560167e948ad11a07a4acea522d63074e0103833374d1c65.jpg",
+        "text": "$$\n\\mathbf { W } _ { k } ^ { \\prime } = \\mathbf { W } \\circ \\mathbf { F } _ { k } , { \\mathrm { ~ w h e r e ~ } } \\mathbf { F } _ { k } = \\mathbf { r } _ { k } \\mathbf { s } _ { k } ^ { \\top } \\in \\mathbb { R } ^ { m \\times d } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            786,
+            648,
+            806
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\circ$ denotes the element-wise product. Applying rank-1 perturbations via $\\mathbf { r }$ and s adds few additional parameters to the overall model. We use an ensemble size of 4 in all experiments. ",
+        "bbox": [
+            173,
+            811,
+            825,
+            840
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "MC-Dropout: Gal and Ghahramani (2016) interpret Dropout (Srivastava et al., 2014) as an ensemble model, leading to its application for uncertainty estimates by sampling multiple dropout masks at test time in order to ensemble its predictions. We use an ensemble size of 20 in all experiments. ",
+        "bbox": [
+            174,
+            845,
+            825,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Deep Ensembles: Composing an ensemble of models, each trained with a different random initialization, provides diverse predictions (Fort et al., 2019) which have been shown to outperform strong baselines on uncertainty estimation tasks (Lakshminarayanan et al., 2017). We use an ensemble size of 4 in all experiments. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this work, we focus on the interaction between data augmentation strategies and BatchEnsemble, MC-Dropout, and deep ensembles. Other popular ensembling approaches leverage weight averaging such as Polyak-Ruppert (Ruppert, 1988), checkpointing (Huang et al., 2017), and stochastic weight averaging (Izmailov et al., 2018) to collect multiple sets of weights during training and aggregate them to make predictions with only a single set. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            209
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 DATA AUGMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            222,
+            372,
+            236
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Data augmentation encourages a model to make invariant predictions under desired transformations which can greatly improve generalization performance. For example, in computer vision, random leftright flipping and cropping are de-facto approaches (He et al., 2016). We highlight two state-of-the-art techniques which we study. ",
+        "bbox": [
+            173,
+            242,
+            825,
+            299
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Mixup: Mixup (Zhang et al., 2018) manipulates both the features and the labels in order to encourage linearly interpolating predictions. Given an example $( x _ { i } , y _ { i } )$ , Mixup applies ",
+        "bbox": [
+            171,
+            305,
+            823,
+            334
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/43a390b8bf1114d1779b3324d1fa31850253c4af28cfea2750445b98e6bf5400.jpg",
+        "text": "$$\n\\tilde { x } _ { i } = \\lambda x _ { i } + ( 1 - \\lambda ) x _ { j } , \\quad \\tilde { y } _ { i } = \\lambda y _ { i } + ( 1 - \\lambda ) y _ { j } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            338,
+            658,
+            356
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, $x _ { j }$ is sampled from the training dataset (taken from the minibatch), and $\\lambda \\sim \\operatorname { B e t a } ( a , a )$ for a fixed hyperparameter $a > 0$ . ",
+        "bbox": [
+            173,
+            361,
+            825,
+            388
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Mixup was shown to be effective for generalization and calibration of deep neural networks (Zhang et al., 2018; Thulasidasan et al., 2019b). Recent work has investigated why Mixup improves generalization (Guo et al., 2018; Shimada et al., 2019) and adversarial robustness (Beckham et al., 2019; Pang et al., 2020; Mangla et al., 2020). Given Mixup’s simplicity, many extensions have been proposed with further improvements (Yun et al., 2019; Berthelot et al., 2019; Verma et al., 2019; Roady et al., 2020; Chou et al., 2020). ",
+        "bbox": [
+            173,
+            395,
+            825,
+            479
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "AugMix: Searching or sampling over a set of data augmentation operations can lead to significant improvement on both generalization error and calibration (Cubuk et al., 2019b;a). AugMix (Hendrycks et al., 2020) applies a sum of augmentations, each with random weighting, with a Jensen-Shannon consistency loss to encourage similarity across the augmentations. AugMix achieves state-of-the-art calibration across in- and out-of-distribution tasks. Let $\\mathcal { O }$ be the set of data augmentation operations and $k$ be the number of AugMix iterations. AugMix samples $w _ { 1 } , \\dots , w _ { k } \\sim { \\mathrm { D i r i c h l e t } } ( a , \\dots , a )$ for a fixed hyperparameter $a > 0$ and $\\boldsymbol { \\mathrm { o p } } _ { 1 } , \\ldots , \\boldsymbol { \\mathrm { o p } } _ { k }$ from $\\mathcal { O }$ . Given an interpolation parameter $m$ , sampled from $\\mathrm { B e t a } ( a , a )$ , the augmented input $\\tilde { x } _ { a u g m i x }$ is: ",
+        "bbox": [
+            173,
+            486,
+            826,
+            599
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ca7595b1549876a8966f17dbeb14d1d052118007c2cd894586c34ac3aaf26ad6.jpg",
+        "text": "$$\n\\tilde { x } _ { a u g m i x } = m x _ { o r i g } + ( 1 - m ) x _ { a u g } , \\qquad x _ { a u g } = \\sum _ { i = 1 } ^ { k } w _ { i } \\mathrm { o p } _ { i } ( x _ { o r i g } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            597,
+            722,
+            640
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 MIXUP-ENSEMBLE PATHOLOGY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            650,
+            472,
+            666
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We seek to understand the effect of data augmentations on ensembles. In particular, we hope to verify the hypothesis of compounding improvements when combining the seemingly orthogonal techniques of data augmentation and ensembles. To our surprise, we find that augmentation techniques can be detrimental to ensemble calibration. ",
+        "bbox": [
+            173,
+            674,
+            825,
+            729
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 THE SURPRISING MISCALIBRATION OF ENSEMBLES WITH MIXUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            741,
+            669,
+            756
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Ensembles are the most known and simple approaches to improving calibration (Ovadia et al., 2019; Lakshminarayanan et al., 2017), and Thulasidasan et al. (2019b) showed that Mixup improves calibration in a single network. Motivated by this, Fig. 1 applies Mixup to each ensemble member on CIFAR-10/CIFAR-100 with WideResNet 28-10 (Zagoruyko and Komodakis, 2016). Here, we searched over Mixup’s optimal hyperparameter $\\alpha$ (Eq. 3) and found that $\\alpha = 1$ gives the best result, which corroborates the finding in Zhang et al. (2018). All data points in Fig. 1 are averaged over 5 random seeds. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            861
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Figs. 1a and 1b demonstrate improved test accuracy (Red (ensembles without Mixup) to Blue (ensembles with Mixup)). However, if we shift focus to Figs. 1c and 1d’s calibration error, it is evident that combining Mixup with ensembles leads to worse calibration (Red to Blue). This is counterintuitive as we would expect Mixup, which improves calibration of individual models (Thulasidasan et al., 2019a), to also improve the calibration of their ensemble. Fig. 1 confirms this pattern across BatchEnsemble (BE), MC-dropout (MC), and deep ensembles (DE). This pathology also occurs on ImageNet, as seen in Table 1. ",
+        "bbox": [
+            173,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/7de16ef0003a45865f116896bc4adabc694829b6b0ca10008acf67cfc5bcbe5e.jpg",
+        "image_caption": [
+            "Figure 1: WideResNet 28-10 on CIFAR-10/CIFAR-100. Red: Ensembles without Mixup; Blue: Ensembles with Mixup; Orange: Individual models in ensembles without Mixup. (a) & (b): Applying Mixup to different ensemble methods leads to consistent improvement on test accuracy. (c) & (d): Applying Mixup to different ensemble methods harms calibration. Averaged over 5 random seeds. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            78,
+            810,
+            277
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            401,
+            825,
+            444
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Why do Mixup ensembles degrade calibration? To investigate this in more detail, Fig. 2 plots a variant of reliability diagrams (DeGroot and Fienberg, 1983) on BatchEnsemble. We bin the predictions into $M = 1 5$ equally spaced intervals based on their confidence (softmax probabilities) and compute the difference between the average confidence and the average accuracy as in Eq. 1 for each bin. Fig. 2 tracks this difference over varying confidence levels. A positive difference (Acc−Conf) implies under-confidence with respect to the true frequencies; negative implies over-confidence; and zero implies perfect calibration. ",
+        "bbox": [
+            174,
+            452,
+            537,
+            617
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The backbone model in Fig. 2 is BatchEnsemble with an ensemble size of 4 (we also found this consistent for MC-Dropout and Deep-Ensemble). The figure presents 4 methods: Single: vanilla WideResNet 28-10; MixupSingle: WideResNet 28-10 model trained with Mixup; BatchEnsemble: vanilla BatchEnsemble WideResNet 28-10 model; MixupBE: BatchEnsemble WideResNet 28-10 model trained with Mixup. Fig. 2 shows that only models trained with Mixup have positive $( \\operatorname { A c c } - \\operatorname { C o n f } )$ values on the test set, which suggests that Mixup encourages under-confidence. Mixup ensemble’s under-confidence is also greater in magnitude than that of the individual Mixup models. This suggests that Mixup ensembles suffer from compounding under-confidence, leading to a worse calibration for the ensemble than the individual Mixup models’ calibration. This is contrary to our intuition that ensembles always improves calibration. ",
+        "bbox": [
+            173,
+            626,
+            537,
+            680
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/c2ab4f9142caea72ad8e4cfafd8a5bf0ae7a9877e08d8dcff755f5ba49661364.jpg",
+        "image_caption": [
+            "Figure 2: Reliability diagrams on CIFAR100 with a WideResNet 28-10. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            545,
+            469,
+            816,
+            628
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            681,
+            826,
+            791
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To further visualize this issue, Appendix C’s Fig. 8 investigates the confidence (softmax probabilities) surface of deep ensembles and Mixup when trained on a toy dataset consisting of 5 clusters, each with a different radius. We ensemble over 4 independently trained copies of 3-layer MLPs. Deep ensemble’s predictive confidence is plotted over the entire input data space in Fig. 8c. The resulting predictions are extremely confident except at the decision boundaries. Deep Ensemble still displays high confidence in the area nearest to the origin which is expected to have lower confidence level. On the other hand, Fig. 8d shows that Mixup-Ensemble is only confident in a very constrained area around the training clusters, leading to an overall under-confident classifier which confirms our postulation of compounding under-confidence. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 IS THE PATHOLOGY SPECIFIC TO MIXUP? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            498,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "At the core of the issue is that Mixup conflates data uncertainty (uncertainty inherent to the data generating process) with model uncertainty. Soft labels can correct for over-confidence in single models which have no other recourse to improve uncertainty estimates. However, when combined with ensembles, which incorporate model uncertainty, this correction may be unnecessary. Because image classification benchmarks tend to be deterministic, soft labels encourage predictions on training data to be less confident about their true targets even if they are correct. We validate this hypothesis by showing it also applies to label smoothing. ",
+        "bbox": [
+            173,
+            125,
+            825,
+            223
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Label Smoothing: Like Mixup, label smoothing applies soft labels: it smoothens decision boundaries by multiplying a data point’s true class by $( 1 - \\alpha )$ , with probability $\\alpha$ spread equally across other classes. Using the same experimental setup as before, we apply increasing levels of label smoothing to ensembles of WideResNet 28-10 models trained on CIFAR-10. Fig. 3 demonstrates the harmful effect of label smoothing on CIFAR-10 ECE, particularly when aggressive (coeff $\\geq 0 . 2$ ). In the concurrent work, Qin et al. (2020) found that label smoothing plus ensemble leads to worse calibration. They showed that adjusting model confidence successfully corrects the compounding underconfidence. ",
+        "bbox": [
+            173,
+            229,
+            825,
+            327
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/2328151ade7bb16f576d3496a242db1d6119f59bda46bd5b2894e140726a9e82.jpg",
+        "image_caption": [
+            "Errorand ECE of Label Smoothing on WideResNet 28-10 trained on CIFAR-10 ",
+            "Figure 3: ECE and Error on CIFAR-10 with label smoothing on MC Dropout, Deep Ensembles, and BatchEnsemble. ECE degrades with label smoothing, particularly when it is more aggressive $( \\geq 0 . 2 )$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            354,
+            818,
+            478
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 CONFIDENCE ADJUSTED MIXUP ENSEMBLES (CAMIXUP) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            536,
+            689,
+            553
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we aim to fix the compounding under-confidence issue when combining Mixup and ensembles without sacrificing its improved accuracy on both in- and out-of-distribution data. ",
+        "bbox": [
+            174,
+            559,
+            828,
+            588
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 CLASS BASED CAMIXUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            599,
+            392,
+            614
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Mixup encourages model under-confidence as shown in Fig. 2. Notice that Mixup assigns a uniform hyperparameter $\\alpha$ to all examples in the training set. To improve Mixup, we start from the intuition that in classification, some classes are prone to be more difficult than others to predict. This can be confirmed by Fig. 4a, which provides examples of per-class test accuracy. Ideally, we prefer our model to be confident when it is predicting over easy classes such as cars and ships. For harder classes like cats and dogs, the model is encouraged to be less confident to achieve better calibration. ",
+        "bbox": [
+            174,
+            621,
+            825,
+            705
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Therefore, instead of a uniform Mixup hyperparameter for all classes, we propose to adjust the Mixup hyperparameter of each class by the difference between its accuracy and confidence. CAMixup’s intuition is that we want to apply Mixup on hard classes on which models tend to be over-confident. On easy examples, we impose the standard data-augmentation without Mixup. This partially prevents Mixup models from being over-confident on difficult classes while maintaining its good calibration on out-of-distribution inputs.2 ",
+        "bbox": [
+            173,
+            712,
+            825,
+            796
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Denote the accuracy and confidence of class $i$ as $\\operatorname { A c c } ( C _ { i } )$ and $\\operatorname { C o n f } ( C _ { i } )$ . We adjust Mixup’s $\\lambda$ in Eqn. 3 by the sign of $\\operatorname { A c c } ( C _ { i } ) - \\operatorname { C o n f } ( C _ { i } )$ , which are defined as $\\begin{array} { r } { \\operatorname { A c c } ( \\dot { C } _ { i } ) = \\frac { 1 } { | C _ { i } | } \\dot { \\sum } _ { x _ { j } \\in C _ { i } } \\mathbb { 1 } \\bar { ( y _ { j } = i ) } } \\end{array}$ and $\\begin{array} { r } { \\mathrm { C o n f } ( C _ { i } ) = \\frac { 1 } { | C _ { i } | } \\sum _ { x _ { j } \\in C _ { i } } \\hat { p _ { i } } } \\end{array}$ . ",
+        "bbox": [
+            173,
+            803,
+            826,
+            853
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a159144384820b4f5ed026102ff6e9dcb94ec5af8a15335d086ede9e67bb10b8.jpg",
+        "text": "$$\n\\lambda _ { i } = { \\left\\{ \\begin{array} { l l } { 0 } & { \\operatorname { A c c } ( C _ { i } ) > \\operatorname { C o n f } ( C _ { i } ) } \\\\ { \\lambda } & { \\operatorname { A c c } ( C _ { i } ) \\leq \\operatorname { C o n f } ( C _ { i } ) . } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            851,
+            609,
+            886
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/95afc36f6c2c12253cda3c96aa22255d9112dd3f392eab512b9f9ded1ff43870.jpg",
+        "image_caption": [
+            "Figure 4: Left: An illustration of the proposed CAMixup data augmentation. Selected per-class test accuracies are showed in brown. Overall test accuracy is $9 6 . 2 \\%$ on CIFAR-10; Right: Number of epochs (out of 250) where CAMixup enables Mixup for selected classes in BatchEnsemble. CAMixup tends to assign Mixup to hard classes. Counts are accumulated individually for each ensemble member (ensemble size 4). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            103,
+            821,
+            289
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "If the model is already under-confident on class $i$ $( \\operatorname { A c c } ( C _ { i } ) > \\operatorname { C o n f } ( C _ { i } ) )$ , Mixup is not applied to examples in the class, and $\\lambda _ { i } = 0$ . However, if $\\operatorname { A c c } ( C _ { i } ) \\leq \\operatorname { C o n f } ( C _ { i } )$ , the model is over-confident on this class, and Mixup is applied to reduce model confidence. We compute the accuracy and confidence on a validation dataset after each training epoch. ",
+        "bbox": [
+            173,
+            392,
+            825,
+            449
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/448a92d6a9ed5defb12abf632c929d52ca4d0d5dfd34a7d32422b6742a648e99.jpg",
+        "image_caption": [
+            "Figure 5: WideResNet 28-10 on CIFAR-10/CIFAR-100. Red: Ensembles without Mixup; Blue: Ensembles with Mixup; Green: Our proposed CAMixup improves both accuracy & ECE of ensembles. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            465,
+            816,
+            665
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Notice that $\\lambda _ { i }$ is dynamically updated at the end of each epoch. To understand which classes are more often assigned Mixup operation, Fig. 4 calculates the number of times that $\\lambda _ { i } > 0$ throughout training. The maximum number of times is the number of total training epochs, which is 250 in the BatchEnsemble model. We find that CAMixup rarely enables Mixup to easy classes such as cars and ships: the number of times is less than $1 0 \\%$ of the total epochs. For harder classes like cats and dogs, CAMixup assigns Mixup operation almost every epoch, accounting for more than $8 0 \\%$ of total epochs. In summary, Fig. 4 shows that CAMixup reduces model confidence on difficult classes and encourages model confidence on easy classes, leading to better overall calibration. Appendix D.1’s Fig. 9a also shows that CAMixup effectively shifts the confidence to the lower region. ",
+        "bbox": [
+            173,
+            720,
+            825,
+            847
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Fig. 5 presents results of CAMixup on CIFAR-10 and CIFAR-100 test set, where we compare the effect of Mixup and CAMixup on different ensembling strategies (BatchEnsemble, MC Dropout, DeepEnsemble). Adding Mixup to ensembles improves accuracy but worsens ECE. Adding CAMixup to ensembles significantly improves accuracy of ensembles in all cases. More importantly, the calibration results in Figs. 5c and 5d show that CAMixup ensembles are significantly better calibrated than Mixup ensembles, for instance, CAMixup reduces ECE by more than 5X for BatchEnsemble over Mixup. We observe a minor decrease in test accuracy (at most $0 . 2 \\%$ ) when comparing CAMixup ensembles with Mixup ensembles, but we believe that this is a worthwhile trade-off given the significant improvement in test ECE. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1 presents similar experiments applied to ResNet-50 on ImageNet, using BatchEnsemble as the base ensembling strategy. These results are state of the art to the best of our knowledge: Dusenberry et al. (2020) report $1 . 7 \\%$ ECE with Rank-1 Bayesian neural nets and $3 . 0 \\%$ with Deep Ensembles; Thulasidasan et al. (2019a) report $3 . 2 \\%$ for ResNet-50 with Mixup, $2 . 9 \\%$ for ResNet-50 with an entropy-regularized loss, and $1 . 8 \\%$ for ResNet-50 with label smoothing. ",
+        "bbox": [
+            174,
+            166,
+            581,
+            279
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/e77a2c65e4adfa0cb3288626d7c1c9cb2b346d936d83fbb7c00855c86ccaebf1.jpg",
+        "table_caption": [
+            "Table 1: BatchEnsemble with ensemble size 4 on ImageNet. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>ACC</td><td>ECE</td></tr><tr><td>BatchEnsemble</td><td>77.0</td><td>2.0%</td></tr><tr><td>MixupBE</td><td>77.5</td><td>2.1%</td></tr><tr><td>CAMixupBE</td><td>77.4</td><td>1.5%</td></tr></table>",
+        "bbox": [
+            593,
+            198,
+            825,
+            271
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 PERFORMANCE UNDER DISTRIBUTION SHIFT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            290,
+            529,
+            304
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Here, we assess model resilience to covariate shift by evaluating on the CIFAR-10-C and CIFAR-100-C benchmarks (C stands for corruptions) proposed by Hendrycks and Dietterich (2019a), which apply 15 types of corruptions each with 5 levels of intensity. We evaluate the performance of CAMixup vs Mixup when applied to different ensembles, and report average error on ECE across different types of corruptions and intensities. ",
+        "bbox": [
+            174,
+            311,
+            517,
+            436
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Fig. 6a shows that Mixup improves accuracy on the corrupted dataset because of its strong regularization effect. However, the models tend to be over-confident as one moves further from the original distribution (higher corruption intensities), so encouraging underconfidence is not an issue. This explains why Mixup ensembles maintain low ECE on out-of-distribution test data in Fig. 6b. ",
+        "bbox": [
+            174,
+            444,
+            517,
+            555
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/e247a496dee5a83d0292aa2da827d3c725000b1b3fd45ee5b7e80a9a777da7fe.jpg",
+        "image_caption": [
+            "Figure 6: WideResNet 28-10 on CIFAR-10-C. Red: Ensembles without Mixup; Blue: Ensembles with Mixup; Green: Ensembles with CAMixup (ours). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            535,
+            316,
+            802,
+            489
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Fig. 6b also shows that CAMixup’s calibration on out-of-distribution data (CIFAR-10-C) is also on par with Mixup ensembles. We observe the same result on CIFAR-100-C (Appendix D.1’s Fig. 9). Thus, we successfully improve model calibration on in-distribution datasets without sacrificing its calibration on out-of-distribution datasets. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            617
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 COMPOUNDING THE BENEFITS OF CAMIXUP WITH AUGMIX ENSEMBLES ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            632,
+            815,
+            648
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We have investigated why certain data augmentation schemes may not provide complementary benefits to ensembling. We proposed class-adjusted Mixup (CAMixup) which compounds both accuracy and ECE over vanilla ensembles. We believe that the insights from our work will allow the community and practitioners to compound SOTA performance. We provide two concrete examples. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            712
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 AUGMIX ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            724,
+            277,
+            738
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We show how CAMixup can compound performance over ensembles of models trained with AugMix, which were shown by Hendrycks et al. (2020) to achieve state-of-the-art accuracy and calibration on both clean and corrupted benchmarks. We primarily focus on improving BatchEnsemble and we investigate if adding better data augmentation schemes closes the gap between memory-efficient ensembles (BatchEnsemble) and independent deep ensembles. ",
+        "bbox": [
+            174,
+            746,
+            825,
+            815
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As discussed in Section 2.3, AugMix only uses label-preserving transformations. Therefore AugMix provides complementary benefits to ensembles (and CAMixup). This is consistent with calibration improvements in the literature with ensemble methods, which apply standard data augmentation such as random flips, which also do not smoothen labels. ",
+        "bbox": [
+            174,
+            823,
+            825,
+            878
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We consider a combination of AugMix and Mixup as it allows the model to encounter both diverse label-preserving augmentations and soft labels under a linearly interpolating regime. The combination ",
+        "bbox": [
+            173,
+            886,
+            823,
+            914
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/0a192a9b07380f96c62a6518a30dc271c9cd46cb5426c6368fa6afb30194de5e.jpg",
+        "image_caption": [
+            "Figure 7: Performance on BatchEnsemble under dataset shift. Mixup and AugMixup improve accuracy and calibration under shift but significantly worsen in-distribution calibration. Our proposed CAMixup and AugCAMixup improve accuracy and calibration. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            68,
+            816,
+            193
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/85f097dfb5316e2458499460f1e42e919d76fd12d0c5a44e5aac1d002073e5ee.jpg",
+        "table_caption": [
+            "Table 2: Results for Wide ResNet-28-10 BatchEnsemble on in- and out-of-distribution CIFAR-10/100 with various data augmentations, averaged over 3 seeds. AugMix: AugMix $^ +$ BatchEnsemble; AugMixup: AugMix $^ +$ Mixup BatchEnsemble; AugCAMixup: AugMix $^ +$ CAMixup BatchEnsemble. Adding Mixup to AugMix model increases test accuracy and corrupt accuracy at the cost of calibration decay on testset. CAMixup bridges this gap with only a minor drop in accuracy. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method/Metric</td><td colspan=\"3\">CIFAR-10</td><td colspan=\"3\">CIFAR-100</td></tr><tr><td>Acc(↑)</td><td>ECE(↓)</td><td>cA/cECE</td><td>Acc(↑)</td><td>ECE(↓)</td><td>cA/cECE</td></tr><tr><td>AugMix BE</td><td>97.36</td><td>1.02%</td><td>89.49/2.6%</td><td>83.57</td><td>2.96%</td><td>67.12/7.1%</td></tr><tr><td>AugMixup BE</td><td>97.52</td><td>1.71%</td><td>90.05/2.8%</td><td>83.77</td><td>4.19%</td><td>69.26/4.8%</td></tr><tr><td>AugCAMixup BE</td><td>97.47</td><td>0.45%</td><td>89.81/2.4%</td><td>83.74</td><td>2.35%</td><td>68.71/4.4%</td></tr></table>",
+        "bbox": [
+            194,
+            258,
+            802,
+            359
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "AugMixup (AugMix $^ +$ Mixup) can be written as ",
+        "bbox": [
+            174,
+            458,
+            491,
+            473
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bf2fb62c87f695e3c62bf0dc09cfac421a64f2e7a1def10c1d385de5addd3135.jpg",
+        "text": "$$\nx = \\lambda * \\operatorname { A u g M i x } ( x _ { 1 } ) + ( 1 - \\lambda ) \\operatorname { A u g M i x } ( x _ { 2 } ) , \\quad y = \\lambda * y _ { 1 } + ( 1 - \\lambda ) * y _ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            245,
+            479,
+            751,
+            497
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Consistent with earlier results on Mixup, Table 2 shows combining AugMixup with BatchEnsemble improves accuracy but worsens ECE, leading to under-confidence on in-distribution data. (Appendix D.2’s Fig. 10). With our proposed fix CAMixup, the combination AugCAMixup (AugMix $^ +$ CAMixup) improves calibration while retaining the highest accuracy for ensembles. Fig. 7 shows detailed results on CIFAR-10-C and CIFAR-100-C. Similar to Mixup, AugMixup improves calibration under shift but worsens calibration on in-distribution. However, our proposed AugCAMixup improves accuracy and calibration of ensembles on both clean and corrupted data. ",
+        "bbox": [
+            173,
+            510,
+            826,
+            608
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To the best of our knowledge, these results are state-of-the-art in the literature: Dusenberry et al. (2020) report $0 . 8 \\%$ ECE and $1 . 8 \\%$ ECE for CIFAR-10 and CIFAR-100 along with $8 \\%$ and ${ \\mathrm { { \\dot { 1 } } 1 . 7 \\% } }$ ECE for corruptions; Guo et al. (2017) report $0 . 5 4 \\%$ and $2 . 3 \\%$ ECE for the smaller Wide ResNet 32 on CIFAR-10 and CIFAR-100 with temperature scaling $9 3 \\%$ and $72 \\%$ accuracy), and Ovadia et al. (2019) demonstrated that temperature scaling does not extend to distribution shift. ",
+        "bbox": [
+            174,
+            614,
+            825,
+            685
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 TEMPERATURE SCALING",
+        "text_level": 1,
+        "bbox": [
+            174,
+            696,
+            387,
+            712
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In concurrent work, Rahaman and Thiery (2020) consider the interplay between data augmentation and ensembling on calibration. They also find that Mixup ensembles can be under-confident, and propose temperature scaling as a solution. Their core contribution is the same but differ in slight ways: we further this analysis by showing the compounding under-confidence extends to other techniques applying soft labels such as label smoothing, and we propose CAMixup as a solution. Post-hoc calibration techniques like temperature scaling are complementary to our proposal and do not address the core conflation issue with Mixup. Corroborating findings of Ovadia et al. (2019), Appendix G shows combining CAMixup and temperature scaling can further improve test calibration error; it does not improve out-of-distribution calibration. Another concurrent work showed that calibrated ensemble members do not always lead to calibrated ensemble predictions (Anonymous, 2021). ",
+        "bbox": [
+            174,
+            718,
+            825,
+            858
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            872,
+            318,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Contrary to existing wisdom in the literature, we find that combining ensembles and Mixup consistently degrades calibration performance across three ensembling techniques. From a detailed analysis, we identify a compounding under-confidence, where Mixup’s soft labels (and more broadly, label-based augmentation strategies) introduce a negative confidence bias that hinders its combination with ensembles. To correct this, we propose CAMixup, which applies Mixup to only those classes on which the model tends to be over-confident, modulated throughout training. CAMixup combines well with state-of-the-art methods. It produces new state-of-the-art calibration across CIFAR-10, CIFAR-100, and ImageNet while obtaining competitive accuracy. Appendix H points out potential future work and limitations of CAMixup. ",
+        "bbox": [
+            176,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chirag Agarwal and Sara Hooker. Estimating example difficulty using variance of gradients. arXiv preprint arXiv:2008.11600, 2020. ",
+        "bbox": [
+            174,
+            125,
+            823,
+            154
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Anonymous. Should ensemble members be calibrated? In Submitted to International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id $=$ wTWLfuDkvKp. under review. ",
+        "bbox": [
+            174,
+            162,
+            823,
+            205
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Arsenii Ashukha, Alexander Lyzhov, Dmitry Molchanov, and Dmitry Vetrov. Pitfalls of in-domain uncertainty estimation and ensembling in deep learning. In International Conference on Learning Representations, 2020. ",
+        "bbox": [
+            174,
+            214,
+            823,
+            257
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christopher Beckham, Sina Honari, Alex Lamb, Vikas Verma, Farnoosh Ghadiri, R. Devon Hjelm, and Christopher Joseph Pal. Adversarial mixup resynthesizers. ArXiv, abs/1903.02709, 2019. ",
+        "bbox": [
+            173,
+            266,
+            825,
+            296
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Berthelot, Nicholas Carlini, Ian Goodfellow, Nicolas Papernot, Avital Oliver, and Colin A Raffel. Mixmatch: A holistic approach to semi-supervised learning. In Advances in Neural Information Processing Systems, pages 5049–5059, 2019. ",
+        "bbox": [
+            176,
+            304,
+            823,
+            347
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hsin-Ping Chou, S. Chang, J. Pan, Wei Wei, and D. Juan. Remix: Rebalanced mixup. ArXiv, abs/2007.03943, 2020. ",
+        "bbox": [
+            171,
+            356,
+            825,
+            385
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ekin D. Cubuk, Barret Zoph, Jonathon Shlens, and Quoc V. Le. Randaugment: Practical automated data augmentation with a reduced search space. arXiv: Computer Vision and Pattern Recognition, 2019a. ",
+        "bbox": [
+            174,
+            393,
+            826,
+            436
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ekin Dogus Cubuk, Barret Zoph, Dandelion Mané, V. Vasudevan, and Quoc V. Le. Autoaugment: Learning augmentation strategies from data. 2019 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 113–123, 2019b. ",
+        "bbox": [
+            174,
+            445,
+            826,
+            488
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Morris H. DeGroot and Stephen E. Fienberg. The Comparison and Evaluation of Forecasters. The Statistician, 32(1/2):12, March 1983. ISSN 00390526. doi: 10.2307/2987588. URL https: //www.jstor.org/stable/10.2307/2987588?origin ${ \\bf \\Phi } = { \\bf \\Phi }$ crossref. ",
+        "bbox": [
+            173,
+            497,
+            826,
+            541
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Fei-Fei Li. Imagenet: A large-scale hierarchical image database. 2009 IEEE Conference on Computer Vision and Pattern Recognition, pages 248–255, 2009. ",
+        "bbox": [
+            173,
+            549,
+            825,
+            592
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thomas G. Dietterich. Ensemble methods in machine learning. In Multiple Classifier Systems, 2000. ",
+        "bbox": [
+            173,
+            601,
+            825,
+            617
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael W Dusenberry, Dustin Tran, Edward Choi, Jonas Kemp, Jeremy Nixon, Ghassen Jerfel, Katherine Heller, and Andrew M Dai. Analyzing the role of model uncertainty for electronic health records. arXiv preprint arXiv:1906.03842, 2019. ",
+        "bbox": [
+            174,
+            625,
+            823,
+            669
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael W. Dusenberry, Ghassen Jerfel, Yeming Wen, Yi-an Ma, Jasper Snoek, Katherine Heller, Balaji Lakshminarayanan, and Dustin Tran. Efficient and scalable Bayesian neural nets with rank-1 factors. In ICML, 2020. ",
+        "bbox": [
+            176,
+            678,
+            825,
+            720
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stanislav Fort, Huiyi Hu, and Balaji Lakshminarayanan. Deep Ensembles: A Loss Landscape Perspective. arXiv preprint arXiv:1912.02757, 2019. ",
+        "bbox": [
+            173,
+            728,
+            823,
+            758
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yarin Gal and Zoubin Ghahramani. Dropout as a Bayesian approximation: Representing model uncertainty in deep learning. In International Conference on Machine Learning, 2016. ",
+        "bbox": [
+            173,
+            767,
+            825,
+            796
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chuan Guo, Geoff Pleiss, Yu Sun, and Kilian Q Weinberger. On Calibration of Modern Neural Networks. In International Conference on Machine Learning (ICML), volume cs.LG. Cornell University Library, August 2017. URL http://arxiv.org/abs/1706.04599v2. ",
+        "bbox": [
+            176,
+            804,
+            825,
+            848
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hongyu Guo, Yongyi Mao, and Richong Zhang. Mixup as locally linear out-of-manifold regularization. In AAAI, 2018. ",
+        "bbox": [
+            173,
+            857,
+            823,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hongyu Guo, Yongyi Mao, and Richong Zhang. Augmenting data with mixup for sentence classification: An empirical study. arXiv preprint arXiv:1905.08941, 2019. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Danijar Hafner, Dustin Tran, Alex Irpan, Timothy Lillicrap, and James Davidson. Reliable uncertainty estimates in deep neural networks using noise contrastive priors. arXiv preprint arXiv:1807.09289, 2018. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lars Kai Hansen and Péter Salamon. Neural network ensembles. IEEE Trans. Pattern Anal. Mach. Intell., 12:993–1001, 1990. ",
+        "bbox": [
+            173,
+            155,
+            825,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Computer Vision and Pattern Recognition, 2016. ",
+        "bbox": [
+            174,
+            194,
+            823,
+            223
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks and Thomas Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. In International Conference on Learning Representations, 2019a. URL https://openreview.net/forum?id $=$ HJz6tiCqYm. ",
+        "bbox": [
+            173,
+            233,
+            825,
+            276
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks and Thomas Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. In International Conference on Learning Representations, 2019b. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            314
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks, Norman Mu, Ekin D. Cubuk, Barret Zoph, Justin Gilmer, and Balaji Lakshminarayanan. Augmix: A simple data processing method to improve robustness and uncertainty. ArXiv, abs/1912.02781, 2020. ",
+        "bbox": [
+            173,
+            324,
+            825,
+            366
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Q. Weinberger. Deep networks with stochastic depth. In ECCV, 2016. ",
+        "bbox": [
+            171,
+            376,
+            825,
+            405
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Yixuan Li, Geoff Pleiss, Zhuang Liu, John E Hopcroft, and Kilian Q Weinberger. Snapshot ensembles: Train 1, get m for free. arXiv preprint arXiv:1704.00109, 2017. ",
+        "bbox": [
+            171,
+            415,
+            825,
+            444
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pavel Izmailov, Dmitrii Podoprikhin, Timur Garipov, Dmitry Vetrov, and Andrew Gordon Wilson. Averaging weights leads to wider optima and better generalization. In Uncertainty in Artificial Intelligence, 2018. ",
+        "bbox": [
+            176,
+            453,
+            825,
+            496
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            173,
+            506,
+            692,
+            522
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Neural Information Processing Systems, pages 1097–1105, 2012. ",
+        "bbox": [
+            173,
+            531,
+            825,
+            560
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Anders Krogh and Jesper Vedelsby. Neural network ensembles, cross validation, and active learning. In Advances in neural information processing systems, pages 231–238, 1995. ",
+        "bbox": [
+            173,
+            569,
+            823,
+            599
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ananya Kumar, Percy Liang, and Tengyu Ma. Verified uncertainty calibration. ArXiv, abs/1909.10155, 2019. ",
+        "bbox": [
+            173,
+            608,
+            821,
+            637
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Balaji Lakshminarayanan, Alexander Pritzel, and Charles Blundell. Simple and scalable predictive uncertainty estimation using deep ensembles. In Neural Information Processing Systems, 2017. ",
+        "bbox": [
+            174,
+            646,
+            825,
+            676
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Puneet Mangla, Vedant Singh, Shreyas Jayant Havaldar, and Vineeth N. Balasubramanian. Varmixup: Exploiting the latent space for robust training and inference. ArXiv, abs/2003.06566, 2020. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            714
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mahdi Pakdaman Naeini, Gregory F. Cooper, and Milos Hauskrecht. Obtaining Well Calibrated Probabilities Using Bayesian Binning. In AAAI Conference on Artificial Intelligence, volume 2015, pages 2901–2907, January 2015. URL https://www.ncbi.nlm.nih.gov/pmc/ articles/PMC4410090/pdf/nihms679964.pdf. ",
+        "bbox": [
+            173,
+            723,
+            826,
+            781
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jeremy Nixon, Mike Dusenberry, Linchuan Zhang, Ghassen Jerfel, and Dustin Tran. Measuring Calibration in Deep Learning. arXiv:1904.01685 [cs, stat], April 2019. URL http://arxiv. org/abs/1904.01685. ",
+        "bbox": [
+            173,
+            790,
+            825,
+            833
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yaniv Ovadia, Emily Fertig, Jie Ren, Zachary Nado, D Sculley, Sebastian Nowozin, Joshua V Dillon, Balaji Lakshminarayanan, and Jasper Snoek. Can you trust your model’s uncertainty? Evaluating predictive uncertainty under dataset shift. In Neural Information Processing Systems, 2019. ",
+        "bbox": [
+            174,
+            843,
+            823,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tianyu Pang, Kun Xu, and Jun Zhu. Mixup inference: Better exploiting mixup to defend adversarial attacks. ArXiv, abs/1909.11515, 2020. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael P. Perrone and Leon N. Cooper. When networks disagree: Ensemble methods for hybrid neural networks. 1992.   \nYao Qin, Xuezhi Wang, Alex Beutel, and Ed Huai hsin Chi. Improving uncertainty estimates through the relationship with adversarial robustness. ArXiv, abs/2006.16375, 2020.   \nRahul Rahaman and Alexandre H Thiery. Uncertainty quantification and deep ensembles. arXiv preprint arXiv:2007.08792, 2020.   \nRyne Roady, T. Hayes, and Christopher Kanan. Improved robustness to open set inputs via tempered mixup. ArXiv, abs/2009.04659, 2020.   \nAlejandro Romero, Nicolas Ballas, Samira Ebrahimi Kahou, Antoine Chassang, Carlo Gatta, and Yoshua Bengio. FitNets: Hints for thin deep nets. CoRR, abs/1412.6550, 2015.   \nDavid Ruppert. Efficient estimations from a slowly convergent Robbins-Monro process. Technical report, Cornell University Operations Research and Industrial Engineering, 1988.   \nTakuya Shimada, Shoichiro Yamaguchi, Kohei Hayashi, and Sosuke Kobayashi. Data interpolating prediction: Alternative interpretation of mixup. ArXiv, abs/1906.08412, 2019.   \nNitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1):1929–1958, 2014.   \nRupesh Kumar Srivastava, Klaus Greff, and Jürgen Schmidhuber. Highway networks. CoRR, abs/1505.00387, 2015.   \nIlya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In Neural Information Processing Systems, 2014.   \nSunil Thulasidasan, Gopinath Chennupati, Jeff A Bilmes, Tanmoy Bhattacharya, and Sarah Michalak. On mixup training: Improved calibration and predictive uncertainty for deep neural networks. In Advances in Neural Information Processing Systems, pages 13888–13899, 2019a.   \nSunil Thulasidasan, Gopinath Chennupati, Jeff A. Bilmes, Tanmoy Bhattacharya, and Sarah Ellen Michalak. On mixup training: Improved calibration and predictive uncertainty for deep neural networks. In NeurIPS, 2019b.   \nMariya Toneva, Alessandro Sordoni, Remi Tachet des Combes, Adam Trischler, Yoshua Bengio, and Geoffrey J Gordon. An empirical study of example forgetting during deep neural network learning. arXiv preprint arXiv:1812.05159, 2018.   \nJuozas Vaicenavicius, D. Widmann, Carl R. Andersson, F. Lindsten, J. Roll, and Thomas Bo Schön. Evaluating model calibration in classification. In AISTATS, 2019.   \nVikas Verma, Alex Lamb, Christopher Beckham, Amir Najafi, Ioannis Mitliagkas, David Lopez-Paz, and Yoshua Bengio. Manifold mixup: Better representations by interpolating hidden states. In International Conference on Machine Learning, pages 6438–6447. PMLR, 2019.   \nYeming Wen, Dustin Tran, and Jimmy Ba. BatchEnsemble: An alternative approach to efficient ensemble and lifelong learning. In International Conference on Learning Representations, 2020.   \nFlorian Wenzel, Jasper Snoek, Dustin Tran, and Rodolphe Jenatton. Hyperparameter ensembles for robustness and uncertainty quantification. In Neural Information Processing Systems, 2020.   \nD. Widmann, F. Lindsten, and D. Zachariah. Calibration tests in multi-class classification: A unifying framework. ArXiv, abs/1910.11385, 2019.   \nSangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, and Youngjoon Yoo. Cutmix: Regularization strategy to train strong classifiers with localizable features. In Proceedings of the IEEE International Conference on Computer Vision, pages 6023–6032, 2019.   \nSergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.   \nHongyi Zhang, Moustapha Cissé, Yann Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. ArXiv, abs/1710.09412, 2018. ",
+        "bbox": [
+            171,
+            75,
+            828,
+            925
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A DATASET DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            366,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "CIFAR & CIFAR-C: We consider two CIFAR datasets, CIFAR-10 and CIFAR-100 (Krizhevsky, 2009). Each consists of a training set of size 50K and a test set of size 10K. They are natural images with $3 2 \\mathrm { x } 3 2 $ pixels. Each class has 5,000 training images and 500 training images on CIFAR-10 and CIFAR-100 respectively. In our experiments, we follow the standard data pre-processing schemes including zero-padding with 4 pixels on each sise, random crop and horizon flip (Romero et al., 2015; Huang et al., 2016; Srivastava et al., 2015). If a training method requires validation dataset such as CAMixup, we use separate 2, 500 images from 50K training images as the validation set. ",
+        "bbox": [
+            173,
+            126,
+            825,
+            224
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "It’s important to test whether models are well calibrated under distribution shift. CIFAR-10 corruption dataset (Hendrycks and Dietterich, 2019a) is designed to accomplish this. The dataset consists of 15 types of corruptions to the images. Each corruption types have 5 intensities. Thus, in total CIFAR-10C has 75 corrupted datasets. Notice that the corrupted dataset is used as a testset without training on it. Ovadia et al. (2019) benchmarked a number of methods on CIFAR-10 corruption. Similarly, we can apply the same corruptions to CIFAR-100 dataset to obtain CIFAR-100C. ",
+        "bbox": [
+            174,
+            231,
+            825,
+            314
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "ImageNet & ImageNet-C: We used the ILSVRC 2012 classification dataset (Deng et al., 2009) which consists of a total of 1.2 million training images, 50,000 validation images and 150,000 testing images. Images span over 1,000 classes. We follow the data augmentation scheme in He et al. (2016), such as random crop and random flip, to preprocess the training images. During testing time, we apply a $2 2 4 \\mathbf { x } 2 2 4$ center crop to images. Similarly to CIFAR-C, we apply 15 corruption types with 5 intensities each to obtain ImageNet-C (Hendrycks and Dietterich, 2019b). ",
+        "bbox": [
+            174,
+            320,
+            825,
+            405
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B HYPERPARAMETERS IN SECTION 3 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            420,
+            500,
+            435
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We kept the same set of hyperparameters as the BatchEnsemble model in Wen et al. (2020). All hyperparameters can be found in Table 3. The most sensitive hyperparameter we found is whether to use ensemble batch norm, which applies a separate batch norm layer for each ensemble member; and the value of random_sign_init, which controls the standard deviation of Gaussian distributed initialization of s and r. We kept BatchEnsemble CIFAR-10 the same as Wen et al. (2020), which does not deploy ensemble batch norm. We enable ensemble batch norm on CIFAR-100 and ImageNet. This allows us to use larger standard deviation in the initialization. The random_sign_init is $- 0 . 5$ on CIFAR-10 and $- 0 . 7 5$ on CIFAR-100 and -0.75 on ImageNet. In the code, we use negative value to denote the standard deviation of Gaussian distribution (positive value instead initializes with a Bernoulli distribution under that probability). In our case, we only use negative random_sign_init, which means we only consider Gaussian distributed initialization in this work. ",
+        "bbox": [
+            173,
+            443,
+            826,
+            595
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/c71413666c803c1abc5a440410ed026366edbf9d988b117b1a56a8cfbdf31d2a.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 3: Hyperparameters we used in Section 3 regarding to BatchEnsemble. The difference between CIFAR-10 and CIFAR-100 is l2, random_sign_init and whether to use SyncEnsemble_BN. "
+        ],
+        "table_body": "<table><tr><td>Dataset</td><td>CIFAR-10</td><td>CIFAR-100</td></tr><tr><td>ensemble_size base_learning_rate per_core_batch_size num_cores lr_decay_ratio train_epochs</td><td colspan=\"2\">4 0.1 64 8 0.1 250</td></tr><tr><td>lr_decay_epochs 12</td><td>0.0001</td><td>[80,160,200] 0.0003</td></tr><tr><td>random_sign_init SyncEnsemble_BN</td><td>0.5 False</td><td>0.75 True</td></tr></table>",
+        "bbox": [
+            325,
+            609,
+            666,
+            786
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C EXCESSIVE UNDER-CONFIDENCE ON SYNTHETIC DATA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            845,
+            661,
+            861
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "To further understand the confidence surface of Mixup $^ +$ Ensembles, we provided a visualization in Fig. 8. We trained on a synthetic dataset consisting of 5 clusters, each with a different radius. We ensemble over 4 independently trained copies of 3-layer MLPs. We plotted the softmax probabilities surface of Mixup-Single model, Deep-Ensemble and Mixup-Ensemble. The softmax probabilities represent the model confidence. Fig. 8c shows that Deep-Ensemble predictions are extremely confident except at the decision boundaries. Fig. 8b displays a lower confidence than Deep-Ensemble. This is beneficial in the single model context because single deep neural networks tend to be over-confident and Mixup can partially correct this bias. On the other hand, Fig. 8d shows that MixupEnsemble is only confident in a very constrained area around the training clusters, leading to an overall under-confident classifier which confirms our postulation of compounding under-confidence. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/4c21c18d93455688887e0ec4d911ad98c2664f072558ac9645d281177ed2c49b.jpg",
+        "image_caption": [
+            "Figure 8: Softmax probabilities surface of different ensemble methods (ensemble size 4) in the input space after training on synthetic data. Deep ensemble is over-confident in the area around origin. Mixup-Ensemble leads to gloabl under-confidence. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            103,
+            813,
+            238
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/7e18c46478f8c1945a9cec0cdf368fafe4410460963629986a99b860c4edb73f.jpg",
+        "image_caption": [
+            "Figure 9: Left: Reliability diagrams on CIFAR-100 with a WideResNet 28-10. Our proposed CAMixup successfully fixes the under-confidence of Mixup BatchEnsemble, leading to better calibration. (b) & (c): Red: Ensembles without Mixup; Blue: Ensembles with Mixup; Green: Our proposed CAMixup does not harm the out-of-distribution performance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            308,
+            807,
+            505
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            614,
+            826,
+            698
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D MORE CALIBRATION RESULTS OF MIXUP-BATCHENSEMBLE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            713,
+            714,
+            729
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In Section 3.1, we demonstrated that combining Mixup and ensembles leads to worse calibration on testset. In this appendix section, we complement the above conclusion with the analysis on corrupted datasets and with data-augmentation techniques like AugMix. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            779
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D.1 SUPPLEMENTARY RESULTS ON CAMIXUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            791,
+            506,
+            805
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In this section, we provided supplementary results on CAMixup. Fig. 2 shows that combining Mixup and BatchEnsemble leads to excessive under-confidence. In Fig. 9a, we showed that our proposed CAMixup fixes this issue by correcting the confidence bias. This explains why CAMixup achieves better calibration on in-distribution testset. As demonstrated in Section 4.2, Mixup improves model out-of-distribution performance because of its strong regularization effect. We showed that our proposed CAMixup inherits Mixup’s improvement on CIFAR-10-C. Fig. 9b and Fig. 9c show that this conclusion seamlessly transfers to CIFAR-100-C. We also supplement Fig. 5 with Table 4 and Table 5, illusrating detailed numbers. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/f76a87b2f9497b7fa10e32b6f5cab1e5870f1af219775b2ca07d30be42f73fc2.jpg",
+        "image_caption": [
+            "Figure 10: Reliability diagrams on CIFAR-10 and CIFAR-100. Both plots show that AugMix does not lead to under-confidence when combined with ensembles. However, if we combine AugMix with Mixup (AugMixup), the compounding under-confidence issue still exists, leading to suboptimal calibration. Our proposed AugCAMixup corrects this underconfidence bias. ",
+            "Table 5: CIFAR-100 results for Wide ResNet-28-10 BatchEnsemble (Wen et al., 2020) (BE), averaged over 5 seeds. This table is used to supplement Fig. 5. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            93,
+            795,
+            290
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "D.2 SUPPLEMENTARY RESULTS ON AUGMIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            386,
+            488,
+            398
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We show that Mixup does not combine with ensembles without sacrificing in-distribution calibration in Section 3.1. As discussed in Section 2.3, AugMix only uses label-preserving transformations and does not modify the labels. Intuitively, it does not reduce model confidence. We support this intuition with Fig. 10. It shows that AugMix does not lead to under-confidence. Therefore it can be combined with ensembles without any calibration issue. ",
+        "bbox": [
+            173,
+            406,
+            825,
+            477
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In Table 2, we showed that combining AugMix and Mixup leads to worse calibration due to the under-confidence although AugMix itself does not. To better understand the insights beyond staring at scalars, we provided the reliability diagram analysis as well. In Figure 10, we showed that the underconfidence issue of AugMixup (Augmi $\\mathbf { \\boldsymbol { x } } + \\mathbf { \\boldsymbol { M } } \\mathbf { \\dot { \\boldsymbol { i } } } \\mathbf { \\boldsymbol { x } }$ up) still exists. It suggests that applying CAMixup to Augmix can correct the under-confidence bias as what we showed in Fig. 10a and Fig. 10b. Our proposed CAMixup allows to compound performance of ensembles and data augmentation to achieve the best possible performance. ",
+        "bbox": [
+            173,
+            482,
+            826,
+            580
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/f7dc17eaccdf954f6013d6888f51bc7e87a043bc5f6455ae66d6d45d9b110c84.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method/Metric</td><td colspan=\"3\">CIFAR-10</td></tr><tr><td>Ac(↑)</td><td>ECE(↓)</td><td>cA/cE</td></tr><tr><td>BatchEnsemble</td><td>96.22 ±0.07</td><td>1.8 ±0.2 %</td><td>77.5±0.3 /12.9 ±1.2 %</td></tr><tr><td>Mixup BE</td><td>96.98±0.08</td><td>6.4 ±0.4 %</td><td>80.0±0.4 /9.3±0.3 %</td></tr><tr><td>CAMixup BE</td><td>96.94 ±0.10</td><td>1.2 ±0.2 %</td><td>81.1±0.4 /9.7±0.35%</td></tr></table>",
+        "bbox": [
+            248,
+            593,
+            748,
+            693
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/40062847c5610484b75a36e06db9c452b846eb4149ca9359b25b59a426c0327f.jpg",
+        "table_caption": [
+            "Table 4: CIFAR-10 results for Wide ResNet-28-10 BatchEnsemble (Wen et al., 2020) (BE), averaged over 5 seeds. This table is used to supplement Fig. 5. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method/Metric</td><td colspan=\"3\">CIFAR-100</td></tr><tr><td>Acc(↑)</td><td>ECE(↓)</td><td>cA/cE</td></tr><tr><td>BatchEnsemble</td><td>81.85±0.09</td><td>2.8±0.1%</td><td>54.1±0.3/19.1±0.8%</td></tr><tr><td>Mixup BE</td><td>83.12±0.08</td><td>9.7±0.5 %</td><td>59.3±0.3/8.8±0.4%</td></tr><tr><td>CAMixup BE</td><td>83.02±0.10</td><td>2.3±0.1%</td><td>59.7±0.3/8.9±0.4%</td></tr></table>",
+        "bbox": [
+            259,
+            733,
+            736,
+            832
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/d7605a8706128ff685c755fec1195e0d4fafcd7f5c8dcb94f7def8186ea5fbe6.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td colspan=\"3\">CIFAR-10</td><td colspan=\"3\">CIFAR-100</td></tr><tr><td>Metric</td><td>Acc(↑）</td><td>ECE(↓)</td><td>cA/cE</td><td>Acc(1）</td><td>ECE(↓)</td><td>cA/cE</td></tr><tr><td>Deep Ensembles</td><td>96.66</td><td>0.78%</td><td>76.80/9.8%</td><td>82.7</td><td>2.1%</td><td>54.1/13.8%</td></tr><tr><td>Mixup DE</td><td>97.11</td><td>6.15%</td><td>83.33/8.0%</td><td>83.90</td><td>9.42%</td><td>61.02/8.9%</td></tr><tr><td>CAMixup DE</td><td>96.95</td><td>1.92%</td><td>83.01/4.4%</td><td>83.68</td><td>5.22%</td><td>59.18/8.6%</td></tr><tr><td>AugMix DE</td><td>97.39</td><td>0.59%</td><td>89.50/3.3%</td><td>84.15</td><td>5.13%</td><td>68.21/6.7%</td></tr><tr><td>AugMixup DE</td><td>97.56</td><td>2.71%</td><td>90.03/4.3%</td><td>84.85</td><td>6.86%</td><td>69.31/7.6%</td></tr><tr><td>AugCAMixup DE</td><td>97.48</td><td>1.89%</td><td>89.94/4.7%</td><td>84.64</td><td>5.29%</td><td>69.19/5.9%</td></tr></table>",
+        "bbox": [
+            196,
+            101,
+            802,
+            267
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Table 6: Mixup/AugMix/AugMixup/AugCAMixup on deep ensembles. We can conclude that Mixup worsens ensemble predictions in deep ensembles as well as in BatchEnsemble. This suggests we can use CAMixup on deep ensembles as well. However, the improvement is not as obvious as it is on BatchEnsemble, leading to the fact that AugMix is the most calibrated (in- and out-of-distribution) data augmentation strategy on deep ensembles. ",
+        "bbox": [
+            173,
+            277,
+            825,
+            348
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "E DEEP ENSEMBLES WITH MIXUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            390,
+            473,
+            406
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We showed that CAMixup improves Mixup BatchEnsemble calibration on testset without undermining its calibration under distribution shift in Section 4. In this section, we show that the improvement can also be observed on deep ensembles. In Fig. 11, we showed the under-confidence bias we observed on Mixup $^ +$ BatchEnsemble also exists on Mixup $^ +$ deep ensembles, with an even more obvious trend. Beyond commonly used ECE measure, we also explore other calibration measures. They further confirmed our under-confidence intuition. We provide some brief explanation on how to calculate ACE, SCE and TACE. ",
+        "bbox": [
+            174,
+            412,
+            825,
+            510
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "ACE measure is the same as ECE except for the binning scheme. Rather than equally divide the confidence evenly into several bins, ACE choses an adaptive scheme which spaces the bin intervals so that each contains an equal number of predictions. SCE is the same as ECE except that it accounts for all classes into calibration measure rather than just looking at the class with maximum probability. The softmax predictions induce infinitesimal probabilities. These tiny predictions can wash out the calibration score. TACE is proposed to set a threshold to only include predictions with large predictive probability, to address the above issue. ",
+        "bbox": [
+            173,
+            517,
+            825,
+            614
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We present the results of Mixup, CAMixup, AugMix, AugMixup and AugCAMixup on deep ensembles in Table 6. We notice that the improvement of CAMixup on deep ensembles is smaller than its improvement on BatchEnsemble. We postulate that this is because Mixup $^ +$ deep ensembles is much badly calibrated than Mixup $^ +$ BatchEnsemble. For example, AugMixup $^ +$ deep ensembles achieve $2 . 7 1 \\%$ and $6 . 8 6 \\%$ ECE on CIFAR-10 and CIFAR-100. In the meanwhile, AugMixup $^ +$ BatchEnsemble achieve $1 . 7 1 \\%$ and $4 . 1 9 \\%$ . Thus, even if CAMixup can improve the calibration of Mixup $^ +$ deep ensembles, it still cannot beat AugMix $^ +$ deep ensembles. As a result, when we say we close the calibration gap between BatchEnsemble and deep ensembles, we are comparing AugCAMixup BatchEnsemble (BatchEnsemble $^ +$ CAMi $\\mathrm  { a p } + \\mathrm  { A u } \\{ $ mix) to AugMix deep ensembles. This is because AugMix deep ensembles achieve the best calibration among all variants we tried. How to completely fix the under-confidence in deep ensembles is a natural extension of this work. Since we focus on bridging the calibration gap between BatchEnsemble and deep ensembles, we delegate the complete fix in deep ensembles to the future work. ",
+        "bbox": [
+            173,
+            621,
+            825,
+            803
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "F METRICS OTHER THAN ECE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            816,
+            442,
+            833
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "ECE is the standard metric in calibration, but it is a biased estimate of true calibration (Vaicenavicius et al., 2019). Heavily relying on ECE metric might lead to inconsistent conclusion. In this section, we computed the calibration error with recently proposed calibration estimator which reduces bias in ECE, including debiased calibration estimator (Kumar et al., 2019) (DCE) and SKCE (Widmann et al., 2019). fig. 12 shows that our conclusion in the main section are also supported by these two recently proposed calibration estimators. In particular, the improvement of proposed CAMixup over ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/633278aee038c021af573c49fd7c50e614b66a15a002152dd564d8d1cf8c29d3.jpg",
+        "image_caption": [
+            "Figure 11: WideResNet-28-10 Deep Ensembles with Mixup on CIFAR-10. We plotted the reliability diagram of ensemble and individual predictions. Besides ECE, we also plotted other calibration metrics such as ACE, SCE and TACE proposed in Nixon et al. (2019). All metrics verify the conclusion that Mixup $^ +$ Ensembles leads to under-confidence on testset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            41,
+            759,
+            838
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/eae25726e895d82a57879070e436e0db1da4c27299505a97e89fb490df957083.jpg",
+        "table_caption": [
+            "Table 7: Results for Wide ResNet-28-10 BatchEnsemble (Wen et al., 2020) and Deep Ensembles on CIFAR-10 and CIFAR-10-C, averaged over 3 seeds. This table is used to supplement Fig. 12 "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method/Metric</td><td colspan=\"3\">BatchEnsemble</td><td colspan=\"3\">Deep-Ensembles</td></tr><tr><td>Acc(↑)</td><td>SKCE(↓)</td><td>cA/cSKCE</td><td>Acc(↑)</td><td>SKCE(↓)</td><td>cA/cSKCE</td></tr><tr><td>Vanilla</td><td>96.22</td><td>3.4e-4</td><td>77.5/0.026</td><td>96.66</td><td>3.4e-5</td><td>54.1/0.018</td></tr><tr><td>Mixup</td><td>96.98</td><td>4e-3</td><td>80.0/0.024</td><td>97.11</td><td>4.4e-3</td><td>59.3/0.0068</td></tr><tr><td>CAMixup</td><td>96.94</td><td>1.3e-4</td><td>81.1/0.019</td><td>96.95</td><td>4.3e-4</td><td>59.7/0.0032</td></tr></table>",
+        "bbox": [
+            197,
+            101,
+            800,
+            200
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/c71a903195907a190dcd87a2fc60471bf147b76fe445b996b9cecd42435a586f.jpg",
+        "image_caption": [
+            "Mixup on testset is even larger than what ECE reflects in Fig. 5. Table 7 demonstrates the specific numbers used in Fig. 12. ",
+            "Figure 12: WideResNet 28-10 on CIFAR-10 and CIFAR-10-C, averaged over 3 random seeds. SKCE: Squared kernel calibration error computed in Widmann et al. (2019). DCE: Debiased calibration error in Kumar et al. (2019). Red: Ensembles without Mixup; Blue: Ensembles with Mixup; Green: Ensembles with CAMixup (ours). Both SKCE and DCE give consistent rankings on calibration error to the ranking in Fig. 5 and Fig. 6. This plot shows that our proposed CAMixup is effective in reducing Mixup calibration error when combined with ensembles. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            292,
+            812,
+            487
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "G CAMIXUP WITH TEMPERATURE SCALING",
+        "text_level": 1,
+        "bbox": [
+            174,
+            604,
+            560,
+            622
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "See Fig. 13. ",
+        "bbox": [
+            174,
+            628,
+            253,
+            643
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "H LIMITATIONS AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            496,
+            118
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "We describe limitations of our work, signalling areas for future research. One limitation of CAMixup is that all examples in the same class still share the same Mixup coefficient. This leaves room for developing more fine-grained adaptive Mixup mechanisms, such as adapting the Mixup coefficient per example. This relates to an open research question: how do you measure the training difficulty of a data point given a deep network? (Toneva et al., 2018; Agarwal and Hooker, 2020) Another limitation is we showed that CAMixup still cannot fully fix the miscalibration of Mixup $^ +$ deep ensembles in Appendix E, due to the fact that Mixup $^ +$ deep ensembles leads to even worse calibration than Mixup $^ +$ BatchEnsemble. This raises a harder question which CAMixup cannot completely solve but also leaves more research room to further understand why Mixup is worse on deep ensembles and how to address it. Thus, we leave the question on how to address the above issues to future work. Next, we determine whether to use Mixup based on the reliability (Mean Accuracy - Mean Confidence) of each class on validation set. One concern is that CAMixup does not scale well to a large number of classes. Fortunately, we showed that this works on problems up to 1000 classes (ImageNet). Additionally, Mixup has been most successful in the vision domain, hence our focus; and with preliminary success on tabular data and natural language processing (Zhang et al., 2018; Guo et al., 2019). Assessing whether CAMixup and ensembling techniques translate to text is an interesting area. ",
+        "bbox": [
+            173,
+            125,
+            825,
+            347
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "We took a first step in developing a more fine-grained adaptive Mixup mechanism. Recall that class based CAMixup calculates the reliability (Accuracy - Confidence) at the end of each epoch, then it decided whether to apply Mixup in each class (illustrated in Fig. 4). This requires extra computation on validation dataset and it assigns uniform Mixup coefficient within one class. By leveraging recently developed forgetting count (Toneva et al., 2018), we can adjust Mixup coefficient for each example based on its forgetting counts. The intuition is if an examples is associated with high forgetting counts, it indicates the model tends to forget this example. To achieve better calibration, we should place low confidence on this example. The algorithm of forgetting counts based CAMixup is presented in Algorithm 1. In summary, we first calculate the forgetting counts for each training example and obtain the median of these counts as the threshold. Then, CAMixup applies Mixup to the training example whose forgetting counts are higher than the median. ",
+        "bbox": [
+            174,
+            354,
+            516,
+            645
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "We provided a preliminary results on CIFAR-10 in Fig. 14. It demonstrates that forgetting counts based CAMixup outperforms class based CAMixup on most metrics across BatchEnsemble and MC-dropout. One exception is that it underperforms on test calibration on MC-dropout. We could not observe the same improvement on CIFAR-100. We postulate that the reliability of forgetting count on CIFAR-100 is not as good as it is on CIFAR-10, leading to the inconsistent results. We leave the question on how to improve orgeting count based CAMixup on CIFAR-100 into future work. ",
+        "bbox": [
+            174,
+            652,
+            517,
+            797
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "table",
+        "img_path": "images/e0a6e7b0f48a9e0cdac0e1f5cee67a7ad9d807843fa3b701893d01c5b669585a.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm CAMixup</td><td>1Forgetting Count Based</td></tr><tr><td>initialize prevacci = O,i ∈ D initialize forgettingT[i]=O,i∈D initialize MixupCoeffli] = 0 while training do ApplyMixup MixupCoeff for example; ∈ B do compute acci end if end for rank = sort(T) threshold = rank[|D|//2] for example; ∈ B do else end if end for</td><td>B ~ D # sample a minibatch onB based if prevacci &gt; acci then T[i]=T[]+1 prevacci = acCi gradient update classifier on B if T[i] &gt;threshold then MixupCoeff[i] = a MixupCoeff[𝑖] = 0</td></tr></table>",
+        "bbox": [
+            531,
+            373,
+            825,
+            758
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            184,
+            791,
+            596,
+            805
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/48c4cc653f2fc176ffdc1bad559dbfb22e200b2cf241629db49fa1548ac8506b.jpg",
+        "image_caption": [
+            "Figure 13: Combining CAMixup and Temperature Scaling further improves test ECE. It does not make further improvements on out-of-distribution calibration however. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            258,
+            94,
+            736,
+            895
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/daf9fd143d0db37bed1038611e668ed8c4f6db601d7971c2dd568811b63bea74.jpg",
+        "image_caption": [
+            "Figure 14: WideResNet 28-10 on CIFAR-10 and CIFAR-10-C. Green: Class based CAMixup. Purple: Forgetting count based CAMixup. Forgetting count based CAMixup outperforms class based Mixup in most metrics across BatchEnsemble and MC-dropout. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            375,
+            816,
+            575
+        ],
+        "page_idx": 20
+    }
+]

parse/train/ppv5yqhpNyE/ppv5yqhpNyE.md

@@ -0,0 +1,289 @@
+# EditGAN: High-Precision Semantic Image Editing
+
+Huan Ling1,2,3,∗ Karsten Kreis1,∗ Daiqing Li 1
+
+Seung Wook Kim1,2,3 Antonio Torralba4 Sanja Fidler1,2,3
+
+1NVIDIA 2University of Toronto 3Vector Institute 4MIT
+
+{huling,kkreis,daiqingl,seungwookk,sfidler}@nvidia.com, torralba@mit.edu
+
+# Abstract
+
+Generative adversarial networks (GANs) have recently found applications in image editing. However, most GAN-based image editing methods often require large-scale datasets with semantic segmentation annotations for training, only provide high level control, or merely interpolate between different images. Here, we propose EditGAN, a novel method for high-quality, high-precision semantic image editing, allowing users to edit images by modifying their highly detailed part segmentation masks, e.g., drawing a new mask for the headlight of a car. EditGAN builds on a GAN framework that jointly models images and their semantic segmentations [1, 2], requiring only a handful of labeled examples – making it a scalable tool for editing. Specifically, we embed an image into the GAN’s latent space and perform conditional latent code optimization according to the segmentation edit, which effectively also modifies the image. To amortize optimization, we find “editing vectors” in latent space that realize the edits. The framework allows us to learn an arbitrary number of editing vectors, which can then be directly applied on other images at interactive rates. We experimentally show that EditGAN can manipulate images with an unprecedented level of detail and freedom, while preserving full image quality.We can also easily combine multiple edits and perform plausible edits beyond EditGAN’s training data. We demonstrate EditGAN on a wide variety of image types and quantitatively outperform several previous editing methods on standard editing benchmark tasks. Project page: https://nv-tlabs.github.io/editGAN.
+
+# 1 Introduction
+
+AI-driven photo and image editing has the potential to streamline the workflow of photographers and content creators and to enable new levels of creativity and digital artistry [3]. AI-based image editing tools have already found their way into consumer software in the form of neural photo editing filters, and the deep learning
+
+![](images/782f0d95cf6c1f39f92812cd3e25c760b0d31805d8af630f0f9c23dfff5334ad.jpg)  
+Figure 1: High-precision semantic image editing with EditGAN.
+
+research community is actively developing further techniques. A particularly promising line of research uses generative adversarial networks (GANs) [4, 5, 6, 7, 8] and either embeds images into the GAN’s latent space or works directly with GAN-generated images. Careful modifications of the latent embeddings then translate to desired changes in generated output, allowing, for example, to coherently change facial expressions in portraits [9, 10, 11, 12, 13, 14, 15, 16], change viewpoint or shapes and textures of cars [17], or to interpolate between different images in a semantically meaningful manner [18, 19, 20, 21].
+
+![](images/c899d3cd93c67236587887acfd6de43587f4198a2a8293fb1b4b06e06d566106.jpg)  
+Figure 2: (1) EditGAN builds on a GAN framework that jointly models images and their semantic segmentations. (2 & 3) Users can modify segmentation masks, based on which we perform optimization in the GAN’s latent space to realize the edit. (4) Users can perform editing simply by applying previously learnt editing vectors and manipulate images at interactive rates.
+
+Most GAN-based image editing methods fall into few categories. Some works rely on GANs conditioning on class labels or pixel-wise semantic segmentation annotations [19, 10, 22, 11], where different conditionings lead to modifications in the output, while others use auxiliary attribute classifiers [23, 15] to guide synthesis and edit images. However, training such conditional GANs or external classifiers requires large labeled datasets. Therefore, these methods are currently limited to image types for which large annotated datasets are available, like portraits [10]. Furthermore, even if annotations are available, most techniques offer only limited editing control, since these annotations usually consist only of high-level global attributes or relatively coarse pixel-wise segmentations. Another line of work focuses on mixing and interpolating features from different images [18, 19, 20, 21], thereby requiring reference images as editing targets and usually also not offering fine control. Other approaches carefully analyze and dissect GANs’ latent spaces, finding disentangled latent variables suitable for editing [24, 25, 12, 13, 14, 26, 27], or control the GANs’ network parameters [25, 28, 16]. Usually, these methods do not enable detailed editing and are often slow.
+
+In this work, we are addressing these limitations and propose EditGAN, a novel GAN-based image editing framework that enables high-precision semantic image editing by allowing users to modify detailed object part segmentations. EditGAN builds on a recently proposed GAN that jointly models both images and their semantic segmentations based on the same underlying latent code [1, 2], and requires as few as 16 labeled examples – allowing it to scale to many object classes and choices of part labels. We achieve editing by modifying the segmentation mask according to a desired edit and optimizing the latent code to be consistent with the new segmentation, thus effectively changing the RGB image. To achieve efficiency, we learn editing vectors in latent space that realize the edits, and that can be directly applied on other images, without any or only few additional optimization steps. We can thus pre-train a library of interesting edits that a user can directly utilize in an interactive tool.
+
+We apply EditGAN on a wide range of images, including images of cars, cats, birds, and human faces, demonstrating unprecedented high-precision editing. We perform quantitative comparisons to multiple baselines and outperform them in metrics such as identity preservation, quality preservation, and target attribute accuracy, while requiring orders of magnitude less annotated training data. EditGAN is the first GAN-driven image editing framework, which simultaneously (i) offers very highprecision editing, (ii) requires only very little annotated training data (and does not rely on external classifiers), (iii) can be run interactively in real time, (iv) allows for straightforward compositionality of multiple edits, (v) and works on real embedded, GAN-generated, and even out-of-domain images.
+
+# 2 Related Work
+
+Image Editing and Manipulation. Image Editing has a long history in computer vision and graphics, as well as machine learning [29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 18, 11, 28, 41, 42, 16]. Recently, deep generative models [4, 43, 44], in particular modern GANs [6, 45, 7, 46, 8], received much attention as a promising tool for efficient image editing, as it was found that latent space manipulations often lead to interpretable and predictable changes in output [47, 24, 48, 49, 26, 27, 50].
+
+GAN-based image editing methods can be broadly sorted into a number of categories. (i) One line of work relies on the careful dissection of the GAN’s latent space, aiming to find interpretable and disentangled latent variables, which can be leveraged for image editing, in a fully unsupervised manner [47, 24, 25, 12, 13, 14, 48, 49, 26, 27, 50, 51]. Although powerful, these approaches usually do not result in any high-precision editing capabilities. The editing vectors we are learning in EditGAN would be too hard to find independently without segmentation-based guidance. (ii) Other works utilize GANs that condition on class or pixel-wise semantic segmentation labels to control synthesis and achieve editing [9, 52, 46, 19, 10, 22, 11]. Hence, these works usually rely on large annotated datasets, which are often not available, and even if available, the possible editing operations are tied to whatever labels are available. This stands in stark contrast to EditGAN, which can be trained in a semi-supervised fashion with very little labeled data and where an arbitrary number of high-precision edits can be learnt. (iii) Furthermore, auxiliary attribute classifiers have been used for image manipulation [23, 15], thereby still relying on annotated data and usually only providing high-level control. (iv) Image editing is often explored in the context of “interpolating” between a target and different reference image in sophisticated ways, for example by replacing certain features in a given image with features from a reference images [18, 19, 20, 21]. From the general image editing perspective, the requirement of reference images limits the broad applicability of these techniques and prevents the user from performing specific, detailed edits for which potentially no reference images are available. (v) Recently, different works proposed to directly operate in the parameter space of the GAN instead of the latent space to realize different edits [25, 28, 16]. For example, [25, 28] essentially specialize the generator network for certain images at test time to aid image embedding or “rewrite” the network to achieve desired semantic changes in output. The drawback is that such specializations prevent the model from being used in real-time on different images and with different edits. [16] proposed an approach that more directly analyses the parameter space of a GAN and treats it as a latent space in which to apply edits. However, the method still merely discovers edits in the network’s parameter space, rather than actively defining them like we do. It remains unclear whether their method can combine multiple such edits, as we can, considering that they change the GAN parameters themselves. (vi) Finally, another line of research targets primarily very high-level image and photo stylization and global appearance modifications [37, 53, 54, 55, 52, 56, 46, 57, 41].
+
+Generally, most works only do relatively high-level and not the detailed, high-precision editing, which EditGAN targets. Hence, we consider EditGAN as complementary to this body of work.
+
+GANs and Latent Space Image Embedding. EditGAN builds on top of DatasetGAN [1] and SemanticGAN [2], which proposed to jointly model images and their semantic segmentations using shared latent codes. However, these works leveraged this model design only for semi-supervised learning, not for editing. EditGAN also relies on an encoder, together with optimization, to embed new images to be edited into the GAN’s latent space. This task in itself has been studied extensively in different contexts before, and we are building on these works. Previous papers studied encoder-based methods [58, 59, 60, 61, 62], used primarily optimization-based techniques [63, 64, 65, 66, 67, 68, 69, 26], and developed hybrid approaches [63, 24, 25, 70, 71].
+
+Finally, a concurrent paper [72] shares similarities with DatasetGAN [1], on which our method builds, and explores an editing approach related to our EditGAN as one of its applications. However, our editing approach is methodologically different and leverages editing vectors, and also demonstrates significantly more diverse and stronger experimental results. Furthermore, [73] shares some highlevel ideas with EditGAN; however, it leverages the CLIP [74] model and targets text-driven editing.
+
+# 3 High-Precision Semantic Image Editing with EditGAN
+
+# 3.1 Background
+
+EditGAN’s image generation component is StyleGAN2 [7, 8], currently the state-of-the-art GAN for image synthesis. The StyleGAN2 generator maps latent codes $\mathbf { z } \in { \mathcal { Z } }$ , drawn from a multivariate Normal distribution, into realistic images. A latent code $\mathbf { z }$ is first transformed into an intermediate code $\mathbf { w } \in \mathcal { W }$ by a non-linear mapping function and then further transformed into $K + 1$ vectors, $\mathbf { w } ^ { 0 } , . . . , \mathbf { w } ^ { K }$ , through learned affine transformations. These transformed latent codes are fed into synthesis blocks, whose outputs are deep feature maps.
+
+Deep generative models such as StyleGAN2, which are trained to synthesize highly realistic images, acquire a semantic understanding of the modeled images in their high-dimensional feature space. Recently, DatasetGAN [1] and SemanticGAN [2] built on this insight to learn a joint distribution $p ( \mathbf { x } , \mathbf { y } )$ over images $\mathbf { x }$ and pixel-wise semantic segmentation labels y, while requiring only a handful of labeled examples. EditGAN utilizes this joint distribution $p ( \mathbf { x } , \mathbf { y } )$ to perform high-precision semantic image editing of real and synthesized images.
+
+Both methods [1, 2] model $p ( \mathbf { x } , \mathbf { y } )$ by adding an additional segmentation branch to the image generator, which is a pre-trained StyleGAN [1]. We follow DatasetGAN [1], which applies a simple three-layer multi-layer perceptron classifier on the layer-wise concatenated and appropriately upsampled feature maps. This classifier operates on the concatenated feature maps in a per-pixel fashion and predicts the segmentation label of each pixel.
+
+# 3.2 Segmentation Training and Inference by Embedding Images into GAN’s Latent Space
+
+To both train the segmentation branch and perform segmentation on a new image, we embed an image into the GAN’s latent space using an encoder and optimization. To this end, we build on previous works [66, 62, 2] and train an encoder that embeds images into $\mathcal { W } ^ { + }$ space, which is defined as $\mathcal { W }$ but where the w’s are modeled independently [66, 62]. Our objectives to train this encoder consist of standard pixel-wise L2 and perceptual LPIPS reconstruction losses using both the real training data as well as samples from the GAN itself. For the GAN samples, we also explicitly regularize the encoder with the known underlying latent codes. In practice, we use the encoder to initialize images’ latent space embeddings and then iteratively refine the latent code $\mathbf { w } ^ { + }$ via optimization, again using standard reconstruction objectives.
+
+In that way, we embed the annotated images $\mathbf { x }$ from a dataset labeled with semantic segmentations into latent space, and train the segmentation branch of the generator using standard supervised learning objectives, i.e., the cross entropy loss. We keep the image generator’s weights frozen and only backpropagate the loss to the segmentation branch [1]. After training the segmentation branch, we can formally define a generator $\bar { \tilde { G } } : \mathcal { W } ^ { + }  \mathcal { X } , \mathcal { Y }$ that models the joint distribution $p ( \mathbf { x } , \mathbf { y } )$ of images $\mathbf { x }$ and semantic segmentations y. Details about encoder and segmentation branch training as well as optimization for image embedding can be found in the Appendix.
+
+# 3.3 Finding Semantics in Latent Space via Segmentation Editing
+
+The key idea of EditGAN lies in leveraging the joint distribution $p ( \mathbf { x } , \mathbf { y } )$ of images and semantic segmentations for high-precision image editing. Given a new image $\mathbf { x }$ to be edited, we can embed it into EditGAN’s $\mathcal { W } ^ { + }$ latent space, as described above (alternatively, we can also sample images from the model itself and use those). The segmentation branch will then generate the corresponding segmentation $\mathbf { y }$ , since segmentations and RGB im
+
+![](images/fb823d3601a32de596c1cacd81969ca423dc943ff186a4849f28d8fb75c7fe52.jpg)  
+Figure 3: We modify semantic segmentations and optimize the shared latent code for consistency with the new segmentation within the editing region, and with the RGB appearance outside the editing region. Corresponding gradients are backpropagated through the shared generator. The result is a latent space editing vector $\delta \mathbf { w } _ { \mathrm { e d i t } } ^ { + }$ .
+
+ages share the same latent codes $\mathbf { w } ^ { + }$ . Using simple interactive digital painting or labeling tools, we can now manually modify the segmentation according to a desired edit. We denote the edited segmentation mask by $\mathbf { y } _ { \mathrm { e d i t e d } }$ . Starting from the embedding $\mathbf { w } ^ { + }$ of the unedited image x and segmentation $\mathbf { y }$ , we can then perform optimization within $\mathcal { W } ^ { + }$ to find a new $\mathbf { w } _ { \mathrm { e d i t e d } } ^ { + } = \mathbf { w } ^ { + } + \delta \mathbf { w } _ { \mathrm { e d i t } } ^ { + }$ consistent with the new segmentation $\mathbf { y } _ { \mathrm { e d i t e d } }$ , while allowing the RGB output $\mathbf { x }$ to change within the editing region.
+
+Formally, we are seeking an editing vector $\delta \mathbf { w } _ { \mathrm { e d i t } } ^ { + } \in \mathcal { W } ^ { + }$ such that $( \mathbf { x } _ { \mathrm { e d i t e d } } , \mathbf { y } _ { \mathrm { e d i t e d } } ) = \tilde { G } ( \mathbf { w } ^ { + } + \delta \mathbf { w } _ { \mathrm { e d i t } } ^ { + } )$ where $\tilde { G }$ denotes the fixed generator that synthesizes both images and segmentations. Defining $( \mathbf { x } ^ { \prime } , \mathbf { y } ^ { \prime } ) = \tilde { G } ( \mathbf { w } ^ { + } + \delta \mathbf { w } ^ { + } )$ , we perform optimization to approximate $\delta \mathbf { w } _ { \mathrm { e d i t } } ^ { + }$ by $\delta \mathbf { w } ^ { + }$ . The region of interest $r$ within which we expect the image to change due to the edit is formally given by
+
+$$
+r = \left\{ p : c _ { p } ^ { \mathbf { y } } \in Q _ { \mathrm { e d i t } } \right\} \cup \left\{ p : c _ { p } ^ { \mathbf { y } _ { \mathrm { e d i t e d } } } \in Q _ { \mathrm { e d i t } } \right\}
+$$
+
+which means that $r$ is defined by all pixels $p$ whose part segmentation labels $c _ { p } ^ { \{ \mathbf { y } , \mathbf { y } _ { \mathrm { e d i t e d } } \} }$ according to either the initial segmentation $\mathbf { y }$ or the edited one $\mathbf { y } _ { \mathrm { e d i t e d } }$ are within an edit-specific pre-specified list
+
+$Q _ { \mathrm { e d i t } }$ of part labels relevant for the edit. For example, when modifying the wheel in a photo of a car $Q _ { \mathrm { e d i t } }$ would contain all part labels related to the wheels, such as tire, spoke, and wheelhub (see Fig. 3). We use a further buffer of 5 pixels to give the GAN freedom in modeling the transition between the edited and non-edited area. In practice, $r$ acts as a binary pixel-wise mask (see Eqs. 2 and 3 below).
+
+Note that $\mathbf { x } _ { \mathrm { e d i t e d } }$ is not available during optimization. After all, $\mathbf { x } _ { \mathrm { e d i t e d } }$ is the edited image we are ultimately intested in. It emerges indirectly when optimizing for the segmentation modification, since images and segmentations are closely tied together in the joint distribution $p ( \mathbf { x } , \mathbf { y } )$ modeled by $\tilde { G }$ We further define $\mathbf { x } ^ { \prime } = \tilde { G } ^ { \mathbf { x } } ( \mathbf { w } ^ { + } + \delta \mathbf { w } ^ { + } )$ as $\tilde { G }$ ’s image generation and $\mathbf { y } ^ { \prime } = \tilde { G } ^ { \mathbf { y } } ( \mathbf { w } ^ { + } + \delta \mathbf { w } ^ { + } )$ as $\tilde { G }$ ’s segmentation generation branch.
+
+To find $\delta \mathbf { w } ^ { + }$ , approximating $\delta \mathbf { w } _ { \mathrm { e d i t } } ^ { + }$ , we use the following losses as minimization targets:
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { \mathrm { R G B } } ( \delta \mathbf { w } ^ { + } ) = L _ { \mathrm { L P I P S } } ( \tilde { G } ^ { \mathbf { x } } ( \mathbf { w } ^ { + } + \delta \mathbf { w } ^ { + } ) \odot ( 1 - r ) , \ \mathbf { x } \odot ( 1 - r ) ) } \\ & { \qquad + L _ { L 2 } ( \tilde { G } ^ { \mathbf { x } } ( \mathbf { w } ^ { + } + \delta \mathbf { w } ^ { + } ) \odot ( 1 - r ) , \ \mathbf { x } \odot ( 1 - r ) ) } \end{array}
+$$
+
+$$
+\begin{array} { r } { \mathcal { L } _ { \mathrm { C E } } \big ( \delta \mathbf { w } ^ { + } \big ) = H \big ( \tilde { G } ^ { \mathbf { y } } \big ( \mathbf { w } ^ { + } + \delta \mathbf { w } ^ { + } \big ) \odot r , \ \mathbf { y } _ { \mathrm { e d i t e d } } \odot r \big ) } \end{array}
+$$
+
+where $H$ denotes the pixel-wise cross-entropy, $L _ { \mathrm { L P I P S } }$ loss is based on the Learned Perceptual Image Patch Similarity (LPIPS) distance [75], and $L _ { L 2 }$ is a regular pixel-wise L2 loss. $\mathcal { L } _ { \mathrm { R G B } } ( \delta \mathbf { \bar { w } } ^ { + } )$ ensures that the image appearance does not change outside the region of interest, while $\mathcal { L } _ { \mathrm { C E } } ( \delta \mathbf { w } ^ { + } )$ ensures that the target segmentation $\mathbf { y } _ { \mathrm { e d i t e d } }$ is enforced within the editing region (see visualization in Fig. 3). When editing human faces, we also apply the identity loss [62]:
+
+$$
+\begin{array} { r } { \mathcal { L } _ { \mathrm { I D } } ( \delta \mathbf { w } ^ { + } ) = \langle R ( \tilde { G } ^ { \mathbf { x } } ( \mathbf { w } ^ { + } + \delta \mathbf { w } ^ { + } ) ) , R ( \mathbf { x } ) \rangle } \end{array}
+$$
+
+with $R$ denoting the pretrained ArcFace feature extraction network [76] and $\langle \cdot , \cdot \rangle$ cosine-similiarity. The final objective function for optimization then becomes:
+
+$$
+\begin{array} { r } { \mathcal { L } _ { \mathrm { e d i t i n g } } ( \delta \mathbf { w } ^ { + } ) = \lambda _ { 1 } ^ { \mathrm { e d i t i n g } } \mathcal { L } _ { \mathrm { R G B } } ( \delta \mathbf { w } ^ { + } ) + \lambda _ { 2 } ^ { \mathrm { e d t i n g } } \mathcal { L } _ { \mathrm { C E } } ( \delta \mathbf { w } ^ { + } ) + \lambda _ { 3 } ^ { \mathrm { e d t i n g } } \mathcal { L } _ { \mathrm { I D } } ( \delta \mathbf { w } ^ { + } ) } \end{array}
+$$
+
+with hyperparameters $\lambda _ { 1 , \dots , 3 } ^ { \mathrm { e d i t i n g } }$ . The only “learnable” variable is the editing vector $\delta \mathbf { w } ^ { + }$ ; all neural networks are kept fixed. After optimizing $\delta \mathbf { w } ^ { + }$ with the objective function, we can use $\delta \mathbf { w } ^ { + } \approx \delta \mathbf { w } _ { \mathrm { e d i t } } ^ { + }$ Note that there is a certain amount of ambiguity in how the segmentation modification is realized in RGB output. We rely on the GAN generator, trained to synthesize realistic images, to modify the RGB values in the editing region in a plausible way consistent with the segmentation edit.
+
+# 3.4 Different Ways of Editing during Inference
+
+The latent space editing vectors $\delta \mathbf { w } _ { \mathrm { e d i t } } ^ { + }$ obtained by optimization as described are semantically meaningful and often disentangled with other attributes. Therefore, for new images $\mathbf { x }$ to be edited, we can embed the images into the $\mathcal { W } ^ { + }$ latent space and the same editing operations can be directly performed by applying the previously learnt $\delta \mathbf { w } _ { \mathrm { e d i t } } ^ { + }$ as $( \mathbf { x } ^ { \prime } , \mathbf { y } ^ { \prime } ) = G ( \mathbf { w } ^ { + } + s _ { \mathrm { e d i t } } \delta \mathbf { w } _ { \mathrm { e d i t } } ^ { + } )$ without doing any optimization from scratch again. In other words, the learnt editing vectors $\bar { \delta } \bar { \mathbf { w } } ^ { + }$ amortize the iterative optimization that was necessary to achieve the edit initially. For well-disentangled editing operations, $\mathbf { x } ^ { \prime }$ can be used directly as the edited image $\mathbf { x } _ { \mathrm { e d i t e d } }$ . Note that we introduced $s _ { \mathrm { e d i t } }$ , a scalar editing coefficient, which effectively scales and controls the editing magnitude during inference. For $s _ { \mathrm { e d i t } } = 0$ , we do not do any editing at all, while for $s _ { \mathrm { e d i t } } > 1$ we manipulate the images with an effectively larger editing operation in latent space, leading to exaggerated effects.
+
+Unfortunately, disentanglement is not always perfect and the editing vectors $\delta \mathbf { w } _ { \mathrm { e d i t } } ^ { + }$ do not always translate perfectly to other images. We can remove editing artifacts in other regions of the image by a few additional optimization steps at test time. Specifically, we can use the exact same minimization obas s as above, using the initial prediction . This assumes that the editing vector $\mathbf { y } ^ { \prime }$ , obtained after applying the editing vector ll induces a plausible segmentation chang $\delta \mathbf { w } _ { \mathrm { e d i t } } ^ { + }$ $\mathbf { y } _ { \mathrm { e d i t e d } }$   
+applied on other images and that artifacts only arise in RGB output. The RGB objective $\mathcal { L } _ { \mathrm { { R G B } } }$ then removes these editing artifacts outside the editing region, while $\mathcal { L } _ { \mathrm { C E } }$ ensures that the modified segmentation stays as predicted by the editing vector.
+
+Summarizing, we can perform image editing with EditGAN in three different modes:
+
+• Real-time Editing with Editing Vectors. For localized, well-disentangled edits we perform editing purely by applying previously learnt editing vectors with varying scales $s _ { \mathrm { e d i t } }$ and manipulate images at interactive rates.
+
+![](images/742a614d56b78b2c1585a7e070b2c2ba2262df73e8b0ab63e51925ccf624d04e.jpg)  
+Figure 4: Examples of segmentation-driven edits with EditGAN. Results are based on editing with editing vectors and 30 steps self-supervised refinement. Blue boxes: Original images. Orange boxes: Zoom-in views.
+
+• Vector-based Editing with Self-Supervised Refinement. For localized edits that are not perfectly disentangled with other parts of the image, we can remove editing artifacts by additional optimization at test time, while initializing the edit using the learnt editing vectors. • Optimization-based Editing. Image-specific and very large edits do not transfer to other images via editing vectors. For such operations, we perform optimization from scratch.
+
+# 4 Experiments
+
+We extensively evaluate EditGAN on images across four different categories: Cars ( $3 8 4 \times 5 1 2$ spatial resolution), Birds $( 5 1 2 \times 5 1 2 )$ , Cats $( 2 5 6 \times 2 5 6 )$ , and Faces $( 1 0 2 4 \times 1 0 2 4 )$ .
+
+Implementation We train our segmentation branch as described in Sec. 3.2 using 16, 16, 30, and 30 image-mask pairs as labeled training data for Faces, Cars, Birds, and Cats, respectively. We utilize very highly-detailed part segmentations from [1]. The annotation scheme for faces is shown in Fig. 7, all others are presented in the Appendix. When editing is done purely optimization-based or when learning the editing vectors, we always perform 100 steps of optimization using Adam [77]. For Car, Cat, and Faces, we use real images from DatasetGAN’s test set that were not part of GAN training to demonstrate editing functionality. These images are first embedded into EditGAN’s latent space via an encoder and optimization as described in Sec. 3.2. For Birds, we show editing on GAN-generated images. Model details and hyperparameters are provided in the Appendix.
+
+# 4.1 Qualitative Results
+
+In-Domain Results In Fig. 4, we demonstrate our EditGAN framework when applying previously learnt editing vectors $\delta \mathbf { w } _ { \mathrm { e d i t } } ^ { + }$ on novel images and refining with 30 steps of optimization. Our editing operations preserve high image quality and are well disentangled for all classes. We also show the ability to combine multiple different edits in Fig. 5. To the best of our knowledge, no previous methods can perform as complex and high-precision edits as we do, while preserving image quality and subject identity. In Fig. 8, we demonstrate that we can even perform extremely high-precision edits, such as rotating a car’s wheel spoke or dilating pupils. EditGAN can edit semantic parts of objects that consist of only few pixels. At the same time, we can use EditGAN to perform large-scale modifications, too: In Fig. 9, we present how we can remove the entire roof of a car or convert it to a station wagon-like vehicle, simply by modifying the segmentation mask accordingly and optimizing. It is worth noting that several of our editing operations generate plausible manipulated images unlike those appearing in the GAN training data. For example, the training data does not include cats with overly large eyes or ears. Nevertheless, we achieve such edits in a high-quality manner.
+
+![](images/af4bf814241ab3da1430ddc5310405757b5f5cc1f2f6882f1581f9a97675afad.jpg)  
+Figure 5: We combine multiple edits. Results are based on editing with editing vectors and 30 steps selfsupervised refinement. Blue boxes: Original images. Edits in detail: Second row, first person: open eyes, add hair, add mustache. Second person: smile, look left. Third row, first car: remove mirror, remove door handle, shrink wheels. Second car: remove license plate, enlarge wheels. Third row, bird: longer beak, bigger belly, head up. Third row, cat: open mouth, bigger ear, bigger eyes.
+
+The edits in Figs. 4, 5 and 8 are based on learnt editing vectors with self-supervised refinement. However, without such refinement usually only very minor artifacts occur, as shown in Fig. 10, hence allowing for real-time high-precision semantic image editing (discussed in detail below).
+
+Out-of-Domain Results We demonstrate the generalization capability of EditGAN to out-ofdomain data on the MetFaces [8] data set. We use our EditGAN model trained on FFHQ [8], and create editing vectors $\delta \mathbf { w } _ { \mathrm { e d i t } } ^ { + }$ using in-domain real faces. We then embed out-of-domain MetFaces partraits (with 100 steps optimization) and apply the editing vectors with 30 steps self-supervised refinement. The results are shown in Fig. 6. We find that our editing operations seamlessly translate even to such far out-of-domain examples.
+
+# 4.2 Quantitative Results
+
+To quantitatively measure EditGAN’s image editing capabilities, we use the smile edit benchmark introduced by MaskGAN [10]. Faces with neutral expressions are converted into smiling faces and performance is measured by three metrics: a. Semantic Correctness: Using a pre-trained smile attribute classifier, we measure whether the faces show smiling expressions after editing. b. Distribution-level Image Quality: Frechet Inception Distance (FID) [78, 79] and Kernel Inception Distance (KID) [80] are calculated between 400 edited test images and the CelebA-HD test dataset. c.
+
+![](images/a61605ec5f7b2608b329439b051ff89b4dd3b4fd77ff0d41e5416083b44f10ec.jpg)  
+Figure 6: We combine multiple edits on out-of-domain images. Results are based on editing with editing vectors and 30 steps self-supervised refinement. Edits in detail: First row, first example: look left, frown. Second example: smile, look right. Second row, first example: open eyes, lift eyebrow. Second example: open eyes.
+
+Identity Preservation: Using the pretrained ArcFace feature extraction network [76], we measure whether the subjects’ identity is maintained when applying the edit. Specifically, we report cosinesimiliarity between original and edited images. Further details can be found in the Appendix.
+
+For our EditGAN, we simply learn a smiling editing vector $\delta \mathbf { w } _ { \mathrm { e d i t } } ^ { + }$ using a hold-out neutral expression face image. We embed it into EditGAN, infer its pixel-wise segmentation labels, and manually modify the segmentation towards a smile. Then we perform optimization in latent space, as described above, to learn the editing vector. For the results in Tab. 1, it is applied with unit scale $s _ { \mathrm { e d i t } } { = } 1$ on new images. We do
+
+<table><tr><td>Metric</td><td>Annot.</td><td>#Mask #Attribute Annot.</td><td>Attribute Acc.(%)↑</td><td>FID↓</td><td>KID↓</td><td>ID Score ↑</td></tr><tr><td>MaskGAN [10]</td><td>30.000</td><td></td><td>77.3</td><td></td><td>46.84 0.020</td><td>0.4611</td></tr><tr><td>LocalEditing [18]</td><td>-</td><td></td><td>26.0</td><td>41.26</td><td>0.012</td><td>0.5823</td></tr><tr><td>LocalEditing - Encoding4Editing [81]</td><td>-</td><td>-</td><td>41.75</td><td>48.28</td><td>0.016</td><td>0.6603</td></tr><tr><td>InterFaceGAN [13]</td><td>-</td><td>30.000</td><td>83.5</td><td>39.42</td><td>0.010</td><td>0.7295</td></tr><tr><td>EditGAN (ours)</td><td>16</td><td>-</td><td>91.5</td><td>41.74</td><td>0.013</td><td>0.7047</td></tr><tr><td>EditGAN+30 (ours)</td><td>16</td><td>-</td><td>85.8</td><td>40.83</td><td>0.012</td><td>0.7452</td></tr><tr><td>StyleGAN2 Distillation [82]</td><td>-</td><td>30.000</td><td>98.3</td><td>45.09 0.013</td><td></td><td>0.7823</td></tr></table>
+
+Table 1: Quantitative comparisons to multiple baselines on the smile edit benchmark.
+
+not use the identity loss (Eq. 4) in this experiment, since identity preservation is already a target metric itself. We compare our method with three strong baselines: (i) $M a s k G A N ^ { 2 }$ [10]: It takes non-smiling images, their segmentation masks, and a target smiling segmentation mask as inputs. Note that training MaskGAN requires large annotated datasets, in contrast to us. We also compare to (ii) LocalEditing3 [18]: It clusters GAN features to achieve local editing and relies on reference images, in this case images of faces with smiling expressions. Another baseline we use is (iii) InterFace $G A N ^ { 4 }$ [13]: Similar to EditGAN, InterFaceGAN aims at finding editing vectors in latent space. However, it uses auxiliary attribute classifiers, relies on large annotated datasets, and can generally not achieve the fine editing control of our EditGAN. Finally, we compare to (iv) StyleGAN2 Distillation5 [82], which creates an alternative approach that does not require real image embeddings and also relies on an editing-vector model to create a training dataset.
+
+Results are reported in Tab. 1. Using 1, $8 7 5 \times$ less training labels, we outperform MaskGAN on all three metrics. We similarly obtain significantly stronger results than LocalEditing. In our observation, LocalEditing does not work well on real image embeddings. We further exploit a better encoder [81] for the LocalEditing baseline, which leads to a significant improvement in attribute accuracy and ID score, but slightly worse FID & KID scores. We find that EditGAN outperforms InterFaceGAN on identity preservation and attribute classification accuracy, while InterFaceGAN reaches slightly better FID & KID scores (for the results in Tab. 1, the latent space edits learnt by InterfaceGAN are also applied with unit scale, like for EditGAN). In Fig. 11, we report a more detailed comparison to InterFaceGAN, where we apply the smile editing vectors with different scale coefficients from zero to two. As shown, when the editing vector scale is small, the identity score is high while the smiling attribute score is low, since the modification of the original images is minimal. We find that our realtime editing with editing vectors is on-par with InterFaceGAN. When we perform self-supervised refinement at test time, EditGAN outperforms InterFaceGAN. In Tab. 1, we also compare with StyleGAN2 Distillation [82], which achieves strong performance. However, StyleGAN2 Distillation relies on pre-trained classifiers, like InterfaceGAN, and only enables relatively high-level editing of image attributes for which large-scale annotations exit. Moreover, it distills edits into separate Pixel2PixelHD networks, such that a new network needs to be trained for each edit, limiting broad, user-interactive applicability. Hence, we consider StyleGAN2 Distillation orthogonal to our EditGAN.
+
+![](images/82aed2cce7459a336ae87233a9042f1ee642601d6b485bb205aecab5ad27d17e.jpg)  
+Figure 7: Face part labeling schema [1].
+
+![](images/ec5e57176ee9dd96a0c35e7e44b1e68c3c05f10a2598c6a27b653ace1bbfbc45.jpg)  
+Figure 8: High-precision editing with EditGAN for extreme details. Left: We rotate Rotate Wheel Spoke Change pupil Sizethe spoke. Right: We modify pupil size. Results are based on editing with editing vectors and 30 steps self-supervised refinement.
+
+![](images/40b140c5ee1e246522137b6ac9a2945eff98f726b22711f6d4416174a8e77e7b.jpg)  
+Figure 9: Pure optimization-based editing. We demonstrate large-scale semantic edits that do not transfer seamlessly to other images via editing vectors. Hence, we perform optimization from scratch.
+
+![](images/a1abbd5adb6d1505d2819a994d24a10e48d6a51e57149c772524e86d426ec6f8.jpg)  
+Figure 10: Left: We apply learnt editing vectors with varying scales (see 5 markers in FID plots) both without (top row for each class) and with (bottom row for each class) additional 30-step self-supervised refinement to correct artifacts. Red boxes denote original images. For each class, the leftmost image is the one used to learn the editing vector, with the editing result next to it and orginal and modified segmentations below. Right: Visual quality after editing with different scales as measured by FID with and without refinement.
+
+Running Time We carefully measure the run time of our editing on an NVIDIA Tesla V100 GPU. Conditional optimization, given an edited segmentation mask, with 30 (60) optimization steps takes 11.4 (18.9) seconds. This operation provides us the editing vector. Application of editing vectors is almost instantaneous, taking only 0.4 seconds, therefore allowing for complex real-time interactive editing. A 10 (30) step self-supervised refinement would add an additional 4.2 (9.5) seconds.
+
+# 4.3 Ablation Studies: Self-Supervised Refinement and Editing Vector Scale
+
+Fig. 11 also contains a quantitative ablation study on the number of additional optimization steps done when initializing an edit with a learnt editing vector and refining with additional optimization. Generally, the more refinement steps we perform, the better the performance our model can achieve. As shown in Fig. 11, we find that further optimization can indeed slightly improve performance. Specifically, here we improve the trade-off between maintaining identity and achieving the desired semantic operation when performing editing with different scalings $s _ { \mathrm { e d i t } }$ of the editing vector. However, performing many steps of optimization leads to a run-time vs. performance trade-off, and our results suggest that the improvement beyond 30 additional optimization steps becomes marginal.
+
+In Fig. 10, we analyze the editing vector scale and self-supervised refinement visually and with respect to perceptual metrics. As highlighted in the zoom-in areas, small artifacts can appear due to imperfect disentanglement in latent space when applying editing operations with large scales. Self-supervised refinement successfully cleans these editing errors up. We also apply the same edit with different scales on 400 test images and measure FID with respect to 10,000 data from GAN training, inspired by the analyses in [16]. We can clearly see that image quality degrades as measured by FID, the stronger the edit is applied. We also observe small improvements with the iterative refinement on this metric, although the difference is small. Further details are in the Appendix. We conclude that for most editing operations, real-time editing without iterative refinement already performs very well. However, to clean up artifacts and maintain highest image quality possible, self-supervised refinement with a couple of additional optimization steps is always available.
+
+Additional experiments are presented in the Appendix.
+
+# 5 Conclusions
+
+Limitations Like all GAN-based image editing methods, EditGAN is limited to images that can be modeled by the GAN. This makes EditGAN’s application on, for instance, photos of vivid city scenes challenging. Although most of our high-precision edits readily transfer to other images via learnt editing vectors, we also encountered challenging edits that required iterative optimization on each example. Future research therefore includes speeding up the optimization for such edits as well as building better generative models with more disentangled latent spaces.
+
+![](images/690211948c1cfdaeb4947e26111732183937f423e3528f4344ff12d15a1cbf6a.jpg)  
+Figure 11: InterFaceGAN’s and EditGAN’s performance on the smile edit benchmark for different editing vector scalings (scale increases from top-left points towards bottomright points; see main text and Appendix for details). For EditGAN, we optionally add 10, 30 or 60 additional optimization steps.
+
+Summary We propose EditGAN, a novel method for high-precision, high-quality semantic image editing. It relies on a GAN that jointly models RGB images and their pixel-wise semantic segmentations and that requires only very few annotated data for training. Editing is achieved by performing optimization in latent space while conditioning on edited segmentation masks. This optimization can be amortized into editing vectors in latent space, which can be applied on other images directly, allowing for real-time interactive editing without any or only little further optimization. We demonstrate a broad variety of editing operations on different kinds of images, achieving an unprecedented level of flexibility and freedom in terms of editing, while preserving high image quality.
+
+# 6 Broader Impact
+
+Where previous generative modeling-based image editing methods offer only limited high-level editing capabilities, our method provides users unprecedented high-precision semantic editing possibilities. Our proposed techniques can be used for artistic purposes and creative expression and benefit designers, photographers, and content creators [3]. AI-driven image editing tools like ours promise to democratize high-quality image editing. Related methods have already found their way into everyday applications in the form of neural photo editing filters. On a larger scale, the ability to synthesize data with specific attributes can be leveraged in training and finetuning machine learning models.
+
+At the same time, more precise photo editing also offers opportunities for advanced photo manipulation for nefarious purposes. The recent progress of generative models and AI-driven photo editing has profound implications on image authenticity and beyond, which is an area of active debate [83]. As one potential way to tackle these challenges, methods for automatically validating real images and detecting manipulated or fake images are being developed by the research community [84, 85]. Furthermore, generative models like ours are usually only as good as the data they were trained on. Therefore, biases in the underlying datasets are still present in the synthesized images and preserved even when applying our proposed editing methods. It is therefore important to be aware of such biases in the underlying data and counteract them, for example by actively collecting more representative data or by using bias correction methods, an area of active research [86, 87, 88, 89].
+
+# Funding Statement
+
+This work was funded by NVIDIA. Huan Ling and Seung Wook Kim acknowledge additional revenue in the form of student scholarships from University of Toronto and the Vector Institute, which are not in direct support of this work.
+
+# References
+
+[1] Yuxuan Zhang, Huan Ling, Jun Gao, Kangxue Yin, Jean-Francois Lafleche, Adela Barriuso, Antonio Torralba, and Sanja Fidler. Datasetgan: Efficient labeled data factory with minimal human effort. arXiv preprint arXiv:2104.06490, 2021.   
+[2] Daiqing Li, Junlin Yang, Karsten Kreis, Antonio Torralba, and Sanja Fidler. Semantic segmentation with generative models: Semi-supervised learning and strong out-of-domain generalization. arXiv preprint arXiv:2104.05833, 2021.   
+[3] J. Bailey. The tools of generative art, from flash to neural networks. Art in America, 2020.   
+[4] Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pages 2672–2680, 2014.   
+[5] Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.   
+[6] Tero Karras, Timo Aila, Samuli Laine, and Jaakko Lehtinen. Progressive growing of gans for improved quality, stability, and variation. arXiv preprint arXiv:1710.10196, 2017.   
+[7] Tero Karras, Samuli Laine, and Timo Aila. A style-based generator architecture for generative adversarial networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4401–4410, 2019.   
+[8] Tero Karras, Samuli Laine, Miika Aittala, Janne Hellsten, Jaakko Lehtinen, and Timo Aila. Analyzing and improving the image quality of stylegan. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 8110–8119, 2020.   
+[9] Yunjey Choi, Minje Choi, Munyoung Kim, Jung-Woo Ha, Sunghun Kim, and Jaegul Choo. Stargan: Unified generative adversarial networks for multi-domain image-to-image translation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2018.   
+[10] Cheng-Han Lee, Ziwei Liu, Lingyun Wu, and Ping Luo. Maskgan: Towards diverse and interactive facial image manipulation. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.   
+[11] Rongliang Wu, Gongjie Zhang, Shijian Lu, and Tao Chen. Cascade ef-gan: Progressive facial expression editing with local focuses. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.   
+[12] Yujun Shen, Jinjin Gu, Xiaoou Tang, and Bolei Zhou. Interpreting the latent space of gans for semantic face editing. In CVPR, 2020.   
+[13] Yujun Shen, Ceyuan Yang, Xiaoou Tang, and Bolei Zhou. Interfacegan: Interpreting the disentangled face representation learned by gans. TPAMI, 2020.   
+[14] Yazeed Alharbi and Peter Wonka. Disentangled image generation through structured noise injection. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.   
+[15] Xianxu Hou, Xiaokang Zhang, Linlin Shen, Zhihui Lai, and Jun Wan. Guidedstyle: Attribute knowledge guided style manipulation for semantic face editing. arXiv preprint arXiv:2012.11856, 2020.   
+[16] Anton Cherepkov, Andrey Voynov, and Artem Babenko. Navigating the gan parameter space for semantic image editing. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2021.   
+[17] Yuxuan Zhang, Wenzheng Chen, Huan Ling, Jun Gao, Yinan Zhang, Antonio Torralba, and Sanja Fidler. Image gans meet differentiable rendering for inverse graphics and interpretable 3d neural rendering. arXiv preprint arXiv:2010.09125, 2020.   
+[18] Edo Collins, Raja Bala, Bob Price, and Sabine Süsstrunk. Editing in style: Uncovering the local semantics of GANs. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.   
+[19] Peihao Zhu, Rameen Abdal, Yipeng Qin, and Peter Wonka. Sean: Image synthesis with semantic regionadaptive normalization. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.   
+[20] Kathleen M Lewis, Srivatsan Varadharajan, and Ira Kemelmacher-Shlizerman. Vogue: Try-on by stylegan interpolation optimization. arXiv preprint arXiv:2101.02285, 2021.   
+[21] Hyunsu Kim, Yunjey Choi, Junho Kim, Sungjoo Yoo, and Youngjung Uh. Exploiting spatial dimensions of latent in gan for real-time image editing. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2021.   
+[22] Shu-Yu Chen, Wanchao Su, Lin Gao, Shihong Xia, and Hongbo Fu. Deepfacedrawing: Deep generation of face images from sketches. ACM Trans. Graph., 39(4), 2020.   
+[23] Z. He, W. Zuo, M. Kan, S. Shan, and X. Chen. Attgan: Facial attribute editing by only changing what you want. IEEE Transactions on Image Processing, 28(11):5464–5478, Nov 2019.   
+[24] David Bau, Jun-Yan Zhu, Hendrik Strobelt, Bolei Zhou, Joshua B. Tenenbaum, William T. Freeman, and Antonio Torralba. Gan dissection: Visualizing and understanding generative adversarial networks. In Proceedings of the International Conference on Learning Representations (ICLR), 2019.   
+[25] David Bau, Hendrik Strobelt, William Peebles, Jonas Wulff, Bolei Zhou, Jun-Yan Zhu, and Antonio Torralba. Semantic photo manipulation with a generative image prior. ACM Trans. Graph., 38(4), 2019.   
+[26] Antoine Plumerault, Hervé Le Borgne, and Céline Hudelot. Controlling generative models with continuous factors of variations. In International Conference on Learning Representations, 2020.   
+[27] Erik Härkönen, Aaron Hertzmann, Jaakko Lehtinen, and Sylvain Paris. Ganspace: Discovering interpretable gan controls. In Proc. NeurIPS, 2020.   
+[28] David Bau, Steven Liu, Tongzhou Wang, Jun-Yan Zhu, and Antonio Torralba. Rewriting a deep generative model. In Proceedings of the European Conference on Computer Vision (ECCV), 2020.   
+[29] George Wolberg. Digital Image Warping. IEEE Computer Society Press, Washington, DC, USA, 1st edition, 1994.   
+[30] Alexei A. Efros and William T. Freeman. Image quilting for texture synthesis and transfer. SIGGRAPH ’01, page 341–346, New York, NY, USA, 2001. Association for Computing Machinery.   
+[31] Aaron Hertzmann, Charles E. Jacobs, Nuria Oliver, Brian Curless, and David H. Salesin. Image analogies. In Proceedings of the 28th Annual Conference on Computer Graphics and Interactive Techniques, SIGGRAPH ’01, page 327–340, New York, NY, USA, 2001. Association for Computing Machinery.   
+[32] E. Reinhard, M. Adhikhmin, B. Gooch, and P. Shirley. Color transfer between images. IEEE Computer Graphics and Applications, 21(5):34–41, 2001.   
+[33] Patrick Pérez, Michel Gangnet, and Andrew Blake. Poisson image editing. SIGGRAPH ’03, page 313–318, New York, NY, USA, 2003. Association for Computing Machinery.   
+[34] Scott Schaefer, Travis McPhail, and Joe Warren. Image deformation using moving least squares. ACM Trans. Graph., 25(3):533–540, 2006.   
+[35] Connelly Barnes, Eli Shechtman, Adam Finkelstein, and Dan B Goldman. Patchmatch: A randomized correspondence algorithm for structural image editing. ACM Trans. Graph., 28(3), 2009.   
+[36] Michael W. Tao, Micah K. Johnson, and Sylvain Paris. Error-tolerant image compositing. In ECCV, 2010.   
+[37] Leon A. Gatys, Alexander S. Ecker, and Matthias Bethge. Image style transfer using convolutional neural networks. In 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016.   
+[38] Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. In Proceedings of the IEEE international conference on computer vision, pages 2223–2232, 2017.   
+[39] Tiziano Portenier, Qiyang Hu, Attila Szabó, Siavash Arjomand Bigdeli, Paolo Favaro, and Matthias Zwicker. Faceshop: Deep sketch-based face image editing. ACM Trans. Graph., 37(4), 2018.   
+[40] Huan Ling, David Acuna, Karsten Kreis, Seung Wook Kim, and Sanja Fidler. Variational amodal object completion. Advances in Neural Information Processing Systems, 2020.   
+[41] Taesung Park, Jun-Yan Zhu, Oliver Wang, Jingwan Lu, Eli Shechtman, Alexei A. Efros, and Richard Zhang. Swapping autoencoder for deep image manipulation. In Advances in Neural Information Processing Systems, 2020.   
+[42] Seung Wook Kim, Jonah Philion, Antonio Torralba, and Sanja Fidler. DriveGAN: Towards a Controllable High-Quality Neural Simulation. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2021.   
+[43] Diederik P Kingma and Max Welling. Auto-encoding variational bayes. In The International Conference on Learning Representations (ICLR), 2014.   
+[44] Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In International Conference on Machine Learning, pages 1278–1286, 2014.   
+[45] Andrew Brock, Jeff Donahue, and Karen Simonyan. Large scale GAN training for high fidelity natural image synthesis. In International Conference on Learning Representations, 2019.   
+[46] Taesung Park, Ming-Yu Liu, Ting-Chun Wang, and Jun-Yan Zhu. Semantic image synthesis with spatiallyadaptive normalization. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 2337–2346, 2019.   
+[47] Lore Goetschalckx, Alex Andonian, Aude Oliva, and Phillip Isola. Ganalyze: Toward visual definitions of cognitive image properties. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), October 2019.   
+[48] Ali Jahanian\*, Lucy Chai\*, and Phillip Isola. On the "steerability" of generative adversarial networks. In International Conference on Learning Representations, 2020.   
+[49] Andrey Voynov and Artem Babenko. Unsupervised discovery of interpretable directions in the gan latent space. In International Conference on Machine Learning, pages 9786–9796. PMLR, 2020.   
+[50] Binxu Wang and Carlos R Ponce. A geometric analysis of deep generative image models and its applications. In International Conference on Learning Representations, 2021.   
+[51] Yujun Shen and Bolei Zhou. Closed-form factorization of latent semantics in gans. In CVPR, 2021.   
+[52] Ting-Chun Wang, Ming-Yu Liu, Jun-Yan Zhu, Andrew Tao, Jan Kautz, and Bryan Catanzaro. Highresolution image synthesis and semantic manipulation with conditional gans. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 8798–8807, 2018.   
+[53] Fujun Luan, Sylvain Paris, Eli Shechtman, and Kavita Bala. Deep photo style transfer. In 2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2017.   
+[54] Ming-Yu Liu, Thomas Breuel, and Jan Kautz. Unsupervised image-to-image translation networks. In Advances in neural information processing systems, pages 700–708, 2017.   
+[55] Yijun Li, Ming-Yu Liu, Xueting Li, Ming-Hsuan Yang, and Jan Kautz. A closed-form solution to photorealistic image stylization. In Proceedings of the European Conference on Computer Vision (ECCV), 2018.   
+[56] H. Kazemi, S. Iranmanesh, and N. Nasrabadi. Style and content disentanglement in generative adversarial networks. In 2019 IEEE Winter Conference on Applications of Computer Vision (WACV), pages 848–856, Los Alamitos, CA, USA, jan 2019. IEEE Computer Society.   
+[57] Jaejun Yoo, Youngjung Uh, Sanghyuk Chun, Byeongkyu Kang, and Jung-Woo Ha. Photorealistic style transfer via wavelet transforms. In 2019 IEEE/CVF International Conference on Computer Vision (ICCV), 2019.   
+[58] Guim Perarnau, Joost van de Weijer, Bogdan Raducanu, and Jose M. Álvarez. Invertible conditional gans for image editing. arXiv preprint arXiv:1611.06355, 2016.   
+[59] Jeff Donahue, Philipp Krähenbühl, and Trevor Darrell. Adversarial feature learning. arXiv preprint arXiv:1605.09782, 2016.   
+[60] Andrew Brock, Theodore Lim, James M. Ritchie, and Nick Weston. Neural photo editing with introspective adversarial networks. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings. OpenReview.net, 2017.   
+[61] Vincent Dumoulin, Ishmael Belghazi, Ben Poole, Alex Lamb, Martín Arjovsky, Olivier Mastropietro, and Aaron C. Courville. Adversarially learned inference. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings. OpenReview.net, 2017.   
+[62] Elad Richardson, Yuval Alaluf, Or Patashnik, Yotam Nitzan, Yaniv Azar, Stav Shapiro, and Daniel CohenOr. Encoding in style: a stylegan encoder for image-to-image translation. arXiv preprint arXiv:2008.00951, 2020.   
+[63] Jun-Yan Zhu, Philipp Krähenbühl, Eli Shechtman, and Alexei A Efros. Generative visual manipulation on the natural image manifold. In European conference on computer vision, pages 597–613. Springer, 2016.   
+[64] R. A. Yeh, C. Chen, T. Y. Lim, A. G. Schwing, M. Hasegawa-Johnson, and M. N. Do. Semantic image inpainting with deep generative models. In 2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 6882–6890, 2017.   
+[65] Zachary C. Lipton and Subarna Tripathi. Precise recovery of latent vectors from generative adversarial networks. arXiv preprint arXiv:1702.04782, 2017.   
+[66] Rameen Abdal, Yipeng Qin, and Peter Wonka. Image2stylegan: How to embed images into the stylegan latent space? In Proceedings of the IEEE International Conference on Computer Vision, pages 4432–4441, 2019.   
+[67] Minyoung Huh, Richard Zhang, Jun-Yan Zhu, Sylvain Paris, and Aaron Hertzmann. Transforming and projecting images into class-conditional generative networks. arXiv preprint arXiv:2005.01703, 2020.   
+[68] A. Creswell and A. A. Bharath. Inverting the generator of a generative adversarial network. IEEE Transactions on Neural Networks and Learning Systems, 30(7):1967–1974, 2019.   
+[69] A. Raj, Y. Li, and Y. Bresler. Gan-based projector for faster recovery with convergence guarantees in linear inverse problems. In 2019 IEEE/CVF International Conference on Computer Vision (ICCV), pages 5601–5610, 2019.   
+[70] D. Bau, J. Zhu, J. Wulff, W. Peebles, B. Zhou, H. Strobelt, and A. Torralba. Seeing what a gan cannot generate. In 2019 IEEE/CVF International Conference on Computer Vision (ICCV), pages 4501–4510, 2019.   
+[71] Jiapeng Zhu, Yujun Shen, Deli Zhao, and Bolei Zhou. In-domain gan inversion for real image editing. arXiv preprint arXiv:2004.00049, 2020.   
+[72] Jianjin Xu and Changxi Zheng. Linear semantics in generative adversarial networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9351–9360, 2021.   
+[73] David Bau, Alex Andonian, Audrey Cui, YeonHwan Park, Ali Jahanian, Aude Oliva, and Antonio Torralba. Paint by word. arXiv preprint arXiv:2103.10951, 2021.   
+[74] Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. Learning transferable visual models from natural language supervision. arXiv preprint arXiv:2103.00020, 2021.   
+[75] 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, pages 586–595, 2018.   
+[76] Jiankang Deng, Jia Guo, Niannan Xue, and Stefanos Zafeiriou. Arcface: Additive angular margin loss for deep face recognition. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4690–4699, 2019.   
+[77] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   
+[78] Maximilian Seitzer. pytorch-fid: FID Score for PyTorch. https://github.com/mseitzer/ pytorch-fid, August 2020. Version 0.1.1.   
+[79] Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett, editors, Advances in Neural Information Processing Systems 30, pages 6626–6637. Curran Associates, Inc., 2017.   
+[80] Mikołaj Binkowski, Danica J. Sutherland, Michael Arbel, and Arthur Gretton. Demystifying MMD GANs.´ In International Conference on Learning Representations, 2018.   
+[81] Omer Tov, Yuval Alaluf, Yotam Nitzan, Or Patashnik, and Daniel Cohen-Or. Designing an encoder for stylegan image manipulation. ACM Transactions on Graphics (TOG), 40(4):1–14, 2021.   
+[82] Yuri Viazovetskyi, Vladimir Ivashkin, and Evgeny Kashin. Stylegan2 distillation for feed-forward image manipulation. In European Conference on Computer Vision, pages 170–186. Springer, 2020.   
+[83] Cristian Vaccari and Andrew Chadwick. Deepfakes and disinformation: Exploring the impact of synthetic political video on deception, uncertainty, and trust in news. Social Media $^ +$ Society, 6(1):2056305120903408, 2020.   
+[84] Thanh Thi Nguyen, Quoc Viet Hung Nguyen, Cuong M. Nguyen, Dung Nguyen, Duc Thanh Nguyen, and Saeid Nahavandi. Deep learning for deepfakes creation and detection: A survey. arXiv preprint arXiv:1909.11573, 2021.   
+[85] Yisroel Mirsky and Wenke Lee. The creation and detection of deepfakes: A survey. ACM Comput. Surv., 54(1), 2021.   
+[86] Aditya Grover, Jiaming Song, Ashish Kapoor, Kenneth Tran, Alekh Agarwal, Eric J Horvitz, and Stefano Ermon. Bias correction of learned generative models using likelihood-free importance weighting. In Advances in Neural Information Processing Systems, 2019.   
+[87] Kristy Choi, Aditya Grover, Trisha Singh, Rui Shu, and Stefano Ermon. Fair generative modeling via weak supervision. In Proceedings of the 37th International Conference on Machine Learning, 2020.   
+[88] Ning Yu, Ke Li, Peng Zhou, Jitendra Malik, Larry Davis, and Mario Fritz. Inclusive GAN: improving data and minority coverage in generative models. In Computer Vision - ECCV 2020 - 16th European Conference, Glasgow, UK, August 23-28, 2020, Proceedings, Part XXII, 2020.   
+[89] Jinhee Lee, Haeri Kim, Youngkyu Hong, and Hye Won Chung. Self-diagnosing gan: Diagnosing underrepresented samples in generative adversarial networks. arXiv preprint arXiv:2102.12033, 2021.

parse/train/ppv5yqhpNyE/ppv5yqhpNyE_content_list.json

@@ -0,0 +1,1165 @@
+[
+    {
+        "type": "text",
+        "text": "EditGAN: High-Precision Semantic Image Editing ",
+        "text_level": 1,
+        "bbox": [
+            192,
+            122,
+            807,
+            148
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Huan Ling1,2,3,∗ Karsten Kreis1,∗ Daiqing Li 1 ",
+        "bbox": [
+            295,
+            199,
+            714,
+            215
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Seung Wook Kim1,2,3 Antonio Torralba4 Sanja Fidler1,2,3 ",
+        "bbox": [
+            276,
+            234,
+            779,
+            252
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1NVIDIA 2University of Toronto 3Vector Institute 4MIT ",
+        "bbox": [
+            312,
+            263,
+            691,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "{huling,kkreis,daiqingl,seungwookk,sfidler}@nvidia.com, torralba@mit.edu ",
+        "bbox": [
+            266,
+            285,
+            756,
+            296
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            332,
+            535,
+            348
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative adversarial networks (GANs) have recently found applications in image editing. However, most GAN-based image editing methods often require large-scale datasets with semantic segmentation annotations for training, only provide high level control, or merely interpolate between different images. Here, we propose EditGAN, a novel method for high-quality, high-precision semantic image editing, allowing users to edit images by modifying their highly detailed part segmentation masks, e.g., drawing a new mask for the headlight of a car. EditGAN builds on a GAN framework that jointly models images and their semantic segmentations [1, 2], requiring only a handful of labeled examples – making it a scalable tool for editing. Specifically, we embed an image into the GAN’s latent space and perform conditional latent code optimization according to the segmentation edit, which effectively also modifies the image. To amortize optimization, we find “editing vectors” in latent space that realize the edits. The framework allows us to learn an arbitrary number of editing vectors, which can then be directly applied on other images at interactive rates. We experimentally show that EditGAN can manipulate images with an unprecedented level of detail and freedom, while preserving full image quality.We can also easily combine multiple edits and perform plausible edits beyond EditGAN’s training data. We demonstrate EditGAN on a wide variety of image types and quantitatively outperform several previous editing methods on standard editing benchmark tasks. Project page: https://nv-tlabs.github.io/editGAN. ",
+        "bbox": [
+            233,
+            364,
+            766,
+            654
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            680,
+            310,
+            696
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "AI-driven photo and image editing has the potential to streamline the workflow of photographers and content creators and to enable new levels of creativity and digital artistry [3]. AI-based image editing tools have already found their way into consumer software in the form of neural photo editing filters, and the deep learning ",
+        "bbox": [
+            174,
+            709,
+            393,
+            845
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/782f0d95cf6c1f39f92812cd3e25c760b0d31805d8af630f0f9c23dfff5334ad.jpg",
+        "image_caption": [
+            "Figure 1: High-precision semantic image editing with EditGAN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            411,
+            681,
+            816,
+            830
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "research community is actively developing further techniques. A particularly promising line of research uses generative adversarial networks (GANs) [4, 5, 6, 7, 8] and either embeds images into the GAN’s latent space or works directly with GAN-generated images. Careful modifications of the latent embeddings then translate to desired changes in generated output, allowing, for example, to coherently change facial expressions in portraits [9, 10, 11, 12, 13, 14, 15, 16], change viewpoint or shapes and textures of cars [17], or to interpolate between different images in a semantically meaningful manner [18, 19, 20, 21]. ",
+        "bbox": [
+            176,
+            847,
+            823,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/c899d3cd93c67236587887acfd6de43587f4198a2a8293fb1b4b06e06d566106.jpg",
+        "image_caption": [
+            "Figure 2: (1) EditGAN builds on a GAN framework that jointly models images and their semantic segmentations. (2 & 3) Users can modify segmentation masks, based on which we perform optimization in the GAN’s latent space to realize the edit. (4) Users can perform editing simply by applying previously learnt editing vectors and manipulate images at interactive rates. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            64,
+            820,
+            242
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            313,
+            825,
+            383
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Most GAN-based image editing methods fall into few categories. Some works rely on GANs conditioning on class labels or pixel-wise semantic segmentation annotations [19, 10, 22, 11], where different conditionings lead to modifications in the output, while others use auxiliary attribute classifiers [23, 15] to guide synthesis and edit images. However, training such conditional GANs or external classifiers requires large labeled datasets. Therefore, these methods are currently limited to image types for which large annotated datasets are available, like portraits [10]. Furthermore, even if annotations are available, most techniques offer only limited editing control, since these annotations usually consist only of high-level global attributes or relatively coarse pixel-wise segmentations. Another line of work focuses on mixing and interpolating features from different images [18, 19, 20, 21], thereby requiring reference images as editing targets and usually also not offering fine control. Other approaches carefully analyze and dissect GANs’ latent spaces, finding disentangled latent variables suitable for editing [24, 25, 12, 13, 14, 26, 27], or control the GANs’ network parameters [25, 28, 16]. Usually, these methods do not enable detailed editing and are often slow. ",
+        "bbox": [
+            173,
+            390,
+            825,
+            569
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we are addressing these limitations and propose EditGAN, a novel GAN-based image editing framework that enables high-precision semantic image editing by allowing users to modify detailed object part segmentations. EditGAN builds on a recently proposed GAN that jointly models both images and their semantic segmentations based on the same underlying latent code [1, 2], and requires as few as 16 labeled examples – allowing it to scale to many object classes and choices of part labels. We achieve editing by modifying the segmentation mask according to a desired edit and optimizing the latent code to be consistent with the new segmentation, thus effectively changing the RGB image. To achieve efficiency, we learn editing vectors in latent space that realize the edits, and that can be directly applied on other images, without any or only few additional optimization steps. We can thus pre-train a library of interesting edits that a user can directly utilize in an interactive tool. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            714
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We apply EditGAN on a wide range of images, including images of cars, cats, birds, and human faces, demonstrating unprecedented high-precision editing. We perform quantitative comparisons to multiple baselines and outperform them in metrics such as identity preservation, quality preservation, and target attribute accuracy, while requiring orders of magnitude less annotated training data. EditGAN is the first GAN-driven image editing framework, which simultaneously (i) offers very highprecision editing, (ii) requires only very little annotated training data (and does not rely on external classifiers), (iii) can be run interactively in real time, (iv) allows for straightforward compositionality of multiple edits, (v) and works on real embedded, GAN-generated, and even out-of-domain images. ",
+        "bbox": [
+            174,
+            719,
+            825,
+            832
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            843,
+            321,
+            859
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Image Editing and Manipulation. Image Editing has a long history in computer vision and graphics, as well as machine learning [29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 18, 11, 28, 41, 42, 16]. Recently, deep generative models [4, 43, 44], in particular modern GANs [6, 45, 7, 46, 8], received much attention as a promising tool for efficient image editing, as it was found that latent space manipulations often lead to interpretable and predictable changes in output [47, 24, 48, 49, 26, 27, 50]. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "GAN-based image editing methods can be broadly sorted into a number of categories. (i) One line of work relies on the careful dissection of the GAN’s latent space, aiming to find interpretable and disentangled latent variables, which can be leveraged for image editing, in a fully unsupervised manner [47, 24, 25, 12, 13, 14, 48, 49, 26, 27, 50, 51]. Although powerful, these approaches usually do not result in any high-precision editing capabilities. The editing vectors we are learning in EditGAN would be too hard to find independently without segmentation-based guidance. (ii) Other works utilize GANs that condition on class or pixel-wise semantic segmentation labels to control synthesis and achieve editing [9, 52, 46, 19, 10, 22, 11]. Hence, these works usually rely on large annotated datasets, which are often not available, and even if available, the possible editing operations are tied to whatever labels are available. This stands in stark contrast to EditGAN, which can be trained in a semi-supervised fashion with very little labeled data and where an arbitrary number of high-precision edits can be learnt. (iii) Furthermore, auxiliary attribute classifiers have been used for image manipulation [23, 15], thereby still relying on annotated data and usually only providing high-level control. (iv) Image editing is often explored in the context of “interpolating” between a target and different reference image in sophisticated ways, for example by replacing certain features in a given image with features from a reference images [18, 19, 20, 21]. From the general image editing perspective, the requirement of reference images limits the broad applicability of these techniques and prevents the user from performing specific, detailed edits for which potentially no reference images are available. (v) Recently, different works proposed to directly operate in the parameter space of the GAN instead of the latent space to realize different edits [25, 28, 16]. For example, [25, 28] essentially specialize the generator network for certain images at test time to aid image embedding or “rewrite” the network to achieve desired semantic changes in output. The drawback is that such specializations prevent the model from being used in real-time on different images and with different edits. [16] proposed an approach that more directly analyses the parameter space of a GAN and treats it as a latent space in which to apply edits. However, the method still merely discovers edits in the network’s parameter space, rather than actively defining them like we do. It remains unclear whether their method can combine multiple such edits, as we can, considering that they change the GAN parameters themselves. (vi) Finally, another line of research targets primarily very high-level image and photo stylization and global appearance modifications [37, 53, 54, 55, 52, 56, 46, 57, 41]. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            526
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Generally, most works only do relatively high-level and not the detailed, high-precision editing, which EditGAN targets. Hence, we consider EditGAN as complementary to this body of work. ",
+        "bbox": [
+            176,
+            532,
+            820,
+            560
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "GANs and Latent Space Image Embedding. EditGAN builds on top of DatasetGAN [1] and SemanticGAN [2], which proposed to jointly model images and their semantic segmentations using shared latent codes. However, these works leveraged this model design only for semi-supervised learning, not for editing. EditGAN also relies on an encoder, together with optimization, to embed new images to be edited into the GAN’s latent space. This task in itself has been studied extensively in different contexts before, and we are building on these works. Previous papers studied encoder-based methods [58, 59, 60, 61, 62], used primarily optimization-based techniques [63, 64, 65, 66, 67, 68, 69, 26], and developed hybrid approaches [63, 24, 25, 70, 71]. ",
+        "bbox": [
+            174,
+            566,
+            825,
+            678
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Finally, a concurrent paper [72] shares similarities with DatasetGAN [1], on which our method builds, and explores an editing approach related to our EditGAN as one of its applications. However, our editing approach is methodologically different and leverages editing vectors, and also demonstrates significantly more diverse and stronger experimental results. Furthermore, [73] shares some highlevel ideas with EditGAN; however, it leverages the CLIP [74] model and targets text-driven editing. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            753
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 High-Precision Semantic Image Editing with EditGAN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            776,
+            661,
+            795
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Background ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            804,
+            299,
+            819
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "EditGAN’s image generation component is StyleGAN2 [7, 8], currently the state-of-the-art GAN for image synthesis. The StyleGAN2 generator maps latent codes $\\mathbf { z } \\in { \\mathcal { Z } }$ , drawn from a multivariate Normal distribution, into realistic images. A latent code $\\mathbf { z }$ is first transformed into an intermediate code $\\mathbf { w } \\in \\mathcal { W }$ by a non-linear mapping function and then further transformed into $K + 1$ vectors, $\\mathbf { w } ^ { 0 } , . . . , \\mathbf { w } ^ { K }$ , through learned affine transformations. These transformed latent codes are fed into synthesis blocks, whose outputs are deep feature maps. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Deep generative models such as StyleGAN2, which are trained to synthesize highly realistic images, acquire a semantic understanding of the modeled images in their high-dimensional feature space. Recently, DatasetGAN [1] and SemanticGAN [2] built on this insight to learn a joint distribution $p ( \\mathbf { x } , \\mathbf { y } )$ over images $\\mathbf { x }$ and pixel-wise semantic segmentation labels y, while requiring only a handful of labeled examples. EditGAN utilizes this joint distribution $p ( \\mathbf { x } , \\mathbf { y } )$ to perform high-precision semantic image editing of real and synthesized images. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            175
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Both methods [1, 2] model $p ( \\mathbf { x } , \\mathbf { y } )$ by adding an additional segmentation branch to the image generator, which is a pre-trained StyleGAN [1]. We follow DatasetGAN [1], which applies a simple three-layer multi-layer perceptron classifier on the layer-wise concatenated and appropriately upsampled feature maps. This classifier operates on the concatenated feature maps in a per-pixel fashion and predicts the segmentation label of each pixel. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            251
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Segmentation Training and Inference by Embedding Images into GAN’s Latent Space ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            255,
+            810,
+            270
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To both train the segmentation branch and perform segmentation on a new image, we embed an image into the GAN’s latent space using an encoder and optimization. To this end, we build on previous works [66, 62, 2] and train an encoder that embeds images into $\\mathcal { W } ^ { + }$ space, which is defined as $\\mathcal { W }$ but where the w’s are modeled independently [66, 62]. Our objectives to train this encoder consist of standard pixel-wise L2 and perceptual LPIPS reconstruction losses using both the real training data as well as samples from the GAN itself. For the GAN samples, we also explicitly regularize the encoder with the known underlying latent codes. In practice, we use the encoder to initialize images’ latent space embeddings and then iteratively refine the latent code $\\mathbf { w } ^ { + }$ via optimization, again using standard reconstruction objectives. ",
+        "bbox": [
+            173,
+            273,
+            825,
+            398
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In that way, we embed the annotated images $\\mathbf { x }$ from a dataset labeled with semantic segmentations into latent space, and train the segmentation branch of the generator using standard supervised learning objectives, i.e., the cross entropy loss. We keep the image generator’s weights frozen and only backpropagate the loss to the segmentation branch [1]. After training the segmentation branch, we can formally define a generator $\\bar { \\tilde { G } } : \\mathcal { W } ^ { + }  \\mathcal { X } , \\mathcal { Y }$ that models the joint distribution $p ( \\mathbf { x } , \\mathbf { y } )$ of images $\\mathbf { x }$ and semantic segmentations y. Details about encoder and segmentation branch training as well as optimization for image embedding can be found in the Appendix. ",
+        "bbox": [
+            173,
+            404,
+            826,
+            503
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 Finding Semantics in Latent Space via Segmentation Editing ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            512,
+            635,
+            526
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The key idea of EditGAN lies in leveraging the joint distribution $p ( \\mathbf { x } , \\mathbf { y } )$ of images and semantic segmentations for high-precision image editing. Given a new image $\\mathbf { x }$ to be edited, we can embed it into EditGAN’s $\\mathcal { W } ^ { + }$ latent space, as described above (alternatively, we can also sample images from the model itself and use those). The segmentation branch will then generate the corresponding segmentation $\\mathbf { y }$ , since segmentations and RGB im",
+        "bbox": [
+            173,
+            537,
+            408,
+            715
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/fb823d3601a32de596c1cacd81969ca423dc943ff186a4849f28d8fb75c7fe52.jpg",
+        "image_caption": [
+            "Figure 3: We modify semantic segmentations and optimize the shared latent code for consistency with the new segmentation within the editing region, and with the RGB appearance outside the editing region. Corresponding gradients are backpropagated through the shared generator. The result is a latent space editing vector $\\delta \\mathbf { w } _ { \\mathrm { e d i t } } ^ { + }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            423,
+            534,
+            823,
+            637
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "ages share the same latent codes $\\mathbf { w } ^ { + }$ . Using simple interactive digital painting or labeling tools, we can now manually modify the segmentation according to a desired edit. We denote the edited segmentation mask by $\\mathbf { y } _ { \\mathrm { e d i t e d } }$ . Starting from the embedding $\\mathbf { w } ^ { + }$ of the unedited image x and segmentation $\\mathbf { y }$ , we can then perform optimization within $\\mathcal { W } ^ { + }$ to find a new $\\mathbf { w } _ { \\mathrm { e d i t e d } } ^ { + } = \\mathbf { w } ^ { + } + \\delta \\mathbf { w } _ { \\mathrm { e d i t } } ^ { + }$ consistent with the new segmentation $\\mathbf { y } _ { \\mathrm { e d i t e d } }$ , while allowing the RGB output $\\mathbf { x }$ to change within the editing region. ",
+        "bbox": [
+            173,
+            717,
+            826,
+            786
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Formally, we are seeking an editing vector $\\delta \\mathbf { w } _ { \\mathrm { e d i t } } ^ { + } \\in \\mathcal { W } ^ { + }$ such that $( \\mathbf { x } _ { \\mathrm { e d i t e d } } , \\mathbf { y } _ { \\mathrm { e d i t e d } } ) = \\tilde { G } ( \\mathbf { w } ^ { + } + \\delta \\mathbf { w } _ { \\mathrm { e d i t } } ^ { + } )$ where $\\tilde { G }$ denotes the fixed generator that synthesizes both images and segmentations. Defining $( \\mathbf { x } ^ { \\prime } , \\mathbf { y } ^ { \\prime } ) = \\tilde { G } ( \\mathbf { w } ^ { + } + \\delta \\mathbf { w } ^ { + } )$ , we perform optimization to approximate $\\delta \\mathbf { w } _ { \\mathrm { e d i t } } ^ { + }$ by $\\delta \\mathbf { w } ^ { + }$ . The region of interest $r$ within which we expect the image to change due to the edit is formally given by ",
+        "bbox": [
+            173,
+            792,
+            825,
+            854
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/98fe13a07967cfe2137e2e43e22097f5a9fd8aa0b6ce75299f95b38cddcf6d96.jpg",
+        "text": "$$\nr = \\left\\{ p : c _ { p } ^ { \\mathbf { y } } \\in Q _ { \\mathrm { e d i t } } \\right\\} \\cup \\left\\{ p : c _ { p } ^ { \\mathbf { y } _ { \\mathrm { e d i t e d } } } \\in Q _ { \\mathrm { e d i t } } \\right\\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            856,
+            642,
+            876
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "which means that $r$ is defined by all pixels $p$ whose part segmentation labels $c _ { p } ^ { \\{ \\mathbf { y } , \\mathbf { y } _ { \\mathrm { e d i t e d } } \\} }$ according to either the initial segmentation $\\mathbf { y }$ or the edited one $\\mathbf { y } _ { \\mathrm { e d i t e d } }$ are within an edit-specific pre-specified list ",
+        "bbox": [
+            173,
+            882,
+            828,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$Q _ { \\mathrm { e d i t } }$ of part labels relevant for the edit. For example, when modifying the wheel in a photo of a car $Q _ { \\mathrm { e d i t } }$ would contain all part labels related to the wheels, such as tire, spoke, and wheelhub (see Fig. 3). We use a further buffer of 5 pixels to give the GAN freedom in modeling the transition between the edited and non-edited area. In practice, $r$ acts as a binary pixel-wise mask (see Eqs. 2 and 3 below). ",
+        "bbox": [
+            174,
+            90,
+            826,
+            147
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that $\\mathbf { x } _ { \\mathrm { e d i t e d } }$ is not available during optimization. After all, $\\mathbf { x } _ { \\mathrm { e d i t e d } }$ is the edited image we are ultimately intested in. It emerges indirectly when optimizing for the segmentation modification, since images and segmentations are closely tied together in the joint distribution $p ( \\mathbf { x } , \\mathbf { y } )$ modeled by $\\tilde { G }$ We further define $\\mathbf { x } ^ { \\prime } = \\tilde { G } ^ { \\mathbf { x } } ( \\mathbf { w } ^ { + } + \\delta \\mathbf { w } ^ { + } )$ as $\\tilde { G }$ ’s image generation and $\\mathbf { y } ^ { \\prime } = \\tilde { G } ^ { \\mathbf { y } } ( \\mathbf { w } ^ { + } + \\delta \\mathbf { w } ^ { + } )$ as $\\tilde { G }$ ’s segmentation generation branch. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            227
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To find $\\delta \\mathbf { w } ^ { + }$ , approximating $\\delta \\mathbf { w } _ { \\mathrm { e d i t } } ^ { + }$ , we use the following losses as minimization targets: ",
+        "bbox": [
+            169,
+            232,
+            753,
+            248
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5d61e5a8c48279e5f5820d2d42faac559d3c5a64f2640bb466442b42effa5401.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { L } _ { \\mathrm { R G B } } ( \\delta \\mathbf { w } ^ { + } ) = L _ { \\mathrm { L P I P S } } ( \\tilde { G } ^ { \\mathbf { x } } ( \\mathbf { w } ^ { + } + \\delta \\mathbf { w } ^ { + } ) \\odot ( 1 - r ) , \\ \\mathbf { x } \\odot ( 1 - r ) ) } \\\\ & { \\qquad + L _ { L 2 } ( \\tilde { G } ^ { \\mathbf { x } } ( \\mathbf { w } ^ { + } + \\delta \\mathbf { w } ^ { + } ) \\odot ( 1 - r ) , \\ \\mathbf { x } \\odot ( 1 - r ) ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            282,
+            251,
+            715,
+            292
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e36b47bffd390476c6000b5ff9551822e952968dc0237018bda1dcacad7edf74.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { L } _ { \\mathrm { C E } } \\big ( \\delta \\mathbf { w } ^ { + } \\big ) = H \\big ( \\tilde { G } ^ { \\mathbf { y } } \\big ( \\mathbf { w } ^ { + } + \\delta \\mathbf { w } ^ { + } \\big ) \\odot r , \\ \\mathbf { y } _ { \\mathrm { e d i t e d } } \\odot r \\big ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            297,
+            669,
+            316
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $H$ denotes the pixel-wise cross-entropy, $L _ { \\mathrm { L P I P S } }$ loss is based on the Learned Perceptual Image Patch Similarity (LPIPS) distance [75], and $L _ { L 2 }$ is a regular pixel-wise L2 loss. $\\mathcal { L } _ { \\mathrm { R G B } } ( \\delta \\mathbf { \\bar { w } } ^ { + } )$ ensures that the image appearance does not change outside the region of interest, while $\\mathcal { L } _ { \\mathrm { C E } } ( \\delta \\mathbf { w } ^ { + } )$ ensures that the target segmentation $\\mathbf { y } _ { \\mathrm { e d i t e d } }$ is enforced within the editing region (see visualization in Fig. 3). When editing human faces, we also apply the identity loss [62]: ",
+        "bbox": [
+            173,
+            319,
+            826,
+            388
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ef4b99d1b708797e0ea8d558b7a7b49dfde1afde3527d68c7835fd9d6737e886.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { L } _ { \\mathrm { I D } } ( \\delta \\mathbf { w } ^ { + } ) = \\langle R ( \\tilde { G } ^ { \\mathbf { x } } ( \\mathbf { w } ^ { + } + \\delta \\mathbf { w } ^ { + } ) ) , R ( \\mathbf { x } ) \\rangle } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            391,
+            642,
+            410
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "with $R$ denoting the pretrained ArcFace feature extraction network [76] and $\\langle \\cdot , \\cdot \\rangle$ cosine-similiarity. The final objective function for optimization then becomes: ",
+        "bbox": [
+            171,
+            412,
+            825,
+            448
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3b5df6fc9922305b7fbdbddc8e4bc41629d9f62c276c26c8c8539b8f15ed4291.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { L } _ { \\mathrm { e d i t i n g } } ( \\delta \\mathbf { w } ^ { + } ) = \\lambda _ { 1 } ^ { \\mathrm { e d i t i n g } } \\mathcal { L } _ { \\mathrm { R G B } } ( \\delta \\mathbf { w } ^ { + } ) + \\lambda _ { 2 } ^ { \\mathrm { e d t i n g } } \\mathcal { L } _ { \\mathrm { C E } } ( \\delta \\mathbf { w } ^ { + } ) + \\lambda _ { 3 } ^ { \\mathrm { e d t i n g } } \\mathcal { L } _ { \\mathrm { I D } } ( \\delta \\mathbf { w } ^ { + } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            248,
+            450,
+            750,
+            470
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "with hyperparameters $\\lambda _ { 1 , \\dots , 3 } ^ { \\mathrm { e d i t i n g } }$ . The only “learnable” variable is the editing vector $\\delta \\mathbf { w } ^ { + }$ ; all neural networks are kept fixed. After optimizing $\\delta \\mathbf { w } ^ { + }$ with the objective function, we can use $\\delta \\mathbf { w } ^ { + } \\approx \\delta \\mathbf { w } _ { \\mathrm { e d i t } } ^ { + }$ Note that there is a certain amount of ambiguity in how the segmentation modification is realized in RGB output. We rely on the GAN generator, trained to synthesize realistic images, to modify the RGB values in the editing region in a plausible way consistent with the segmentation edit. ",
+        "bbox": [
+            173,
+            474,
+            826,
+            550
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 Different Ways of Editing during Inference ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            558,
+            513,
+            573
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The latent space editing vectors $\\delta \\mathbf { w } _ { \\mathrm { e d i t } } ^ { + }$ obtained by optimization as described are semantically meaningful and often disentangled with other attributes. Therefore, for new images $\\mathbf { x }$ to be edited, we can embed the images into the $\\mathcal { W } ^ { + }$ latent space and the same editing operations can be directly performed by applying the previously learnt $\\delta \\mathbf { w } _ { \\mathrm { e d i t } } ^ { + }$ as $( \\mathbf { x } ^ { \\prime } , \\mathbf { y } ^ { \\prime } ) = G ( \\mathbf { w } ^ { + } + s _ { \\mathrm { e d i t } } \\delta \\mathbf { w } _ { \\mathrm { e d i t } } ^ { + } )$ without doing any optimization from scratch again. In other words, the learnt editing vectors $\\bar { \\delta } \\bar { \\mathbf { w } } ^ { + }$ amortize the iterative optimization that was necessary to achieve the edit initially. For well-disentangled editing operations, $\\mathbf { x } ^ { \\prime }$ can be used directly as the edited image $\\mathbf { x } _ { \\mathrm { e d i t e d } }$ . Note that we introduced $s _ { \\mathrm { e d i t } }$ , a scalar editing coefficient, which effectively scales and controls the editing magnitude during inference. For $s _ { \\mathrm { e d i t } } = 0$ , we do not do any editing at all, while for $s _ { \\mathrm { e d i t } } > 1$ we manipulate the images with an effectively larger editing operation in latent space, leading to exaggerated effects. ",
+        "bbox": [
+            173,
+            583,
+            825,
+            722
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Unfortunately, disentanglement is not always perfect and the editing vectors $\\delta \\mathbf { w } _ { \\mathrm { e d i t } } ^ { + }$ do not always translate perfectly to other images. We can remove editing artifacts in other regions of the image by a few additional optimization steps at test time. Specifically, we can use the exact same minimization obas s as above, using the initial prediction . This assumes that the editing vector $\\mathbf { y } ^ { \\prime }$ , obtained after applying the editing vector ll induces a plausible segmentation chang $\\delta \\mathbf { w } _ { \\mathrm { e d i t } } ^ { + }$ $\\mathbf { y } _ { \\mathrm { e d i t e d } }$   \napplied on other images and that artifacts only arise in RGB output. The RGB objective $\\mathcal { L } _ { \\mathrm { { R G B } } }$ then removes these editing artifacts outside the editing region, while $\\mathcal { L } _ { \\mathrm { C E } }$ ensures that the modified segmentation stays as predicted by the editing vector. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            839
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Summarizing, we can perform image editing with EditGAN in three different modes: ",
+        "bbox": [
+            174,
+            844,
+            730,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• Real-time Editing with Editing Vectors. For localized, well-disentangled edits we perform editing purely by applying previously learnt editing vectors with varying scales $s _ { \\mathrm { e d i t } }$ and manipulate images at interactive rates. ",
+        "bbox": [
+            217,
+            869,
+            823,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/742a614d56b78b2c1585a7e070b2c2ba2262df73e8b0ab63e51925ccf624d04e.jpg",
+        "image_caption": [
+            "Figure 4: Examples of segmentation-driven edits with EditGAN. Results are based on editing with editing vectors and 30 steps self-supervised refinement. Blue boxes: Original images. Orange boxes: Zoom-in views. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            94,
+            823,
+            483
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• Vector-based Editing with Self-Supervised Refinement. For localized edits that are not perfectly disentangled with other parts of the image, we can remove editing artifacts by additional optimization at test time, while initializing the edit using the learnt editing vectors. • Optimization-based Editing. Image-specific and very large edits do not transfer to other images via editing vectors. For such operations, we perform optimization from scratch. ",
+        "bbox": [
+            218,
+            526,
+            826,
+            602
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            613,
+            312,
+            631
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We extensively evaluate EditGAN on images across four different categories: Cars ( $3 8 4 \\times 5 1 2$ spatial resolution), Birds $( 5 1 2 \\times 5 1 2 )$ , Cats $( 2 5 6 \\times 2 5 6 )$ , and Faces $( 1 0 2 4 \\times 1 0 2 4 )$ . ",
+        "bbox": [
+            176,
+            637,
+            823,
+            666
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Implementation We train our segmentation branch as described in Sec. 3.2 using 16, 16, 30, and 30 image-mask pairs as labeled training data for Faces, Cars, Birds, and Cats, respectively. We utilize very highly-detailed part segmentations from [1]. The annotation scheme for faces is shown in Fig. 7, all others are presented in the Appendix. When editing is done purely optimization-based or when learning the editing vectors, we always perform 100 steps of optimization using Adam [77]. For Car, Cat, and Faces, we use real images from DatasetGAN’s test set that were not part of GAN training to demonstrate editing functionality. These images are first embedded into EditGAN’s latent space via an encoder and optimization as described in Sec. 3.2. For Birds, we show editing on GAN-generated images. Model details and hyperparameters are provided in the Appendix. ",
+        "bbox": [
+            173,
+            672,
+            825,
+            797
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Qualitative Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            808,
+            346,
+            821
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In-Domain Results In Fig. 4, we demonstrate our EditGAN framework when applying previously learnt editing vectors $\\delta \\mathbf { w } _ { \\mathrm { e d i t } } ^ { + }$ on novel images and refining with 30 steps of optimization. Our editing operations preserve high image quality and are well disentangled for all classes. We also show the ability to combine multiple different edits in Fig. 5. To the best of our knowledge, no previous methods can perform as complex and high-precision edits as we do, while preserving image quality and subject identity. In Fig. 8, we demonstrate that we can even perform extremely high-precision edits, such as rotating a car’s wheel spoke or dilating pupils. EditGAN can edit semantic parts of objects that consist of only few pixels. At the same time, we can use EditGAN to perform large-scale modifications, too: In Fig. 9, we present how we can remove the entire roof of a car or convert it to a station wagon-like vehicle, simply by modifying the segmentation mask accordingly and optimizing. It is worth noting that several of our editing operations generate plausible manipulated images unlike those appearing in the GAN training data. For example, the training data does not include cats with overly large eyes or ears. Nevertheless, we achieve such edits in a high-quality manner. ",
+        "bbox": [
+            174,
+            828,
+            823,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/af4bf814241ab3da1430ddc5310405757b5f5cc1f2f6882f1581f9a97675afad.jpg",
+        "image_caption": [
+            "Figure 5: We combine multiple edits. Results are based on editing with editing vectors and 30 steps selfsupervised refinement. Blue boxes: Original images. Edits in detail: Second row, first person: open eyes, add hair, add mustache. Second person: smile, look left. Third row, first car: remove mirror, remove door handle, shrink wheels. Second car: remove license plate, enlarge wheels. Third row, bird: longer beak, bigger belly, head up. Third row, cat: open mouth, bigger ear, bigger eyes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            225,
+            50,
+            772,
+            465
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            542,
+            825,
+            641
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The edits in Figs. 4, 5 and 8 are based on learnt editing vectors with self-supervised refinement. However, without such refinement usually only very minor artifacts occur, as shown in Fig. 10, hence allowing for real-time high-precision semantic image editing (discussed in detail below). ",
+        "bbox": [
+            174,
+            646,
+            825,
+            689
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Out-of-Domain Results We demonstrate the generalization capability of EditGAN to out-ofdomain data on the MetFaces [8] data set. We use our EditGAN model trained on FFHQ [8], and create editing vectors $\\delta \\mathbf { w } _ { \\mathrm { e d i t } } ^ { + }$ using in-domain real faces. We then embed out-of-domain MetFaces partraits (with 100 steps optimization) and apply the editing vectors with 30 steps self-supervised refinement. The results are shown in Fig. 6. We find that our editing operations seamlessly translate even to such far out-of-domain examples. ",
+        "bbox": [
+            174,
+            705,
+            825,
+            790
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 Quantitative Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            801,
+            354,
+            815
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To quantitatively measure EditGAN’s image editing capabilities, we use the smile edit benchmark introduced by MaskGAN [10]. Faces with neutral expressions are converted into smiling faces and performance is measured by three metrics: a. Semantic Correctness: Using a pre-trained smile attribute classifier, we measure whether the faces show smiling expressions after editing. b. Distribution-level Image Quality: Frechet Inception Distance (FID) [78, 79] and Kernel Inception Distance (KID) [80] are calculated between 400 edited test images and the CelebA-HD test dataset. c. ",
+        "bbox": [
+            174,
+            827,
+            826,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/a61605ec5f7b2608b329439b051ff89b4dd3b4fd77ff0d41e5416083b44f10ec.jpg",
+        "image_caption": [
+            "Figure 6: We combine multiple edits on out-of-domain images. Results are based on editing with editing vectors and 30 steps self-supervised refinement. Edits in detail: First row, first example: look left, frown. Second example: smile, look right. Second row, first example: open eyes, lift eyebrow. Second example: open eyes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            243,
+            89,
+            756,
+            284
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Identity Preservation: Using the pretrained ArcFace feature extraction network [76], we measure whether the subjects’ identity is maintained when applying the edit. Specifically, we report cosinesimiliarity between original and edited images. Further details can be found in the Appendix. ",
+        "bbox": [
+            174,
+            334,
+            826,
+            376
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For our EditGAN, we simply learn a smiling editing vector $\\delta \\mathbf { w } _ { \\mathrm { e d i t } } ^ { + }$ using a hold-out neutral expression face image. We embed it into EditGAN, infer its pixel-wise segmentation labels, and manually modify the segmentation towards a smile. Then we perform optimization in latent space, as described above, to learn the editing vector. For the results in Tab. 1, it is applied with unit scale $s _ { \\mathrm { e d i t } } { = } 1$ on new images. We do ",
+        "bbox": [
+            174,
+            382,
+            452,
+            520
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/8b942210047dc63610e55e8490b2b13d8ffe356c22805fd5ed9a16d4f01ac883.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Metric</td><td>Annot.</td><td>#Mask #Attribute Annot.</td><td>Attribute Acc.(%)↑</td><td>FID↓</td><td>KID↓</td><td>ID Score ↑</td></tr><tr><td>MaskGAN [10]</td><td>30.000</td><td></td><td>77.3</td><td></td><td>46.84 0.020</td><td>0.4611</td></tr><tr><td>LocalEditing [18]</td><td>-</td><td></td><td>26.0</td><td>41.26</td><td>0.012</td><td>0.5823</td></tr><tr><td>LocalEditing - Encoding4Editing [81]</td><td>-</td><td>-</td><td>41.75</td><td>48.28</td><td>0.016</td><td>0.6603</td></tr><tr><td>InterFaceGAN [13]</td><td>-</td><td>30.000</td><td>83.5</td><td>39.42</td><td>0.010</td><td>0.7295</td></tr><tr><td>EditGAN (ours)</td><td>16</td><td>-</td><td>91.5</td><td>41.74</td><td>0.013</td><td>0.7047</td></tr><tr><td>EditGAN+30 (ours)</td><td>16</td><td>-</td><td>85.8</td><td>40.83</td><td>0.012</td><td>0.7452</td></tr><tr><td>StyleGAN2 Distillation [82]</td><td>-</td><td>30.000</td><td>98.3</td><td>45.09 0.013</td><td></td><td>0.7823</td></tr></table>",
+        "bbox": [
+            467,
+            385,
+            821,
+            489
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Quantitative comparisons to multiple baselines on the smile edit benchmark. ",
+        "bbox": [
+            465,
+            492,
+            823,
+            517
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "not use the identity loss (Eq. 4) in this experiment, since identity preservation is already a target metric itself. We compare our method with three strong baselines: (i) $M a s k G A N ^ { 2 }$ [10]: It takes non-smiling images, their segmentation masks, and a target smiling segmentation mask as inputs. Note that training MaskGAN requires large annotated datasets, in contrast to us. We also compare to (ii) LocalEditing3 [18]: It clusters GAN features to achieve local editing and relies on reference images, in this case images of faces with smiling expressions. Another baseline we use is (iii) InterFace $G A N ^ { 4 }$ [13]: Similar to EditGAN, InterFaceGAN aims at finding editing vectors in latent space. However, it uses auxiliary attribute classifiers, relies on large annotated datasets, and can generally not achieve the fine editing control of our EditGAN. Finally, we compare to (iv) StyleGAN2 Distillation5 [82], which creates an alternative approach that does not require real image embeddings and also relies on an editing-vector model to create a training dataset. ",
+        "bbox": [
+            173,
+            520,
+            825,
+            672
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results are reported in Tab. 1. Using 1, $8 7 5 \\times$ less training labels, we outperform MaskGAN on all three metrics. We similarly obtain significantly stronger results than LocalEditing. In our observation, LocalEditing does not work well on real image embeddings. We further exploit a better encoder [81] for the LocalEditing baseline, which leads to a significant improvement in attribute accuracy and ID score, but slightly worse FID & KID scores. We find that EditGAN outperforms InterFaceGAN on identity preservation and attribute classification accuracy, while InterFaceGAN reaches slightly better FID & KID scores (for the results in Tab. 1, the latent space edits learnt by InterfaceGAN are also applied with unit scale, like for EditGAN). In Fig. 11, we report a more detailed comparison to InterFaceGAN, where we apply the smile editing vectors with different scale coefficients from zero to two. As shown, when the editing vector scale is small, the identity score is high while the smiling attribute score is low, since the modification of the original images is minimal. We find that our realtime editing with editing vectors is on-par with InterFaceGAN. When we perform self-supervised refinement at test time, EditGAN outperforms InterFaceGAN. In Tab. 1, we also compare with StyleGAN2 Distillation [82], which achieves strong performance. However, StyleGAN2 Distillation relies on pre-trained classifiers, like InterfaceGAN, and only enables relatively high-level editing of image attributes for which large-scale annotations exit. Moreover, it distills edits into separate Pixel2PixelHD networks, such that a new network needs to be trained for each edit, limiting broad, user-interactive applicability. Hence, we consider StyleGAN2 Distillation orthogonal to our EditGAN. ",
+        "bbox": [
+            173,
+            679,
+            825,
+            844
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/82aed2cce7459a336ae87233a9042f1ee642601d6b485bb205aecab5ad27d17e.jpg",
+        "image_caption": [
+            "Figure 7: Face part labeling schema [1]. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            89,
+            318,
+            176
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/ec5e57176ee9dd96a0c35e7e44b1e68c3c05f10a2598c6a27b653ace1bbfbc45.jpg",
+        "image_caption": [
+            "Figure 8: High-precision editing with EditGAN for extreme details. Left: We rotate Rotate Wheel Spoke Change pupil Sizethe spoke. Right: We modify pupil size. Results are based on editing with editing vectors and 30 steps self-supervised refinement. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            333,
+            90,
+            818,
+            171
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/40b140c5ee1e246522137b6ac9a2945eff98f726b22711f6d4416174a8e77e7b.jpg",
+        "image_caption": [
+            "Figure 9: Pure optimization-based editing. We demonstrate large-scale semantic edits that do not transfer seamlessly to other images via editing vectors. Hence, we perform optimization from scratch. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            217,
+            821,
+            279
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/a1abbd5adb6d1505d2819a994d24a10e48d6a51e57149c772524e86d426ec6f8.jpg",
+        "image_caption": [
+            "Figure 10: Left: We apply learnt editing vectors with varying scales (see 5 markers in FID plots) both without (top row for each class) and with (bottom row for each class) additional 30-step self-supervised refinement to correct artifacts. Red boxes denote original images. For each class, the leftmost image is the one used to learn the editing vector, with the editing result next to it and orginal and modified segmentations below. Right: Visual quality after editing with different scales as measured by FID with and without refinement. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            313,
+            800,
+            491
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            568,
+            825,
+            651
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Running Time We carefully measure the run time of our editing on an NVIDIA Tesla V100 GPU. Conditional optimization, given an edited segmentation mask, with 30 (60) optimization steps takes 11.4 (18.9) seconds. This operation provides us the editing vector. Application of editing vectors is almost instantaneous, taking only 0.4 seconds, therefore allowing for complex real-time interactive editing. A 10 (30) step self-supervised refinement would add an additional 4.2 (9.5) seconds. ",
+        "bbox": [
+            174,
+            665,
+            825,
+            736
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3 Ablation Studies: Self-Supervised Refinement and Editing Vector Scale ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            743,
+            707,
+            758
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Fig. 11 also contains a quantitative ablation study on the number of additional optimization steps done when initializing an edit with a learnt editing vector and refining with additional optimization. Generally, the more refinement steps we perform, the better the performance our model can achieve. As shown in Fig. 11, we find that further optimization can indeed slightly improve performance. Specifically, here we improve the trade-off between maintaining identity and achieving the desired semantic operation when performing editing with different scalings $s _ { \\mathrm { e d i t } }$ of the editing vector. However, performing many steps of optimization leads to a run-time vs. performance trade-off, and our results suggest that the improvement beyond 30 additional optimization steps becomes marginal. ",
+        "bbox": [
+            173,
+            766,
+            826,
+            877
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 10, we analyze the editing vector scale and self-supervised refinement visually and with respect to perceptual metrics. As highlighted in the zoom-in areas, small artifacts can appear due to imperfect disentanglement in latent space when applying editing operations with large scales. Self-supervised refinement successfully cleans these editing errors up. We also apply the same edit with different scales on 400 test images and measure FID with respect to 10,000 data from GAN training, inspired by the analyses in [16]. We can clearly see that image quality degrades as measured by FID, the stronger the edit is applied. We also observe small improvements with the iterative refinement on this metric, although the difference is small. Further details are in the Appendix. We conclude that for most editing operations, real-time editing without iterative refinement already performs very well. However, to clean up artifacts and maintain highest image quality possible, self-supervised refinement with a couple of additional optimization steps is always available. ",
+        "bbox": [
+            173,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            826,
+            215
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Additional experiments are presented in the Appendix. ",
+        "bbox": [
+            176,
+            222,
+            532,
+            237
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            250,
+            307,
+            267
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Limitations Like all GAN-based image editing methods, EditGAN is limited to images that can be modeled by the GAN. This makes EditGAN’s application on, for instance, photos of vivid city scenes challenging. Although most of our high-precision edits readily transfer to other images via learnt editing vectors, we also encountered challenging edits that required iterative optimization on each example. Future research therefore includes speeding up the optimization for such edits as well as building better generative models with more disentangled latent spaces. ",
+        "bbox": [
+            174,
+            277,
+            549,
+            416
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/690211948c1cfdaeb4947e26111732183937f423e3528f4344ff12d15a1cbf6a.jpg",
+        "image_caption": [
+            "Figure 11: InterFaceGAN’s and EditGAN’s performance on the smile edit benchmark for different editing vector scalings (scale increases from top-left points towards bottomright points; see main text and Appendix for details). For EditGAN, we optionally add 10, 30 or 60 additional optimization steps. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            562,
+            220,
+            802,
+            337
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Summary We propose EditGAN, a novel method for high-precision, high-quality semantic image editing. It relies on a GAN that jointly models RGB images and their pixel-wise semantic segmentations and that requires only very few annotated data for training. Editing is achieved by performing optimization in latent space while conditioning on edited segmentation masks. This optimization can be amortized into editing vectors in latent space, which can be applied on other images directly, allowing for real-time interactive editing without any or only little further optimization. We demonstrate a broad variety of editing operations on different kinds of images, achieving an unprecedented level of flexibility and freedom in terms of editing, while preserving high image quality. ",
+        "bbox": [
+            173,
+            428,
+            826,
+            540
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Broader Impact ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            553,
+            339,
+            569
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Where previous generative modeling-based image editing methods offer only limited high-level editing capabilities, our method provides users unprecedented high-precision semantic editing possibilities. Our proposed techniques can be used for artistic purposes and creative expression and benefit designers, photographers, and content creators [3]. AI-driven image editing tools like ours promise to democratize high-quality image editing. Related methods have already found their way into everyday applications in the form of neural photo editing filters. On a larger scale, the ability to synthesize data with specific attributes can be leveraged in training and finetuning machine learning models. ",
+        "bbox": [
+            174,
+            579,
+            825,
+            676
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "At the same time, more precise photo editing also offers opportunities for advanced photo manipulation for nefarious purposes. The recent progress of generative models and AI-driven photo editing has profound implications on image authenticity and beyond, which is an area of active debate [83]. As one potential way to tackle these challenges, methods for automatically validating real images and detecting manipulated or fake images are being developed by the research community [84, 85]. Furthermore, generative models like ours are usually only as good as the data they were trained on. Therefore, biases in the underlying datasets are still present in the synthesized images and preserved even when applying our proposed editing methods. It is therefore important to be aware of such biases in the underlying data and counteract them, for example by actively collecting more representative data or by using bias correction methods, an area of active research [86, 87, 88, 89]. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            821
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Funding Statement ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            838,
+            336,
+            856
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work was funded by NVIDIA. Huan Ling and Seung Wook Kim acknowledge additional revenue in the form of student scholarships from University of Toronto and the Vector Institute, which are not in direct support of this work. ",
+        "bbox": [
+            176,
+            869,
+            823,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            266,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Yuxuan Zhang, Huan Ling, Jun Gao, Kangxue Yin, Jean-Francois Lafleche, Adela Barriuso, Antonio Torralba, and Sanja Fidler. Datasetgan: Efficient labeled data factory with minimal human effort. arXiv preprint arXiv:2104.06490, 2021.   \n[2] Daiqing Li, Junlin Yang, Karsten Kreis, Antonio Torralba, and Sanja Fidler. Semantic segmentation with generative models: Semi-supervised learning and strong out-of-domain generalization. arXiv preprint arXiv:2104.05833, 2021.   \n[3] J. Bailey. The tools of generative art, from flash to neural networks. Art in America, 2020.   \n[4] Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pages 2672–2680, 2014.   \n[5] Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.   \n[6] Tero Karras, Timo Aila, Samuli Laine, and Jaakko Lehtinen. Progressive growing of gans for improved quality, stability, and variation. arXiv preprint arXiv:1710.10196, 2017.   \n[7] Tero Karras, Samuli Laine, and Timo Aila. A style-based generator architecture for generative adversarial networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4401–4410, 2019.   \n[8] Tero Karras, Samuli Laine, Miika Aittala, Janne Hellsten, Jaakko Lehtinen, and Timo Aila. Analyzing and improving the image quality of stylegan. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 8110–8119, 2020.   \n[9] Yunjey Choi, Minje Choi, Munyoung Kim, Jung-Woo Ha, Sunghun Kim, and Jaegul Choo. Stargan: Unified generative adversarial networks for multi-domain image-to-image translation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2018.   \n[10] Cheng-Han Lee, Ziwei Liu, Lingyun Wu, and Ping Luo. Maskgan: Towards diverse and interactive facial image manipulation. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.   \n[11] Rongliang Wu, Gongjie Zhang, Shijian Lu, and Tao Chen. Cascade ef-gan: Progressive facial expression editing with local focuses. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.   \n[12] Yujun Shen, Jinjin Gu, Xiaoou Tang, and Bolei Zhou. Interpreting the latent space of gans for semantic face editing. In CVPR, 2020.   \n[13] Yujun Shen, Ceyuan Yang, Xiaoou Tang, and Bolei Zhou. Interfacegan: Interpreting the disentangled face representation learned by gans. TPAMI, 2020.   \n[14] Yazeed Alharbi and Peter Wonka. Disentangled image generation through structured noise injection. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.   \n[15] Xianxu Hou, Xiaokang Zhang, Linlin Shen, Zhihui Lai, and Jun Wan. Guidedstyle: Attribute knowledge guided style manipulation for semantic face editing. arXiv preprint arXiv:2012.11856, 2020.   \n[16] Anton Cherepkov, Andrey Voynov, and Artem Babenko. Navigating the gan parameter space for semantic image editing. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2021.   \n[17] Yuxuan Zhang, Wenzheng Chen, Huan Ling, Jun Gao, Yinan Zhang, Antonio Torralba, and Sanja Fidler. Image gans meet differentiable rendering for inverse graphics and interpretable 3d neural rendering. arXiv preprint arXiv:2010.09125, 2020.   \n[18] Edo Collins, Raja Bala, Bob Price, and Sabine Süsstrunk. Editing in style: Uncovering the local semantics of GANs. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.   \n[19] Peihao Zhu, Rameen Abdal, Yipeng Qin, and Peter Wonka. Sean: Image synthesis with semantic regionadaptive normalization. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.   \n[20] Kathleen M Lewis, Srivatsan Varadharajan, and Ira Kemelmacher-Shlizerman. Vogue: Try-on by stylegan interpolation optimization. arXiv preprint arXiv:2101.02285, 2021.   \n[21] Hyunsu Kim, Yunjey Choi, Junho Kim, Sungjoo Yoo, and Youngjung Uh. Exploiting spatial dimensions of latent in gan for real-time image editing. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2021.   \n[22] Shu-Yu Chen, Wanchao Su, Lin Gao, Shihong Xia, and Hongbo Fu. Deepfacedrawing: Deep generation of face images from sketches. ACM Trans. Graph., 39(4), 2020.   \n[23] Z. He, W. Zuo, M. Kan, S. Shan, and X. Chen. Attgan: Facial attribute editing by only changing what you want. IEEE Transactions on Image Processing, 28(11):5464–5478, Nov 2019.   \n[24] David Bau, Jun-Yan Zhu, Hendrik Strobelt, Bolei Zhou, Joshua B. Tenenbaum, William T. Freeman, and Antonio Torralba. Gan dissection: Visualizing and understanding generative adversarial networks. In Proceedings of the International Conference on Learning Representations (ICLR), 2019.   \n[25] David Bau, Hendrik Strobelt, William Peebles, Jonas Wulff, Bolei Zhou, Jun-Yan Zhu, and Antonio Torralba. Semantic photo manipulation with a generative image prior. ACM Trans. Graph., 38(4), 2019.   \n[26] Antoine Plumerault, Hervé Le Borgne, and Céline Hudelot. Controlling generative models with continuous factors of variations. In International Conference on Learning Representations, 2020.   \n[27] Erik Härkönen, Aaron Hertzmann, Jaakko Lehtinen, and Sylvain Paris. Ganspace: Discovering interpretable gan controls. In Proc. NeurIPS, 2020.   \n[28] David Bau, Steven Liu, Tongzhou Wang, Jun-Yan Zhu, and Antonio Torralba. Rewriting a deep generative model. In Proceedings of the European Conference on Computer Vision (ECCV), 2020.   \n[29] George Wolberg. Digital Image Warping. IEEE Computer Society Press, Washington, DC, USA, 1st edition, 1994.   \n[30] Alexei A. Efros and William T. Freeman. Image quilting for texture synthesis and transfer. SIGGRAPH ’01, page 341–346, New York, NY, USA, 2001. Association for Computing Machinery.   \n[31] Aaron Hertzmann, Charles E. Jacobs, Nuria Oliver, Brian Curless, and David H. Salesin. Image analogies. In Proceedings of the 28th Annual Conference on Computer Graphics and Interactive Techniques, SIGGRAPH ’01, page 327–340, New York, NY, USA, 2001. Association for Computing Machinery.   \n[32] E. Reinhard, M. Adhikhmin, B. Gooch, and P. Shirley. Color transfer between images. IEEE Computer Graphics and Applications, 21(5):34–41, 2001.   \n[33] Patrick Pérez, Michel Gangnet, and Andrew Blake. Poisson image editing. SIGGRAPH ’03, page 313–318, New York, NY, USA, 2003. Association for Computing Machinery.   \n[34] Scott Schaefer, Travis McPhail, and Joe Warren. Image deformation using moving least squares. ACM Trans. Graph., 25(3):533–540, 2006.   \n[35] Connelly Barnes, Eli Shechtman, Adam Finkelstein, and Dan B Goldman. Patchmatch: A randomized correspondence algorithm for structural image editing. ACM Trans. Graph., 28(3), 2009.   \n[36] Michael W. Tao, Micah K. Johnson, and Sylvain Paris. Error-tolerant image compositing. In ECCV, 2010.   \n[37] Leon A. Gatys, Alexander S. Ecker, and Matthias Bethge. Image style transfer using convolutional neural networks. In 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016.   \n[38] Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. In Proceedings of the IEEE international conference on computer vision, pages 2223–2232, 2017.   \n[39] Tiziano Portenier, Qiyang Hu, Attila Szabó, Siavash Arjomand Bigdeli, Paolo Favaro, and Matthias Zwicker. Faceshop: Deep sketch-based face image editing. ACM Trans. Graph., 37(4), 2018.   \n[40] Huan Ling, David Acuna, Karsten Kreis, Seung Wook Kim, and Sanja Fidler. Variational amodal object completion. Advances in Neural Information Processing Systems, 2020.   \n[41] Taesung Park, Jun-Yan Zhu, Oliver Wang, Jingwan Lu, Eli Shechtman, Alexei A. Efros, and Richard Zhang. Swapping autoencoder for deep image manipulation. In Advances in Neural Information Processing Systems, 2020.   \n[42] Seung Wook Kim, Jonah Philion, Antonio Torralba, and Sanja Fidler. DriveGAN: Towards a Controllable High-Quality Neural Simulation. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2021.   \n[43] Diederik P Kingma and Max Welling. Auto-encoding variational bayes. In The International Conference on Learning Representations (ICLR), 2014.   \n[44] Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In International Conference on Machine Learning, pages 1278–1286, 2014.   \n[45] Andrew Brock, Jeff Donahue, and Karen Simonyan. Large scale GAN training for high fidelity natural image synthesis. In International Conference on Learning Representations, 2019.   \n[46] Taesung Park, Ming-Yu Liu, Ting-Chun Wang, and Jun-Yan Zhu. Semantic image synthesis with spatiallyadaptive normalization. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 2337–2346, 2019.   \n[47] Lore Goetschalckx, Alex Andonian, Aude Oliva, and Phillip Isola. Ganalyze: Toward visual definitions of cognitive image properties. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), October 2019.   \n[48] Ali Jahanian\\*, Lucy Chai\\*, and Phillip Isola. On the \"steerability\" of generative adversarial networks. In International Conference on Learning Representations, 2020.   \n[49] Andrey Voynov and Artem Babenko. Unsupervised discovery of interpretable directions in the gan latent space. In International Conference on Machine Learning, pages 9786–9796. PMLR, 2020.   \n[50] Binxu Wang and Carlos R Ponce. A geometric analysis of deep generative image models and its applications. In International Conference on Learning Representations, 2021.   \n[51] Yujun Shen and Bolei Zhou. Closed-form factorization of latent semantics in gans. In CVPR, 2021.   \n[52] Ting-Chun Wang, Ming-Yu Liu, Jun-Yan Zhu, Andrew Tao, Jan Kautz, and Bryan Catanzaro. Highresolution image synthesis and semantic manipulation with conditional gans. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 8798–8807, 2018.   \n[53] Fujun Luan, Sylvain Paris, Eli Shechtman, and Kavita Bala. Deep photo style transfer. In 2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2017.   \n[54] Ming-Yu Liu, Thomas Breuel, and Jan Kautz. Unsupervised image-to-image translation networks. In Advances in neural information processing systems, pages 700–708, 2017.   \n[55] Yijun Li, Ming-Yu Liu, Xueting Li, Ming-Hsuan Yang, and Jan Kautz. A closed-form solution to photorealistic image stylization. In Proceedings of the European Conference on Computer Vision (ECCV), 2018.   \n[56] H. Kazemi, S. Iranmanesh, and N. Nasrabadi. Style and content disentanglement in generative adversarial networks. In 2019 IEEE Winter Conference on Applications of Computer Vision (WACV), pages 848–856, Los Alamitos, CA, USA, jan 2019. IEEE Computer Society.   \n[57] Jaejun Yoo, Youngjung Uh, Sanghyuk Chun, Byeongkyu Kang, and Jung-Woo Ha. Photorealistic style transfer via wavelet transforms. In 2019 IEEE/CVF International Conference on Computer Vision (ICCV), 2019.   \n[58] Guim Perarnau, Joost van de Weijer, Bogdan Raducanu, and Jose M. Álvarez. Invertible conditional gans for image editing. arXiv preprint arXiv:1611.06355, 2016.   \n[59] Jeff Donahue, Philipp Krähenbühl, and Trevor Darrell. Adversarial feature learning. arXiv preprint arXiv:1605.09782, 2016.   \n[60] Andrew Brock, Theodore Lim, James M. Ritchie, and Nick Weston. Neural photo editing with introspective adversarial networks. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings. OpenReview.net, 2017.   \n[61] Vincent Dumoulin, Ishmael Belghazi, Ben Poole, Alex Lamb, Martín Arjovsky, Olivier Mastropietro, and Aaron C. Courville. Adversarially learned inference. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings. OpenReview.net, 2017.   \n[62] Elad Richardson, Yuval Alaluf, Or Patashnik, Yotam Nitzan, Yaniv Azar, Stav Shapiro, and Daniel CohenOr. Encoding in style: a stylegan encoder for image-to-image translation. arXiv preprint arXiv:2008.00951, 2020.   \n[63] Jun-Yan Zhu, Philipp Krähenbühl, Eli Shechtman, and Alexei A Efros. Generative visual manipulation on the natural image manifold. In European conference on computer vision, pages 597–613. Springer, 2016.   \n[64] R. A. Yeh, C. Chen, T. Y. Lim, A. G. Schwing, M. Hasegawa-Johnson, and M. N. Do. Semantic image inpainting with deep generative models. In 2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 6882–6890, 2017.   \n[65] Zachary C. Lipton and Subarna Tripathi. Precise recovery of latent vectors from generative adversarial networks. arXiv preprint arXiv:1702.04782, 2017.   \n[66] Rameen Abdal, Yipeng Qin, and Peter Wonka. Image2stylegan: How to embed images into the stylegan latent space? In Proceedings of the IEEE International Conference on Computer Vision, pages 4432–4441, 2019.   \n[67] Minyoung Huh, Richard Zhang, Jun-Yan Zhu, Sylvain Paris, and Aaron Hertzmann. Transforming and projecting images into class-conditional generative networks. arXiv preprint arXiv:2005.01703, 2020.   \n[68] A. Creswell and A. A. Bharath. Inverting the generator of a generative adversarial network. IEEE Transactions on Neural Networks and Learning Systems, 30(7):1967–1974, 2019.   \n[69] A. Raj, Y. Li, and Y. Bresler. Gan-based projector for faster recovery with convergence guarantees in linear inverse problems. In 2019 IEEE/CVF International Conference on Computer Vision (ICCV), pages 5601–5610, 2019.   \n[70] D. Bau, J. Zhu, J. Wulff, W. Peebles, B. Zhou, H. Strobelt, and A. Torralba. Seeing what a gan cannot generate. In 2019 IEEE/CVF International Conference on Computer Vision (ICCV), pages 4501–4510, 2019.   \n[71] Jiapeng Zhu, Yujun Shen, Deli Zhao, and Bolei Zhou. In-domain gan inversion for real image editing. arXiv preprint arXiv:2004.00049, 2020.   \n[72] Jianjin Xu and Changxi Zheng. Linear semantics in generative adversarial networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9351–9360, 2021.   \n[73] David Bau, Alex Andonian, Audrey Cui, YeonHwan Park, Ali Jahanian, Aude Oliva, and Antonio Torralba. Paint by word. arXiv preprint arXiv:2103.10951, 2021.   \n[74] Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. Learning transferable visual models from natural language supervision. arXiv preprint arXiv:2103.00020, 2021.   \n[75] 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, pages 586–595, 2018.   \n[76] Jiankang Deng, Jia Guo, Niannan Xue, and Stefanos Zafeiriou. Arcface: Additive angular margin loss for deep face recognition. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4690–4699, 2019.   \n[77] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   \n[78] Maximilian Seitzer. pytorch-fid: FID Score for PyTorch. https://github.com/mseitzer/ pytorch-fid, August 2020. Version 0.1.1.   \n[79] Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett, editors, Advances in Neural Information Processing Systems 30, pages 6626–6637. Curran Associates, Inc., 2017.   \n[80] Mikołaj Binkowski, Danica J. Sutherland, Michael Arbel, and Arthur Gretton. Demystifying MMD GANs.´ In International Conference on Learning Representations, 2018.   \n[81] Omer Tov, Yuval Alaluf, Yotam Nitzan, Or Patashnik, and Daniel Cohen-Or. Designing an encoder for stylegan image manipulation. ACM Transactions on Graphics (TOG), 40(4):1–14, 2021.   \n[82] Yuri Viazovetskyi, Vladimir Ivashkin, and Evgeny Kashin. Stylegan2 distillation for feed-forward image manipulation. In European Conference on Computer Vision, pages 170–186. Springer, 2020.   \n[83] Cristian Vaccari and Andrew Chadwick. Deepfakes and disinformation: Exploring the impact of synthetic political video on deception, uncertainty, and trust in news. Social Media $^ +$ Society, 6(1):2056305120903408, 2020.   \n[84] Thanh Thi Nguyen, Quoc Viet Hung Nguyen, Cuong M. Nguyen, Dung Nguyen, Duc Thanh Nguyen, and Saeid Nahavandi. Deep learning for deepfakes creation and detection: A survey. arXiv preprint arXiv:1909.11573, 2021.   \n[85] Yisroel Mirsky and Wenke Lee. The creation and detection of deepfakes: A survey. ACM Comput. Surv., 54(1), 2021.   \n[86] Aditya Grover, Jiaming Song, Ashish Kapoor, Kenneth Tran, Alekh Agarwal, Eric J Horvitz, and Stefano Ermon. Bias correction of learned generative models using likelihood-free importance weighting. In Advances in Neural Information Processing Systems, 2019.   \n[87] Kristy Choi, Aditya Grover, Trisha Singh, Rui Shu, and Stefano Ermon. Fair generative modeling via weak supervision. In Proceedings of the 37th International Conference on Machine Learning, 2020.   \n[88] Ning Yu, Ke Li, Peng Zhou, Jitendra Malik, Larry Davis, and Mario Fritz. Inclusive GAN: improving data and minority coverage in generative models. In Computer Vision - ECCV 2020 - 16th European Conference, Glasgow, UK, August 23-28, 2020, Proceedings, Part XXII, 2020.   \n[89] Jinhee Lee, Haeri Kim, Youngkyu Hong, and Hye Won Chung. Self-diagnosing gan: Diagnosing underrepresented samples in generative adversarial networks. arXiv preprint arXiv:2102.12033, 2021. ",
+        "bbox": [
+            171,
+            98,
+            828,
+            920
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            77,
+            828,
+            920
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            42,
+            828,
+            916
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            70,
+            828,
+            919
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            92,
+            828,
+            382
+        ],
+        "page_idx": 14
+    }
+]