Add files using upload-large-folder tool

parse/train/H1xwNhCcYm/H1xwNhCcYm.md

@@ -0,0 +1,382 @@
+# DO DEEP GENERATIVE MODELS KNOW WHAT THEY DON’T KNOW?
+
+Eric Nalisnick∗†, Akihiro Matsukawa, Yee Whye Teh, Dilan Gorur, Balaji Lakshminarayanan∗ DeepMind
+
+# ABSTRACT
+
+A neural network deployed in the wild may be asked to make predictions for inputs that were drawn from a different distribution than that of the training data. A plethora of work has demonstrated that it is easy to find or synthesize inputs for which a neural network is highly confident yet wrong. Generative models are widely viewed to be robust to such mistaken confidence as modeling the density of the input features can be used to detect novel, out-of-distribution inputs. In this paper we challenge this assumption. We find that the density learned by flow-based models, VAEs, and PixelCNNs cannot distinguish images of common objects such as dogs, trucks, and horses (i.e. CIFAR-10) from those of house numbers (i.e. SVHN), assigning a higher likelihood to the latter when the model is trained on the former. Moreover, we find evidence of this phenomenon when pairing several popular image data sets: FashionMNIST vs MNIST, CelebA vs SVHN, ImageNet vs CIFAR-10 / CIFAR-100 / SVHN. To investigate this curious behavior, we focus analysis on flow-based generative models in particular since they are trained and evaluated via the exact marginal likelihood. We find such behavior persists even when we restrict the flows to constant-volume transformations. These transformations admit some theoretical analysis, and we show that the difference in likelihoods can be explained by the location and variances of the data and the model curvature. Our results caution against using the density estimates from deep generative models to identify inputs similar to the training distribution until their behavior for out-of-distribution inputs is better understood.
+
+# 1 INTRODUCTION
+
+Deep learning has achieved impressive success in applications for which the goal is to model a conditional distribution $p ( y | \mathbf { \boldsymbol { x } } )$ , with $y$ being a label and $_ { \textbf { \em x } }$ the features. While the conditional model $p ( y | \mathbf { \boldsymbol { x } } )$ may be highly accurate on inputs $_ { \textbf { \em x } }$ sampled from the training distribution, there are no guarantees that the model will work well on $_ { \textbf { \em x } }$ ’s drawn from some other distribution. For example, Louizos & Welling (2017) show that simply rotating an MNIST digit can make a neural network predict another class with high confidence (see their Figure 1a). Ostensibly, one way to avoid such overconfidently wrong predictions would be to train a density model $p ( { \pmb x } ; { \pmb \theta } )$ (with $\pmb \theta$ denoting the parameters) to approximate the true distribution of training inputs $p ^ { * } ( { \pmb x } )$ and refuse to make a prediction for any $_ { \textbf { \em x } }$ that has a sufficiently low density under $p ( { \pmb x } ; { \pmb \theta } )$ . The intuition is that the discriminative model $p ( y | \mathbf { \boldsymbol { x } } )$ likely did not observe enough samples in that region to make a reliable decision for those inputs. This idea has been proposed by various papers, cf. (Bishop, 1994), and as recently as in the panel discussion at Advances in Approximate Bayesian Inference (AABI) 2017 (Blei et al., 2017).
+
+Anomaly detection is just one motivating example for which we require accurate densities, and others include information regularization (Szummer & Jaakkola, 2003), open set recognition (Herbei & Wegkamp, 2006), uncertainty estimation, detecting covariate shift, active learning, model-based reinforcement learning, and transfer learning. Accordingly, these applications have lead to widespread interest in deep generative models, which take many forms such as variational auto-encoders (VAEs) (Kingma & Welling, 2014; Rezende et al., 2014), generative adversarial networks (GANs) (Goodfellow et al., 2014), auto-regressive models (van den Oord et al., 2016b;a), and invertible latent variable models (Tabak & Turner, 2013). The last two classes—auto-regressive and invertible models—are especially attractive since they offer exact computation of the marginal likelihood, requiring no approximate inference techniques.
+
+In this paper, we investigate if modern deep generative models can be used for anomaly detection, as suggested by Bishop (1994) and the AABI pannel (Blei et al., 2017), expecting a well-calibrated model to assign higher density to the training data than to some other data set. However, we find this to not be the case: when trained on CIFAR-10 (Krizhevsky & Hinton, 2009), VAEs, autoregressive models, and flow-based generative models all assign a higher density to SVHN (Netzer et al., 2011) than to the training data. We find this observation to be quite problematic and unintuitive since SVHN’s digit images are so visually distinct from the dogs, horses, trucks, boats, etc. found in CIFAR-10. Yet this phenomenon is not restricted to CIFAR-10 vs SVHN, and we report similar findings for models trained on CelebA and ImageNet. We go on to study these curious observations in flow-based models in particular since they allow for exact marginal density calculations. When the flow is restricted to have constant volume across inputs, we show that the out-of-distribution behavior can be explained in terms of the data’s variance and the model’s curvature.
+
+To the best of our knowledge, we are the first to report these unintuitive findings for a variety of deep generative models and image data sets. Moreover, our experiments with flow-based models isolate some crucial experimental variables such as the effect of constant-volume vs non-volume-preserving transformations. Lastly, our analysis provides some simple but general expressions for quantifying the gap in the model density between two data sets. We close the paper by urging more study of the out-of-training-distribution properties of deep generative models. Understanding their behaviour in this setting is crucial for their deployment to the real world.
+
+# 2 BACKGROUND
+
+We begin by establishing notation and reviewing the necessary background material. We denote matrices with upper-case and bold letters (e.g. $\boldsymbol { X }$ ), vectors with lower-case and bold (e.g. $\textbf { \em x }$ ), and scalars with lower-case and no bolding (e.g. $x )$ . As our focus is on generative models, let the collection of all observations be denoted by $\mathbf { \bar { X } } = \{ \pmb { x } _ { n } \} _ { n = 1 } ^ { N }$ with $_ { \textbf { \em x } }$ representing a vector containing all features and, if present, labels. All examples are assumed independently and identically drawn from some population $\pmb { x } \sim p ^ { * } ( \pmb { x } )$ (which is unknown) with support denoted $\mathcal { X }$ . We define the model density function to be $p ( { \pmb x } ; { \pmb \theta } )$ where $\theta \in \Theta$ are the model parameters, and let the model likelihood be denoted $\begin{array} { r } { p ( X ; \pmb { \theta } ) = \prod _ { n = 1 } ^ { N } p ( \pmb { x } _ { n } ; \pmb { \theta } ) } \end{array}$ .
+
+# 2.1 TRAINING NEURAL GENERATIVE MODELS
+
+Given (training) data $\boldsymbol { X }$ and a model class $\{ p ( \cdot ; \pmb \theta ) : \pmb \theta \in \Theta \}$ , we are interested in finding the parameters $\pmb \theta$ that make the model closest to the true but unknown data distribution $p ^ { * } ( { \pmb x } )$ . We can quantify this gap in terms of a Kullback–Leibler divergence (KLD):
+
+$$
+\mathrm { K L D } [ p ^ { * } ( x ) | | p ( x ; \pmb \theta ) ] = \int p ^ { * } ( \pmb x ) \log \frac { p ^ { * } ( \pmb x ) } { p ( \pmb x ; \pmb \theta ) } d \pmb x \approx - \frac { 1 } { N } \log p ( \pmb X ; \pmb \theta ) - \mathbb { H } [ p ^ { * } ]
+$$
+
+where the first term in the right-most expression is the average log-likelihood and the second is the entropy of the true distribution. As the latter is a fixed constant, minimizing the KLD amounts to finding the parameter settings that maximize the data’s log density: $\begin{array} { r } { \pmb { \theta } ^ { * } = \arg \operatorname* { m a x } _ { \pmb { \theta } } \log p ( \pmb { X } ; \pmb { \theta } ) = } \end{array}$ arg $\begin{array} { r } { \operatorname* { m a x } _ { \pmb { \theta } } \sum _ { n = 1 } ^ { N } \log p ( \pmb { x } _ { n } ; \pmb { \theta } ) } \end{array}$ . Note that $p ( { \pmb x } _ { n } ; { \pmb \theta } )$ alone does not have any interpretation as a probability. To extract probabilities from the model density, we need to integrate over some region $\begin{array} { r } { \Omega \colon \bar { P } ( \Omega ) = \int _ { \Omega } p ( \dot { \mathbf { x } } ; \pmb { \theta } ) d x } \end{array}$ . Adding noise to the data during model optimization can mock this integration step, encouraging the density model to output something nearer to probabilities (Theis et al., 2016):
+
+$$
+\log \int p ( { \pmb x } _ { n } + { \pmb \delta } ; { \pmb \theta } ) p ( { \pmb \delta } ) d { \pmb \delta } \geq \mathbb { E } _ { { \pmb \delta } } \left[ \log p ( { \pmb x } _ { n } + { \pmb \delta } ; { \pmb \theta } ) \right] \approx \log p ( { \pmb x } _ { n } + { \tilde { \pmb \delta } } ; { \pmb \theta } )
+$$
+
+where $\tilde { \delta }$ is a sample from $p ( \delta )$ . The resulting objective is a lower-bound, making it a suitable optimization target. All models in all of the experiments that we report are trained with input noise.
+
+Due to this ambiguity between densities and probabilities, we call the quantity $\log p ( X + \tilde { \Delta } ; \pmb { \theta } )$ a ‘log-likelihood,’ even if $\boldsymbol { X }$ is drawn from a distribution unlike the training data.
+
+Regarding the choice of density model, we could choose one of the standard density functions for $p ( { \pmb x } _ { n } ; { \pmb \theta } )$ , e.g. a Gaussian, but these may not be suitable for modeling the complex, high-dimensional data sets we often observe in the real world. Hence, we want to parametrize the model density with some high-capacity function $f$ , which is usually chosen to be a neural network. That way the model has a somewhat compact representation and can be optimized via gradient ascent. We experiment with three variants of neural generative models: autoregressive, latent variable, and invertible. In the first class, we study the PixelCNN (van den Oord et al., 2016b), and due to space constraints, we refer the reader to van den Oord et al. (2016b) for its definition. As a representative of the second class, we use a $V A E$ (Kingma & Welling, 2014; Rezende et al., 2014). See Rosca et al. (2018) for descriptions of the precise versions we use. Lastly, invertible flow-based generative models are the third class. We define them in detail below since we study them with the most depth.
+
+# 2.2 GENERATIVE MODELS VIA CHANGE OF VARIABLES
+
+The VAE and many other generative models are defined as a joint distribution between the observed and latent variables. However, another path forward is to perform a change of variables. In this case $_ { \textbf { \em x } }$ and $_ { z }$ are one and the same, and there is no longer any notion of a product space $\mathcal { X } \times \mathcal { Z }$ . Let $f : \mathcal X \mapsto \mathcal Z$ be a diffeomorphism from the data space $\mathcal { X }$ to a latent space $\mathcal { Z }$ . Using $f$ then allows us to compute integrals over $_ z$ as an integral over $_ { \textbf { \em x } }$ and vice versa:
+
+$$
+\int _ { z } p _ { z } ( z ) d z = \int _ { x } p _ { z } ( f ( x ) ) \left| { \frac { \partial f } { \partial x } } \right| d x = \int _ { x } p _ { x } ( x ) d x = \int _ { z } p _ { x } ( f ^ { - 1 } ( z ) ) \left| { \frac { \partial f ^ { - 1 } } { \partial z } } \right| d z
+$$
+
+where $| \partial f / \partial x |$ and $| \partial f ^ { - 1 } / \partial z |$ are known as the volume elements as they adjust for the volume change under the alternate measure. Specifically, when the change is w.r.t. coordinates, the volume element is the determinant of the diffeomorphism’s Jacobian matrix, which we denote as $| \partial f / \partial x |$ .
+
+The change of variables formula is a powerful tool for generative modeling as it allows us to define a distribution $p ( { \pmb x } )$ entirely in terms of an auxiliary distribution $p ( z )$ , which we are free to choose, and $f$ . Denote the parameters of the change of variables model as $\pmb \theta = \{ \phi , \psi \}$ with $\phi$ being the diffeomorphism’s parameters, i.e. $f ( { \pmb x } ; \phi )$ , and $\psi$ being the auxiliary distribution’s parameters, i.e. $p ( z ; \psi )$ . We can perform maximum likelihood estimation for the model as follows:
+
+$$
+\theta ^ { * } = \underset { \theta } { \arg \operatorname* { m a x } } \log p _ { x } ( X ; \theta ) = \underset { \phi , \psi } { \arg \operatorname* { m a x } } \sum _ { n = 1 } ^ { N } \log p _ { z } ( f ( x _ { n } ; \phi ) ; \psi ) + \log \left| \frac { \partial f _ { \phi } } { \partial x _ { n } } \right| .
+$$
+
+Optimizing $\psi$ must be done carefully so as to not result in a trivial model. For instance, optimization could make $p ( z ; \psi )$ close to uniform if there are no constraints on its variance. For this reason, most implementations leave $\psi$ as fixed (usually a standard Gaussian) in practice. Likewise, we assume it as fixed from here forward, thus omitting $\psi$ from equations to reduce notational clutter. After training, samples can be drawn from the model via the inverse transform: $\tilde { \pmb { x } } = f ^ { - 1 } ( \tilde { z } ; \phi ) , \tilde { z } \sim p ( \mathbf { z } )$ .
+
+For the particular form of $f$ , most work to date has constructed the bijection from affine coupling layers (ACLs) (Dinh et al., 2017), which transform $_ { \textbf { \em x } }$ by way of translation and scaling operations. Specifically, ACLs take the form: $f _ { \mathrm { A C L } } ( \pmb { x } ; \pmb { \phi } ) = [ \mathrm { e x p } \{ s ( \pmb { x } _ { d : } ; \phi _ { s } ) \} \odot \pmb { x } _ { : d } + t ( \pmb { x } _ { d : } ; \phi _ { t } ) , \pmb { x } _ { d : } ] .$ , where $\odot$ denotes an element-wise product. This transformation, firstly, splits the input vector in half, i.e. $\pmb { x } = [ \pmb { x } _ { : d } , \pmb { x } _ { d : } ]$ (using Python list syntax). Then the second half of the vector is fed into two arbitrary neural networks (possibly with tied parameters) whose outputs are denoted $t ( x _ { d } ; \phi _ { t } )$ and $s ( \pmb { x } _ { d : } ; \phi _ { s } )$ , with $\phi$ · being the collection of weights and biases. Finally, the output is formed by (1) scaling the first half of the input by one neural network output, i.e. $\mathrm { e x p } \{ s ( { \pmb x } _ { d : } ; \phi _ { s } ) \} \odot { \pmb x } _ { : d }$ , (2) translating the result of the scaling operation by the second neural network output, i.e. $( \cdot ) + t ( { \pmb x } _ { d : } ; \phi _ { t } )$ , and (3) copying the second half of $_ { \textbf { \em x } }$ forward, making it the second half of $f _ { \mathrm { A C L } } ( \pmb { x } ; \dot { \phi } )$ , i.e. $f _ { d : } = \pmb { x } _ { d : }$ . ACLs are stacked to make rich hierarchical transforms, and the latent representation $_ z$ is output from this composition, i.e. $z _ { n } = f ( \pmb { x } _ { n } ; \phi )$ . A permutation operation is required between ACLs to ensure the same elements are not repeatedly used in the copy operations. We use $f$ without subscript to denote the complete transform and overload the use of $\phi$ to denote the parameters of all constituent layers.
+
+This class of transform is known as non-volume preserving (NVP) (Dinh et al., 2017) since the volume element does not necessarily evaluate to one and can vary with each input $_ { \textbf { \em x } }$ . Although non-zero, the log determinant of the Jacobian is still tractable: $\begin{array} { r } { \log | \partial f _ { \phi } / \partial \pmb { x } | = \sum _ { j = d } ^ { D } s _ { j } ( \pmb { x } _ { d } ; \pmb { \phi } _ { s } ) } \end{array}$ A diffeomorphic transform can also be defined with just translation operations, as was done in earlier work by Dinh et al. (2015), and this transformation is volume preserving (VP) since the volume term is one and thus has no influence in the likelihood calculation. We will examine another class of flows we term constant-volume (CV) since the volume, while not preserved, is constant across all $_ { \textbf { \em x } }$ . Appendix A provides additional details on implementing flow-based generative models.
+
+# 3 MOTIVATING OBSERVATIONS
+
+Given the impressive advances of deep generative models, we sought to test their ability to quantify when an input comes from a different distribution than that of the training set. This calibration w.r.t. out-of-distribution data is essential for applications such as safety—if we were using the generative model to filter the inputs to a discriminative model—and for active learning. For the experiment, we trained the same Glow architecture described in Kingma & Dhariwal (2018)—except small enough that it could fit on one $\mathrm { G P U ^ { 1 } }$ —on FashionMNIST and CIFAR-10. Appendix A provides additional implementation details. We then calculated the log-likelihood (higher value is better) and bits-per-dimension (BPD, lower value is better)2 of the test split of two different data sets of the same dimensionality—MNIST $( 2 8 \times 2 8 )$ and SVHN $( 3 2 \times 3 2 \times 3 )$ respectively. We expect the models to assign a lower probability to this data because they were not trained on it. Samples from the Glow models trained on each data set are shown in Figure 13 in the Appendix.
+
+Data Set Avg. Bits Per Dimension  
+
+<table><tr><td colspan="2">Glow Trained on CIFAR-10</td></tr><tr><td>CIFAR10-Train</td><td>3.386</td></tr><tr><td>CIFAR10-Test SVHN-Test</td><td>3.464 2.389</td></tr><tr><td colspan="2">Glow Trained on SVHN</td></tr><tr><td>SVHN-Test</td><td>2.057</td></tr></table>
+
+Data Set Avg. Bits Per Dimension  
+Figure 1: Testing Out-of-Distribution. Log-likelihood (expressed in bits per dimension) calculated from Glow (Kingma & Dhariwal, 2018) on MNIST, FashionMNIST, SVHN, CIFAR-10.   
+
+<table><tr><td>DataSet Avg.BitsPerDimension</td></tr><tr><td>Glow Trained on FashionMNIST</td></tr><tr><td>FashionMNIST-Train 2.902 FashionMNIST-Test 2.958</td></tr><tr><td>MNIST-Test 1.833</td></tr><tr><td>Glow Trained on MNIST</td></tr><tr><td></td></tr><tr><td>MNIST-Test 1.262</td></tr></table>
+
+Beginning with FashionMNIST vs MNIST, the left subtable of Figure 1 shows the average BPD of the training data (FashionMNIST-Train), the in-distribution test data (FashionMNIST-Test), and the out-of-distribution data (MNIST-Test). We see a peculiar result: the MNIST split has the lowest BPD, more than one bit less than the FashionMNIST train and test sets. To check if this is due to outliers skewing the average, we report a (normalized) histogram in Figure 2 (a) of the log-likelihoods for the three splits. We see that MNIST (red bars) is clearly and systematically shifted to the RHS of the plot (highest likelihood).
+
+Moving on to CIFAR-10 vs SVHN, the right subtable of Figure 1 again reports the BPD of the training data (CIFAR10-Train), the in-distribution test data (CIFAR10-Test), and the out-of-distribution data (SVHN-Test). We again see the phenomenon: the SVHN BPD is one bit lower than that of both in-distribution data sets. Figure 2 (b) shows a similar histogram of the log-likelihoods. Clearly the SVHN examples (red bars) have a systematically higher likelihood, and therefore the result is not caused by any outliers.
+
+Subfigures (c) and (d) of Figure 2 show additional results for CelebA and ImageNet. When trained on CelebA, Glow assigns a higher likelihood to SVHN (red bars), a data set the model has never seen before. Similarly, when trained on ImageNet, Glow assigns a higher likelihood to the test splits of SVHN (red), CIFAR-10 (yellow), and CIFAR-100 (green). The difference is quite drastic in the case of SVHN (red) but modest for the two CIFAR splits. This phenomenon is not symmetric. CIFAR-10 does not have a higher likelihood under a Glow trained on SVHN; see Figure 6 in Appendix B for these results. We report results only for Glow, but we observed the same behavior for RNVP transforms (Dinh et al., 2017).
+
+![](images/0a9475f2441d377608b0ca17c4c491d7bfbbfe7d9410ec065c5f4f423f775144.jpg)  
+Figure 2: Histogram of Glow log-likelihoods for FashionMNIST vs MNIST (a), CIFAR-10 vs SVHN (b), CelebA vs SVHN (c), and ImageNet vs CIFAR-10 / CIFAR-100 / SVHN (d).
+
+We next tested if the phenomenon occurs for other common deep generative models: PixelCNNs and VAEs. We do not include GANs in the comparison since evaluating their likelihood is an open problem. Figure 3 reports the same histograms as above for these models, showing the distribution of $\log p ( { \pmb x } )$ evaluations for FashionMNIST vs MNIST (a, b) and CIFAR-10 vs SVHN (c, d). The training splits are again denoted with black bars, and the test splits with blue, and the out-of-distribution splits with red. The red bars are shifted to the right in all four plots, signifying the behavior exists in spite of the differences between model classes.
+
+# 4 DIGGING DEEPER INTO THE FLOW-BASED MODEL
+
+While we observed the out-of-distribution phenomenon for PixelCNN, VAE, and Glow, now we narrow our investigation to just the class of invertible generative models. The rationale is that they allow for better experimental control as, firstly, they can compute exact marginal likelihoods (unlike VAEs), and secondly, the transforms used in flow-based models have Jacobian constraints that simplify the analysis we present in Section 5. To further analyze the high likelihood of the out-of-distribution (non-training) samples, we next report the contributions to the likelihood of each term in the change-of-variables formula. At first this suggested the volume element was the primary cause of SVHN’s high likelihood, but further experiments with constant-volume flows show the problem exists with them as well.
+
+Decomposing the change-of-variables objective. To further examine this curious phenomenon, we inspect the change-of-variables objective itself, investigating if one or both terms give the outof-distribution data a higher value. We report the constituent $\log p ( z )$ and $\log | \partial f _ { \phi } / \partial x |$ terms for NVP-Glow in Figure 4, showing histograms for $\log p ( z )$ in subfigure (a) and for $\dot { \log { | \partial \dot { f } _ { \phi } / \partial x | } }$ in subfigure (b). We see that $p ( z )$ behaves mostly as expected. The red bars (SVHN) are clearly shifted to the left, representing lower likelihoods under the latent distribution. Moving on to the volume element, this term seems to cause SVHN’s higher likelihood. Subfigure (b) shows that all of the
+
+![](images/fc1649764335e1ea87f9326797000f78bfd2837c7e74868d0524da29d89f0651.jpg)  
+Figure 3: PixelCNN and VAE. Log-likelihoods calculated by PixelCNN (a, c) and VAE (b, d) on FashionMNIST vs MNIST (a, b) and CIFAR-10 vs SVHN (c, d). VAE models are the convolutional categorical variant described by Rosca et al. (2018).
+
+![](images/0a2b15e61de054ad748934aa2484ba56a64f549675399d1b0cdb99a606913a77.jpg)  
+Figure 4: Decomposing the Likelihood of NVP-Glow / CV-Glow Results. The histograms in (a) and (b) show NVP-Glow’s log-likelihood decomposed into contributions from the $_ z$ -distribution and volume element, respectively, for CIFAR-10 vs SVHN. Subfigure (c) shows log-likelihood evaluations for constant-volume (CV) Glow, again when trained on CIFAR-10 and tested on SVHN. Subfigure (d) reports NVP-Glow’s BPD over the course of training, showing that the phenomenon happens throughout and could not be prevented by early stopping.
+
+SVHN log-volume evaluations (red) are conspicuously shifted to the right—to higher values—when compared to CIFAR-10’s (blue and black). Since SVHN’s $p ( z )$ evaluations are only slightly less than CIFAR-10’s, the volume term dominates, resulting in SVHN having a higher likelihood.
+
+Is the volume the culprit? In addition to the empirical evidence against the volume element, we notice that one of the terms in the change-of-variables objective—by rewarding the maximization of the Jacobian determinant—encourages the model to increase its sensitivity to perturbations in $\mathcal { X }$ . This behavior starkly contradicts a long history of derivative-based regularization penalties that reward the model for decreasing its sensitivity to input directions. For instance, Girosi et al. (1995) and Rifai et al. (2011) propose penalizing the Frobenius norm of a neural network’s Jacobian for classifiers and autoencoders respectively. See Appendix C for more analysis of the log volume element.
+
+To experimentally control for the effect of the volume term, we trained Glow with constant-volume (CV) transformations. We modify the affine layers to use only translation operations (Dinh et al., 2015) but keep the $1 \times 1$ convolutions as is. The log-determinant-Jacobian is then $\begin{array} { r } { H W \sum _ { k } \log \left| U _ { k } \right| } \end{array}$ where $| U _ { k } |$ is the determinant of the convolutional weights $U _ { k }$ for the $k$ th flow. This makes the volume element constant across all inputs $_ { \textbf { \em x } }$ , allowing us to isolate its effect while still keeping the model expressive. Subfigures (c) and (d) of Figure 4 show the results for this model, which we term CV-Glow (constant-volume Glow). Subfigure (c) shows a histogram of the $\log p ( { \pmb x } )$ evaluations, just as shown before in Figure 2, and we see that SVHN (red) still achieves a higher likelihood (lower BPD) than the CIFAR-10 training set. Subfigure (d) shows the SVHN vs CIFAR-10 BPD over the course of training for NVP-Glow. Notice that there is no cross-over point in the curves.
+
+Other experiments: random and constant images, ensembles. Other work on generative models (Sønderby et al., 2017; van den Oord et al., 2018) has noted that they often assign the highest likelihood to constant inputs. We also test this case, reporting the BPD in Appendix Figure 8 for NVP-Glow models. We find constant inputs have the highest likelihood for our models as well: 0.589 BPD for CIFAR-10. We also include in the table the BPD of random inputs for comparison.
+
+We also hypothesized that averaging over the parameters may mitigate the phenomenon. While integration over the entire parameter space would be ideal, this is analytically and computationally difficult for Glow. Lakshminarayanan et al. (2017) show that deep ensembles can guard against over-confidence for anomalous inputs while being more practical to implement. We opted for this approach, training five Glow models independently and averaging their likelihoods to evaluate test data. Each model was given a different initialization of the parameters to help diversify the ensemble. Figure 9 in Appendix F reports a histogram of the $\log p ( { \pmb x } )$ evaluations when averaging over the ensemble. We see nearly identical results: SVHN is still assigned a higher likelihood than the CIFAR-10 training data.
+
+# 5 SECOND ORDER ANALYSIS
+
+In this section, we aim to provide a more direct analysis of when another distribution might have higher likelihood than the one used for training. We propose analyzing the phenomenon by way of linearizing the difference in expected log-likelihoods. This approach undoubtedly gives a crude approximation, but as we show below, it agrees with and gives insight into some of the observations reported above. Consider two distributions: the training distribution $\ b { x } \sim p ^ { * }$ and some dissimilar distribution $x \sim q$ also with support on $\mathcal { X }$ . For a given generative model $p ( { \pmb x } ; { \pmb \theta } )$ , the adversarial distribution $q$ will have a higher likelihood than the training data’s if $\mathbb { E } _ { q } [ \log p ( { \pmb x } ; { \pmb \theta } ) ] - \mathbb { E } _ { p ^ { * } } [ \log p ( { \pmb x } ; { \pmb \theta } ) ] > 0$ . This expression is hard to analyze directly so we perform a second-order expansion of the log-likelihood around an interior point $\scriptstyle { \mathbf { { \mathit { x } } } } _ { 0 }$ . Applying the expansion $\begin{array} { r } { \log p ( { \pmb x } ; { \pmb \theta } ) \approx \log \bar { p } ( { \pmb x } _ { 0 } ; { \pmb \theta } ) + \nabla _ { { \pmb x } _ { 0 } } \log p ( { \pmb x } _ { 0 } ; { \pmb \theta } ) ^ { T } ( { \pmb x } - { \pmb x } _ { 0 } ) + } \end{array}$ $\begin{array} { r } { \frac { 1 } { 2 } \operatorname { T r } \{ \nabla _ { \pmb { x } _ { 0 } } ^ { 2 } \log p ( \pmb { x } _ { 0 } ; \mathbf { \hat { \theta } } ) ( \pmb { x } - \pmb { x } _ { 0 } ) ( \mathbf { \hat { x } } - \pmb { x } _ { 0 } ) ^ { T } \} } \end{array}$ 0    to both likelihoods, taking expectations, and canceling the common terms, we have:
+
+$$
+\begin{array} { r l } & { 0 < \mathbb { E } _ { q } [ \log p ( \pmb { x } ; \pmb { \theta } ) ] - \mathbb { E } _ { p ^ { * } } [ \log p ( \pmb { x } ; \pmb { \theta } ) ] } \\ & { \quad \approx \nabla _ { \pmb { x } _ { 0 } } \log p ( x _ { 0 } ; \pmb { \theta } ) ^ { T } ( \mathbb { E } _ { q } [ \pmb { x } ] - \mathbb { E } _ { p ^ { * } } [ \pmb { x } ] ) + \frac { 1 } { 2 } \operatorname { T r } \{ \nabla _ { \pmb { x } _ { 0 } } ^ { 2 } \log p ( \pmb { x } _ { 0 } ; \pmb { \theta } ) ( \pmb { \Sigma } _ { q } - \pmb { \Sigma } _ { p ^ { * } } ) \} } \end{array}
+$$
+
+where $\pmb { \Sigma } = \mathbb { E } \left[ ( \pmb { x } - \pmb { x } _ { 0 } ) ( \pmb { x } - \pmb { x } _ { 0 } ) ^ { T } \right]$ , the covariance matrix, and $\operatorname { T r } \{ \cdot \}$ is the trace operation. Since the expansion is accurate only locally around $\scriptstyle { \mathbf { { \mathit { x } } } } _ { 0 }$ , we next assume that $\mathbb { E } _ { q } [ { \pmb x } ] = \mathbb { E } _ { p ^ { * } } [ { \pmb x } ] = { \pmb x } _ { 0 }$ . While this at first glance may seem like a strong assumption, it is not too removed from practice since data is usually centered before being fed to the model. For SVHN and CIFAR-10 in particular, we find this assumption to hold; see Figure 5 (a) for the empirical means of each dimension of CIFAR-10 (green) and SVHN (orange). All of SVHN’s means fall within the empirical range of CIFAR-10’s, and the maximum difference between any dimension is less than 38 pixel values. Assuming equal means, we then have:
+
+$$
+\begin{array} { l } { 0 < \mathbb { E } _ { q } [ \log p ( \pmb { x } ; \pmb { \theta } ) ] - \mathbb { E } _ { p ^ { * } } [ \log p ( \pmb { x } ; \pmb { \theta } ) ] \approx \displaystyle \frac { 1 } { 2 } \operatorname { T r } \{ \nabla _ { \pmb { x } _ { 0 } } ^ { 2 } \log p ( \pmb { x } _ { 0 } ; \pmb { \theta } ) ( \pmb { \Sigma } _ { q } - \pmb { \Sigma } _ { p ^ { * } } ) \} } \\ { = \displaystyle \frac { 1 } { 2 } \operatorname { T r } \left\{ \left[ \nabla _ { \pmb { x } _ { 0 } } ^ { 2 } \log p _ { z } ( f ( \pmb { x } _ { 0 } ; \phi ) ) + \nabla _ { \pmb { x } _ { 0 } } ^ { 2 } \log \left| \frac { \partial f _ { \phi } } { \partial \pmb { x } _ { 0 } } \right| \right] ( \pmb { \Sigma } _ { q } - \pmb { \Sigma } _ { p ^ { * } } ) \right\} , } \end{array}
+$$
+
+where the second line assumes the generative model to be flow-based.
+
+Analysis of CV-Glow. We use the expression in Equation 5 to analyze the behavior of CV-Glow on CIFAR-10 vs SVHN, seeing if the difference in likelihoods can be explained by the model curvature
+
+and data’s second moment. The second derivative terms simplify considerably for CV-Glow with a   
+spherical latent density. Given a $C \times C$ kernel $U _ { k }$ , with $k$ indexing the flow and $C$ the number of   
+input channels, tspatial height andderivative is then $\begin{array} { r } { \partial f _ { h , w , c } / \partial x _ { h , w , c } = \prod _ { k } \sum _ { j = 1 } ^ { C } u _ { k , c , j } } \end{array}$ , with olutio $h$ and l ker $w$ indexing thel. The second $j$ $k$ $1 \times 1$ $\partial ^ { 2 } f _ { h , w , c } / \bar { \partial x } _ { h , w , c } ^ { 2 } = 0$
+
+$$
+\begin{array} { l } { { \mathrm { T r } \left\{ \left[ \nabla _ { x _ { 0 } } ^ { 2 } \log p ( x _ { 0 } ; \theta ) \right] ( \Sigma _ { q } - \Sigma _ { p ^ { * } } ) \right\} } } \\ { { \mathrm { } = \displaystyle \frac { \partial ^ { 2 } } { \partial z ^ { 2 } } \log p ( z ; \psi ) \sum _ { c = 1 } ^ { C } \left( \prod _ { k = 1 } ^ { K } \sum _ { j = 1 } ^ { C } u _ { k , c , j } \right) ^ { 2 } \sum _ { h , w } ( \sigma _ { q , h , w , c } ^ { 2 } - \sigma _ { p ^ { * } , h , w , c } ^ { 2 } ) . } } \end{array}
+$$
+
+The derivation is given in Appendix G. Plugging in the second derivative of the Gaussian’s log density—a common choice for the latent distribution in flow models (Dinh et al., 2017; Kingma & Dhariwal, 2018)—and the empirical variances, we have:
+
+$$
+\begin{array} { r l } & { \mathbb { E } _ { \mathrm { s v \pi } } [ \log p ( \boldsymbol { x } ; \boldsymbol { \theta } ) ] - \mathbb { E } _ { \mathrm { c I F A R - 1 0 } } [ \log p ( \boldsymbol { x } ; \boldsymbol { \theta } ) ] } \\ & { \qquad \approx \displaystyle \frac { - 1 } { 2 \sigma _ { \psi } ^ { 2 } } \left[ \alpha _ { 1 } ^ { 2 } ( 4 9 . 6 - 6 1 . 9 ) + \alpha _ { 2 } ^ { 2 } ( 5 2 . 7 - 5 9 . 2 ) + \alpha _ { 3 } ^ { 2 } ( 5 3 . 6 - 6 8 . 1 ) \right] } \\ & { \qquad \quad = \displaystyle \frac { 1 } { 2 \sigma _ { \psi } ^ { 2 } } \left[ \alpha _ { 1 } ^ { 2 } \cdot 1 2 . 3 + \alpha _ { 2 } ^ { 2 } \cdot 6 . 5 + \alpha _ { 3 } ^ { 2 } \cdot 1 4 . 5 \right] \ge 0 \quad \mathrm { w h e r e } \alpha _ { c } = \prod _ { k = 1 } ^ { K } \sum _ { j = 1 } ^ { C } u _ { k , c , j } } \end{array}
+$$
+
+and where $\sigma _ { \psi } ^ { 2 }$ is the variance of the latent distribution. We know the final expression is greater than or equal to zero since all $\alpha _ { c } ^ { 2 } \geq 0$ . Equality is achieved only for $\sigma _ { \psi _ { - } } ^ { 2 } \to \infty$ or in the unusual case of at least one all-zero row in any convolutional kernel for all channels. Thus, the second-order expression does indeed predict we should see a higher likelihood for SVHN than for CIFAR-10. Moreover, we leave the CV-Glow’s parameters as constants to emphasize the expression is non-negative for any parameter setting. This finding is supported by our observations that using an ensemble of Glows resulted in an almost identical likelihood gap (Figure 9) and that the gap remained relatively constant over the course of training (Figure 4d). Furthermore, the $\partial ^ { 2 } \log p ( z ; \bar { \psi } ) / \partial z ^ { 2 }$ term would be negative for any log-concave density function, meaning that changing the latent density to Laplace or logistic would not change the result.
+
+![](images/9404be5a5d1add49dc13ed53bdf4d51577914e8b6cda1879cef284556435b94c.jpg)  
+(a) Histogram of per-dimension means and variances (empirical). (b) Graying images increases likelihood.   
+Figure 5: Empirical Distributions and Graying Effect. Note that pixels are converted from 0-255 scale to 0-1 scale by diving by 256. See Figure 10 for results on datasets of $2 8 \times 2 8 \times 1$ images.
+
+Our conclusion is that SVHN simply "sits inside of" CIFAR-10—roughly same mean, smaller variance—resulting in its higher likelihood. This insight also holds true for the additional results presented in subfigures (c) and (d) of Figure 2. Examining Figure 5 (a) again, we see that ImageNet, the CIFARs, and SVHN all have nearly overlapping means and that ImageNet has the highest variance. Therefore we expect SVHN and the CIFARs to have a higher likelihood than ImageNet on an ImageNet-trained model, which is exactly what we observe in Figure 2 (d). Moreover, the degree of the differences in likelihoods agrees with the differences in variances. SVHN clearly has the smallest variance and the largest likelihood. In turn, we can artificially increase the likelihood of a data set by shrinking its variance. For RGB images, shrinking the variance is equivalent to ’graying’ the images, i.e. making the pixel values closer to 128. We show in Figure 5 (b) that doing exactly this improves the likelihood of both CIFAR-10 and SVHN. Reducing the variance of the latent representations has the same effect, which is shown by Figure 12 in the Appendix.
+
+# 6 RELATED WORK
+
+This paper is inspired by and most related to recent work on evaluation of generative models. Worthy of foremost mention is the work of Theis et al. (2016), which showed that high likelihood is neither sufficient nor necessary for the model to produce visually satisfying samples. However, their paper does not consider out-of-distribution inputs. In this regard, there has been much work on adversarial inputs (Szegedy et al., 2014). While the term is used broadly, it commonly refers to inputs that have been imperceptibly modified so that the model can no longer provide an accurate output (a mis-classification, usually). Adversarial attacks on generative models have been studied by (at least) Tabacof et al. (2016) and Kos et al. (2018), but these methods of attack require access to the model. We, on the other hand, are interested in model calibration for any out-of-distribution set and especially for common data sets not constructed with any nefarious intentions nor for attack on a particular model. Various papers (Hendrycks & Gimpel, 2017; Lakshminarayanan et al., 2017; Liang et al., 2018) have reported that discriminative neural networks can produce overconfident predictions on out-of-distribution inputs. In a related finding, Lee et al. (2018) reported that it was much harder to recognize an input as out-of-distribution when the classifier was trained on CIFAR-10 in comparison to training on SVHN.
+
+Testing the robustness of deep generative models to out-of-distribution inputs had not been investigated previously, to the best of our knowledge. However, there is work concurrent with ours that has tested their ability to detect anomalous inputs. Shafaei et al. (2018) and Hendrycks et al. (2019) also observe that $\mathrm { P i x e l C N N + + }$ cannot provide reliable outlier detection. Hendrycks et al. (2019) mitigate the CIFAR-10 vs SVHN issue by exposing the model to outliers during training. They do not consider flow-based models. Škvára et al. (2018) experimentally compare VAEs and GANs against $\mathbf { k }$ -nearest neighbors (kNNs), showing that VAEs and GANs outperform kNNs only when known outliers can be used for hyperparameter selection. In the work most similar to ours, Choi & Jang (2018) report the same CIFAR-10 vs SVHN phenomenon for Glow—independently confirming our motivating observation. As a fix, they propose training an ensemble of generative models with an adversarial objective and testing for out-of-training-distribution inputs by computing the WatanabeAkaike information criterion via the ensemble. This work is complementary to ours since they focus on providing a detection method whereas we are interested in understanding how and when the phenomenon can arise. The results we present in Equation 6 do not apply to Choi & Jang (2018)’s models since they use scaling operations in their affine coupling layers, making them NVP.
+
+# 7 DISCUSSION
+
+We have shown that comparing the likelihoods of deep generative models alone cannot identify the training set or inputs like it. Therefore we urge caution when using these models with outof-training-distribution inputs or in unprotected user-facing systems. Moreover, our analysis in Section 5 shows that the CIFAR-10 vs SVHN phenomenon would persist for any constant-volume Glow no matter the parameter values nor the choice of latent density (as long as it is log-concave). While we cannot conclude that this is a pathology in deep generative models, it does suggest the need for further work on generative models and their evaluation. The models we tested seem to be capturing low-level statistics rather than high-level semantics, and better inductive biases, optimization procedures, or uncertainty quantification may be necessary. Yet, deep generative models can detect out-of-distribution inputs when using alternative metrics (Choi & Jang, 2018) and modified training procedures (Hendrycks et al., 2019). The problem then may be a fundamental limitation of high-dimensional likelihoods. Until these open problems are better understood, we must temper the enthusiasm with which we preach the benefits of deep generative models.
+
+# ACKNOWLEDGMENTS
+
+We thank Aaron van den Oord, Danilo Rezende, Eric Jang, Florian Stimberg, Josh Dillon, Mihaela Rosca, Rui Shu, Sander Dieleman, and the anonymous reviewers for their helpful feedback and discussions.
+
+# REFERENCES
+
+Christopher M Bishop. Novelty Detection and Neural Network Validation. IEE Proceedings-Vision, Image and Signal processing, 141(4):217–222, 1994.
+
+Christopher M Bishop. Training with Noise is Equivalent to Tikhonov Regularization. Neural Computation, 7(1):108–116, 1995.
+
+David Blei, Katherine Heller, Tim Salimans, Max Welling, and Zoubin Ghahramani. Panel Discussion. Advances in Approximate Bayesian Inference, December 2017. URL https://youtu.be/ x1UByHT60mQ?t $= 4$ 6m2s. NeurIPS Workshop.
+
+Hyunsun Choi and Eric Jang. Generative Ensembles for Robust Anomaly Detection. ArXiv e-Print arXiv:1810.01392, 2018.
+
+Laurent Dinh, David Krueger, and Yoshua Bengio. NICE: Non-Linear Independent Components Estimation. ICLR Workshop Track, 2015.
+
+Laurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density Estimation Using Real NVP. In International Conference on Learning Representations (ICLR), 2017.
+
+Federico Girosi, Michael Jones, and Tomaso Poggio. Regularization Theory and Neural Networks Architectures. Neural Computation, 7(2):219–269, 1995.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aäron Courville, and Yoshua Bengio. Generative Adversarial Nets. In Advances in Neural Information Processing Systems (NeurIPS), 2014.
+
+Dan Hendrycks and Kevin Gimpel. A Baseline for Detecting Misclassified and Out-of-Distribution Examples in Neural Networks. In International Conference on Learning Representations (ICLR), 2017.
+
+Dan Hendrycks, Mantas Mazeika, and Thomas Dietterich. Deep Anomaly Detection with Outlier Exposure. In International Conference on Learning Representations (ICLR), 2019.
+
+Radu Herbei and Marten H Wegkamp. Classification with Reject Option. Canadian Journal of Statistics, 34(4):709–721, 2006.
+
+Diederik P. Kingma and Prafulla Dhariwal. Glow: Generative Flow with Invertible 1x1 Convolutions. In Advances in Neural Information Processing Systems (NeurIPS), 2018.
+
+Diederik P Kingma and Max Welling. Auto-Encoding Variational Bayes. International Conference on Learning Representations (ICLR), 2014.
+
+Jernej Kos, Ian Fischer, and Dawn Song. Adversarial Examples for Generative Models. In 2018 IEEE Security and Privacy Workshops (SPW), pp. 36–42. IEEE, 2018.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning Multiple Layers of Features from Tiny Images. Technical report, University of Toronto, 2009.
+
+Balaji Lakshminarayanan, Alexander Pritzel, and Charles Blundell. Simple and Scalable Predictive Uncertainty Estimation Using Deep Ensembles. In Advances in Neural Information Processing Systems (NeurIPS), 2017.
+
+Kimin Lee, Honglak Lee, Kibok Lee, and Jinwoo Shin. Training Confidence-Calibrated Classifiers for Detecting Out-of-Distribution Samples. In International Conference on Learning Representations (ICLR), 2018.
+
+Shiyu Liang, Yixuan Li, and R Srikant. Enhancing the Reliability of Out-of-Distribution Image Detection in Neural Networks. International Conference on Learning Representations (ICLR), 2018.
+
+Christos Louizos and Max Welling. Multiplicative Normalizing Flows for Variational Bayesian Neural Networks. In Proceedings of the 34th International Conference on Machine Learning (ICML), 2017.
+
+Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading Digits in Natural Images with Unsupervised Feature Learning. In NeurIPS Workshop on Deep Learning and Unsupervised Feature Learning, 2011.
+
+Danilo Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic Backpropagation and Approximate Inference in Deep Generative Models. In Proceedings of the 31st International Conference on Machine Learning (ICML), pp. 1278–1286, 2014.
+
+Salah Rifai, Pascal Vincent, Xavier Muller, Xavier Glorot, and Yoshua Bengio. Contractive AutoEncoders: Explicit Invariance During Feature Extraction. In Proceedings of the 28th International Conference on Machine Learning (ICML), 2011.
+
+Mihaela Rosca, Balaji Lakshminarayanan, and Shakir Mohamed. Distribution matching in variational inference. ArXiv e-Print arXiv:1802.06847, 2018.
+
+Alireza Shafaei, Mark Schmidt, and James J Little. Does Your Model Know the Digit 6 Is Not a Cat? A Less Biased Evaluation of “Outlier" Detectors. ArXiv e-Print arXiv:1809.04729, 2018.
+
+Vít Škvára, Tomáš Pevny, and Václav Šmídl. Are Generative Deep Models for Novelty Detection \` Truly Better? KDD Workshop on Outlier Detection De-Constructed (ODD v5.0), 2018.
+
+Casper Kaae Sønderby, Jose Caballero, Lucas Theis, Wenzhe Shi, and Ferenc Huszár. Amortised MAP Inference for Image Super-Resolution. International Conference on Learning Representations (ICLR), 2017.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing Properties of Neural Networks. International Conference on Learning Representations (ICLR), 2014.
+
+Martin Szummer and Tommi S Jaakkola. Information Regularization with Partially Labeled Data. In Advances in Neural Information Processing Systems (NeurIPS), 2003.
+
+Pedro Tabacof, Julia Tavares, and Eduardo Valle. Adversarial Images for Variational Autoencoders. ArXiv e-Print, 2016.
+
+EG Tabak and Cristina V Turner. A Family of Nonparametric Density Estimation Algorithms. Communications on Pure and Applied Mathematics, 66(2):145–164, 2013.
+
+Lucas Theis, Aäron van den Oord, and Matthias Bethge. A Note on the Evaluation of Generative Models. In International Conference on Learning Representations (ICLR), 2016.
+
+Aäron van den Oord, Sander Dieleman, Heiga Zen, Karen Simonyan, Oriol Vinyals, Alex Graves, Nal Kalchbrenner, Andrew Senior, and Koray Kavukcuoglu. Wavenet: A Generative Model for Raw Audio. ArXiv e-Print, 2016a.
+
+Aäron van den Oord, Nal Kalchbrenner, Lasse Espeholt, Oriol Vinyals, Alex Graves, et al. Conditional image generation with pixel CNN decoders. In Advances in Neural Information Processing Systems (NeurIPS), 2016b.
+
+Aaron van den Oord, Yazhe Li, Igor Babuschkin, Karen Simonyan, Oriol Vinyals, Koray Kavukcuoglu, George van den Driessche, Edward Lockhart, Luis Cobo, Florian Stimberg, Norman Casagrande, Dominik Grewe, Seb Noury, Sander Dieleman, Erich Elsen, Nal Kalchbrenner, Heiga Zen, Alex Graves, Helen King, Tom Walters, Dan Belov, and Demis Hassabis. Parallel WaveNet: Fast high-fidelity speech synthesis. In Proceedings of the 35th International Conference on Machine Learning (ICML), pp. 3918–3926, 2018.
+
+# A ADDITIONAL IMPLEMENTATION DETAILS
+
+# A.1 FLOW-BASED MODELS
+
+We have described the core building blocks of invertible generative models above, but there are several other architectural choices required in practice. Due to space requirements, we only describe them briefly, referring the reader to the original papers for details. In the most recent extension of this line of work, Kingma & Dhariwal (2018) propose the Glow architecture, with its foremost contribution being the use of $1 \times 1$ convolutions in place of discrete permutation operations. Convolutions of this form can be thought of as a relaxed but generalized permutation, having all the representational power of the discrete version with the added benefit of parameters amenable to gradient-based training. As the transformation function becomes deeper, it becomes prone to the same scale pathologies as deep neural networks and therefore requires a normalization step of some form. Dinh et al. (2017) propose incorporating batch normalization and describe how to compute its contribution to the log-determinant-Jacobian term. Kingma & Dhariwal (2018) apply a similar normalization, which they call actnorm, but it uses trainable parameters instead of batch statistics. Lastly, both Dinh et al. (2017) and Kingma & Dhariwal (2018) use multi-scale architectures that factor out variables at regular intervals, copying them forward to the final latent representation. This gradually reduces the dimensionality of the transformations, improving upon computational costs.
+
+For our MNIST experiments, we used a Glow architecture of 2 blocks of 16 affine coupling layers, squeezing the spatial dimension in between the 2 blocks. For our CIFAR experiments, we used 3 blocks of 8 affine coupling blocks, applying the multi-scale architecture between each block. For all coupling blocks, we used a 3-layer Highway network with 200 hidden units for MNIST and 400 hidden units for CIFAR. The networks we trained were shallower than those in Kingma & Dhariwal (2018). We also found that initializing the last layer of the coupling networks to 0 was sufficient to prevent scale pathologies, hence we did not use any form of normalization (batchnorm nor actnorm) for ease of initialization and training in a distributed setting. Convolution kernels were initialized with a truncated normal with variance $1 / \sqrt { D }$ where $D$ is fan-in size, except where zero-initialization is prescribed by Glow. All networks were trained with the RMSProp optimizer, with a learning rate of $1 e - 5$ for 100K steps, decaying by half at 80K and 90K steps. We used a prior with zero mean and unit variance for all experiments. We applied L2 regularization of $5 e - 2$ to CIFAR experiments. All experiments used batch size 32.
+
+For CV-Glow, we used additive rather than affine coupling blocks, which removes the influence of coupling blocks on the log-det-Jacobian term. The volume change of the $1 \times 1$ convolutions depend on its weights rather than the input, so the network has a constant volume change.
+
+# A.2 PIXELCNN
+
+We trained a GatedPixelCNN with a categorical distribution. For FashionMNIST, we used a network with 5 gated layers with 32 features, and the final skip connection layer with size 256. We trained for 100K steps with the Adam optimizer and an initial learning rate of $1 e - 4$ , and decaying at 80K and 90K steps. For CIFAR experiments, we used 15 dated layers with 128 features, and a skip connection size of 1024. Convolutions were initialized with Tensorflow’s variance scaling initializer with a uniform distribution and a scale of 1. We trained for 200K steps with the RMSProp optimizer with an initial learning rate of $1 e - 4$ , decaying by $1 / 3$ at 120K, 180K, and 195K steps. All experiments used batch size 32.
+
+# A.3 VARIATIONAL AUTO-ENCODERS
+
+We refer to (Rosca et al., 2018, Appendix K) for additional details on the VAEs used in our CIFAR experiments. We used the CIFAR configurations without modification. For FashionMNIST, we used the encoder given in Table 4 of (Rosca et al., 2018, Appendix K, Table 4) and a decoder composed of one linear layer with $7 * 7 * 6 4$ hidden units, followed by a reshape and three transposed convolutions of feature sizes 32, 32, 256 and strides 2, 2, 1. Weights were initialized with a normal distribution with variance 0.02. We trained for 200K steps using the RMSProp optimizer, with a constant learning rate of $1 e - 4$ .
+
+![](images/af5f921c69a777a494c952835d08bb95ffb4fad2c91d1e8de3fb97219106aefe.jpg)  
+Figure 6: Histogram of Glow log-likelihoods for MNIST vs FashionMNIST and SVHN vs CIFAR-10. Note that the model trained on SVHN (MNIST) is able to assign lower likelihood to CIFAR-10 (FashionMNIST), which illustrates the asymmetry compared to Figure 2.
+
+# C ANALYZING THE CHANGE-OF-VARIABLES FORMULA AS ANOPTIMIZATION FUNCTION
+
+Consider the intuition underlying the volume term in the change of variables objective (Equation 3). As we are maximizing the Jacobian’s determinant, it means that the model is being encouraged to maximize the $\partial f _ { j } / \partial { \bar { x } } _ { j }$ partial derivatives. In other words, the model is rewarded for making the transformation sensitive to small changes in $_ { \textbf { \em x } }$ . This behavior starkly contradicts a long history of derivative-based regularization penalties. Dating back at least to (Girosi et al., 1995), penalizing the Frobenius norm of a neural network’s Jacobian—which upper bounds the volume term3—has been shown to improve generalization. This agrees with intuition since we would like the model to be insensitive to small changes in the input, which are likely noise. Moreover, Bishop (1995) showed that training a network under additive Gaussian noise is equivalent to Jacobian regularization, and Rifai et al. (2011) proposed contractive autoencoders, which penalize the Jacobian-norm of the encoder. Allowing invertible generative models to maximize the Jacobian term without constraint suggests, at minimum, that these models will not learn robust representations.
+
+Limiting Behavior. We next attempt to quantify the limiting behavior of the log volume element. Let us assume, for the purposes of a general treatment, that the bijection $f _ { \phi }$ is an $L$ -Lipschitz function. Both terms in Equation 3 can be bounded as follows:
+
+$$
+\log p ( { \pmb x } ; \pmb \theta ) = \underbrace { \log p _ { z } ( f ( { \pmb x } ; \phi ) ) } _ { \mathcal { O } ( \operatorname* { m a x } _ { z } \log p _ { z } ( z ) } + \underbrace { \log \left| \frac { \partial f _ { \phi } } { \partial { \pmb x } } \right| } _ { \mathcal { O } ( D \log L ) } \le \operatorname* { m a x } _ { z } \log p _ { z } ( z ) + D \log L
+$$
+
+where $L$ is the Lipschitz constant, $D$ the dimensionality, and $\mathcal { O } ( \operatorname* { m a x } _ { z } \log p _ { z } ( z ) )$ an expression for the (log) mode of $p ( z )$ . We will make this mode term for concrete for Gaussian distributions below. The bound on the volume term follows from Hadamard’s inequality:
+
+$$
+\log \left| \frac { \partial f _ { \phi } } { \partial x } \right| \leq \log \prod _ { j = 1 } ^ { D } \left| \frac { \partial f _ { \phi } } { \partial x } e _ { j } \right| \leq \log ( L \left| e _ { \cdot } \right| ) ^ { D } = D \log L
+$$
+
+where $e _ { j }$ is an eigenvector. While this expression is too general to admit any strong conclusions, we can see from it that the ‘peakedness’ of the distribution represented by the mode must keep pace with the Lipschitz constant, especially as dimensionality increases, in order for both terms to contribute equally to the objective.
+
+We can further illuminate the connection between $L$ and the concentration of the latent distribution through the following proposition:
+
+Proposition 1. Assume $x \sim p ^ { * }$ is distributed with moments $\mathbb { E } [ x ] = \mu _ { x }$ and $V a r [ x ] = \sigma _ { x } ^ { 2 }$ . Moreover, let $f : \mathcal X \mapsto \mathcal Z$ be $L$ -Lipschitz and $f ( \mu _ { x } ) = \mu _ { z }$ . We then have the following concentration inequality for some constant $\delta$ :
+
+$$
+P \left( | f ( x ) - \mu _ { z } | \geq \delta \right) \leq \frac { L ^ { 2 } \sigma _ { x } ^ { 2 } } { \delta ^ { 2 } } .
+$$
+
+Proof : From the fact that $f$ is $L$ -Lipschitz, we know $| f ( x ) - \mu _ { z } | \leq L \left| x - f ^ { - 1 } ( \mu _ { z } ) \right|$ . Assuming $\mu _ { x } = f ^ { - 1 } ( \mu _ { z } ) )$ , we can apply Chebyshev’s inequality to the RHS: $\begin{array} { r } { P r ( L \left| x - f ^ { - 1 } ( \dot { \mu } _ { z } ) \right| \ge \delta ) \le } \end{array}$ $L ^ { 2 } \sigma _ { x } ^ { 2 } / \delta ^ { 2 }$ . Since $L \left| x - f ^ { - 1 } ( \mu _ { z } ) \right| \geq | f ( x ) - \mu _ { z } |$ , we can plug the RHS into the inequality and the bound will continue to hold.
+
+From the inequality we can see that the latent distribution can be made more concentrated by decreasing $L$ and/or the data’s variance $\sigma _ { x } ^ { 2 }$ . Since the latter is fixed, optimization only influences $L$ Yet, recall that the volume term in the change-of-variables objective rewards increasing $f$ ’s derivatives and thus $L$ . While we have given an upper bound and therefore cannot say that increasing $L$ will necessarily decrease concentration in latent space, it is for certain that leaving $L$ unconstrained does not directly pressure the $f ( { \pmb x } )$ evaluations to concentrate.
+
+Previous work (Dinh et al., 2015; 2017; Kingma & Dhariwal, 2018) has almost exclusively used a factorized zero-mean Gaussian as the latent distribution, and therefore we examine this case in particular. The log-mode can be expressed as $- D / 2 \cdot \log 2 \pi \sigma _ { z } ^ { 2 }$ , making the likelihood bound
+
+$$
+\log \mathrm { N } ( f ( x ; \phi ) ; \mathbf { 0 } , \sigma _ { z } ^ { 2 } \mathbb { I } ) + \log \left| \frac { \partial f _ { \phi } } { \partial x } \right| \leq \frac { - D } { 2 } \log 2 \pi \sigma _ { z } ^ { 2 } + D \log L .
+$$
+
+We see that both terms scale with $D$ although in different directions, with the contribution of the $z$ -distribution becoming more negative and the volume term’s becoming more positive. We performed a simulation to demonstrate this behavior on the two moons data set, which is shown in Figure 7 (a). We replicated the original two dimensions to create data sets of dimensionality of up to 100. The results are shown in Figure 7 (b). The empirical values of the two terms are shown by the solid lines, and indeed, we see they exhibit the expected diverging behavior as dimensionality increases.
+
+![](images/d7b554b4592ddf24118bee1661fc3c2091763ae2808b35b528b8ce9251982b92.jpg)  
+Figure 7: Limiting Bounds. We trained an RNVP transformation on two moons data sets—which is shown in (a) for 2 dimensions—of increasing dimensionality, tracking the empirical value of each term against the upper bounds. Subfigure (b) shows Glow with an exp parametrization for the scales and (c) shows Glow with a sigmoid parametrization.
+
+# D GLOW WITH SIGMOID PARAMETRIZATION
+
+Upon reading the open source implementation of Glow,4 we found that Kingma & Dhariwal (2018) in practice parametrize the scaling factor as sigmoid $\left( s ( \pmb { x } _ { d : } ; \phi _ { s } ) \right)$ instead of $\exp \{ s ( \pmb { x } _ { d } ; \pmb { \phi } _ { s } ) \}$ . This
+
+choice allows the volume only to decrease and thus results in the volume term being bounded as (ignoring the convolutional transforms)
+
+$$
+\log \left| \frac { \partial f _ { \phi } } { \partial \pmb { x } } \right| = \sum _ { f = 1 } ^ { F } \sum _ { j = 1 } ^ { d _ { f } } \log \textnormal { s i g m o i d } ( s _ { f , j } ( \pmb { x } _ { d _ { f } ; } \phi _ { s } ) ) \leq F D \log 1 = 0
+$$
+
+where $f$ indexes the flows and $d _ { f }$ the dimensionality at flow $f$ . Interestingly, this parametrization has a fixed upper bound of zero, removing the dependence on $D$ found in Equation 8. We demonstrate the change in behavior introduced by the alternate parametrization via the same two moon simulation. The only difference is that the RNVP transforms use a sigmoid parametrizations for the scaling operation. See Figure 7 (c) for the results: we see that now both change-of-variable terms are oriented downward as dimensionality grows. We conjecture this parametrization helps condition the log-likelihood, limiting the volume term’s influence, when training the large models $( \sim 9 0$ flows) used by Kingma & Dhariwal (2018). However, it does not fix the out-of-distribution over-confidence we report in Section 3.
+
+# E CONSTANT AND RANDOM INPUTS
+
+<table><tr><td>Data Set</td><td>Avg.Bits Per Dimension</td></tr><tr><td>Glow Trained on FashionMNIST</td><td></td></tr><tr><td>Random</td><td>8.686</td></tr><tr><td>Constant (0)</td><td>0.339</td></tr></table>
+
+Figure 8: Random and constant images. Log-likelihood (expressed in bits per dimension) of random and constant inputs calculated from NVP-Glow for models trained on FashionMNIST (left) and CIFAR-10 (right).   
+
+<table><tr><td>Data Set Avg.</td><td>Bits Per Dimension</td></tr><tr><td>Glow Trained on CIFAR-10</td><td></td></tr><tr><td>Random</td><td>15.773</td></tr><tr><td>Constant (128)</td><td>0.589</td></tr></table>
+
+# F ENSEMBLING GLOWS
+
+The likelihood function technically measures how likely the parameters are under the data (and not how likely the data is under the model), and perhaps a better quantity would be the posterior predictive distribution $\begin{array} { r } { p ( { \pmb x } _ { t e s t } | { \pmb x } _ { t r a i n } ) = \frac { 1 } { M } \sum _ { m } \hat { p ( { \pmb x } _ { t e s t } | { \pmb \theta } _ { m } ) } } \end{array}$ where we draw samples from posterior distribution $\pmb { \theta } _ { m } \sim p ( \pmb { \theta } | \pmb { x } _ { t r a i n } )$ . Intutitively, it seems that such an integration would be more robust than a single maximum likelihood point estimate. As a crude approximation to Bayesian inference, we tried averaging over ensembles of generative models since Lakshminarayanan et al. (2017) showed that ensembles of discriminative models are robust to out-of-distribution inputs. We compute an “ensemble predictive distribution” as $\begin{array} { r } { p ( { \pmb x } ) = \frac { 1 } { M } \sum _ { m } p ( { \pmb x } ; { \pmb \theta } _ { m } ) } \end{array}$ , where $m$ indexes over models. However, as Figure 9 shows, ensembles did not significantly change the relative difference between in-distribution (CIFAR-10, black and blue) and out-of-distribution (SVHN, red).
+
+# G DERIVATION OF CV-GLOW’S LIKELIHOOD DIFFERENCE
+
+We start with Equation 5:
+
+$$
+\frac { 1 } { 2 } \operatorname { T r } \left\{ \left[ \nabla _ { x _ { 0 } } ^ { 2 } \log { p _ { z } ( f ( x _ { 0 } ; \phi ) ) } + \nabla _ { x _ { 0 } } ^ { 2 } \log { \left| \frac { \partial f _ { \phi } } { \partial x _ { 0 } } \right| } \right] ( \pmb { \Sigma } _ { q } - \pmb { \Sigma } _ { p ^ { * } } ) \right\} .
+$$
+
+The volume element for CV-Glow does not depend on $\scriptstyle { \mathbf { { \mathit { x } } } } _ { 0 }$ and therefore drops from the equation:
+
+$$
+\nabla _ { \pmb { x } _ { 0 } } ^ { 2 } \log \left| \frac { \partial { f _ { \phi } } } { \partial \pmb { x } _ { 0 } } \right| = \nabla _ { \pmb { x } _ { 0 } } ^ { 2 } H W \sum _ { k } \log \left| U _ { k } \right| = 0
+$$
+
+![](images/f4b1b6ca847a7158dc914ed94b2dfdc2cb29f4e5ba3fe67b46306198e07497bb.jpg)  
+Figure 9: Ensemble of Glows. The plot above shows a histogram of log-likelihoods computed using an ensemble of Glow models trained on CIFAR-10, tested on SVHN. Ensembles were not found to be robust against this phenomenon.
+
+where $U _ { k }$ denotes the $k$ th $1 \times 1$ -convolution’s kernel. Moving on to the first term, the log probability under the latent distribution, we have:
+
+$$
+\begin{array} { l } { \nabla _ { x _ { 0 } } ^ { 2 } \log p ( f ( x _ { 0 } ) ; \psi ) = \nabla _ { x _ { 0 } } ^ { 2 } \left\{ \displaystyle \frac { - 1 } { 2 \sigma _ { \psi } ^ { 2 } } | | f ( x _ { 0 } ) | | _ { 2 } ^ { 2 } - \frac { D } { 2 } \log 2 \pi \sigma _ { \psi } ^ { 2 } \right\} } \\ { = \nabla _ { x _ { 0 } } \left\{ \displaystyle \frac { - 1 } { \sigma _ { \psi } ^ { 2 } } \left( \sum _ { d } f _ { d } ( x _ { 0 } ) \right) \nabla _ { x _ { 0 } } f ( x _ { 0 } ) \right\} } \\ { = \displaystyle \frac { - 1 } { \sigma _ { \psi } ^ { 2 } } \left[ \nabla _ { x _ { 0 } } f ( x _ { 0 } ) ( \nabla _ { x _ { 0 } } f ( x _ { 0 } ) ) ^ { T } + \left( \sum _ { d } f _ { d } ( x _ { 0 } ) \right) \nabla _ { x _ { 0 } } ^ { 2 } f ( x _ { 0 } ) \right] . } \end{array}
+$$
+
+Since $f$ is comprised of translation operations and $1 \times 1$ convolutions, its partial derivatives involve just the latter (as the former are all ones), and therefore we have the partial derivatives:
+
+$$
+\frac { \partial f _ { h , w , c } ( \pmb { x } _ { 0 } ) } { \partial x _ { h , w , c } } = \prod _ { k = 1 } ^ { K } \sum _ { j = 1 } ^ { C _ { k } } u _ { k , c , j } , \quad \frac { \partial ^ { 2 } f _ { h , w , c } ( \pmb { x } _ { 0 } ) } { \partial x _ { h , w , c } ^ { 2 } } = 0
+$$
+
+where $h$ and $w$ index the input spatial dimensions, $c$ the input channel dimensions, $k$ the series of flows, and $j$ the column dimensions of the $C _ { k } \times C _ { k }$ -sized convolutional kernel $U _ { k }$ . The diagonal elements of $\nabla _ { { \pmb x } _ { 0 } } f ( { \pmb x } _ { 0 } ) ( \nabla _ { { \pmb x } _ { 0 } } f ( { \pmb x } _ { 0 } ) ) ^ { T }$ are then $( \textstyle \prod _ { k = 1 } ^ { K } \sum _ { j = 1 } ^ { C _ { k } } u _ { k , c , j } ) ^ { 2 }$ , and the diagonal element of $\nabla _ { \pmb { x } _ { 0 } } ^ { 2 } f ( \pmb { x } _ { 0 } )$ are all zero.
+
+Then returning to the full equation, for the constant-volume Glow model we have:
+
+$$
+\begin{array} { r l } & { \frac { 1 } { 2 } \operatorname { T r } \left\{ \left[ \nabla _ { x _ { 0 } } ^ { 2 } \log p ( f ( x _ { 0 } ) ) + \nabla _ { x _ { 0 } } ^ { 2 } \log \left| \frac { \partial f } { \partial x _ { 0 } } \right| \right] ( \Sigma _ { q } - \Sigma _ { p ^ { * } } ) \right\} } \\ & { \quad = \frac { 1 } { 2 } \operatorname { T r } \left\{ \left[ \nabla _ { x _ { 0 } } ^ { 2 } \log p ( f ( x _ { 0 } ) ) \right] ( \Sigma _ { q } - \Sigma _ { p ^ { * } } ) \right\} } \\ & { \quad = \frac { - 1 } { 2 \sigma _ { \psi } ^ { 2 } } \operatorname { T r } \left\{ \left[ \nabla _ { x _ { 0 } } f ( x _ { 0 } ) ( \nabla _ { x _ { 0 } } f ( x _ { 0 } ) ) ^ { T } + \left( \sum _ { d } f _ { d } ( x _ { 0 } ) \right) \nabla _ { x _ { 0 } } ^ { 2 } f ( x _ { 0 } ) \right] ( \Sigma _ { q } - \Sigma _ { p ^ { * } } ) \right\} } \\ & { \quad = \frac { - 1 } { 2 \sigma _ { \psi } ^ { 2 } } \sum _ { l , m } \left\{ \left[ \nabla _ { x _ { 0 } } f ( x _ { 0 } ) ( \nabla _ { x _ { 0 } } f ( x _ { 0 } ) ) ^ { T } + \left( \sum _ { d } f _ { d } ( x _ { 0 } ) \right) \nabla _ { x _ { 0 } } ^ { 2 } f ( x _ { 0 } ) \right] \odot ( \Sigma _ { q } - \Sigma _ { p ^ { * } } ) \right\} _ { l , m } . } \end{array}
+$$
+
+Lastly, we assume that both $\Sigma _ { q }$ and $\Sigma _ { p ^ { * } }$ are diagonal and thus the element-wise multiplication with $\nabla _ { \pmb { x } _ { 0 } } ^ { 2 } \log p ( f ( \pmb { x } _ { 0 } ) )$ collects only its diagonal elements:
+
+$$
+\begin{array} { l } { \displaystyle \frac { - 1 } { 2 \sigma _ { \psi } ^ { 2 } } \displaystyle \sum _ { l , m } \left\{ \left[ \nabla _ { x _ { 0 } } f ( { \bf x } _ { 0 } ) \big ( \nabla _ { x _ { 0 } } f ( { \bf x } _ { 0 } ) \big ) ^ { T } + \left( \sum _ { d } f _ { d } ( { \bf x } _ { 0 } ) \right) \nabla _ { x _ { 0 } } ^ { 2 } f ( { \bf x } _ { 0 } ) \right] \odot \big ( \Sigma _ { q } - \Sigma _ { p ^ { * } } \big ) \right\} _ { l , m } } \\ { \displaystyle = \frac { - 1 } { 2 \sigma _ { \psi } ^ { 2 } } \displaystyle \sum _ { h } \sum _ { w } \sum _ { c } \left( \prod _ { k = 1 } ^ { H } \sum _ { j = 1 } ^ { C _ { k } } u _ { k , c , j } \right) ^ { 2 } \big ( \sigma _ { q , h , w , c } ^ { 2 } - \sigma _ { p ^ { * } , h , w , c } ^ { 2 } \big ) } \\ { \displaystyle = \frac { - 1 } { 2 \sigma _ { \psi } ^ { 2 } } \displaystyle \sum _ { c } ^ { C } \left( \prod _ { k = 1 } ^ { H } \sum _ { j = 1 } ^ { C _ { k } } u _ { k , c , j } \right) ^ { 2 } \sum _ { h } ^ { H } \sum _ { w } ^ { W } \big ( \sigma _ { q , h , w , c } ^ { 2 } - \sigma _ { p ^ { * } , h , w , c } ^ { 2 } \big ) } \end{array}
+$$
+
+where we arrived at the last line by rearranging the sum to collect the shared channel terms.
+
+# H HISTOGRAM OF DATA STATISTICS
+
+![](images/7aa7221a8c3a23f4d65574966482690587b49f9c2688792fcc797d27c0082793.jpg)  
+Figure 10: Data statistics: Histogram of per-dimensional mean, computed as $\begin{array} { r } { \mu _ { d } = \frac { 1 } { N } \sum _ { n = 1 } ^ { N } x _ { n d } } \end{array}$ and per-dimensional variance, computed as 1N−1 PNn=1(xnd − µd)2. Note that pixels are converted from 0-255 scale to 0-1 scale by diving by 256. See Figure 5a for results on datasets of $3 2 \times 3 2 \times 3$ images: SVHN, CIFAR-10, CIFAR-100, CelebA and ImageNet.
+
+![](images/b8b72283e56202c4ac3bf358fd419c58470a0d95ddaa7328e89b69a5210d02f6.jpg)  
+Figure 11: Analysis of codes obtained using CV-Glow model. Histogram of means (left column) $\begin{array} { r } { \mu _ { d } = \frac { 1 } { N } \sum _ { n = 1 } ^ { N } z _ { n d } } \end{array}$ , standard deviation (middle column) $\begin{array} { r } { \sigma _ { d } = \sqrt { \frac { 1 } { N - 1 } \sum _ { n = 1 } ^ { N } ( z _ { n d } - \mu _ { d } ) ^ { 2 } } } \end{array}$ 1 PNn=1(znd − µd)2 and norms normalized by $\sqrt { D }$ (right column) computed as $\begin{array} { r } { \frac { | z _ { n } | } { \sqrt { D } } = \sqrt { \frac { 1 } { D } \sum _ { d } z _ { n d } ^ { 2 } } } \end{array}$ .
+
+# I RESULTS ILLUSTRATING EFFECT OF GRAYING ON CODES
+
+![](images/de981bd99cad3a10e0361fb1a86d086337316d0ca7eb126960eeeda780a4cf74.jpg)  
+Figure 12 shows the effect of graying on codes.
+
+Figure 12: Effect of graying on codes. Left (mean), middle (standard deviation) and norm (right).
+
+![](images/296d0783887fb325245e846e34703778c92446325cab2382062dd37a27a9b7bf.jpg)  
+Figure 13: Samples. Samples from CV-Glow models used for analysis.

parse/train/HJ1kmv9xx/HJ1kmv9xx.md

@@ -0,0 +1,333 @@
+# LR-GAN: LAYERED RECURSIVE GENERATIVE ADVERSARIAL NETWORKS FOR IMAGE GENERATION
+
+Jianwei Yang∗ Virginia Tech Blacksburg, VA jw2yang@vt.edu
+
+Anitha Kannan Facebook AI Research Menlo Park, CA akannan@fb.com
+
+Dhruv Batra∗and Devi Parikh∗ Georgia Institute of Technology Atlanta, GA {dbatra, parikh}@gatech.edu
+
+# ABSTRACT
+
+We present LR-GAN: an adversarial image generation model which takes scene structure and context into account. Unlike previous generative adversarial networks (GANs), the proposed GAN learns to generate image background and foregrounds separately and recursively, and stitch the foregrounds on the background in a contextually relevant manner to produce a complete natural image. For each foreground, the model learns to generate its appearance, shape and pose. The whole model is unsupervised, and is trained in an end-to-end manner with gradient descent methods. The experiments demonstrate that LR-GAN can generate more natural images with objects that are more human recognizable than DCGAN.
+
+# 1 INTRODUCTION
+
+Generative adversarial networks (GANs) (Goodfellow et al., 2014) have shown significant promise as generative models for natural images. A flurry of recent work has proposed improvements over the original GAN work for image generation (Radford et al., 2015; Denton et al., 2015; Salimans et al., 2016; Chen et al., 2016; Zhu et al., 2016; Zhao et al., 2016), multi-stage image generation including part-based models (Im et al., 2016; Kwak & Zhang, 2016), image generation conditioned on input text or attributes (Mansimov et al., 2015; Reed et al., 2016b;a), image generation based on 3D structure (Wang & Gupta, 2016), and even video generation (Vondrick et al., 2016).
+
+While the holistic ‘gist’ of images generated by these approaches is beginning to look natural, there is clearly a long way to go. For instance, the foreground objects in these images tend to be deformed, blended into the background, and not look realistic or recognizable.
+
+One fundamental limitation of these methods is that they attempt to generate images without taking into account that images are 2D projections of a 3D visual world, which has a lot of structures in it. This manifests as structure in the 2D images that capture this world. One example of this structure is that images tend to have a background, and foreground objects are placed in this background in contextually relevant ways.
+
+We develop a GAN model that explicitly encodes this structure. Our proposed model generates images in a recursive fashion: it first generates a background, and then conditioned on the background generates a foreground along with a shape (mask) and a pose (affine transformation) that together define how the background and foreground should be composed to obtain a complete image. Conditioned on this composite image, a second foreground and an associated shape and pose are generated, and so on. As a byproduct in the course of recursive image generation, our approach generates some object-shape foreground-background masks in a completely unsupervised way, without access to any object masks for training. Note that decomposing a scene into foreground-background layers is a classical ill-posed problem in computer vision. By explicitly factorizing appearance and transformation, LR-GAN encodes natural priors about the images that the same foreground can be ‘pasted’ to the different backgrounds, under different affine transformations. According to the experiments, the absence of these priors result in degenerate foreground-background decompositions, and thus also degenerate final composite images.
+
+![](images/92f1dafd19871af9a89f576fc0395ce1ddba7cbe105573c7bc7d9d76a4374c01.jpg)  
+Figure 1: Generation results of our model on CUB-200 (Welinder et al., 2010). It generates images in two timesteps. At the first timestep, it generates background images, while generates foreground images, masks and transformations at the second timestep. Then, they are composed to obtain the final images. From top left to bottom right (row major), the blocks are real images, generated background images, foreground images, foreground masks, carved foreground images, carved and transformed foreground images, final composite images, and their nearest neighbor real images in the training set. Note that the model is trained in a completely unsupervised manner.
+
+We mainly evaluate our approach on four datasets: MNIST-ONE (one digit) and MNIST-TWO (two digits) synthesized from MNIST (LeCun et al., 1998), CIFAR-10 (Krizhevsky & Hinton, 2009) and CUB-200 (Welinder et al., 2010). We show qualitatively (via samples) and quantitatively (via evaluation metrics and human studies on Amazon Mechanical Turk) that LR-GAN generates images that globally look natural and contain clear background and object structures in them that are realistic and recognizable by humans as semantic entities. An experimental snapshot on CUB-200 is shown in Fig. 1. We also find that LR-GAN generates foreground objects that are contextually relevant to the backgrounds (e.g., horses on grass, airplanes in skies, ships in water, cars on streets, etc.). For quantitative comparison, besides existing metrics in the literature, we propose two new quantitative metrics to evaluate the quality of generated images. The proposed metrics are derived from the sufficient conditions for the closeness between generated image distribution and real image distribution, and thus supplement existing metrics.
+
+# 2 RELATED WORK
+
+Early work in parametric texture synthesis was based on a set of hand-crafted features (Portilla & Simoncelli, 2000). Recent improvements in image generation using deep neural networks mainly fall into one of the two stochastic models: variational autoencoders (VAEs) (Kingma et al., 2016) and generative adversarial networks (GANs) (Goodfellow et al., 2014). VAEs pair a top-down probabilistic generative network with a bottom up recognition network for amortized probabilistic inference. Two networks are jointly trained to maximize a variational lower bound on the data likelihood. GANs consist of a generator and a discriminator in a minmax game with the generator aiming to fool the discriminator with its samples with the latter aiming to not get fooled.
+
+Sequential models have been pivotal for improved image generation using variational autoencoders: DRAW (Gregor et al., 2015) uses attention based recurrence conditioning on the canvas drawn so far. In Eslami et al. (2016), a recurrent generative model that draws one object at a time to the canvas was used as the decoder in VAE. These methods are yet to show scalability to natural images. Early compelling results using GANs used sequential coarse-to-fine multiscale generation and classconditioning (Denton et al., 2015). Since then, improved training schemes (Salimans et al., 2016) and better convolutional structure (Radford et al., 2015) have improved the generation results using
+
+GANs. PixelRNN (van den Oord et al., 2016) is also recently proposed to sequentially generates a pixel at a time, along the two spatial dimensions.
+
+In this paper, we combine the merits of sequential generation with the flexibility of GANs. Our model for sequential generation imbibes a recursive structure that more naturally mimics image composition by inferring three components: appearance, shape, and pose. One closely related work combining recursive structure with GAN is that of Im et al. (2016) but it does not explicitly model object composition and follows a similar paradigm as by Gregor et al. (2015). Another closely related work is that of Kwak & Zhang (2016). It combines recursive structure and alpha blending. However, our work differs in three main ways: (1) We explicitly use a generator for modeling the foreground poses. That provides significant advantage for natural images, as shown by our ablation studies; (2) Our shape generator is separate from the appearance generator. This factored representation allows more flexibility in the generated scenes; (3) Our recursive framework generates subsequent objects conditioned on the current and previous hidden vectors, and previously generated object. This allows for explicit contextual modeling among generated elements in the scene. See Fig. 17 for contextually relevant foregrounds generated for the same background, or Fig. 6 for meaningful placement of two MNIST digits relative to each.
+
+Models that provide supervision to image generation using conditioning variables have also been proposed: Style/Structure GANs (Wang & Gupta, 2016) learns separate generative models for style and structure that are then composed to obtain final images. In Reed et al. (2016a), GAN based image generation is conditioned on text and the region in the image where the text manifests, specified during training via keypoints or bounding boxes. While not the focus of our work, the model proposed in this paper can be easily extended to take into account these forms of supervision.
+
+# 3 PRELIMINARIES
+
+# 3.1 GENERATIVE ADVERSARIAL NETWORKS
+
+Generative Adversarial Networks (GANs) consist of a generator $G$ and a discriminator $D$ that are simultaneously trained with competing goals: The generator $G$ is trained to generate samples that can ‘fool’ a discriminator $D$ , while the discriminator is trained to classify its inputs as either real (coming from the training dataset) or fake (coming from the samples of $G$ ). This competition leads to a minmax formulation with a value function:
+
+$$
+\operatorname* { m i n } _ { \theta _ { G } } \operatorname* { m a x } _ { \theta _ { D } } \Big ( \mathrm { E } _ { a \sim p _ { d a t a } ( x ) } [ \log ( D ( x ; \theta _ { D } ) ) ] + \mathrm { E } _ { z \sim p _ { z } ( z ) } [ \log ( 1 - D ( G ( z ; \theta _ { G } ) ; \theta _ { D } ) ) ] \Big ) ,
+$$
+
+where $_ { z }$ is a random vector from a standard multivariate Gaussian or a uniform distribution $p _ { z } ( z )$ , $G ( z ; \theta _ { G } )$ maps $_ z$ to the data space, $D ( { \pmb x } )$ is the probability that $_ { \textbf { \em x } }$ is real estimated by $D$ . The advantage of the GANs formulation is that it lacks an explicit loss function and instead uses the discriminator to optimize the generative model. The discriminator, in turn, only cares whether the sample it receives is on the data manifold, and not whether it exactly matches a particular training example (as opposed to losses such as MSE). Hence, the discriminator provides a gradient signal only when the generated samples do not lie on the data manifold so that the generator can readjust its parameters accordingly. This form of training enables learning the data manifold of the training set and not just optimizing to reconstruct the dataset, as in autoencoder and its variants.
+
+While the GANs framework is largely agnostic to the choice of $G$ and $D$ , it is clear that generative models with the ‘right’ inductive biases will be more effective in learning from the gradient information (Denton et al., 2015; Im et al., 2016; Gregor et al., 2015; Reed et al., 2016a; Yan et al., 2015). With this motivation, we propose a generator that models image generation via a recurrent process – in each time step of the recurrence, an object with its own appearance and shape is generated and warped according to a generated pose to compose an image in layers.
+
+# 3.2 LAYERED STRUCTURE OF IMAGE
+
+An image taken of our 3D world typically contains a layered structure. One way of representing an image layer is by its appearance and shape. As an example, an image $_ { \textbf { \em x } }$ with two layers, foreground $f$ and background $^ { b }$ may be factorized as:
+
+$$
+\pmb { x } = \pmb { f } \odot \pmb { m } + \pmb { b } \odot ( 1 - \pmb { m } ) ,
+$$
+
+where $_ { \mathbf { \nabla } } \mathbf { m } _ { \mathbf { \nabla } }$ is the mask depicting the shapes of image layers, and $\odot$ the element wise multiplication operator. Some existing methods assume the access to the shape of the object either during training (Isola & Liu, 2013) or both at train and test time (Reed et al., 2016a; Yan et al., 2015). Representing images in layered structure is even straightforward for video with moving objects (Darrell & Pentland, 1991; Wang & Adelson, 1994; Kannan et al., 2005). Vondrick et al. (2016) generates videos by separately generating a fixed background and moving foregrounds. A similar way of generating single image can be found in Kwak & Zhang (2016).
+
+Another way is modeling the layered structure with object appearance and pose as:
+
+$$
+\pmb { x } = S T ( \pmb { f } , \pmb { a } ) + \pmb { b } ,
+$$
+
+where $f$ and $^ { b }$ are foreground and background, respectively; $\textbf { \em a }$ is the affine transformation; $S T$ is the spatial transformation operator. Several works fall into this group (Roux et al., 2011; Huang & Murphy, 2015; Eslami et al., 2016). In Huang & Murphy (2015), images are decomposed into layers of objects with specific poses in a variational autoencoder framework, while the number of objects (i.e., layers) is adaptively estimated in Eslami et al. (2016).
+
+To contrast with these works, LR-GAN uses a layered composition, and the foreground layers simultaneously model all three dominant factors of variation: appearance $f$ , shape $_ { \mathbf { \nabla } } \mathbf { m }$ and pose $\textbf { \em a }$ . We will elaborate it in the following section.
+
+# 4 LAYERED RECURSIVE GAN (LR-GAN)
+
+The basic structure of LR-GAN is similar to GAN: it consists of a discriminator and a generator that are simultaneously trained using the minmax formulation of GAN, as described in $\ S . 3 . 1$ . The key innovation of our work is the layered recursive generator, which is what we describe in this section.
+
+The generator in LR-GAN is recursive in that the image is constructed recursively using a recurrent network. Layered in that each recursive step composes an object layer that is ‘pasted’ on the image generated so far. Object layer at timestep $t$ is parameterized by the following three constituents – ‘canonical’ appearance $\pmb { f } _ { t }$ , shape (or mask) $\mathbf { \nabla } m _ { t }$ , and pose (or affine transformation) $\mathbf { } \mathbf { a } _ { t }$ for warping the object before pasting in the image composition.
+
+Fig. 2 shows the architecture of the LR-GAN with the generator architecture unrolled for generating background $\scriptstyle { \mathbf { { \mathit { x } } } } _ { 0 }$ $( \doteq \pmb { x } _ { b } )$ and foreground $\scriptstyle { \mathbf { { \vec { x } } } } _ { 1 }$ and $\mathbf { x } _ { 2 }$ . At each time step $t$ , the generator composes the next image $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { t } }$ via the following recursive computation:
+
+$$
+\begin{array} { r l } { x _ { t } = \mathrm { ~ { \mathcal { S } } ~ } T ( m _ { t } , a _ { t } ) , \quad \odot \quad } & { { } { \mathcal { S } } T ( f _ { t } , a _ { t } ) , \quad \quad + ( 1 - { S T } ( m _ { t } , a _ { t } ) ) \odot x _ { t - 1 , } , \quad \forall t \in [ 1 , T ] } \end{array}
+$$
+
+where $S T ( \circ , \pmb { a } _ { t } )$ is a spatial transformation operator that outputs the affine transformed version of $\diamond$ with $\mathbf { } \mathbf { a } _ { t }$ indicating parameters of the affine transformation.
+
+Since our proposed model has an explicit transformation variable $\mathbf { } \mathbf { a } _ { t }$ that is used to warp the object, it can learn a canonical object representation that can be re-used to generate scenes where the object occurs as mere transformations of it, such as different scales or rotations. By factorizing the appearance, shape and pose, the object generator can focus on separately capturing regularities in these three factors that constitute an object. We will demonstrate in our experiments that removing these factorizations from the model leads to its spending capacity in variability that may not solely be about the object in Section 5.5 and 5.6.
+
+# 4.1 DETAILS OF GENERATOR ARCHITECTURE
+
+Fig. 2 shows our LR-GAN architecture in detail – we use different shapes to indicate different kinds of layers (convolutional, fractional convolutional, (non)linear, etc), as indicated by the legend. Our model consists of two main pieces – a background generator $G _ { b }$ and a foreground generator $G _ { f }$ . $G _ { b }$ and $G _ { f }$ do not share parameters with each other. $G _ { b }$ computation happens only once, while $G _ { f }$ is recurrent over time, i.e., all object generators share the same parameters. In the following, we will introduce each module and connections between them.
+
+Temporal Connections. LR-GAN has two kinds of temporal connections – informally speaking, one on ‘top’ and one on ‘bottom’. The ‘top’ connections perform the act of sequentially ‘pasting’ object layers (Eqn. 4). The ‘bottom’ connections are constructed by a LSTM on the noise vectors $z _ { \mathrm { 0 } } , z _ { \mathrm { 1 } } , z _ { \mathrm { 2 } }$ . Intuitively, this noise-vector-LSTM provides information to the foreground generator about what else has been generated in past. Besides, when generating multiple objects, we use a pooling layer $P _ { f } ^ { c }$ and a fully-connected layer $E _ { f } ^ { c }$ to extract the information from previous generated object response map. By this way, the model is able to ‘see’ previously generated objects.
+
+![](images/79a2c73e95232f085950c43b5fe393cac10d2e42a3969656315cbce8f01e7db4.jpg)  
+Figure 2: LR-GAN architecture unfolded to three timesteps. It mainly consists of one background generator, one foreground generator, temporal connections and one discriminator. The meaning of each component is explained in the legend.
+
+Background Generator. The background generator $G _ { b }$ is purposely kept simple. It takes the hidden state of noise-vector-LSTM $h _ { l } ^ { 0 }$ as the input and passes it to a number of fractional convolutional layers (also called ‘deconvolution’ layer in some papers) to generate images at its end. The output of background generator $\scriptstyle { \mathbf { \mathcal { x } } } _ { b }$ will be used as the canvas for the following generated foregrounds.
+
+Foreground Generator. The foreground generator $G _ { f }$ is used to generate an object with appearance and shape. Correspondingly, $G _ { f }$ consists of three sub-modules, $G _ { f } ^ { c }$ , which is a common ‘trunk’ whose outputs are shared by $G _ { f } ^ { i }$ and $G _ { f } ^ { m }$ . $G _ { f } ^ { i }$ is used to generate the foreground appearance $\pmb { f } _ { t }$ , while $G _ { f } ^ { m }$ generates the mask $\mathbf { \nabla } m _ { t }$ for the foreground. All three sub-modules consists of one or more fractional convolutional layers combined with batch-normalization and nonlinear layers. The generated foreground appearance and mask have the same spatial size as the background. The top of $G _ { f } ^ { m }$ is a sigmoid layer in order to generate one channel mask whose values range in $( 0 , 1 )$ .
+
+Spatial Transformer. To spatially transform foreground objects, we need to estimate the transformation matrix. As in Jaderberg et al. (2015), we predict the affine transformation matrix with a linear layer $T _ { f }$ that has six-dimensional outputs. Then based on the predicted transformation matrix, we use a grid generator $G _ { g }$ to generate the corresponding sampling coordinates in the input for each location at the output. The generated foreground appearance and mask share the same transformation matrix, and thus the same sampling grid. Given the grid, the sampler $S$ will simultaneously sample the $\pmb { f } _ { t }$ and ${ \mathbf { } } m _ { t }$ to obtain $\hat { f } _ { t }$ and $\hat { m } _ { t }$ , respectively. Different from Jaderberg et al. (2015), our sampler here normally performs downsampling, since the the foreground typically has smaller size than the background. Pixels in $\hat { f } _ { t }$ and $\hat { m } _ { t }$ that are from outside the extent of $\pmb { f } _ { t }$ and ${ \mathbf { } } m _ { t }$ are set to zero. Finally, $\hat { f } _ { t }$ and $\hat { m } _ { t }$ are sent to the compositor $C$ which combines the canvas ${ \mathbf { } } _ { { \mathbf { } } { \mathbf { } } { \mathbf { } } - 1 }$ and $\hat { f } _ { t }$ through layered composition with blending weights given by $\hat { m } _ { t }$ (Eqn. 4).
+
+Pseudo-code for our approach and detailed model configuration are provided in the Appendix.
+
+# 4.2 NEW EVALUATION METRICS
+
+Several metrics have been proposed to evaluate GANs, such as Gaussian parzen window (Goodfellow et al., 2014), Generative Adversarial Metric (GAM) (Im et al., 2016) and Inception Score (Salimans et al., 2016). The common goal is to measure the similarity between the generated data distribution $P _ { g } ( \pmb { x } ) = G ( \pmb { z } ; \theta _ { z } )$ and the real data distribution $P ( { \pmb x } )$ . Most recently, Inception Score has been used in several works (Salimans et al., 2016; Zhao et al., 2016). However, it is an assymetric metric and could be easily fooled by generating centers of data modes.
+
+In addition to these metrics, we present two new metrics based on the following intuition – a sufficient (but not necessary) condition for closeness of $P _ { g } ( \pmb { x } )$ and $P ( { \pmb x } )$ is closeness of $P _ { g } ( \pmb { x } | y )$ and $P ( { \pmb x } | { \pmb y } )$ , i.e., distributions of generated data and real data conditioned on all possible variables of interest $y$ , e.g., category label. One way to obtain this variable of interest $y$ is via human annotation. Specifically, given the data sampled from $P _ { g } ( \pmb { x } )$ and $P ( { \pmb x } )$ , we ask people to label the category of the samples according to some rules. Note that such human annotation is often easier than comparing samples from the two distributions (e.g., because there is no 1:1 correspondence between samples to conduct forced-choice tests).
+
+After the annotations, we need to verify whether the two distributions are similar in each category. Clearly, directly comparing the distributions $P _ { g } ( \pmb { x } | y )$ and $P ( { \pmb x } | { \pmb y } )$ may be as difficult as comparing $P _ { g } ( \pmb { x } )$ and $P ( { \pmb x } )$ . Fortunately, we can use Bayes rule and alternatively compare $P _ { g } ( y | \mathbf { \boldsymbol { x } } )$ and $P ( y | \bar { \mathbf { x } } )$ , which is a much easier task. In this case, we can simply train a discriminative model on the samples from $P _ { g } ( \pmb { x } )$ and $P ( { \pmb x } )$ together with the human annotations about categories of these samples. With a slight abuse of notation, we use $P _ { g } ( y | \mathbf { \boldsymbol { x } } )$ and $P ( y | \pmb { x } )$ to denote probability outputs from these two classifiers (trained on generated samples vs trained on real samples). We can then use these two classifiers to compute the following two evaluation metrics:
+
+Adversarial Accuracy: Computes the classification accuracies achieved by these two classifiers on a validation set, which can be the training set or another set of real images sampled from $P ( { \pmb x } )$ . If $P _ { g } ( \pmb { x } )$ is close to $P ( { \pmb x } )$ , we expect to see similar accuracies.
+
+Adversarial Divergence: Computes the KL divergence between $P _ { g } ( y | \mathbf { \boldsymbol { x } } )$ and $P ( \boldsymbol { y } | \boldsymbol { x } )$ . The lower the adversarial divergence, the closer two distributions are. The low bound for this metric is exactly zero, which means $\bar { P _ { g } } ( y | \mathbf { x } ) = P ( y | \mathbf { x } )$ for all samples in the validation set.
+
+As discussed above, we need human efforts to label the real and generated samples. Fortunately, we can further simplify this. Based on the labels given on training data, we split the training data into categories, and train one generator for each category. With all these generators, we generate samples of all categories. This strategy will be used in our experiments on the datasets with labels given.
+
+# 5 EXPERIMENT
+
+We conduct qualitative and quantitative evaluations on three datasets: 1) MNIST (LeCun et al., 1998); 2) CIFAR-10 (Krizhevsky & Hinton, 2009); 3) CUB-200 (Welinder et al., 2010). To add variability to the MNIST images, we randomly scale (factor of 0.8 to 1.2) and rotate $( - \frac { \pi } { 4 }$ to $\frac { \pi } { 4 }$ ) the digits and then stitch them to $4 8 \times 4 8$ uniform backgrounds with random grayscale value between [0, 200]. Images are then rescaled back to $3 2 \times 3 2$ . Each image thus has a different background grayscale value and a different transformed digit as foreground. We rename this sythensized dataset as MNIST-ONE (single digit on a gray background). We also synthesize a dataset MNIST-TWO containing two digits on a grayscale background. We randomly select two images of digits and perform similar transformations as described above, and put one on the left and the other on the right side of a $7 8 \times 7 8$ gray background. We resize the whole image to $6 4 \times 6 4$ .
+
+We develop LR-GAN based on open source code1. We assume the number of objects is known. Therefore, for MNIST-ONE, MNIST-TWO, CIFAR-10, and CUB-200, our model has two, three, two, and two timesteps, respectively. Since the size of foreground object should be smaller than that of canvas, we set the minimal allowed scale 2 in affine transforamtion to be 1.2 for all datasets except for MNIST-TWO, which is set to 2 (objects are smaller in MNIST-TWO). In LR-GAN, the background generator and foreground generator have similar architectures. One difference is that the number of channels in the background generator is half of the one in the foreground generator. We compare our results to that of DCGAN (Radford et al., 2015). Note that LR-GAN without LSTM at the first timestep corresponds exactly to the DCGAN. This allows us to run controlled experiments. In both generator and discriminator, all the (fractional) convolutional layers have $4 \times$ 4 filter size with stride 2. As a result, the number of layers in the generator and discriminator automatically adapt to the size of training images. Please see the Appendix (Section 6.2) for details about the configurations. We use three metrics for quantitative evaluation, including Inception Score (Salimans et al., 2016) and the proposed Adversarial Accuracy, Adversarial Divergence. Note that we report two versions of Inception Score. One is based on the pre-trained Inception net, and the other one is based on the pre-trained classifier on the target datasets.
+
+![](images/ea9d1888db5f0175c63f7dc33705c1a85c916ddedfeb9fbe58ce22e363880dc6.jpg)  
+Figure 3: Generated images on CIFAR-10 based on our model.
+
+![](images/e4acd62c5dabc349e9e9d71827aa0583fbb417f9871d9c1a9114d2dafafaa62e.jpg)  
+Figure 4: Generated images on CUB-200 based on our model.
+
+# 5.1 QUALITATIVE RESULTS
+
+In Fig. 3 and 4, we show the generated samples for CIFAR-10 and CUB-200, respectively. MNIST results are shown in the next subsection. As we can see from the images, the compositional nature of our model results in the images being free of blending artifacts between backgrounds and foregrounds. For CIFAR-10, we can see the horses and cars with clear shapes. For CUB-200, the bird shapes tend to be even sharper.
+
+# 5.2 MNIST-ONE AND MNIST-TWO
+
+We now report the results on MNIST-ONE and MNIST-TWO. Fig. 5 shows the generation results of our model on MNIST-ONE. As we can see, our model generates the background and the foreground in separate timestep, and can disentagle the foreground digits from background nearly perfectly. Though initial values of the mask randomly distribute in the range of $( 0 , 1 )$ , after training, the masks are nearly binary and accurately carve out the digits from the generated foreground. More results on MNIST-ONE (including human studies) can be found in the Appendix (Section 6.3).
+
+Fig. 6 shows the generation results for MNIST-TWO. Similarly, the model is also able to generate background and the two foreground objects separately. The foreground generator tends to generate a single digit at each timestep. Meanwhile, it captures the context information from the previous time steps. When the first digit is placed to the left side, the second one tends to be placed on the right side, and vice versa.
+
+![](images/c9088480f0d89fd14b3ceff741b6beacdf0fbbe1c67e90e5b58b50cda1cee1bc.jpg)  
+Figure 5: Generation results of our model on MNIST-ONE. From left to right, the image blocks are real images, generated background images, generated foreground images, generated masks and final composite images, respectively.
+
+![](images/2d8099797d1198840f43f9d1a7f0d7128c29860c6fe6e072e1b531c7c038e259.jpg)  
+Figure 6: Generation results of our model on MNIST-TWO. From top left to bottom right (row major), the image blocks are real images, generated background images, foreground images and masks at the second timestep, composite images at the second time step, generated foreground images and masks at the third timestep and the final composite images, respectively.
+
+# 5.3 CUB-200
+
+We study the effectiveness of our model trained on the CUB-200 bird dataset. In Fig. 1, we have shown a random set of generated images, along with the intermediate generation results of the model. While being completely unsupervised, the model, for a large fraction of the samples, is able to successfully disentangle the foreground and the background. This is evident from the generated bird-like masks.
+
+![](images/989f9d2e3d2a4070720b93cdc749bb21b33c2a5270b5c3240d846bda141714b0.jpg)  
+Figure 7: Matched pairs of generated images based on DCGAN and LR-GAN, respectivedly. The odd columns are generated by DCGAN, and the even columns are generated by LR-GAN. These are paired according to the perfect matching based on Hungarian algorithm.
+
+![](images/a9475bb0409c08b9126b69efdcf7c3260d528ffc6572639fda597aa5f1790a74.jpg)  
+Figure 8: Qualitative comparison on CIFAR-10. Top three rows are images generated by DCGAN; Bottom three rows are by LR-GAN. From left to right, the blocks display generated images with increasing quality level as determined by human studies.
+
+We do a comparative study based on Amazon Mechanical Turk (AMT) between DCGAN and LRGAN to quantify relative visual quality of the generated images. We first generated 1000 samples from both the models. Then, we performed perfect matching between the two image sets using the Hungarian algorithm on $L 2$ norm distance in the pixel space. This resulted in 1000 image pairs. Some examplar pairs are shown in Fig. 7. For each image pair, 9 judges are asked to choose the one that is more realistic. Based on majority voting, we find that our generated images are selected $6 8 . 4 \%$ times, compared with $3 1 . 6 \%$ times for DCGAN. This demonstrates that our model has generated more realistic images than DCGAN. We can attribute this difference to our model’s ability to generate foreground separately from the background, enabling stronger edge cues.
+
+# 5.4 CIFAR-10
+
+We now qualitatively and quantitatively evaluate our model on CIFAR-10, which contains multiple object categories and also various backgrounds.
+
+Comparison of image generation quality: We conduct AMT studies to compare the fidelity of image generation. Towards this goal, we generate 1000 images from DCGAN and LR-GAN, respectively. We ask 5 judges to label each image to either belong to one of the 10 categories or as ‘non recognizable’ or ‘recognizable but not belonging to the listed categories’. We then assign each image a quality level between [0,5] that captures the number of judges that agree with the majority choice. Fig. 8 shows the images generated by both approaches, ordered by increasing quality level. We merge images at quality level 0 (all judges said non-recognizable) and 1 together, and similarly images at level 4 and 5. Visually, the generated samples by our model have clearer boundaries and object structures. We also computed the fraction of non-recognizable images: Our model had a $10 \%$ absolute drop in non-recognizability rate $( 6 7 . 3 \%$ for ours vs. $7 7 . 7 \%$ for DCGAN). For reference, $1 1 . 4 \%$ of real CIFAR images were categorized as non-recognizable. Fig. 9 shows more generated (intermediate) results of our model.
+
+Quantitative evaluation on generators: We evaluate the generators based on three metrics: 1) Inception Score; 2) Adversarial Accuracy; 3) Adversarial Divergence. To obtain a classifier model for evaluation, we remove the top layer in the discriminator used in our model, and then append two fully connected layers on the top of it. We train this classifier using the training samples of CIFAR-10 based on the annotations. Following Salimans et al. (2016), we generated 50,000 images based on DCGAN and LR-GAN, repsectively. We compute two types of Inception Scores. The standard Inception Score is based on the Inception net as in Salimans et al. (2016), and the contextual Inception Score is based on our trained classifier model. To distinguish, we denote the standard one as ‘Inception Score†’, and the contextual one as ‘Inception Score††’. To obtain the Adversarial Accuracy and Adversarial Divergence scores, we train one generator on each of 10 categories for DCGAN and LR-GAN, respectively. Then, we use these generators to generate samples of different categories. Given these generated samples, we train the classifiers for DCGAN and LR-GAN separately. Along with the classifier trained on the real samples, we compute the Adversarial Accuracy and Adversarial Divergence on the real training samples. In Table 1, we report the Inception Scores, Adversarial Accuracy and Adversarial Divergence for comparison. We can see that our model outperforms DCGAN across the board. To point out, we obtan different Inception Scores based on different classifier models, which indicates that the Inception Score varies with different models.
+
+Table 1: Quantitative comparison between DCGAN and LR-GAN on CIFAR-10.   
+
+<table><tr><td>Training Data</td><td>Real Images</td><td>DCGAN</td><td>Ours</td></tr><tr><td>Inception Scoret</td><td>11.18±0.18</td><td>6.64±0.14</td><td>7.17±0.07</td></tr><tr><td>Inception Scorett</td><td>7.23±0.09</td><td>5.69±0.07</td><td>6.11±0.06</td></tr><tr><td>Adversarial Accuracy</td><td>83.33±0.08</td><td>37.81±0.02</td><td>44.22 ±0.08</td></tr><tr><td>Adversarial Divergence</td><td>0</td><td>7.58±0.04</td><td>5.57±0.06</td></tr></table>
+
+†Evaluate using the pre-trained Inception net as Salimans et al. (2016) ††Evaluate using the supervisedly trained classifier based on the discriminator in LR-GAN.
+
+![](images/62ac4ea9d7d7caf7d3df3bbf1cae137f708b8b0c172bc331afc28396ddbc5e74.jpg)  
+Figure 9: Generation results of our model on CIFAR-10. From left to right, the blocks are: generated background images, foreground images, foreground masks, foreground images carved out by masks, carved foregrounds after spatial transformation, final composite images and nearest neighbor training images to the generated images.
+
+![](images/e40422586846dc636bdcad89dabebfc927006c7e46aae4a86839c89cd3cfcb2d.jpg)  
+Figure 10: Category specific generation results of our model on CIFAR-10 categories of horse, frog, and cat (top to bottom). The blocks from left to right are: generated background images, foreground images, foreground masks, foreground images carved out by masks, carved foregrounds after spatial transformation and final composite images.
+
+Quantitative evaluation on discriminators: We evaluate the discriminator as an extractor for deep representations. Specifically, we use the output of the last convolutional layer in the discriminator as features. We perform a 1-NN classification on the test set given the full training set. Cosine similarity is used as the metric. On the test set, our model achieves $6 2 . 0 9 \% \pm 0 . 0 1 \%$ compared to DCGAN’s $5 6 . 0 5 \% \pm 0 . 0 2 \%$ .
+
+Contextual generation: We also show the efficacy of our approach to generate diverse foregrounds conditioned on fixed background. The results in Fig. 17 in Appendix showcase that the foreground generator generates objects that are compatible with the background. This indicates that the model has captured contextual dependencies between the image layers.
+
+Category specific models: The objects in CIFAR-10 exhibit huge variability in shapes. That can partly explain why some of the generated shapes are not as compelling in Fig. 9. To test this hypothesis, we reuse the generators trained for each of 10 categories used in our metrics to obtain the generation results. Fig. 10 shows results for categories ‘horse’, ‘frog’ and ‘cat’. We can see that the model is now able to generate object-specific appearances and shapes, similar in vein to our results on the CUB-200 dataset.
+
+# 5.5 IMPORTANCE OF TRANSFORMATIONS
+
+![](images/4ce0b42c6c668769875b477b80ca2f9c2683243d0e9ffa760e24f65378ec4efe.jpg)  
+Figure 11: Generation results from an ablated LR-GAN model without affine transformations. From top to bottom, the block rows correspond to different datasets: MNIST-ONE, CUB-200, CIFAR-10. From left to right, the blocks show generated background images, foreground images, foreground masks, and final composite images. For comparison, the rightmost column block shows final generated images from a non-ablated model with affine transformations.
+
+Fig. 11 shows results from an ablated model without affine transformations in the foreground layers, and compares the results with the full model that does include these transformations. We note that one significant problem emerges that the decompositions are degenerate, in the sense that the model is unable to break the symmetry between foreground and background layers, often generating object appearances in the model’s background layer and vice versa. For CUB-200, the final generated images have some blendings between foregrounds and backgrounds. This is particularly the case for those images without bird-shape masks. For CIFAR-10, a number of generated masks are inverted. In this case, the background images are carved out as the foreground objects. The foreground generator takes almost all the duty to generate the final images, which make it harder to generate images as clear as the model with transformation. From these comparisons, we qualitatively demonstrate the importance of modeling transformations in the foreground generation process. Another merit of using transformation is that the intermediate outputs of the model are more interpretable and faciliate to the downstreaming tasks, such as scene paring, which is demonstrated in Section 6.8.
+
+![](images/069b696a48bdecf8e3ddad01ced1477fa9c80c42733db17aea2ce3df16990a4b.jpg)  
+Figure 12: Generation results from an ablated LR-GAN model without mask generator. The block rows correspond to different datasets (from top to bottom: MNIST-ONE, CUB-200, CIFAR-10). From left to right, the blocks show generated background images, foreground images, transformed foreground images, and final composite images. For comparison, the rightmost column block shows final generated images from a non-ablated model with mask generator.
+
+# 5.6 IMPORTANCE OF SHAPES
+
+We perform another ablation study by removing the mask generator to understand the importance of modeling object shapes. In this case, the generated foreground is simply pasted on top of the generated background after being transformed. There is no alpha blending between the foregrounds and backgrounds. The generation results for three datasets, MNIST-ONE, CUB-200, CIFAR-10 are shown in Fig. 12. As we can see, though the model works well for the generation of MNIST-ONE, it fails to generate reasonable images across the other datasets. Particularly, the training does not even converge for CUB-200. Based on these results, we qualitatively demonstrate that mask generator in our model is fairly important to obtain plausible results, especially for realistic images.
+
+# REFERENCES
+
+Xi Chen, Yan Duan, Rein Houthooft, John Schulman, Ilya Sutskever, and Pieter Abbeel. Infogan: Interpretable representation learning by information maximizing generative adversarial nets. arXiv preprint arXiv:1606.03657, 2016.
+
+Trevor Darrell and Alex Pentland. Robust estimation of a multi-layered motion representation. IEEE Workshop on Visual Motion, 1991.
+
+Emily L Denton, Soumith Chintala, Rob Fergus, et al. Deep generative image models using a laplacian pyramid of adversarial networks. In Advances in neural information processing systems, pp. 1486–1494, 2015.   
+S. M. Ali Eslami, Nicolas Heess, Theophane Weber, Yuval Tassa, Koray Kavukcuoglu, and Geoffrey E. Hinton. Attend, infer, repeat: Fast scene understanding with generative models. CoRR, abs/1603.08575, 2016.   
+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, pp. 2672–2680, 2014.   
+Karol Gregor, Ivo Danihelka, Alex Graves, Danilo Jimenez Rezende, and Daan Wierstra. Draw: A recurrent neural network for image generation. arXiv preprint arXiv:1502.046239, 2015.   
+Gary B. Huang, Manu Ramesh, Tamara Berg, and Erik Learned-Miller. Labeled faces in the wild: A database for studying face recognition in unconstrained environments. Technical Report 07-49, University of Massachusetts, Amherst, October 2007.   
+Jonathan Huang and Kevin Murphy. Efficient inference in occlusion-aware generative models of images. CoRR, abs/1511.06362, 2015.   
+Daniel Jiwoong Im, Chris Dongjoo Kim, Hui Jiang, and Roland Memisevic. Generating images with recurrent adversarial networks. arXiv preprint arXiv:1602.05110, 2016.   
+Phillip Isola and Ce Liu. Scene collaging: Analysis and synthesis of natural images with semantic layers. In IEEE International Conference on Computer Vision, pp. 3048–3055, 2013.   
+Max Jaderberg, Karen Simonyan, Andrew Zisserman, and koray kavukcuoglu. Spatial transformer networks. In Advances in Neural Information Processing Systems 28, pp. 2017–2025, 2015.   
+Anitha Kannan, Nebojsa Jojic, and Brendan Frey. Generative model for layers of appearance and deformation. AISTATS, 2005.   
+Diederik P Kingma, Tim Salimans, and Max Welling. Improving variational inference with inverse autoregressive flow. arXiv preprint arXiv:1606.04934, 2016.   
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.   
+Hanock Kwak and Byoung-Tak Zhang. Generating images part by part with composite generative adversarial networks. arXiv preprint arXiv:1607.05387, 2016.   
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.   
+Elman Mansimov, Emilio Parisotto, Jimmy Lei Ba, and Ruslan Salakhutdinov. Generating images from captions with attention. arXiv preprint arXiv:1511.02793, 2015.   
+Javier Portilla and Eero P Simoncelli. A parametric texture model based on joint statistics of complex wavelet coefficients. International journal of computer vision, 40(1):49–70, 2000.   
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.   
+Scott Reed, Zeynep Akata, Santosh Mohan, Samuel Tenka, Bernt Schiele, and Honglak Lee. Learning what and where to draw. arXiv preprint arXiv:1610.02454, 2016a.   
+Scott Reed, Zeynep Akata, Xinchen Yan, Lajanugen Logeswaran, Bernt Schiele, and Honglak Lee. Generative adversarial text to image synthesis. arXiv preprint arXiv:1605.05396, 2016b.   
+Nicolas Le Roux, Nicolas Heess, Jamie Shotton, and John Winn. Learning a generative model of images by factoring appearance and shape. Neural Computation, 23:593–650, 2011.   
+Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. arXiv preprint arXiv:1606.03498, 2016.   
+Aaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks.¨ CoRR, abs/1601.06759, 2016.   
+Carl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Generating videos with scene dynamics. arXiv preprint arXiv:1609.02612, 2016.   
+John Wang and Edward Adelson. Representing moving images with layers. IEEE Transactions on Image Processing, 1994.   
+Xiaolong Wang and Abhinav Gupta. Generative image modeling using style and structure adversarial networks. arXiv preprint arXiv:1603.05631, 2016.   
+P. Welinder, S. Branson, T. Mita, C. Wah, F. Schroff, S. Belongie, and P. Perona. Caltech-UCSD Birds 200. Technical Report CNS-TR-2010-001, California Institute of Technology, 2010.   
+Xinchen Yan, Jimei Yang, Kihyuk Sohn, and Honglak Lee. Attribute2image: Conditional image generation from visual attributes. CoRR, abs/1512.00570, 2015.   
+Junbo Zhao, Michael Mathieu, and Yann LeCun. Energy-based generative adversarial network. arXiv preprint arXiv:1609.03126, 2016.   
+Jun-Yan Zhu, Philipp Krahenb ¨ uhl, Eli Shechtman, and Alexei A Efros. Generative visual manipu- ¨ lation on the natural image manifold. In European Conference on Computer Vision, pp. 597–613. Springer, 2016.
+
+# 6 APPENDIX
+
+# 6.1 ALGORITHM
+
+Algo. 1 illustrates the generative process in our model. $g ( \star )$ evaluates the function $g$ at $\star$ . $\circ$ is a composition operator that composes its operands so that $f \circ g ( \star ) = f ( g ( \star ) )$ .
+
+Algorithm 1 Stochastic Layered Recursive Image Generation   
+
+<table><tr><td>1: zo ~ N(0,I)</td></tr><tr><td>2: xg=Gb(z0) &gt;background generator</td></tr><tr><td>4:c←0 5: fort∈[1..·T] do 6: zt ~ N(0,I)</td></tr><tr><td>7: ht,ct ←LSTM([zt,ht-1,ct-1]) &gt; pass through LSTM</td></tr><tr><td>8: if t=1 then</td></tr><tr><td>9: yt←ht 10: else</td></tr><tr><td>11: yt←E(hth-1) &gt; pass through non-linear embedding layers El</td></tr><tr><td>12: end if</td></tr><tr><td>13: St←G(yt) V predict shared cube for G&#x27;f and Gm</td></tr><tr><td>14: at←Tf(yt) Vobject transformation</td></tr><tr><td>15: ft←G(st) Vgenerate object appearance</td></tr><tr><td>16: mt←Gm(st) generate object shape</td></tr><tr><td>17: h←EoPf(st) &gt; predict shared represenation embedding</td></tr><tr><td>18: xt ← ST(mt,at) ① ST(ft,at) +(1- ST(mt,at)) ① xt-1 19: end for</td></tr></table>
+
+# 6.2 MODEL CONFIGURATIONS
+
+Table 2 lists the information and model configuration for different datasets. The dimensions of random vectors and hidden vectors are all set to 100. We also compare the number of parameters in DCGAN and LR-GAN. The numbers before $" / "$ are our model, after $\cdot / { \cdot }$ are DCGAN. Based on the same notation used in (Zhao et al., 2016), the architectures for the different datasets are:
+
+Table 2: Information and model configurations on different datasets.   
+
+<table><tr><td>Dataset</td><td>MNIST-ONE</td><td>MNIST-TWO</td><td>CIFAR-10</td><td>CUB-200</td></tr><tr><td>Image Size</td><td>32</td><td>64</td><td>32</td><td>64</td></tr><tr><td>#Images</td><td>60,000</td><td>60,000</td><td>50,000</td><td>5,994</td></tr><tr><td>#Timesteps</td><td>2</td><td>3</td><td>2</td><td>2</td></tr><tr><td>#Parameters</td><td>5.25M/4.11M</td><td>7.53M/6.33M</td><td>5.26M/4.11M</td><td>27.3M/6.34M</td></tr></table>
+
+• MNIST-ONE: $G _ { b }$ : (256)4c-(128)4c2s-(64)4c2s-(3)4c2s; $G _ { f } ^ { c }$ : (512)4c-(256)4c2s$( 1 2 8 ) 4 \mathrm { c } 2 \mathrm { s }$ ; ${ \cal G } _ { f } ^ { i }$ : $( 3 ) 4 \mathrm { c } 2 \mathrm { s }$ ; $G _ { f } ^ { m }$ : (1)4c2s; D: (64)4c2s-(128)4c2s-(256)4c2s-(256)4p4s-1   
+MNIST-TWO: $G _ { b }$ : (256)4c-(128)4c2s-(64)4c2s-(32)4c2s-(3)4c2s; $G _ { f } ^ { c }$ : (512)4c(256)4c2s-(128)4c2s-(64)4c2s; ${ \cal G } _ { f } ^ { i }$ : (3)4c2s; $G _ { f } ^ { m }$ : (1)4c2s;D: (64)4c2s-(128)4c2s(256)4c2s-(512)4c2s-(512)4p4s-1 CUB-200: $G _ { b }$ : (512)4c-(256)4c2s-(128)4c2s-(64)4c2s-(3)4c2s; $G _ { f } ^ { c }$ : (1024)4c-(512)4c2s(256)4c2s-(128)4c2s; ${ G } _ { f } ^ { i }$ : (3)4c2s; $G _ { f } ^ { m }$ : (1)4c2s;D: (128)4c2s-(256)4c2s-(512)4c2s(1024)4c2s-(1024)4p4s-1   
+CIFAR-10: $G _ { b }$ : $( 2 5 6 ) 4 \mathrm { c } - ( 1 2 8 ) 4 \mathrm { c } 2 \mathrm { s } - ( 6 4 ) 4 \mathrm { c } 2 \mathrm { s } - ( 3 ) 4 \mathrm { c } 2 \mathrm { s } ;$ $G _ { f } ^ { c }$ : (512)4c-(256)4c2s-(128)4c2s; ${ G } _ { f } ^ { i }$ : (3)4c2s; $G _ { f } ^ { m }$ : (1)4c2s $D$ : (64)4c2s-(128)4c2s-(256)4c2s-(256)4p4s-1
+
+# 6.3 RESULTS ON MNIST-ONE
+
+We conduct human studies on generation results on MNIST-ONE. Specifically, we generate 1,000 images using both LR-GAN and DCGAN. As references, we also include 1000 real images. Then we ask the users on AMT to label each image to be one of the digits (0-9). We also provide them an option ‘non recognizable’ in case the generated image does not seem to contain a digit. Each image was judged by 5 unique workers. Similar to CIFAR-10, if an image is recognized to be the same digit by all 5 users, it is assigned to quality level 5. If it is not recognizable according to all users, it is assigned to quality level 0. Fig. 13 (left) shows the number of images assigned to all six quality levels. Compared to DCGAN, our model generated more samples with high quality levels. As expected, the real images have many samples with high quality levels. In Fig. 13 (right), we show the number of images that are recognized to each digit category (0-9). For qualitative comparison, we show examplar images at each quality level in Fig. 14. From left to right, the quality level increases from 0 to 5. As expected, the images with higher quality level are more clear.
+
+For quantitative evaluation, we use the same way as for CIFAR-10. The classifier model used for contextual Inception Score is trained based on the training set. We generate 60,000 samples based on DCGAN and LR-GAN for evaluation, respectively. To obtain the Adversarial Accuracy and Adversarial Divergence, we first train 10 generators for 10 digit categories separately, and then use the generated samples to train the classifier. As shown in Table 3, our model has higher scores than DCGAN on both standard and contextual Inception Score. Also, our model has a slightly higher adversarial accuracy, and lower adversarial divergence than DCGAN. We find that the all three image sets have low standard Inception Scores. This is mainly because the Inception net is trained on ImageNet, which has a very different data distribution from the MNIST dataset. Based on this, we argue that the standard Inception Score is not suitable for some image datasets.
+
+![](images/f65151910a30b067f353d6b747248729efa4db3cc5af82ea1910883017bfacfd.jpg)  
+Figure 13: Statistics of annotations in human studies on MNIST-ONE. Left: distribution of quality level; Right: distribution of recognized digit categories.
+
+![](images/8466a362068c2ab386d9e2c3063a92dd648912e83f6540f33e88725175034978.jpg)  
+Figure 14: Qualitative comparison on MNIST-ONE. Top three rows are samples generated by DCGAN. Bottom three rows are samples generated by LR-GAN. The quality level increases from left to right as determined via human studies.
+
+Table 3: Quantitative comparison on MNIST-ONE.   
+
+<table><tr><td>Training Data</td><td>Real Images</td><td>DCGAN</td><td>Ours</td></tr><tr><td>Inception Score†</td><td>1.83±0.01</td><td>2.03±0.01</td><td>2.06±0.01</td></tr><tr><td>Inception Scorett</td><td>9.15±0.04</td><td>6.42±0.03</td><td>7.15±0.04</td></tr><tr><td>Adversarial Accuracy</td><td>95.22 ± 0.25</td><td>26.12 ± 0.07</td><td>26.61 ± 0.06</td></tr><tr><td>Adversarial Divergence Score</td><td>0</td><td>8.47 ± 0.03</td><td>8.39 ± 0.04</td></tr></table>
+
+†Evaluate using the pre-trained Inception net as Salimans et al. (2016) ††Evaluate using the supervisedly trained classifier based on the discriminator in LR-GAN.
+
+# 6.4 MORE RESULTS ON CUB-200
+
+In this experiment, we reduce the minimal allowed object scale to 1.1, which allows the model to generate larger foreground objects. The results are shown in Fig. 15. Similar to the results when the constraint is 1.2, the crisp bird-like masks are generated automatically by our model.
+
+![](images/999f8f427a47ea9e2ea5b589cba077741a87930277f8220175c5debf8936c899.jpg)  
+Figure 15: Generation results of our model on CUB-200 when setting minimal allowed scale to 1.1. From left to right, the blocks show the generated background images, foreground images, foreground masks, foreground images carved out by masks, carved foreground images after spatial transformation. The sixth and seventh blocks are final composite images and the nearest neighbor real images.
+
+# 6.5 MORE RESULTS ON CIFAR-10
+
+# 6.5.1 QUALITATIVE RESULTS
+
+In Fig. 16, we show more results on CIFAR-10 when setting minimal allowed object scale to 1.1. The rightmost column block also shows the training images that are closest to the generated images (cosine similarity in pixel space). We can see our model does not memorize the training data.
+
+![](images/d54ce9b1433367df429539cb16b39a92a77af9defcf75c1126f7c71f5c00180d.jpg)  
+Figure 16: Generation results of our model on CIFAR-10 with minimal allowed scale be 1.1, From left to right, the layout is same to Fig. 15.
+
+# 6.5.2 WALKING IN THE LATENT SPACE
+
+Similar to DCGAN, we also show results by walking in the latent space. Note that our model has two or more inputs. So we can walk along any of them or their combination. In Fig. 17, we generate multiple foregrounds for the same fixed generated background. We find that our model consistently generates contextually compatible foregrounds. For example, for the grass-like backgrounds, the foreground generator generates horses and deer, and airplane-like objects for the blue sky.
+
+# 6.5.3 WORD CLOUD BASED ON HUMAN STUDY
+
+As we mentioned above, we conducted human studies on CIFAR-10. Besides asking people to select a name from a list for an image, we also conducted another human study where we ask people to use one word (free-form) to describe the main object in the image. Each image was ‘named’ by 5 unique people. We generate word clouds for real images, images generated by DCGAN and LR-GAN, as shown in Fig. 18.
+
+# 6.6 RESULTS ON LFW FACE DATASET
+
+We conduct experiment on face images in LFW dataset (Huang et al., 2007). Different from previous works which work on cropped and aligned faces, we directly generate the original images which contains a large portion of backgrounds. This configuration helps to verify the efficiency of LR-GAN to model the object appearance, shape and pose. In Fig. 19, we show the (intermediate) generation results of LR-GAN. Surprisingly, without any supervisions, the model generated background and faces in separate steps, and the generated masks accurately depict face shapes. Moreover, the model learns where to place the generated faces so that the whole image looks natural. For comparison, please refer to (Kwak & Zhang, 2016) which does not model the transformation. We can find the generation results degrade much.
+
+![](images/3a93e369441daba5927f9a8da078f8b1c4f6f78c2e063daca18b2b51a249b891.jpg)  
+Figure 17: Walking in the latent foreground space by fixing backgrounds in our model on CIFAR10. From left to right, the blocks are: generated background images, foreground images, foreground masks, foreground images carved out by masks, carved out foreground images after spatial transformation, and final composite images. Each row has the same background, but different foregrounds.
+
+![](images/bec2166c5d0f1cd6eb736809996471e14f963e4067bd61661d678da884b734a4.jpg)  
+Figure 18: Statistics of annotations in human studies on CIFAR-10. Left to right: word cloud for real images, images generated by DCGAN, images generated by LR-GAN.
+
+![](images/d8e4d5aa1f9649246f471c2fc8dbbcbc545914d6835c9041a6bef7610a54e1b4.jpg)  
+Figure 19: Generation results of our model on LFW. From left to right, the blocks are: generated background images, foreground images, foreground masks, carved out foreground images after spatial transformation, and final composite images.
+
+# 6.7 STATISTICS ON TRANSFORMATION MATRICES
+
+In this part, we analyze the statistics on the transformation matrices generated by our model for different datasets, including MNIST-ONE, CUB-200, CIFAR-10 and LFW. We used affine transformation in our model. So there are 6 parameters, scaling in the $\mathbf { X }$ coordinate $( s _ { x } )$ , scaling in the y coordinate $( s _ { y } )$ , translation in the x coordinate $( t _ { x } )$ , translation in the y coordinate $( t _ { y } )$ , rotation in the x coordinate $( r _ { x } )$ and rotation in the y coordinate $( r _ { y } )$ . In Fig. 20, we show the histograms on different parameters for different datasets.These histograms show that the model produces non-trivial varied scaling, translation and rotation on all datasets. For different datasets, the learned transformation have different patterns. We hypothesize that this is mainly determined by the configurations of objects in the images. For example, on MNIST-ONE, all six parameters have some fluctuations since the synthetic dataset contains digits randomly placed at different locations. For the other three datasets, the scalings converge to single value since the object sizes do not vary much, and the variations on rotation and translation suffice to generate realistic images. Specifically, we can find the generator largely relies on the translation on x coordinate for generating CUB-200. This makes sense since birds in the images have similar scales, orientations but various horizontal locations. For CIFAR-10, since there are 10 different object categories, the configurations are more diverse, hence the generator uses all parameters for generation except for the scaling. For LFW, since faces have similar configurations, the learned transformations have less fluctuation as well. As a result, we can see that LR-GAN indeed models the transformations on the foreground to generate images.
+
+# 6.8 CONDITIONAL IMAGE GENERATION
+
+Considering our model can generate object-like masks (shapes) for images, we conducted an experiment to evaluate whether our model can be potentially used for image segmentation and object detection. We make some changes to the model. For the background generator, the input is a real image instead of a random vector. Then the image is passed through an encoder to extract the hidden features, which replaces the random vector $z _ { \mathrm { 0 } }$ and are fed to the background generator. For the foreground generator, we subtract the image generated by the background generator from the input image to obtain a residual image. Then this residual image is fed to the same encoder to get the hidden features, which are used as the input for foreground generator. In our conditional model, we want to reconstruct the image, so we add a reconstruction loss along with the adversarial loss. We train this conditional model on CIFAR-10. The (intermediate) outputs of the model is shown in Fig. 21. Interestingly, the model successfully learned to decompose the input images into background and foreground. The background generator tends to do an image inpainting by generating a complete background without object, while the foreground generator works as a segmentation model to get object mask from the input image.
+
+Similarly, we also run the conditional LR-GAN on LFW dataset. As we can see in Fig. 22, the foreground generator automatically and consistently learned to generate the face regions, even though there are large portion of background in the input images. In other words, the conditional LR-GAN successfully learned to detection faces in images. We suspect this success is due to that it has low cost for the generator to generate similar images, and thus converge to the case that the first generator generate background, and the second generator generate face images.
+
+Based on these experiments, we argue that our model can be possibly used for image segmentation and object detection in a generative and unsupervised manner. One future work would be verifying this by applying it to high-resolution and more complicate datasets.
+
+![](images/0b8f1bdffe8f04e40df2b53cf17d91ee74a89dfcfd628e1bf10ee257600d04b7.jpg)  
+Figure 20: Histograms of transformation parameters learnt in our model for different datasets. From left to right, the datasets are: MNIST-ONE, CUB-200, CIFAR-10 and LFW. From top to bottom, they are scaling $s _ { x }$ , $s _ { y }$ , translation $t _ { x } , t _ { y }$ , and rotation $r _ { x }$ , $r _ { y }$ in $x$ and $y$ coordinate, respectively.
+
+![](images/fef056a8733f18849e71dc175c08276f74f2f2be4cf05c8343170ae723b0c071.jpg)  
+Figure 21: Conditional generation results of our model on CIFAR-10. From left to right, the blocks are: real images, generated background images, foreground images, foreground masks, foreground images carved out by masks, carved foreground images after spatial transformation, and final composite (reconstructed) images.
+
+![](images/bc504a5eb37f6be231b58df1f390632f076bde0b1068e92b1f6ac47d62532dce.jpg)  
+Figure 22: Conditional generation results of our model on LFW, displayed with the same layout to Fig. 21.

parse/train/HJ1kmv9xx/HJ1kmv9xx_content_list.json

@@ -0,0 +1,1692 @@
+[
+    {
+        "type": "text",
+        "text": "LR-GAN: LAYERED RECURSIVE GENERATIVE ADVERSARIAL NETWORKS FOR IMAGE GENERATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jianwei Yang∗ Virginia Tech Blacksburg, VA jw2yang@vt.edu ",
+        "bbox": [
+            184,
+            170,
+            321,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anitha Kannan Facebook AI Research Menlo Park, CA akannan@fb.com ",
+        "bbox": [
+            354,
+            170,
+            504,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Dhruv Batra∗and Devi Parikh∗ Georgia Institute of Technology Atlanta, GA {dbatra, parikh}@gatech.edu ",
+        "bbox": [
+            537,
+            170,
+            799,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            262,
+            544,
+            277
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present LR-GAN: an adversarial image generation model which takes scene structure and context into account. Unlike previous generative adversarial networks (GANs), the proposed GAN learns to generate image background and foregrounds separately and recursively, and stitch the foregrounds on the background in a contextually relevant manner to produce a complete natural image. For each foreground, the model learns to generate its appearance, shape and pose. The whole model is unsupervised, and is trained in an end-to-end manner with gradient descent methods. The experiments demonstrate that LR-GAN can generate more natural images with objects that are more human recognizable than DCGAN. ",
+        "bbox": [
+            233,
+            296,
+            764,
+            422
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            457,
+            336,
+            473
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative adversarial networks (GANs) (Goodfellow et al., 2014) have shown significant promise as generative models for natural images. A flurry of recent work has proposed improvements over the original GAN work for image generation (Radford et al., 2015; Denton et al., 2015; Salimans et al., 2016; Chen et al., 2016; Zhu et al., 2016; Zhao et al., 2016), multi-stage image generation including part-based models (Im et al., 2016; Kwak & Zhang, 2016), image generation conditioned on input text or attributes (Mansimov et al., 2015; Reed et al., 2016b;a), image generation based on 3D structure (Wang & Gupta, 2016), and even video generation (Vondrick et al., 2016). ",
+        "bbox": [
+            174,
+            482,
+            825,
+            580
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While the holistic ‘gist’ of images generated by these approaches is beginning to look natural, there is clearly a long way to go. For instance, the foreground objects in these images tend to be deformed, blended into the background, and not look realistic or recognizable. ",
+        "bbox": [
+            176,
+            587,
+            823,
+            628
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One fundamental limitation of these methods is that they attempt to generate images without taking into account that images are 2D projections of a 3D visual world, which has a lot of structures in it. This manifests as structure in the 2D images that capture this world. One example of this structure is that images tend to have a background, and foreground objects are placed in this background in contextually relevant ways. ",
+        "bbox": [
+            174,
+            636,
+            825,
+            705
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We develop a GAN model that explicitly encodes this structure. Our proposed model generates images in a recursive fashion: it first generates a background, and then conditioned on the background generates a foreground along with a shape (mask) and a pose (affine transformation) that together define how the background and foreground should be composed to obtain a complete image. Conditioned on this composite image, a second foreground and an associated shape and pose are generated, and so on. As a byproduct in the course of recursive image generation, our approach generates some object-shape foreground-background masks in a completely unsupervised way, without access to any object masks for training. Note that decomposing a scene into foreground-background layers is a classical ill-posed problem in computer vision. By explicitly factorizing appearance and transformation, LR-GAN encodes natural priors about the images that the same foreground can be ‘pasted’ to the different backgrounds, under different affine transformations. According to the experiments, the absence of these priors result in degenerate foreground-background decompositions, and thus also degenerate final composite images. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            892
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/92f1dafd19871af9a89f576fc0395ce1ddba7cbe105573c7bc7d9d76a4374c01.jpg",
+        "image_caption": [
+            "Figure 1: Generation results of our model on CUB-200 (Welinder et al., 2010). It generates images in two timesteps. At the first timestep, it generates background images, while generates foreground images, masks and transformations at the second timestep. Then, they are composed to obtain the final images. From top left to bottom right (row major), the blocks are real images, generated background images, foreground images, foreground masks, carved foreground images, carved and transformed foreground images, final composite images, and their nearest neighbor real images in the training set. Note that the model is trained in a completely unsupervised manner. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            823,
+            351
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We mainly evaluate our approach on four datasets: MNIST-ONE (one digit) and MNIST-TWO (two digits) synthesized from MNIST (LeCun et al., 1998), CIFAR-10 (Krizhevsky & Hinton, 2009) and CUB-200 (Welinder et al., 2010). We show qualitatively (via samples) and quantitatively (via evaluation metrics and human studies on Amazon Mechanical Turk) that LR-GAN generates images that globally look natural and contain clear background and object structures in them that are realistic and recognizable by humans as semantic entities. An experimental snapshot on CUB-200 is shown in Fig. 1. We also find that LR-GAN generates foreground objects that are contextually relevant to the backgrounds (e.g., horses on grass, airplanes in skies, ships in water, cars on streets, etc.). For quantitative comparison, besides existing metrics in the literature, we propose two new quantitative metrics to evaluate the quality of generated images. The proposed metrics are derived from the sufficient conditions for the closeness between generated image distribution and real image distribution, and thus supplement existing metrics. ",
+        "bbox": [
+            174,
+            489,
+            825,
+            657
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            681,
+            344,
+            699
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Early work in parametric texture synthesis was based on a set of hand-crafted features (Portilla & Simoncelli, 2000). Recent improvements in image generation using deep neural networks mainly fall into one of the two stochastic models: variational autoencoders (VAEs) (Kingma et al., 2016) and generative adversarial networks (GANs) (Goodfellow et al., 2014). VAEs pair a top-down probabilistic generative network with a bottom up recognition network for amortized probabilistic inference. Two networks are jointly trained to maximize a variational lower bound on the data likelihood. GANs consist of a generator and a discriminator in a minmax game with the generator aiming to fool the discriminator with its samples with the latter aiming to not get fooled. ",
+        "bbox": [
+            174,
+            708,
+            823,
+            819
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Sequential models have been pivotal for improved image generation using variational autoencoders: DRAW (Gregor et al., 2015) uses attention based recurrence conditioning on the canvas drawn so far. In Eslami et al. (2016), a recurrent generative model that draws one object at a time to the canvas was used as the decoder in VAE. These methods are yet to show scalability to natural images. Early compelling results using GANs used sequential coarse-to-fine multiscale generation and classconditioning (Denton et al., 2015). Since then, improved training schemes (Salimans et al., 2016) and better convolutional structure (Radford et al., 2015) have improved the generation results using ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "GANs. PixelRNN (van den Oord et al., 2016) is also recently proposed to sequentially generates a pixel at a time, along the two spatial dimensions. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we combine the merits of sequential generation with the flexibility of GANs. Our model for sequential generation imbibes a recursive structure that more naturally mimics image composition by inferring three components: appearance, shape, and pose. One closely related work combining recursive structure with GAN is that of Im et al. (2016) but it does not explicitly model object composition and follows a similar paradigm as by Gregor et al. (2015). Another closely related work is that of Kwak & Zhang (2016). It combines recursive structure and alpha blending. However, our work differs in three main ways: (1) We explicitly use a generator for modeling the foreground poses. That provides significant advantage for natural images, as shown by our ablation studies; (2) Our shape generator is separate from the appearance generator. This factored representation allows more flexibility in the generated scenes; (3) Our recursive framework generates subsequent objects conditioned on the current and previous hidden vectors, and previously generated object. This allows for explicit contextual modeling among generated elements in the scene. See Fig. 17 for contextually relevant foregrounds generated for the same background, or Fig. 6 for meaningful placement of two MNIST digits relative to each. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            333
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Models that provide supervision to image generation using conditioning variables have also been proposed: Style/Structure GANs (Wang & Gupta, 2016) learns separate generative models for style and structure that are then composed to obtain final images. In Reed et al. (2016a), GAN based image generation is conditioned on text and the region in the image where the text manifests, specified during training via keypoints or bounding boxes. While not the focus of our work, the model proposed in this paper can be easily extended to take into account these forms of supervision. ",
+        "bbox": [
+            174,
+            340,
+            825,
+            424
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            443,
+            339,
+            459
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 GENERATIVE ADVERSARIAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            474,
+            500,
+            488
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Generative Adversarial Networks (GANs) consist of a generator $G$ and a discriminator $D$ that are simultaneously trained with competing goals: The generator $G$ is trained to generate samples that can ‘fool’ a discriminator $D$ , while the discriminator is trained to classify its inputs as either real (coming from the training dataset) or fake (coming from the samples of $G$ ). This competition leads to a minmax formulation with a value function: ",
+        "bbox": [
+            174,
+            500,
+            825,
+            569
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9f9777a3393270f0f2c07be8e9d27adb397193038e9d62893763d18532d988fb.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta _ { G } } \\operatorname* { m a x } _ { \\theta _ { D } } \\Big ( \\mathrm { E } _ { a \\sim p _ { d a t a } ( x ) } [ \\log ( D ( x ; \\theta _ { D } ) ) ] + \\mathrm { E } _ { z \\sim p _ { z } ( z ) } [ \\log ( 1 - D ( G ( z ; \\theta _ { G } ) ; \\theta _ { D } ) ) ] \\Big ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            227,
+            570,
+            767,
+            601
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $_ { z }$ is a random vector from a standard multivariate Gaussian or a uniform distribution $p _ { z } ( z )$ , $G ( z ; \\theta _ { G } )$ maps $_ z$ to the data space, $D ( { \\pmb x } )$ is the probability that $_ { \\textbf { \\em x } }$ is real estimated by $D$ . The advantage of the GANs formulation is that it lacks an explicit loss function and instead uses the discriminator to optimize the generative model. The discriminator, in turn, only cares whether the sample it receives is on the data manifold, and not whether it exactly matches a particular training example (as opposed to losses such as MSE). Hence, the discriminator provides a gradient signal only when the generated samples do not lie on the data manifold so that the generator can readjust its parameters accordingly. This form of training enables learning the data manifold of the training set and not just optimizing to reconstruct the dataset, as in autoencoder and its variants. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            729
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While the GANs framework is largely agnostic to the choice of $G$ and $D$ , it is clear that generative models with the ‘right’ inductive biases will be more effective in learning from the gradient information (Denton et al., 2015; Im et al., 2016; Gregor et al., 2015; Reed et al., 2016a; Yan et al., 2015). With this motivation, we propose a generator that models image generation via a recurrent process – in each time step of the recurrence, an object with its own appearance and shape is generated and warped according to a generated pose to compose an image in layers. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            820
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 LAYERED STRUCTURE OF IMAGE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            837,
+            441,
+            851
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "An image taken of our 3D world typically contains a layered structure. One way of representing an image layer is by its appearance and shape. As an example, an image $_ { \\textbf { \\em x } }$ with two layers, foreground $f$ and background $^ { b }$ may be factorized as: ",
+        "bbox": [
+            176,
+            862,
+            825,
+            904
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3111a2627a6f3a1d72b405887f46877a9373f0a934e3d8e773ecf31a8cacf739.jpg",
+        "text": "$$\n\\pmb { x } = \\pmb { f } \\odot \\pmb { m } + \\pmb { b } \\odot ( 1 - \\pmb { m } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            909,
+            596,
+            925
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $_ { \\mathbf { \\nabla } } \\mathbf { m } _ { \\mathbf { \\nabla } }$ is the mask depicting the shapes of image layers, and $\\odot$ the element wise multiplication operator. Some existing methods assume the access to the shape of the object either during training (Isola & Liu, 2013) or both at train and test time (Reed et al., 2016a; Yan et al., 2015). Representing images in layered structure is even straightforward for video with moving objects (Darrell & Pentland, 1991; Wang & Adelson, 1994; Kannan et al., 2005). Vondrick et al. (2016) generates videos by separately generating a fixed background and moving foregrounds. A similar way of generating single image can be found in Kwak & Zhang (2016). ",
+        "bbox": [
+            173,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Another way is modeling the layered structure with object appearance and pose as: ",
+        "bbox": [
+            173,
+            208,
+            715,
+            223
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c16cd870758e1eeeee14fbfa83d27b943b97825c59335ef9b229b3d589df9276.jpg",
+        "text": "$$\n\\pmb { x } = S T ( \\pmb { f } , \\pmb { a } ) + \\pmb { b } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            433,
+            229,
+            563,
+            246
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $f$ and $^ { b }$ are foreground and background, respectively; $\\textbf { \\em a }$ is the affine transformation; $S T$ is the spatial transformation operator. Several works fall into this group (Roux et al., 2011; Huang & Murphy, 2015; Eslami et al., 2016). In Huang & Murphy (2015), images are decomposed into layers of objects with specific poses in a variational autoencoder framework, while the number of objects (i.e., layers) is adaptively estimated in Eslami et al. (2016). ",
+        "bbox": [
+            173,
+            252,
+            825,
+            323
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To contrast with these works, LR-GAN uses a layered composition, and the foreground layers simultaneously model all three dominant factors of variation: appearance $f$ , shape $_ { \\mathbf { \\nabla } } \\mathbf { m }$ and pose $\\textbf { \\em a }$ . We will elaborate it in the following section. ",
+        "bbox": [
+            176,
+            329,
+            823,
+            372
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 LAYERED RECURSIVE GAN (LR-GAN) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            391,
+            540,
+            409
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The basic structure of LR-GAN is similar to GAN: it consists of a discriminator and a generator that are simultaneously trained using the minmax formulation of GAN, as described in $\\ S . 3 . 1$ . The key innovation of our work is the layered recursive generator, which is what we describe in this section. ",
+        "bbox": [
+            174,
+            416,
+            823,
+            459
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The generator in LR-GAN is recursive in that the image is constructed recursively using a recurrent network. Layered in that each recursive step composes an object layer that is ‘pasted’ on the image generated so far. Object layer at timestep $t$ is parameterized by the following three constituents – ‘canonical’ appearance $\\pmb { f } _ { t }$ , shape (or mask) $\\mathbf { \\nabla } m _ { t }$ , and pose (or affine transformation) $\\mathbf { } \\mathbf { a } _ { t }$ for warping the object before pasting in the image composition. ",
+        "bbox": [
+            173,
+            465,
+            825,
+            536
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Fig. 2 shows the architecture of the LR-GAN with the generator architecture unrolled for generating background $\\scriptstyle { \\mathbf { { \\mathit { x } } } } _ { 0 }$ $( \\doteq \\pmb { x } _ { b } )$ and foreground $\\scriptstyle { \\mathbf { { \\vec { x } } } } _ { 1 }$ and $\\mathbf { x } _ { 2 }$ . At each time step $t$ , the generator composes the next image $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { t } }$ via the following recursive computation: ",
+        "bbox": [
+            173,
+            542,
+            823,
+            585
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5f45bf59e7fe231a9c4f36e7305b9f73cadf829e6b21007088c792b4c7dd8e93.jpg",
+        "text": "$$\n\\begin{array} { r l } { x _ { t } = \\mathrm { ~ { \\mathcal { S } } ~ } T ( m _ { t } , a _ { t } ) , \\quad \\odot \\quad } & { { } { \\mathcal { S } } T ( f _ { t } , a _ { t } ) , \\quad \\quad + ( 1 - { S T } ( m _ { t } , a _ { t } ) ) \\odot x _ { t - 1 , } , \\quad \\forall t \\in [ 1 , T ] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            191,
+            590,
+            787,
+            609
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $S T ( \\circ , \\pmb { a } _ { t } )$ is a spatial transformation operator that outputs the affine transformed version of $\\diamond$ with $\\mathbf { } \\mathbf { a } _ { t }$ indicating parameters of the affine transformation. ",
+        "bbox": [
+            174,
+            636,
+            826,
+            664
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Since our proposed model has an explicit transformation variable $\\mathbf { } \\mathbf { a } _ { t }$ that is used to warp the object, it can learn a canonical object representation that can be re-used to generate scenes where the object occurs as mere transformations of it, such as different scales or rotations. By factorizing the appearance, shape and pose, the object generator can focus on separately capturing regularities in these three factors that constitute an object. We will demonstrate in our experiments that removing these factorizations from the model leads to its spending capacity in variability that may not solely be about the object in Section 5.5 and 5.6. ",
+        "bbox": [
+            173,
+            670,
+            825,
+            768
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 DETAILS OF GENERATOR ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            785,
+            501,
+            799
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Fig. 2 shows our LR-GAN architecture in detail – we use different shapes to indicate different kinds of layers (convolutional, fractional convolutional, (non)linear, etc), as indicated by the legend. Our model consists of two main pieces – a background generator $G _ { b }$ and a foreground generator $G _ { f }$ . $G _ { b }$ and $G _ { f }$ do not share parameters with each other. $G _ { b }$ computation happens only once, while $G _ { f }$ is recurrent over time, i.e., all object generators share the same parameters. In the following, we will introduce each module and connections between them. ",
+        "bbox": [
+            173,
+            804,
+            825,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Temporal Connections. LR-GAN has two kinds of temporal connections – informally speaking, one on ‘top’ and one on ‘bottom’. The ‘top’ connections perform the act of sequentially ‘pasting’ object layers (Eqn. 4). The ‘bottom’ connections are constructed by a LSTM on the noise vectors $z _ { \\mathrm { 0 } } , z _ { \\mathrm { 1 } } , z _ { \\mathrm { 2 } }$ . Intuitively, this noise-vector-LSTM provides information to the foreground generator about what else has been generated in past. Besides, when generating multiple objects, we use a pooling layer $P _ { f } ^ { c }$ and a fully-connected layer $E _ { f } ^ { c }$ to extract the information from previous generated object response map. By this way, the model is able to ‘see’ previously generated objects. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/79a2c73e95232f085950c43b5fe393cac10d2e42a3969656315cbce8f01e7db4.jpg",
+        "image_caption": [
+            "Figure 2: LR-GAN architecture unfolded to three timesteps. It mainly consists of one background generator, one foreground generator, temporal connections and one discriminator. The meaning of each component is explained in the legend. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            112,
+            782,
+            377
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            489,
+            825,
+            561
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Background Generator. The background generator $G _ { b }$ is purposely kept simple. It takes the hidden state of noise-vector-LSTM $h _ { l } ^ { 0 }$ as the input and passes it to a number of fractional convolutional layers (also called ‘deconvolution’ layer in some papers) to generate images at its end. The output of background generator $\\scriptstyle { \\mathbf { \\mathcal { x } } } _ { b }$ will be used as the canvas for the following generated foregrounds. ",
+        "bbox": [
+            174,
+            569,
+            825,
+            625
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Foreground Generator. The foreground generator $G _ { f }$ is used to generate an object with appearance and shape. Correspondingly, $G _ { f }$ consists of three sub-modules, $G _ { f } ^ { c }$ , which is a common ‘trunk’ whose outputs are shared by $G _ { f } ^ { i }$ and $G _ { f } ^ { m }$ . $G _ { f } ^ { i }$ is used to generate the foreground appearance $\\pmb { f } _ { t }$ , while $G _ { f } ^ { m }$ generates the mask $\\mathbf { \\nabla } m _ { t }$ for the foreground. All three sub-modules consists of one or more fractional convolutional layers combined with batch-normalization and nonlinear layers. The generated foreground appearance and mask have the same spatial size as the background. The top of $G _ { f } ^ { m }$ is a sigmoid layer in order to generate one channel mask whose values range in $( 0 , 1 )$ . ",
+        "bbox": [
+            174,
+            631,
+            825,
+            734
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Spatial Transformer. To spatially transform foreground objects, we need to estimate the transformation matrix. As in Jaderberg et al. (2015), we predict the affine transformation matrix with a linear layer $T _ { f }$ that has six-dimensional outputs. Then based on the predicted transformation matrix, we use a grid generator $G _ { g }$ to generate the corresponding sampling coordinates in the input for each location at the output. The generated foreground appearance and mask share the same transformation matrix, and thus the same sampling grid. Given the grid, the sampler $S$ will simultaneously sample the $\\pmb { f } _ { t }$ and ${ \\mathbf { } } m _ { t }$ to obtain $\\hat { f } _ { t }$ and $\\hat { m } _ { t }$ , respectively. Different from Jaderberg et al. (2015), our sampler here normally performs downsampling, since the the foreground typically has smaller size than the background. Pixels in $\\hat { f } _ { t }$ and $\\hat { m } _ { t }$ that are from outside the extent of $\\pmb { f } _ { t }$ and ${ \\mathbf { } } m _ { t }$ are set to zero. Finally, $\\hat { f } _ { t }$ and $\\hat { m } _ { t }$ are sent to the compositor $C$ which combines the canvas ${ \\mathbf { } } _ { { \\mathbf { } } { \\mathbf { } } { \\mathbf { } } - 1 }$ and $\\hat { f } _ { t }$ through layered composition with blending weights given by $\\hat { m } _ { t }$ (Eqn. 4). ",
+        "bbox": [
+            174,
+            742,
+            825,
+            902
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Pseudo-code for our approach and detailed model configuration are provided in the Appendix. ",
+        "bbox": [
+            171,
+            909,
+            789,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 NEW EVALUATION METRICS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            413,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Several metrics have been proposed to evaluate GANs, such as Gaussian parzen window (Goodfellow et al., 2014), Generative Adversarial Metric (GAM) (Im et al., 2016) and Inception Score (Salimans et al., 2016). The common goal is to measure the similarity between the generated data distribution $P _ { g } ( \\pmb { x } ) = G ( \\pmb { z } ; \\theta _ { z } )$ and the real data distribution $P ( { \\pmb x } )$ . Most recently, Inception Score has been used in several works (Salimans et al., 2016; Zhao et al., 2016). However, it is an assymetric metric and could be easily fooled by generating centers of data modes. ",
+        "bbox": [
+            174,
+            125,
+            825,
+            208
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In addition to these metrics, we present two new metrics based on the following intuition – a sufficient (but not necessary) condition for closeness of $P _ { g } ( \\pmb { x } )$ and $P ( { \\pmb x } )$ is closeness of $P _ { g } ( \\pmb { x } | y )$ and $P ( { \\pmb x } | { \\pmb y } )$ , i.e., distributions of generated data and real data conditioned on all possible variables of interest $y$ , e.g., category label. One way to obtain this variable of interest $y$ is via human annotation. Specifically, given the data sampled from $P _ { g } ( \\pmb { x } )$ and $P ( { \\pmb x } )$ , we ask people to label the category of the samples according to some rules. Note that such human annotation is often easier than comparing samples from the two distributions (e.g., because there is no 1:1 correspondence between samples to conduct forced-choice tests). ",
+        "bbox": [
+            174,
+            214,
+            825,
+            325
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "After the annotations, we need to verify whether the two distributions are similar in each category. Clearly, directly comparing the distributions $P _ { g } ( \\pmb { x } | y )$ and $P ( { \\pmb x } | { \\pmb y } )$ may be as difficult as comparing $P _ { g } ( \\pmb { x } )$ and $P ( { \\pmb x } )$ . Fortunately, we can use Bayes rule and alternatively compare $P _ { g } ( y | \\mathbf { \\boldsymbol { x } } )$ and $P ( y | \\bar { \\mathbf { x } } )$ , which is a much easier task. In this case, we can simply train a discriminative model on the samples from $P _ { g } ( \\pmb { x } )$ and $P ( { \\pmb x } )$ together with the human annotations about categories of these samples. With a slight abuse of notation, we use $P _ { g } ( y | \\mathbf { \\boldsymbol { x } } )$ and $P ( y | \\pmb { x } )$ to denote probability outputs from these two classifiers (trained on generated samples vs trained on real samples). We can then use these two classifiers to compute the following two evaluation metrics: ",
+        "bbox": [
+            174,
+            332,
+            825,
+            444
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Adversarial Accuracy: Computes the classification accuracies achieved by these two classifiers on a validation set, which can be the training set or another set of real images sampled from $P ( { \\pmb x } )$ . If $P _ { g } ( \\pmb { x } )$ is close to $P ( { \\pmb x } )$ , we expect to see similar accuracies. ",
+        "bbox": [
+            176,
+            452,
+            821,
+            492
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Adversarial Divergence: Computes the KL divergence between $P _ { g } ( y | \\mathbf { \\boldsymbol { x } } )$ and $P ( \\boldsymbol { y } | \\boldsymbol { x } )$ . The lower the adversarial divergence, the closer two distributions are. The low bound for this metric is exactly zero, which means $\\bar { P _ { g } } ( y | \\mathbf { x } ) = P ( y | \\mathbf { x } )$ for all samples in the validation set. ",
+        "bbox": [
+            174,
+            500,
+            825,
+            542
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As discussed above, we need human efforts to label the real and generated samples. Fortunately, we can further simplify this. Based on the labels given on training data, we split the training data into categories, and train one generator for each category. With all these generators, we generate samples of all categories. This strategy will be used in our experiments on the datasets with labels given. ",
+        "bbox": [
+            174,
+            549,
+            825,
+            606
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            627,
+            316,
+            643
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We conduct qualitative and quantitative evaluations on three datasets: 1) MNIST (LeCun et al., 1998); 2) CIFAR-10 (Krizhevsky & Hinton, 2009); 3) CUB-200 (Welinder et al., 2010). To add variability to the MNIST images, we randomly scale (factor of 0.8 to 1.2) and rotate $( - \\frac { \\pi } { 4 }$ to $\\frac { \\pi } { 4 }$ ) the digits and then stitch them to $4 8 \\times 4 8$ uniform backgrounds with random grayscale value between [0, 200]. Images are then rescaled back to $3 2 \\times 3 2$ . Each image thus has a different background grayscale value and a different transformed digit as foreground. We rename this sythensized dataset as MNIST-ONE (single digit on a gray background). We also synthesize a dataset MNIST-TWO containing two digits on a grayscale background. We randomly select two images of digits and perform similar transformations as described above, and put one on the left and the other on the right side of a $7 8 \\times 7 8$ gray background. We resize the whole image to $6 4 \\times 6 4$ . ",
+        "bbox": [
+            174,
+            654,
+            825,
+            792
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We develop LR-GAN based on open source code1. We assume the number of objects is known. Therefore, for MNIST-ONE, MNIST-TWO, CIFAR-10, and CUB-200, our model has two, three, two, and two timesteps, respectively. Since the size of foreground object should be smaller than that of canvas, we set the minimal allowed scale 2 in affine transforamtion to be 1.2 for all datasets except for MNIST-TWO, which is set to 2 (objects are smaller in MNIST-TWO). In LR-GAN, the background generator and foreground generator have similar architectures. One difference is that the number of channels in the background generator is half of the one in the foreground generator. We compare our results to that of DCGAN (Radford et al., 2015). Note that LR-GAN without LSTM at the first timestep corresponds exactly to the DCGAN. This allows us to run controlled experiments. In both generator and discriminator, all the (fractional) convolutional layers have $4 \\times$ 4 filter size with stride 2. As a result, the number of layers in the generator and discriminator automatically adapt to the size of training images. Please see the Appendix (Section 6.2) for details about the configurations. We use three metrics for quantitative evaluation, including Inception Score (Salimans et al., 2016) and the proposed Adversarial Accuracy, Adversarial Divergence. Note that we report two versions of Inception Score. One is based on the pre-trained Inception net, and the other one is based on the pre-trained classifier on the target datasets. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            869
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/ea9d1888db5f0175c63f7dc33705c1a85c916ddedfeb9fbe58ce22e363880dc6.jpg",
+        "image_caption": [
+            "Figure 3: Generated images on CIFAR-10 based on our model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            102,
+            828,
+            231
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/e4acd62c5dabc349e9e9d71827aa0583fbb417f9871d9c1a9114d2dafafaa62e.jpg",
+        "image_caption": [
+            "Figure 4: Generated images on CUB-200 based on our model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            271,
+            825,
+            406
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            460,
+            825,
+            614
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 QUALITATIVE RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            633,
+            379,
+            647
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 3 and 4, we show the generated samples for CIFAR-10 and CUB-200, respectively. MNIST results are shown in the next subsection. As we can see from the images, the compositional nature of our model results in the images being free of blending artifacts between backgrounds and foregrounds. For CIFAR-10, we can see the horses and cars with clear shapes. For CUB-200, the bird shapes tend to be even sharper. ",
+        "bbox": [
+            174,
+            654,
+            825,
+            723
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 MNIST-ONE AND MNIST-TWO",
+        "text_level": 1,
+        "bbox": [
+            176,
+            742,
+            447,
+            757
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We now report the results on MNIST-ONE and MNIST-TWO. Fig. 5 shows the generation results of our model on MNIST-ONE. As we can see, our model generates the background and the foreground in separate timestep, and can disentagle the foreground digits from background nearly perfectly. Though initial values of the mask randomly distribute in the range of $( 0 , 1 )$ , after training, the masks are nearly binary and accurately carve out the digits from the generated foreground. More results on MNIST-ONE (including human studies) can be found in the Appendix (Section 6.3). ",
+        "bbox": [
+            174,
+            762,
+            825,
+            847
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Fig. 6 shows the generation results for MNIST-TWO. Similarly, the model is also able to generate background and the two foreground objects separately. The foreground generator tends to generate a single digit at each timestep. Meanwhile, it captures the context information from the previous time steps. When the first digit is placed to the left side, the second one tends to be placed on the right side, and vice versa. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/c9088480f0d89fd14b3ceff741b6beacdf0fbbe1c67e90e5b58b50cda1cee1bc.jpg",
+        "image_caption": [
+            "Figure 5: Generation results of our model on MNIST-ONE. From left to right, the image blocks are real images, generated background images, generated foreground images, generated masks and final composite images, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            823,
+            204
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/2d8099797d1198840f43f9d1a7f0d7128c29860c6fe6e072e1b531c7c038e259.jpg",
+        "image_caption": [
+            "Figure 6: Generation results of our model on MNIST-TWO. From top left to bottom right (row major), the image blocks are real images, generated background images, foreground images and masks at the second timestep, composite images at the second time step, generated foreground images and masks at the third timestep and the final composite images, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            275,
+            821,
+            526
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 CUB-200 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            625,
+            284,
+            638
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We study the effectiveness of our model trained on the CUB-200 bird dataset. In Fig. 1, we have shown a random set of generated images, along with the intermediate generation results of the model. While being completely unsupervised, the model, for a large fraction of the samples, is able to successfully disentangle the foreground and the background. This is evident from the generated bird-like masks. ",
+        "bbox": [
+            174,
+            646,
+            825,
+            689
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/989f9d2e3d2a4070720b93cdc749bb21b33c2a5270b5c3240d846bda141714b0.jpg",
+        "image_caption": [
+            "Figure 7: Matched pairs of generated images based on DCGAN and LR-GAN, respectivedly. The odd columns are generated by DCGAN, and the even columns are generated by LR-GAN. These are paired according to the perfect matching based on Hungarian algorithm. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            713,
+            821,
+            866
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/a9475bb0409c08b9126b69efdcf7c3260d528ffc6572639fda597aa5f1790a74.jpg",
+        "image_caption": [
+            "Figure 8: Qualitative comparison on CIFAR-10. Top three rows are images generated by DCGAN; Bottom three rows are by LR-GAN. From left to right, the blocks display generated images with increasing quality level as determined by human studies. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            102,
+            823,
+            199
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            281,
+            823,
+            309
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We do a comparative study based on Amazon Mechanical Turk (AMT) between DCGAN and LRGAN to quantify relative visual quality of the generated images. We first generated 1000 samples from both the models. Then, we performed perfect matching between the two image sets using the Hungarian algorithm on $L 2$ norm distance in the pixel space. This resulted in 1000 image pairs. Some examplar pairs are shown in Fig. 7. For each image pair, 9 judges are asked to choose the one that is more realistic. Based on majority voting, we find that our generated images are selected $6 8 . 4 \\%$ times, compared with $3 1 . 6 \\%$ times for DCGAN. This demonstrates that our model has generated more realistic images than DCGAN. We can attribute this difference to our model’s ability to generate foreground separately from the background, enabling stronger edge cues. ",
+        "bbox": [
+            174,
+            315,
+            825,
+            441
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.4 CIFAR-10 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            460,
+            290,
+            474
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We now qualitatively and quantitatively evaluate our model on CIFAR-10, which contains multiple object categories and also various backgrounds. ",
+        "bbox": [
+            176,
+            481,
+            823,
+            510
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Comparison of image generation quality: We conduct AMT studies to compare the fidelity of image generation. Towards this goal, we generate 1000 images from DCGAN and LR-GAN, respectively. We ask 5 judges to label each image to either belong to one of the 10 categories or as ‘non recognizable’ or ‘recognizable but not belonging to the listed categories’. We then assign each image a quality level between [0,5] that captures the number of judges that agree with the majority choice. Fig. 8 shows the images generated by both approaches, ordered by increasing quality level. We merge images at quality level 0 (all judges said non-recognizable) and 1 together, and similarly images at level 4 and 5. Visually, the generated samples by our model have clearer boundaries and object structures. We also computed the fraction of non-recognizable images: Our model had a $10 \\%$ absolute drop in non-recognizability rate $( 6 7 . 3 \\%$ for ours vs. $7 7 . 7 \\%$ for DCGAN). For reference, $1 1 . 4 \\%$ of real CIFAR images were categorized as non-recognizable. Fig. 9 shows more generated (intermediate) results of our model. ",
+        "bbox": [
+            174,
+            517,
+            825,
+            683
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Quantitative evaluation on generators: We evaluate the generators based on three metrics: 1) Inception Score; 2) Adversarial Accuracy; 3) Adversarial Divergence. To obtain a classifier model for evaluation, we remove the top layer in the discriminator used in our model, and then append two fully connected layers on the top of it. We train this classifier using the training samples of CIFAR-10 based on the annotations. Following Salimans et al. (2016), we generated 50,000 images based on DCGAN and LR-GAN, repsectively. We compute two types of Inception Scores. The standard Inception Score is based on the Inception net as in Salimans et al. (2016), and the contextual Inception Score is based on our trained classifier model. To distinguish, we denote the standard one as ‘Inception Score†’, and the contextual one as ‘Inception Score††’. To obtain the Adversarial Accuracy and Adversarial Divergence scores, we train one generator on each of 10 categories for DCGAN and LR-GAN, respectively. Then, we use these generators to generate samples of different categories. Given these generated samples, we train the classifiers for DCGAN and LR-GAN separately. Along with the classifier trained on the real samples, we compute the Adversarial Accuracy and Adversarial Divergence on the real training samples. In Table 1, we report the Inception Scores, Adversarial Accuracy and Adversarial Divergence for comparison. We can see that our model outperforms DCGAN across the board. To point out, we obtan different Inception Scores based on different classifier models, which indicates that the Inception Score varies with different models. ",
+        "bbox": [
+            174,
+            690,
+            823,
+            761
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/b71c9e0162bb4ace2320abed0654f65b900fbece488293c59f27fe047bce32f8.jpg",
+        "table_caption": [
+            "Table 1: Quantitative comparison between DCGAN and LR-GAN on CIFAR-10. "
+        ],
+        "table_footnote": [
+            "†Evaluate using the pre-trained Inception net as Salimans et al. (2016) ††Evaluate using the supervisedly trained classifier based on the discriminator in LR-GAN. "
+        ],
+        "table_body": "<table><tr><td>Training Data</td><td>Real Images</td><td>DCGAN</td><td>Ours</td></tr><tr><td>Inception Scoret</td><td>11.18±0.18</td><td>6.64±0.14</td><td>7.17±0.07</td></tr><tr><td>Inception Scorett</td><td>7.23±0.09</td><td>5.69±0.07</td><td>6.11±0.06</td></tr><tr><td>Adversarial Accuracy</td><td>83.33±0.08</td><td>37.81±0.02</td><td>44.22 ±0.08</td></tr><tr><td>Adversarial Divergence</td><td>0</td><td>7.58±0.04</td><td>5.57±0.06</td></tr></table>",
+        "bbox": [
+            220,
+            811,
+            776,
+            893
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/62ac4ea9d7d7caf7d3df3bbf1cae137f708b8b0c172bc331afc28396ddbc5e74.jpg",
+        "image_caption": [
+            "Figure 9: Generation results of our model on CIFAR-10. From left to right, the blocks are: generated background images, foreground images, foreground masks, foreground images carved out by masks, carved foregrounds after spatial transformation, final composite images and nearest neighbor training images to the generated images. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            101,
+            821,
+            422
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/e40422586846dc636bdcad89dabebfc927006c7e46aae4a86839c89cd3cfcb2d.jpg",
+        "image_caption": [
+            "Figure 10: Category specific generation results of our model on CIFAR-10 categories of horse, frog, and cat (top to bottom). The blocks from left to right are: generated background images, foreground images, foreground masks, foreground images carved out by masks, carved foregrounds after spatial transformation and final composite images. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            506,
+            823,
+            717
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Quantitative evaluation on discriminators: We evaluate the discriminator as an extractor for deep representations. Specifically, we use the output of the last convolutional layer in the discriminator as features. We perform a 1-NN classification on the test set given the full training set. Cosine similarity is used as the metric. On the test set, our model achieves $6 2 . 0 9 \\% \\pm 0 . 0 1 \\%$ compared to DCGAN’s $5 6 . 0 5 \\% \\pm 0 . 0 2 \\%$ . ",
+        "bbox": [
+            174,
+            166,
+            825,
+            236
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Contextual generation: We also show the efficacy of our approach to generate diverse foregrounds conditioned on fixed background. The results in Fig. 17 in Appendix showcase that the foreground generator generates objects that are compatible with the background. This indicates that the model has captured contextual dependencies between the image layers. ",
+        "bbox": [
+            174,
+            243,
+            825,
+            299
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Category specific models: The objects in CIFAR-10 exhibit huge variability in shapes. That can partly explain why some of the generated shapes are not as compelling in Fig. 9. To test this hypothesis, we reuse the generators trained for each of 10 categories used in our metrics to obtain the generation results. Fig. 10 shows results for categories ‘horse’, ‘frog’ and ‘cat’. We can see that the model is now able to generate object-specific appearances and shapes, similar in vein to our results on the CUB-200 dataset. ",
+        "bbox": [
+            174,
+            306,
+            825,
+            390
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "5.5 IMPORTANCE OF TRANSFORMATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            409,
+            472,
+            422
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/4ce0b42c6c668769875b477b80ca2f9c2683243d0e9ffa760e24f65378ec4efe.jpg",
+        "image_caption": [
+            "Figure 11: Generation results from an ablated LR-GAN model without affine transformations. From top to bottom, the block rows correspond to different datasets: MNIST-ONE, CUB-200, CIFAR-10. From left to right, the blocks show generated background images, foreground images, foreground masks, and final composite images. For comparison, the rightmost column block shows final generated images from a non-ablated model with affine transformations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            440,
+            825,
+            739
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Fig. 11 shows results from an ablated model without affine transformations in the foreground layers, and compares the results with the full model that does include these transformations. We note that one significant problem emerges that the decompositions are degenerate, in the sense that the model is unable to break the symmetry between foreground and background layers, often generating object appearances in the model’s background layer and vice versa. For CUB-200, the final generated images have some blendings between foregrounds and backgrounds. This is particularly the case for those images without bird-shape masks. For CIFAR-10, a number of generated masks are inverted. In this case, the background images are carved out as the foreground objects. The foreground generator takes almost all the duty to generate the final images, which make it harder to generate images as clear as the model with transformation. From these comparisons, we qualitatively demonstrate the importance of modeling transformations in the foreground generation process. Another merit of using transformation is that the intermediate outputs of the model are more interpretable and faciliate to the downstreaming tasks, such as scene paring, which is demonstrated in Section 6.8. ",
+        "bbox": [
+            173,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/069b696a48bdecf8e3ddad01ced1477fa9c80c42733db17aea2ce3df16990a4b.jpg",
+        "image_caption": [
+            "Figure 12: Generation results from an ablated LR-GAN model without mask generator. The block rows correspond to different datasets (from top to bottom: MNIST-ONE, CUB-200, CIFAR-10). From left to right, the blocks show generated background images, foreground images, transformed foreground images, and final composite images. For comparison, the rightmost column block shows final generated images from a non-ablated model with mask generator. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            823,
+            397
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            512,
+            825,
+            609
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "5.6 IMPORTANCE OF SHAPES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            635,
+            388,
+            648
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We perform another ablation study by removing the mask generator to understand the importance of modeling object shapes. In this case, the generated foreground is simply pasted on top of the generated background after being transformed. There is no alpha blending between the foregrounds and backgrounds. The generation results for three datasets, MNIST-ONE, CUB-200, CIFAR-10 are shown in Fig. 12. As we can see, though the model works well for the generation of MNIST-ONE, it fails to generate reasonable images across the other datasets. Particularly, the training does not even converge for CUB-200. Based on these results, we qualitatively demonstrate that mask generator in our model is fairly important to obtain plausible results, especially for realistic images. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            775
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            803,
+            285,
+            818
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xi Chen, Yan Duan, Rein Houthooft, John Schulman, Ilya Sutskever, and Pieter Abbeel. Infogan: Interpretable representation learning by information maximizing generative adversarial nets. arXiv preprint arXiv:1606.03657, 2016. ",
+        "bbox": [
+            174,
+            830,
+            823,
+            872
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Trevor Darrell and Alex Pentland. Robust estimation of a multi-layered motion representation. IEEE Workshop on Visual Motion, 1991. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            922
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Emily L Denton, Soumith Chintala, Rob Fergus, et al. Deep generative image models using a laplacian pyramid of adversarial networks. In Advances in neural information processing systems, pp. 1486–1494, 2015.   \nS. M. Ali Eslami, Nicolas Heess, Theophane Weber, Yuval Tassa, Koray Kavukcuoglu, and Geoffrey E. Hinton. Attend, infer, repeat: Fast scene understanding with generative models. CoRR, abs/1603.08575, 2016.   \nIan 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, pp. 2672–2680, 2014.   \nKarol Gregor, Ivo Danihelka, Alex Graves, Danilo Jimenez Rezende, and Daan Wierstra. Draw: A recurrent neural network for image generation. arXiv preprint arXiv:1502.046239, 2015.   \nGary B. Huang, Manu Ramesh, Tamara Berg, and Erik Learned-Miller. Labeled faces in the wild: A database for studying face recognition in unconstrained environments. Technical Report 07-49, University of Massachusetts, Amherst, October 2007.   \nJonathan Huang and Kevin Murphy. Efficient inference in occlusion-aware generative models of images. CoRR, abs/1511.06362, 2015.   \nDaniel Jiwoong Im, Chris Dongjoo Kim, Hui Jiang, and Roland Memisevic. Generating images with recurrent adversarial networks. arXiv preprint arXiv:1602.05110, 2016.   \nPhillip Isola and Ce Liu. Scene collaging: Analysis and synthesis of natural images with semantic layers. In IEEE International Conference on Computer Vision, pp. 3048–3055, 2013.   \nMax Jaderberg, Karen Simonyan, Andrew Zisserman, and koray kavukcuoglu. Spatial transformer networks. In Advances in Neural Information Processing Systems 28, pp. 2017–2025, 2015.   \nAnitha Kannan, Nebojsa Jojic, and Brendan Frey. Generative model for layers of appearance and deformation. AISTATS, 2005.   \nDiederik P Kingma, Tim Salimans, and Max Welling. Improving variational inference with inverse autoregressive flow. arXiv preprint arXiv:1606.04934, 2016.   \nAlex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.   \nHanock Kwak and Byoung-Tak Zhang. Generating images part by part with composite generative adversarial networks. arXiv preprint arXiv:1607.05387, 2016.   \nYann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.   \nElman Mansimov, Emilio Parisotto, Jimmy Lei Ba, and Ruslan Salakhutdinov. Generating images from captions with attention. arXiv preprint arXiv:1511.02793, 2015.   \nJavier Portilla and Eero P Simoncelli. A parametric texture model based on joint statistics of complex wavelet coefficients. International journal of computer vision, 40(1):49–70, 2000.   \nAlec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.   \nScott Reed, Zeynep Akata, Santosh Mohan, Samuel Tenka, Bernt Schiele, and Honglak Lee. Learning what and where to draw. arXiv preprint arXiv:1610.02454, 2016a.   \nScott Reed, Zeynep Akata, Xinchen Yan, Lajanugen Logeswaran, Bernt Schiele, and Honglak Lee. Generative adversarial text to image synthesis. arXiv preprint arXiv:1605.05396, 2016b.   \nNicolas Le Roux, Nicolas Heess, Jamie Shotton, and John Winn. Learning a generative model of images by factoring appearance and shape. Neural Computation, 23:593–650, 2011.   \nTim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. arXiv preprint arXiv:1606.03498, 2016.   \nAaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks.¨ CoRR, abs/1601.06759, 2016.   \nCarl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Generating videos with scene dynamics. arXiv preprint arXiv:1609.02612, 2016.   \nJohn Wang and Edward Adelson. Representing moving images with layers. IEEE Transactions on Image Processing, 1994.   \nXiaolong Wang and Abhinav Gupta. Generative image modeling using style and structure adversarial networks. arXiv preprint arXiv:1603.05631, 2016.   \nP. Welinder, S. Branson, T. Mita, C. Wah, F. Schroff, S. Belongie, and P. Perona. Caltech-UCSD Birds 200. Technical Report CNS-TR-2010-001, California Institute of Technology, 2010.   \nXinchen Yan, Jimei Yang, Kihyuk Sohn, and Honglak Lee. Attribute2image: Conditional image generation from visual attributes. CoRR, abs/1512.00570, 2015.   \nJunbo Zhao, Michael Mathieu, and Yann LeCun. Energy-based generative adversarial network. arXiv preprint arXiv:1609.03126, 2016.   \nJun-Yan Zhu, Philipp Krahenb ¨ uhl, Eli Shechtman, and Alexei A Efros. Generative visual manipu- ¨ lation on the natural image manifold. In European Conference on Computer Vision, pp. 597–613. Springer, 2016. ",
+        "bbox": [
+            171,
+            60,
+            828,
+            926
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            826,
+            400
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "6 APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            421,
+            294,
+            436
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "6.1 ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            452,
+            303,
+            465
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Algo. 1 illustrates the generative process in our model. $g ( \\star )$ evaluates the function $g$ at $\\star$ . $\\circ$ is a composition operator that composes its operands so that $f \\circ g ( \\star ) = f ( g ( \\star ) )$ . ",
+        "bbox": [
+            173,
+            477,
+            823,
+            507
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/ee3a8f8205b5967affe4df8d9bc5fe7d751a1926c3c9fe1e1a01f06a1b9c89bf.jpg",
+        "table_caption": [
+            "Algorithm 1 Stochastic Layered Recursive Image Generation "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>1: zo ~ N(0,I)</td></tr><tr><td>2: xg=Gb(z0) &gt;background generator</td></tr><tr><td>4:c←0 5: fort∈[1..·T] do 6: zt ~ N(0,I)</td></tr><tr><td>7: ht,ct ←LSTM([zt,ht-1,ct-1]) &gt; pass through LSTM</td></tr><tr><td>8: if t=1 then</td></tr><tr><td>9: yt←ht 10: else</td></tr><tr><td>11: yt←E(hth-1) &gt; pass through non-linear embedding layers El</td></tr><tr><td>12: end if</td></tr><tr><td>13: St←G(yt) V predict shared cube for G&#x27;f and Gm</td></tr><tr><td>14: at←Tf(yt) Vobject transformation</td></tr><tr><td>15: ft←G(st) Vgenerate object appearance</td></tr><tr><td>16: mt←Gm(st) generate object shape</td></tr><tr><td>17: h←EoPf(st) &gt; predict shared represenation embedding</td></tr><tr><td>18: xt ← ST(mt,at) ① ST(ft,at) +(1- ST(mt,at)) ① xt-1 19: end for</td></tr></table>",
+        "bbox": [
+            176,
+            535,
+            825,
+            820
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "6.2 MODEL CONFIGURATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            842,
+            398,
+            856
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 2 lists the information and model configuration for different datasets. The dimensions of random vectors and hidden vectors are all set to 100. We also compare the number of parameters in DCGAN and LR-GAN. The numbers before $\" / \"$ are our model, after $\\cdot / { \\cdot }$ are DCGAN. Based on the same notation used in (Zhao et al., 2016), the architectures for the different datasets are: ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/24f05e5723f13d86f477d8b036e2ded21957572cfe2beeb3460f13c06ef74027.jpg",
+        "table_caption": [
+            "Table 2: Information and model configurations on different datasets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>MNIST-ONE</td><td>MNIST-TWO</td><td>CIFAR-10</td><td>CUB-200</td></tr><tr><td>Image Size</td><td>32</td><td>64</td><td>32</td><td>64</td></tr><tr><td>#Images</td><td>60,000</td><td>60,000</td><td>50,000</td><td>5,994</td></tr><tr><td>#Timesteps</td><td>2</td><td>3</td><td>2</td><td>2</td></tr><tr><td>#Parameters</td><td>5.25M/4.11M</td><td>7.53M/6.33M</td><td>5.26M/4.11M</td><td>27.3M/6.34M</td></tr></table>",
+        "bbox": [
+            253,
+            127,
+            745,
+            207
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "• MNIST-ONE: $G _ { b }$ : (256)4c-(128)4c2s-(64)4c2s-(3)4c2s; $G _ { f } ^ { c }$ : (512)4c-(256)4c2s$( 1 2 8 ) 4 \\mathrm { c } 2 \\mathrm { s }$ ; ${ \\cal G } _ { f } ^ { i }$ : $( 3 ) 4 \\mathrm { c } 2 \\mathrm { s }$ ; $G _ { f } ^ { m }$ : (1)4c2s; D: (64)4c2s-(128)4c2s-(256)4c2s-(256)4p4s-1   \nMNIST-TWO: $G _ { b }$ : (256)4c-(128)4c2s-(64)4c2s-(32)4c2s-(3)4c2s; $G _ { f } ^ { c }$ : (512)4c(256)4c2s-(128)4c2s-(64)4c2s; ${ \\cal G } _ { f } ^ { i }$ : (3)4c2s; $G _ { f } ^ { m }$ : (1)4c2s;D: (64)4c2s-(128)4c2s(256)4c2s-(512)4c2s-(512)4p4s-1 CUB-200: $G _ { b }$ : (512)4c-(256)4c2s-(128)4c2s-(64)4c2s-(3)4c2s; $G _ { f } ^ { c }$ : (1024)4c-(512)4c2s(256)4c2s-(128)4c2s; ${ G } _ { f } ^ { i }$ : (3)4c2s; $G _ { f } ^ { m }$ : (1)4c2s;D: (128)4c2s-(256)4c2s-(512)4c2s(1024)4c2s-(1024)4p4s-1   \nCIFAR-10: $G _ { b }$ : $( 2 5 6 ) 4 \\mathrm { c } - ( 1 2 8 ) 4 \\mathrm { c } 2 \\mathrm { s } - ( 6 4 ) 4 \\mathrm { c } 2 \\mathrm { s } - ( 3 ) 4 \\mathrm { c } 2 \\mathrm { s } ;$ $G _ { f } ^ { c }$ : (512)4c-(256)4c2s-(128)4c2s; ${ G } _ { f } ^ { i }$ : (3)4c2s; $G _ { f } ^ { m }$ : (1)4c2s $D$ : (64)4c2s-(128)4c2s-(256)4c2s-(256)4p4s-1 ",
+        "bbox": [
+            215,
+            232,
+            826,
+            404
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "6.3 RESULTS ON MNIST-ONE",
+        "text_level": 1,
+        "bbox": [
+            176,
+            424,
+            401,
+            439
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We conduct human studies on generation results on MNIST-ONE. Specifically, we generate 1,000 images using both LR-GAN and DCGAN. As references, we also include 1000 real images. Then we ask the users on AMT to label each image to be one of the digits (0-9). We also provide them an option ‘non recognizable’ in case the generated image does not seem to contain a digit. Each image was judged by 5 unique workers. Similar to CIFAR-10, if an image is recognized to be the same digit by all 5 users, it is assigned to quality level 5. If it is not recognizable according to all users, it is assigned to quality level 0. Fig. 13 (left) shows the number of images assigned to all six quality levels. Compared to DCGAN, our model generated more samples with high quality levels. As expected, the real images have many samples with high quality levels. In Fig. 13 (right), we show the number of images that are recognized to each digit category (0-9). For qualitative comparison, we show examplar images at each quality level in Fig. 14. From left to right, the quality level increases from 0 to 5. As expected, the images with higher quality level are more clear. ",
+        "bbox": [
+            173,
+            450,
+            825,
+            617
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For quantitative evaluation, we use the same way as for CIFAR-10. The classifier model used for contextual Inception Score is trained based on the training set. We generate 60,000 samples based on DCGAN and LR-GAN for evaluation, respectively. To obtain the Adversarial Accuracy and Adversarial Divergence, we first train 10 generators for 10 digit categories separately, and then use the generated samples to train the classifier. As shown in Table 3, our model has higher scores than DCGAN on both standard and contextual Inception Score. Also, our model has a slightly higher adversarial accuracy, and lower adversarial divergence than DCGAN. We find that the all three image sets have low standard Inception Scores. This is mainly because the Inception net is trained on ImageNet, which has a very different data distribution from the MNIST dataset. Based on this, we argue that the standard Inception Score is not suitable for some image datasets. ",
+        "bbox": [
+            173,
+            625,
+            825,
+            709
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/f65151910a30b067f353d6b747248729efa4db3cc5af82ea1910883017bfacfd.jpg",
+        "image_caption": [
+            "Figure 13: Statistics of annotations in human studies on MNIST-ONE. Left: distribution of quality level; Right: distribution of recognized digit categories. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            738,
+            794,
+            878
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/8466a362068c2ab386d9e2c3063a92dd648912e83f6540f33e88725175034978.jpg",
+        "image_caption": [
+            "Figure 14: Qualitative comparison on MNIST-ONE. Top three rows are samples generated by DCGAN. Bottom three rows are samples generated by LR-GAN. The quality level increases from left to right as determined via human studies. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            818,
+            185
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/6e4346eb3b27c0f3d4801f9f41f57a4fbb462b8be9663ea71e7c5b6e270d64d2.jpg",
+        "table_caption": [
+            "Table 3: Quantitative comparison on MNIST-ONE. "
+        ],
+        "table_footnote": [
+            "†Evaluate using the pre-trained Inception net as Salimans et al. (2016) ††Evaluate using the supervisedly trained classifier based on the discriminator in LR-GAN. "
+        ],
+        "table_body": "<table><tr><td>Training Data</td><td>Real Images</td><td>DCGAN</td><td>Ours</td></tr><tr><td>Inception Score†</td><td>1.83±0.01</td><td>2.03±0.01</td><td>2.06±0.01</td></tr><tr><td>Inception Scorett</td><td>9.15±0.04</td><td>6.42±0.03</td><td>7.15±0.04</td></tr><tr><td>Adversarial Accuracy</td><td>95.22 ± 0.25</td><td>26.12 ± 0.07</td><td>26.61 ± 0.06</td></tr><tr><td>Adversarial Divergence Score</td><td>0</td><td>8.47 ± 0.03</td><td>8.39 ± 0.04</td></tr></table>",
+        "bbox": [
+            222,
+            284,
+            776,
+            364
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            425,
+            825,
+            481
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "6.4 MORE RESULTS ON CUB-200 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            505,
+            421,
+            520
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, we reduce the minimal allowed object scale to 1.1, which allows the model to generate larger foreground objects. The results are shown in Fig. 15. Similar to the results when the constraint is 1.2, the crisp bird-like masks are generated automatically by our model. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            577
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/999f8f427a47ea9e2ea5b589cba077741a87930277f8220175c5debf8936c899.jpg",
+        "image_caption": [
+            "Figure 15: Generation results of our model on CUB-200 when setting minimal allowed scale to 1.1. From left to right, the blocks show the generated background images, foreground images, foreground masks, foreground images carved out by masks, carved foreground images after spatial transformation. The sixth and seventh blocks are final composite images and the nearest neighbor real images. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            595,
+            825,
+            819
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "6.5 MORE RESULTS ON CIFAR-10 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            428,
+            117
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "6.5.1 QUALITATIVE RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            128,
+            392,
+            143
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 16, we show more results on CIFAR-10 when setting minimal allowed object scale to 1.1. The rightmost column block also shows the training images that are closest to the generated images (cosine similarity in pixel space). We can see our model does not memorize the training data. ",
+        "bbox": [
+            174,
+            154,
+            823,
+            195
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/d54ce9b1433367df429539cb16b39a92a77af9defcf75c1126f7c71f5c00180d.jpg",
+        "image_caption": [
+            "Figure 16: Generation results of our model on CIFAR-10 with minimal allowed scale be 1.1, From left to right, the layout is same to Fig. 15. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            208,
+            823,
+            531
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "6.5.2 WALKING IN THE LATENT SPACE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            593,
+            454,
+            608
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Similar to DCGAN, we also show results by walking in the latent space. Note that our model has two or more inputs. So we can walk along any of them or their combination. In Fig. 17, we generate multiple foregrounds for the same fixed generated background. We find that our model consistently generates contextually compatible foregrounds. For example, for the grass-like backgrounds, the foreground generator generates horses and deer, and airplane-like objects for the blue sky. ",
+        "bbox": [
+            174,
+            618,
+            825,
+            688
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "6.5.3 WORD CLOUD BASED ON HUMAN STUDY ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            703,
+            509,
+            717
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "As we mentioned above, we conducted human studies on CIFAR-10. Besides asking people to select a name from a list for an image, we also conducted another human study where we ask people to use one word (free-form) to describe the main object in the image. Each image was ‘named’ by 5 unique people. We generate word clouds for real images, images generated by DCGAN and LR-GAN, as shown in Fig. 18. ",
+        "bbox": [
+            174,
+            727,
+            825,
+            797
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "6.6 RESULTS ON LFW FACE DATASET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            814,
+            447,
+            828
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We conduct experiment on face images in LFW dataset (Huang et al., 2007). Different from previous works which work on cropped and aligned faces, we directly generate the original images which contains a large portion of backgrounds. This configuration helps to verify the efficiency of LR-GAN to model the object appearance, shape and pose. In Fig. 19, we show the (intermediate) generation results of LR-GAN. Surprisingly, without any supervisions, the model generated background and faces in separate steps, and the generated masks accurately depict face shapes. Moreover, the model learns where to place the generated faces so that the whole image looks natural. For comparison, please refer to (Kwak & Zhang, 2016) which does not model the transformation. We can find the generation results degrade much. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/3a93e369441daba5927f9a8da078f8b1c4f6f78c2e063daca18b2b51a249b891.jpg",
+        "image_caption": [
+            "Figure 17: Walking in the latent foreground space by fixing backgrounds in our model on CIFAR10. From left to right, the blocks are: generated background images, foreground images, foreground masks, foreground images carved out by masks, carved out foreground images after spatial transformation, and final composite images. Each row has the same background, but different foregrounds. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            101,
+            818,
+            375
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/bec2166c5d0f1cd6eb736809996471e14f963e4067bd61661d678da884b734a4.jpg",
+        "image_caption": [
+            "Figure 18: Statistics of annotations in human studies on CIFAR-10. Left to right: word cloud for real images, images generated by DCGAN, images generated by LR-GAN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            463,
+            836,
+            570
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/d8e4d5aa1f9649246f471c2fc8dbbcbc545914d6835c9041a6bef7610a54e1b4.jpg",
+        "image_caption": [
+            "Figure 19: Generation results of our model on LFW. From left to right, the blocks are: generated background images, foreground images, foreground masks, carved out foreground images after spatial transformation, and final composite images. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            630,
+            815,
+            827
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "6.7 STATISTICS ON TRANSFORMATION MATRICES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            162,
+            532,
+            176
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "In this part, we analyze the statistics on the transformation matrices generated by our model for different datasets, including MNIST-ONE, CUB-200, CIFAR-10 and LFW. We used affine transformation in our model. So there are 6 parameters, scaling in the $\\mathbf { X }$ coordinate $( s _ { x } )$ , scaling in the y coordinate $( s _ { y } )$ , translation in the x coordinate $( t _ { x } )$ , translation in the y coordinate $( t _ { y } )$ , rotation in the x coordinate $( r _ { x } )$ and rotation in the y coordinate $( r _ { y } )$ . In Fig. 20, we show the histograms on different parameters for different datasets.These histograms show that the model produces non-trivial varied scaling, translation and rotation on all datasets. For different datasets, the learned transformation have different patterns. We hypothesize that this is mainly determined by the configurations of objects in the images. For example, on MNIST-ONE, all six parameters have some fluctuations since the synthetic dataset contains digits randomly placed at different locations. For the other three datasets, the scalings converge to single value since the object sizes do not vary much, and the variations on rotation and translation suffice to generate realistic images. Specifically, we can find the generator largely relies on the translation on x coordinate for generating CUB-200. This makes sense since birds in the images have similar scales, orientations but various horizontal locations. For CIFAR-10, since there are 10 different object categories, the configurations are more diverse, hence the generator uses all parameters for generation except for the scaling. For LFW, since faces have similar configurations, the learned transformations have less fluctuation as well. As a result, we can see that LR-GAN indeed models the transformations on the foreground to generate images. ",
+        "bbox": [
+            174,
+            188,
+            825,
+            438
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "6.8 CONDITIONAL IMAGE GENERATION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            455,
+            462,
+            469
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "Considering our model can generate object-like masks (shapes) for images, we conducted an experiment to evaluate whether our model can be potentially used for image segmentation and object detection. We make some changes to the model. For the background generator, the input is a real image instead of a random vector. Then the image is passed through an encoder to extract the hidden features, which replaces the random vector $z _ { \\mathrm { 0 } }$ and are fed to the background generator. For the foreground generator, we subtract the image generated by the background generator from the input image to obtain a residual image. Then this residual image is fed to the same encoder to get the hidden features, which are used as the input for foreground generator. In our conditional model, we want to reconstruct the image, so we add a reconstruction loss along with the adversarial loss. We train this conditional model on CIFAR-10. The (intermediate) outputs of the model is shown in Fig. 21. Interestingly, the model successfully learned to decompose the input images into background and foreground. The background generator tends to do an image inpainting by generating a complete background without object, while the foreground generator works as a segmentation model to get object mask from the input image. ",
+        "bbox": [
+            174,
+            482,
+            825,
+            676
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "Similarly, we also run the conditional LR-GAN on LFW dataset. As we can see in Fig. 22, the foreground generator automatically and consistently learned to generate the face regions, even though there are large portion of background in the input images. In other words, the conditional LR-GAN successfully learned to detection faces in images. We suspect this success is due to that it has low cost for the generator to generate similar images, and thus converge to the case that the first generator generate background, and the second generator generate face images. ",
+        "bbox": [
+            174,
+            683,
+            823,
+            766
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "Based on these experiments, we argue that our model can be possibly used for image segmentation and object detection in a generative and unsupervised manner. One future work would be verifying this by applying it to high-resolution and more complicate datasets. ",
+        "bbox": [
+            174,
+            773,
+            825,
+            815
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/0b8f1bdffe8f04e40df2b53cf17d91ee74a89dfcfd628e1bf10ee257600d04b7.jpg",
+        "image_caption": [
+            "Figure 20: Histograms of transformation parameters learnt in our model for different datasets. From left to right, the datasets are: MNIST-ONE, CUB-200, CIFAR-10 and LFW. From top to bottom, they are scaling $s _ { x }$ , $s _ { y }$ , translation $t _ { x } , t _ { y }$ , and rotation $r _ { x }$ , $r _ { y }$ in $x$ and $y$ coordinate, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            142,
+            831,
+            830
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/fef056a8733f18849e71dc175c08276f74f2f2be4cf05c8343170ae723b0c071.jpg",
+        "image_caption": [
+            "Figure 21: Conditional generation results of our model on CIFAR-10. From left to right, the blocks are: real images, generated background images, foreground images, foreground masks, foreground images carved out by masks, carved foreground images after spatial transformation, and final composite (reconstructed) images. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            114,
+            823,
+            438
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "image",
+        "img_path": "images/bc504a5eb37f6be231b58df1f390632f076bde0b1068e92b1f6ac47d62532dce.jpg",
+        "image_caption": [
+            "Figure 22: Conditional generation results of our model on LFW, displayed with the same layout to Fig. 21. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            542,
+            821,
+            867
+        ],
+        "page_idx": 20
+    }
+]

parse/train/QpU7n-6l0n/QpU7n-6l0n.md

@@ -0,0 +1,317 @@
+# ON THE CONSISTENCY LOSS FOR LEVERAGING AUGMENTED DATA TO LEARN ROBUST AND INVARIANT REPRESENTATIONS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Data augmentation is one of the most popular techniques for improving the robustness of neural networks. In addition to directly training the model with original samples and augmented samples, a torrent of methods regularizing the distance between embeddings/representations of the original samples and their augmented counterparts have been introduced. In this paper, we explore these various regularization choices, seeking to provide a general understanding of how we should regularize the embeddings. Our analysis suggests the ideal choices of regularization correspond to various assumptions. With an invariance test, we argue that regularization is important if the model is to be used in a broader context than accuracy-driven setting because non-regularized approaches are limited in learning the concept of invariance, despite equally high accuracy. Finally, we also show that the generic approach we identified (squared $\ell _ { 2 }$ norm regularized augmentation) outperforms several recent methods, which are each specially designed for one task and significantly more complicated than ours, over three different tasks.
+
+# 1 INTRODUCTION
+
+Recent advances in deep learning has delivered remarkable empirical performance over i.i.d test data, and the community continues to investigate the more challenging and realistic scenario when models are tested in robustness over non-i.i.d data (e.g., Ben-David et al., 2010; Szegedy et al., $\boxed { 2 0 1 3 }$ . Recent studies suggest that one cause of the fragility is the model’s tendency in capturing undesired signals $( \overline { { \mathbb { W } \mathrm { a n g ~ e t ~ a l . } } } ) \textcircled { 2 0 2 0 } )$ , thus combating this tendency may be a key to robust models.
+
+To help models ignore the undesired signals, data augmentation (i.e., diluting the undesired signals of training samples by applying transformations to existing examples) is often used. Given its widely usage, we seek to answer the question: how should we train with augmented samples so that the assistance of augmentation can be taken to the fullest extent to learn robust and invariant models?
+
+In this paper, We analyze the generalization behaviors of models trained with augmented data and associated regularization techniques. We investigate a set of assumptions and compare the worstcase expected risk over unseen data when i.i.d samples are allowed to be transformed according to a function belonging to a family. We bound the expected risk with terms that can be computed during training, so that our analysis can inspire how to regularize the training procedure. While all the derived methods have an upper bound of the expected risk, with progressively stronger assumptions, we have progressively simpler regularization, allowing practical choices to be made according to the understanding of the application. Our contributions of this paper are as follows:
+
+• We offer analyses of the generalization behaviors of augmented models trained with different regularizations: these regularizations require progressively stronger assumptions of the data and the augmentation functions, but progressively less computational efforts. For example, with assumptions pertaining to augmentation transformation functions, the Wasserstein distance over the original and augmented empirical distributions can be calculated through simple $\ell _ { 1 }$ norm distance. • We test and compare these methods and offer practical guidance on how to choose regularizations in practice. In short, regularizing the squared $\ell _ { 2 }$ distance of logits between the augmented samples and original samples is a favorable method, suggested by both theoretical and empirical evidence.
+
+• With an invariance test, we argue that vanilla augmentation does not utilize the augmented samples to the fullest extent, especially in learning invariant representations, thus may not be ideal unless the only goal of augmentation is to improve the accuracy over a specific setting.
+
+# 2 RELATED WORK & KEY DIFFERENCES
+
+Data augmentation has been used effectively for years. Tracing back to the earliest convolutional neural networks, we notice that even the LeNet applied on MNIST dataset has been boosted by mixing the distorted images to the original ones $\mathrm { ( \mathbb { L } e C u n \ e t \ a l . ) } \ \mathrm { [ 9 9 8 ] ) }$ . Later, the rapidly growing machine learning community has seen a proliferate development of data augmentation techniques (e.g., flipping, rotation, blurring etc.) that have helped models climb the ladder of the state-of-theart (one may refer to relevant survey (Shorten & Khoshgoftaar, 2019) for details). Recent advances expanded the conventional concept of data augmentation and invented several new approaches, such as leveraging the information in unlabelled data (Xie et al., 2019), automatically learning augmentation functions (Ho et al., 2019; Hu et al., 2019; Wang et al., 2019c; Zhang et al., 2020; Zoph et al., $\boxed { 2 0 1 9 }$ , and generating the samples (with constraint) that maximize the training loss along training (Fawzi et al., 2016), which is later widely accepted as adversarial training (Madry et al., 2018).
+
+While the above works mainly discuss how to generate the augmented samples, in this paper, we mainly answer the question about how to train the models with augmented samples. For example, instead of directly mixing augmented samples with the original samples, one can consider regularizing the representations (or outputs) of original samples and augmented samples to be close under a distance metric (also known as a consistency loss). Many concrete ideas have been explored in different contexts. For example, $\ell _ { 2 }$ distance and cosine similarities between internal representations in speech recognition (Liang et al., 2018), squared $\ell _ { 2 }$ distance between logits (Kannan et al., 2018) , or KL divergence between softmax outputs $( \mathbb { Z } \mathrm { h a n g ~ e t ~ a l . } ) , \underline { 2 0 1 9 \mathrm { a } } )$ in adversarially robust vision models, Jensen–Shannon divergence (of three distributions) between embeddings for texture invariant image classification (Hendrycks et al., $\boxed { 2 0 2 0 }$ . These are but a few highlights of the concrete and successful implementations for different applications out of a huge collection (e.g., (Wu et al., 2019; Guo et al., 2019; Zhang et al., 2019b; Shah et al., 2019; Asai & Hajishirzi, $\boxed { 2 0 2 0 } ;$ Sajjadi et al., 2016; Zheng et al., 2016; Xie et al., 2015)), and one can easily imagine methods permuting these three elements (distance metrics, representation or outputs, and applications) to be invented. Even further, although we are not aware of the following methods in the context of data augmentation, given the popularity of GAN $\left( \overline { { \mathrm { G o o d f e l l o w } } } , \overline { { \mathrm { 2 0 1 6 } } } \right)$ and domain adversarial neural network $\mathrm { ( } \mathrm { G a n i n ~ e t ~ a l . , } \mathrm { ) } \mathrm { . } \mathrm { \overline { { 2 0 1 6 } } \mathrm { ) } }$ , one can also expect the distance metric generalizes to a specialized discriminator (i.e. a classifier), which can be intuitively understood as a calculated (usually maximized) distance measure, Wasserstein-1 metric as an example (Arjovsky et al., 2017; Gulrajani et al., 2017)
+
+Key Differences: With this rich collection of regularizing choices, which one method should we consider in general? More importantly, do we actually need the regularization at all? These questions are important for multiple reasons, especially considering that there are paper suggesting that these regularizations may lead to worse results $( \overbrace { \mathrm { J e o n g ~ e t ~ a l . } } ^ { \bullet } ) \widetilde { \mathbb { Z } \mathrm { 0 1 9 } } )$ . In this paper, we answer the first question with a proved upper bound of the worst case generalization error, and our upper bound explicitly describes what regularizations are needed. For the second question, we will show that regularizations can help the model to learn the concept of invariance.
+
+There are also several previous discussions regarding the detailed understandings of data augmentation (Yang et al., 2019; Chen et al., 2019; Hernandez-Garc ´ ´ıa & Konig, 2018; Rajput et al., 2019; ¨ $\boxed { \mathrm { D a o e t ~ a l . } , \boxed { 2 0 1 9 } }$ , among which, $\overline { { \mathbb { Y } \mathrm { a n g ~ e t ~ a l . } \mathrm { | } \mathrm { \mathscr { L } 0 1 9 | } } }$ is probably the most relevant as it also defends the usage of regularizations. However, we believe our discussions are more comprehensive and supported theoretically, since our analysis directly suggests the ideal regularization. Also, empirically, we design an invariance test in addition to the worst-case accuracy used in the preceding work.
+
+# 3 TRAINING STRATEGIES WITH AUGMENTED DATA
+
+Notations $( \mathbf { X } , \mathbf { Y } )$ denotes the data, where $\mathbf { X } \in \mathcal { R } ^ { n \times p }$ and $\mathbf { Y } \in \{ 0 , 1 \} ^ { n \times k }$ (one-hot vectors for $k$ classes), and $f ( \cdot , \theta )$ denotes the model, which takes in the data and outputs the softmax (probabilities of the prediction) and $\theta$ denotes the corresponding parameters. $g ( \ u )$ completes the prediction (i.e., mapping softmax to one-hot prediction). $l ( \cdot , \cdot )$ denotes a generic loss function. $\overset { \cdot } { a } ( \cdot )$ denotes a transformation that alters the undesired signals of a sample, i.e., the data augmentation method. $a \in { \mathcal { A } }$ , which is the set of transformation functions. $\mathcal { P }$ denotes the distribution of $\displaystyle ( \mathbf { x } , \mathbf { y } )$ . For any sampled $\displaystyle ( \mathbf { x } , \mathbf { y } )$ , we can have $( a ( \mathbf { x } ) , \mathbf { y } )$ , and we use $\mathcal { P } _ { a }$ to denote the distribution of these transformed samples. $r ( \cdot ; \theta )$ denotes the risk of model $\theta . { \widehat { \cdot } }$ denotes the estimated term $\cdot$ .
+
+# 3.1 WELL-BEHAVED DATA TRANSFORMATION FUNCTION
+
+Despite the strong empirical performance data augmentation has demonstrated, it should be intuitively expected that the performance can only be improved when the augmentation is chosen wisely. Therefore, before we proceed to analyze the behaviors of training with data augmentations, we need first regulate some basic properties of the data transformation functions used. Intuitively, we will consider the following three properties.
+
+• “Dependence-preservation” with two perspectives: Label-wise, the transformation cannot alter the label of the data, which is a central requirement of almost all the data augmentation practice. Feature-wise, the transformation will not introduce new dependencies between the samples. • “Efficiency”: the augmentation should only generate new samples of the same label as minor perturbations of the original one. If a transformation violates this property, there should exist other simpler transformations that can generate the same target sample. • “Vertices”: There are extreme cases of the transformations. For example, if one needs the model to be invariant to rotations from $0 ^ { \circ }$ to $6 0 ^ { \circ }$ , we consider the vertices to be $0 ^ { \circ }$ rotation function (thus identity map) and $6 0 ^ { \circ }$ rotation function. In practice, one usually selects the transformation vertices with intuitions and domain knowledge.
+
+We now formally define these three properties. The definition will depend on the model, thus these properties are not only regulating the transformation functions, but also the model. We introduce the Assumptions A1-A3 corresponding to the properties.
+
+A1: Dependence-preservation: the transformation function will not alter the dependency regarding the label (i.e., for any $a ( ) \in { \mathcal { A } }$ , $a ( \mathbf { x } )$ will have the same label as $\mathbf { x }$ ) or the features (i.e., for any $a _ { 1 } ( \ l ) , a _ { 2 } ( \ l ) \in \mathcal { A } , a _ { 1 } ( \mathbf { x } _ { 1 } ) \ \perp \ l \ a _ { 1 } ( \mathbf { x } _ { 2 } )$ for any $\mathbf { x } _ { 1 } , \mathbf { x } _ { 2 } \in \mathbf { X }$ that $\mathbf { x } _ { 1 } \neq \mathbf { x } _ { 2 }$ ).
+
+A2: Efficiency: for $\widehat { \theta }$ and any $a ( ) \in { \mathcal { A } }$ , $f ( a ( \mathbf { x } ) ; \widehat { \theta } )$ is closer to $\mathbf { x }$ than any other samples under a distance metric $d _ { e } ( \cdot , \cdot )$ , i.e., $\begin{array} { r } { \big \langle d _ { e } \big ( f \big ( a ( \mathbf { x } ) ; \widehat { \theta } \big ) , f ( \mathbf { x } ; \widehat { \theta } ) \big ) \leq \operatorname* { m i n } _ { \mathbf { x } ^ { \prime } \in \mathbf { X } - \mathbf { x } } d _ { e } \big ( f \big ( a ( \mathbf { x } ) ; \widehat { \theta } \big ) , f ( \mathbf { x } ^ { \prime } ; \widehat { \theta } ) \big ) } \end{array}$ .
+
+A3: Vertices: For a model $\widehat { \theta }$ and a transformation $a ( )$ , we use $\mathcal { P } _ { a , \widehat { \theta } }$ to denote the distribution of $f ( a ( \mathbf { x } ) ; \widehat { \theta } )$ for $( \mathbf { x } , \mathbf { y } ) \sim \mathcal { P }$ . “Vertices” argues that exists two extreme elements in $\mathcal { A }$ , namely $a ^ { + }$ and $a ^ { - }$ , with certain metric $d _ { x } ( \cdot , \cdot )$ , we have
+
+$$
+d _ { x } ( \mathcal { P } _ { a ^ { + } , \widehat { \theta } } , \mathcal { P } _ { a ^ { - } , \widehat { \theta } } ) = \operatorname* { s u p } _ { a _ { 1 } , a _ { 2 } \in \mathcal { A } } d _ { x } ( \mathcal { P } _ { a _ { 1 } , \widehat { \theta } } , \mathcal { P } _ { a _ { 2 } , \widehat { \theta } } )
+$$
+
+Note that $d _ { x } ( \cdot , \cdot )$ is a metric over two distributions and $d _ { e } ( \cdot , \cdot )$ is a metric over two samples. Also, slightly different from the intuitive understanding of “vertices” above, A3 regulates the behavior of embedding instead of raw data. All of our follow-up analysis will require A1 to hold, but with more assumptions held, we can get computationally lighter methods with bounded error.
+
+# 3.2 BACKGROUND, ROBUSTNESS, AND INVARIANCE
+
+One central goal of machine learning is to understand the generalization error. When the test data and train data are from the same distribution, many previous analyses can be sketched as:
+
+$$
+r _ { \mathcal { P } } ( \widehat { \theta } ) \leq \widehat { r } _ { \mathcal { P } } ( \widehat { \theta } ) + \phi ( | \Theta | , n , \delta )
+$$
+
+which states that the expected risk can be bounded by the empirical risk and a function of hypothesis space $| \Theta |$ and number of samples $n$ ; $\delta$ accounts for the probability when the bound holds. $\phi ( )$ is a function of these three terms. Dependent on the details of different analyses, different concrete examples of this generic term will need different assumptions. We use a generic assumption A4 to denote the assumptions required for each example. More concrete discussions are in Appendix A
+
+Robustness In addition to the generalization error above, we also study the robustness by following the established definition as in the worst case expected risk when the test data is allowed to be shifted to some other distributions by transformation functions in $\mathcal { A }$ . Formally, we study
+
+$$
+r _ { \mathcal { P } ^ { \prime } } ( \widehat { \theta } ) = \mathbb { E } _ { ( \mathbf { x } , \mathbf { y } ) \sim \mathcal { P } } \operatorname* { m a x } _ { a \sim \mathcal { A } } \mathbb { I } ( g ( f ( a ( \mathbf { x } ) ; \widehat { \theta } ) ) \neq \mathbf { y } )
+$$
+
+As $r _ { \mathcal { P } } ( \widehat { \theta } ) \leq r _ { \mathcal { P ^ { \prime } } } ( \widehat { \theta } )$ , we only need to study $\textcircled{3}$ . We will analyze $\textcircled{3}$ in different scenarios involving different assumptions and offer formalizations of the generalization bounds under each scenario. Our bounds shall also immediately inspire the development of methods in each scenario as the terms involved in our bound are all computable within reasonable computational loads.
+
+Invariance In addition to robustness, we are also interested in whether the model learns to be invariant to the undesired signals. Intuitively, if data augmentation is used to help dilute the undesired signals from data by altering the undesired signals with $a ( ) \in { \mathcal { A } }$ , a successfully trained model with augmented data will map the raw data with various undesired signals to the same embedding. Thus, we study the following metric to quantify the model’s ability in learning invariant representations:
+
+$$
+\begin{array} { r } { I ( \widehat { \theta } , \mathcal { P } ) = \underset { a _ { 1 } , a _ { 2 } \in \mathcal { A } } { \operatorname* { s u p } } d _ { x } ( \mathcal { P } _ { a _ { 1 } , \widehat { \theta } } , \mathcal { P } _ { a _ { 2 } , \widehat { \theta } } ) , } \end{array}
+$$
+
+where $\mathcal { P } _ { a , \widehat { \theta } }$ to denote the distribution of $f ( a ( \mathbf { x } ) ; \widehat { \theta } )$ for $( \mathbf { x } , \mathbf { y } ) \sim \mathcal { P } . ~ d _ { x } ( )$ is a distance over two distributions, and we suggest to use Wasserstein metric given its favorable properties (e.g., see practical examples in Figure 1 of (Cuturi & Doucet, $\boxed { 2 0 1 4 }$ or theoretical discussions in $\mathrm { ( \overline { { V i l l a n i } } , \overline { { 2 0 0 8 } } ) } \mathrm { ) }$ ). Due to the difficulties in assessing ${ \widehat { f ( a ( \mathbf { x } ) ; { \widehat { \theta } } ) } }$ (as it depends on $\widehat { \theta } _ { . }$ ), we mainly study $( 4 )$ empirically, and argue that models trained with explicit regularization of the empirical counterpart of $\bar { ( 4 ) }$ will have favorable invariance property.
+
+# 3.3 WORST-CASE AUGMENTATION (ADVERSARIAL TRAINING)
+
+We consider robustness first. $( 3 )$ can be written equivalently into the expected risk over a pseudo distribution ${ \mathcal { P } } ^ { \prime }$ (see Lemma 1 in $\boxed { \mathrm { I u ~ e t ~ a l . } } \boxed { 2 0 1 9 } )$ , which is the distribution that can sample the data leading to the worst expected risk. Thus, equivalently, we can consider $\operatorname* { s u p } _ { { \mathcal { P } } ^ { \prime } \in T ( { \mathcal { P } } , A ) } r _ { { \mathcal { P } } ^ { \prime } } ( { \widehat { \theta } } )$ . With an assumption relating the worst distribution of expected risk and the worst distribution of the empirical risk (namely, A5, in Appendix A), the bound of our interest (i.e., $\operatorname* { s u p } _ { { \mathcal { P } } ^ { \prime } \in T ( { \mathcal { P } } , A ) } r _ { { \mathcal { P } } ^ { \prime } } ( { \widehat { \theta } } ) )$ can be analogously analyzed through $\begin{array} { r } { \operatorname* { s u p } _ { \mathcal { P } ^ { \prime } \in T ( \mathcal { P } , \mathcal { A } ) } ^ { - } \widehat { r } _ { \mathcal { P } ^ { \prime } } ( \widehat { \theta } ) } \end{array}$ . By the definition of ${ \mathcal { P } } ^ { \prime }$ , we can have:
+
+Lemma 3.1. With Assumptions A1, A4, and A5, with probability at least $1 - \delta$ , we have
+
+$$
+\operatorname* { s u p } _ { \mathcal { P } ^ { \prime } \in T ( \mathcal { P } , A ) } r _ { \mathcal { P } ^ { \prime } } ( \widehat { \theta } ) \leq \frac { 1 } { n } \sum _ { ( \mathbf { x } , \mathbf { y } ) \sim \mathcal { P } } \operatorname* { s u p } _ { a \in \mathcal { A } } \mathbb { I } \big ( g \big ( f ( a ( \mathbf { x } ) ; \widehat { \theta } ) ) \neq \mathbf { y } \big ) + \phi \big ( | \Theta | , n , \delta \big )
+$$
+
+This result is a straightforward follow-up of the preceding discussions. In practice, it aligns with the adversarial training $\mathrm { ( } \mathbf { M a d r y \ e t \ a l . } , \mathbf { \bar { 2 0 1 8 } } \mathrm { ) }$ , a method that has demonstrated impressive empirical successes in the robust machine learning community.
+
+While the adversarial training has been valued by its empirical superiorities, it may still have the following two directions that can be improved: firstly, it lacks an explicit enforcement of the concept of invariance between the original sample and the transformed sample; secondly, it assumes that elements of $\mathcal { A }$ are enumerable, thus $\frac { 1 } { n } \sum _ { ( \mathbf { x } , \mathbf { y } ) \sim \mathcal { P } } \operatorname* { s u p } _ { a \in \cal A } \mathbb { I } ( g ( f ( a ( \mathbf { x } ) ; \widehat { \boldsymbol { \theta } } ) ) \neq \mathbf { y } )$ is computable. The remaining discussions expand along these two directions.
+
+# 3.4 REGULARIZED WORST-CASE AUGMENTATION
+
+To force the concept of invariance, the immediate solution might be to apply some regularizations to minimize the distance between the embeddings learned from the original sample and the ones learned from the transformed samples. We have offered a summary of these methods in Section 2.
+
+To have a model with small invariance score, the direct approach will be regularizing the empirical counterpart of $\textcircled{4}$ . We notice that existing methods barely consider this regularization, probably because of the computational difficulty of Wasserstein distance. Conveniently, we have the following result that links the $\ell _ { 1 }$ regularization to the Wasserstein-1 metric in the context of data augmentation.
+
+Proposition 3.2. With $A 2$ , and $d _ { e } ( \cdot , \cdot )$ in $A 2$ chosen to be $\ell _ { 1 }$ norm, for any $a \in { \mathcal { A } }$ , we have
+
+$$
+\sum _ { i } | | f ( \mathbf { x } _ { i } ; \widehat { \boldsymbol { \theta } } ) - f ( a ( \mathbf { x } _ { i } ) ; \widehat { \boldsymbol { \theta } } ) | | _ { 1 } = W _ { 1 } ( f ( \mathbf { x } ; \widehat { \boldsymbol { \theta } } ) , f ( a ( \mathbf { x } ) ; \widehat { \boldsymbol { \theta } } ) )
+$$
+
+This result conveniently allows us to use $\ell _ { 1 }$ norm distance to replace Wasserstein metric, integrating the advantages of Wasserstein metric while avoiding practical issues such as computational complexity and difficulty to pass the gradient back during backpropagation.
+
+We continue to discuss the generalization behaviors. Our analysis remains in the scope of multiclass classification, where the risk is evaluated as misclassification rate, and the model is optimized with cross-entropy loss (with the base chosen to be log base in cross-entropy loss). This setup aligns with A4, and should represent the modern neural network studies well enough.
+
+Before we proceed, we need another technical assumption A6 (details in Appendix A), which can be intuitively considered as a tool that allows us to relax classification error into cross-entropy error, so that we can bound the generalization error with the terms we can directly optimize during training.
+
+We can now offer another technical result:
+
+Theorem 3.3. With Assumptions A1, A2, A4, A5, and A6, and $d _ { e } ( \cdot , \cdot )$ in $A 2$ is $\ell _ { 1 }$ norm, with probability at least $1 - \delta$ , the worst case generalization risk will be bounded as
+
+$$
+\operatorname* { s u p } _ { \mathcal { P } ^ { \prime } \in T ( \mathcal { P } , \mathcal { A } ) } r _ { \mathcal { P } ^ { \prime } } ( \widehat { \theta } ) \leq \widehat { r } _ { \mathcal { P } } ( \widehat { \theta } ) + \sum _ { i } | | f ( \mathbf { x } _ { i } ; \widehat { \theta } ) - f ( \mathbf { x } _ { i } ^ { \prime } ; \widehat { \theta } ) | | _ { 1 } + \phi ( | \Theta | , n , \delta )
+$$
+
+and $\mathbf { x } ^ { \prime } = a ( \mathbf { x } )$ , where $a = \arg \operatorname* { m a x } _ { a \in \mathcal { A } } \mathbf { y } ^ { \top } f ( a ( \mathbf { x } ) ; \widehat { \theta } ) .$
+
+This technical result also immediately inspires the method to guarantee worst case performance, as well as to explicitly enforce the concept of invariance. Notice that $a = \arg \operatorname* { m a x } _ { a \in \mathcal { A } } \mathbf { y } ^ { \top } f ( a ( \mathbf { x } ) ; \widehat { \theta } )$ is simply selecting the augmentation function maximizing the cross-entropy loss, a standard used by many worst case augmenting method (e.g., Madry et al., 2018).
+
+# 3.5 REGULARIZED TRAINING WITH VERTICES
+
+As $\mathcal { A }$ in practice is usually a set with a large number of (and possibly infinite) elements, we may not always be able to identify the worst case transformation function with reasonable computational efforts. This limitation also prevents us from effective estimating the generalization error as the bound requires the identification of the worst case transformation.
+
+Our final discussion is to leverage the vertex property of the transformation function to bound the worst case generalization error:
+
+Lemma 3.4. With Assumptions A1-A6, and $d _ { e } ( \cdot , \cdot )$ in $A 2$ chosen as $\ell _ { 1 }$ norm distance, $d _ { x } ( \cdot , \cdot )$ in $A 3$ chosen as Wasserstein-1 metric, assuming there is a $a ^ { \prime } ( ) \in { \mathcal { A } }$ where $\begin{array} { r } { \widehat { r } _ { \mathcal { P } _ { a ^ { \prime } } } ( \widehat { \theta } ) = \frac { 1 } { 2 } \big ( \widehat { r } _ { \mathcal { P } _ { a ^ { + } } } ( \widehat { \theta } ) + } \end{array}$ ${ \widehat { r } } _ { { \mathcal { P } } _ { a } - } ( { \widehat { \theta } } ) \big )$ , with probability at least $1 - \delta$ , we have:
+
+$$
+\operatorname* { s u p } _ { \substack { 2 \prime \in T ( P , A ) } } r _ { P ^ { \prime } } ( \widehat { \theta } ) \leq \frac { 1 } { 2 } \big ( \widehat { r } _ { \mathcal { P } _ { a } + } ( \widehat { \theta } ) + \widehat { r } _ { \mathcal { P } _ { a } - } ( \widehat { \theta } ) \big ) + \sum _ { i } | | f ( a ^ { + } ( \mathbf { x } _ { i } ) ; \widehat { \theta } ) - f ( a ^ { - } ( \mathbf { x } ^ { \prime } ) ; \widehat { \theta } ) | | _ { 1 } + \phi ( | \Theta | , n , \delta )
+$$
+
+This result inspires the method that can directly guarantee the worst case generalization result and can be optimized conveniently without searching for the worst-case transformations. However, this method requires a good domain knowledge of the vertices of the transformation functions.
+
+# 3.6 ENGINEERING SPECIFICATION OF RELEVANT METHODS
+
+Our theoretical analysis has lead to a line of methods, however, not every method can be effectively implemented, especially due to the difficulties of passing gradient back for optimizations. Therefore, to boost the influence of the loss function through backpropagation, we recommend to adapt the methods with the following two changes: 1) the regularization is enforced on logits instead of softmax; 2) we use squared $\ell _ { 2 }$ norm instead of $\ell _ { 1 }$ norm because $\ell _ { 1 }$ norm is not differentiable everywhere. We discuss the effects of these compromises in ablation studies in Appendix E.
+
+Also, in the cases where we need to identify the worst case transformation functions, we iterate through all the transformation functions and identify the function with the maximum loss.
+
+Overall, our analysis leads to the following main training strategies:
+
+• VA (vanilla augmentation): mix the augmented samples of a vertex function to the original ones for training (original samples are considered as from another vertex in following experiments). • VWA (vanilla worst-case augmentation): at each iteration, identify the worst-case transformation functions and train with samples generated by them (also known as adversarial training). • RA (regularized augmentation): regularizing the squared $\ell _ { 2 }$ distance over logits between the original samples and the augmented samples of a fixed vertex transformation function. • RWA (regularized worst-case augmentation): regularizing the squared $\ell _ { 2 }$ distance over logits between the original samples and the worst-case augmented samples identified at each iteration.
+
+# 4 EXPERIMENTS
+
+We first use some synthetic experiments to verify our assumptions and inspect the consequences when the assumptions are not met (in Appendix $\dot { \mathbf { C } } )$ . Then, in the following paragraphs, we test the methods discussed to support our arguments in learning robustness and invariance. Finally, we show the power of our discussions by competing with advanced methods designed for specific tasks.
+
+# 4.1 EXPERIMENTS FOR LEARNING ROBUST & INVARIANT REPRESENTATION
+
+Experiment Setup: We first test our arguments with two data sets and three different sets of the augmentations. We study MNIST dataset with LeNet architecture, and CIFAR10 dataset with ResNet18 architecture. To examine the effects of the augmentation strategies, we disable all the heuristics that are frequently used to boost the test accuracy of models, such as the default augmentation many models trained for CIFAR10 adopted, and the BatchNorm (also due to the recent arguments against the effects of BatchNorm in learning robust features $( \overline { { \mathrm { W a n g ~ e t ~ a l . } } } , \overline { { 2 0 2 0 } } ) )$ , although forgoing these heuristics will result in a lower overall performance than one usually expects.
+
+We consider three different sets of transformation functions: texture, rotation, and contrast. The details of these transformation functions and the experiment setup are in Appendix D.
+
+We consider three different evaluation metrics:
+
+• Clean: test accuracy on the original test data, mainly reported as a reference for other metrics.   
+• Robustness: the worst accuracy when each sample can be transformed with $a \in { \mathcal { A } }$ .   
+Invariance: A metric to test whether the models learns the concept of invariance (details to follow).
+
+Invariance-test: To test whether a model can truly learns the concept of invariance within ${ \mathcal { A } } =$ $\{ a _ { 1 } ( ) , a _ { 2 } ( ) , \ldots , a _ { t } ( ) \}$ of $t$ elements, we design a new evaluation metric: for a sampled collection of data of the sample label $i$ , denoted as $\mathbf { X } ^ { ( i ) }$ , we generate the transformed copies of it with $\mathcal { A }$ , resulting in $\mathbf { X } _ { a _ { 1 } } ^ { ( i ) } , \mathbf { X } _ { a _ { 2 } } ^ { ( i ) } , \ldots , \mathbf { X } _ { a _ { t } } ^ { ( i ) }$ . We combined these copies into a dataset, denoted as $\chi ^ { ( i ) }$ . For every sample $\mathbf { x }$ in $\chi ^ { ( i ) }$ , we retrieve its $t$ nearest neighbors of other samples in $\chi ^ { ( i ) }$ , and calculate the overlap of the retrieved samples and $\{ a _ { 1 } ( \mathbf { x } ) , a _ { 2 } ( \mathbf { x } ) , \ldots , a _ { t } ( \mathbf { x } ) \}$ . Since the identify map is in $\mathcal { A }$ , so the calculated overlap score will be in $[ 1 / t , 1 ]$ . The distance used is $d ( \cdot , \cdot ) = | | f ( \cdot ; \widehat { \theta } ) - f ( \cdot ; \widehat { \theta } ) | | _ { 1 }$ , where $\widehat { \theta }$ is the model we are interested to examine. Finally, we report the averaged score for every label. Thus, a high overlap score indicates the prediction of model $\widehat { \theta }$ is invariant to the augmentation functions in $\mathcal { A }$ . If we use other distance functions, the reported values may differ, but we notice that the rank of the methods compared in terms of this test barely changes.
+
+Results: We show the results in Table 1 and Table $\bigtriangledown$ (in Appendix) for MNIST and CIFAR10 respectively. Table $^ 1$ shows that RWA is generally a superior method, in terms of all the metrics, especially the invariance evaluation as it shows a much higher invariance score than competing methods. We believe this advantage of invariance comes from two sources: regularizations and the fact that RWA has seen all the augmentation functions in $\boldsymbol { A }$ . In comparison, RA also has regularization but only sees the vertices in $\mathcal { A }$ , so the invariance score of RA is not compatitable to RWA, although better than VA. Table $\boxed { 6 }$ roughly tells the same story. More discussions are in Appendix D.
+
+<table><tr><td rowspan="2"></td><td colspan="3">Texture</td><td colspan="3">Rotation</td><td colspan="3">Contrast</td></tr><tr><td>C</td><td>R</td><td>I</td><td>C</td><td>R</td><td>I</td><td>C</td><td>R</td><td>I</td></tr><tr><td>Base</td><td>0.9921</td><td>0.9860</td><td>0.9236</td><td>0.9921</td><td>0.2960</td><td>0.2056</td><td>0.9921</td><td>0.2699</td><td>0.2003</td></tr><tr><td>VA</td><td>0.9928</td><td>0.9906</td><td>0.9876</td><td>0.9884</td><td>0.9336</td><td>0.5628</td><td>0.9922</td><td>0.9837</td><td>0.4153</td></tr><tr><td>RA</td><td>0.9909</td><td>0.9904</td><td>1</td><td>0.9930</td><td>0.9525</td><td>0.6044</td><td>0.9936</td><td>0.9823</td><td>0.4166</td></tr><tr><td>VWA</td><td>0.9922</td><td>0.9903</td><td>0.9940</td><td>0.9466</td><td>0.9408</td><td>0.6284</td><td>0.536</td><td>0.4470</td><td>0.2210</td></tr><tr><td>RWA</td><td>0.9915</td><td>0.9911</td><td>1</td><td>0.9934</td><td>0.9882</td><td>0.8856</td><td>0.994</td><td>0.9893</td><td>0.8786</td></tr></table>
+
+Table 1: Results of MNIST data (“C” stands for clean accuracy, “R” stands for robustness, and “I” stands for invariance score): invariance score shows big differences while accuracy does not.
+
+Other results (Appendix $\mathbf { E } )$ : The strength of RWA can also be shown in several other different scenarios, even in the out-of-domain test scenario where the transformation functions are not in $\mathcal { A }$ . RWA generally performs the best, although not the best in every single test. We also perform ablation test to validate the choice of squared $\ell _ { 2 }$ norm over logits in contrast to other distance metrics. Our choice performs the best in the worst-case performance. This advantage is expected as our choice is validated by theoretical arguments as well as consideration of engineering convenience.
+
+Overall, the empirical performances align with our expectation from the theoretical discussion: while all methods discussed have a bounded worst case performance, we do not intend to compare the upper bounds because smaller upper bounds do not necessarily guarantee a smaller risk. However, worst case augmentation methods tend to show a better worst case performances because they have been augmented with all the elements in $\mathcal { A }$ . Also, there is no clear evidence suggesting the difference between augmentation methods and its regularized versions in terms of the worst case performance, but it is clear that regularization helps to learn the concept of invariance.
+
+# 4.2 COMPARISON TO ADVANCED METHODS
+
+Finally, we also compete our generic data augmentation methods against several specifically designed methods in different applications. We use the four generic methods (VA, RA, VWA, and RWA) with generic transformation functions $\mathcal { A }$ of “rotation”, “contrast”, or ”texture” used in the synthetic experiments). We compare our methods with techniques invented for three different topics of study (rotation invariant, texture perturbation, and cross-domain generalization), and each of these topics has seen a long line of method development. We follow each own tradition (e.g., rotation methods are usually tested in CIFAR10 dataset, seemingly due to the methods’ computational requirements), test over each own most challenging dataset (e.g., ImageNet-Sketch is the most recent and challenging dataset in domain generalization, although less studied), and report each own evaluation metric (e.g., methods tested with ImageNet-C are usually evaluated with mCE).
+
+Overall, the performances of our generic methods outperform these advanced SOTA techniques. Thus, the main conclusion, as validated by these challenging scenarios, are (1) usage of data augmentation can outperform carefully designed methods; (2) usage of the consistency loss can further improve the performances; (3) regularized worst-case augmentation generally works the best.
+
+Due to the limitation of space, we leave the background details of these experiments in Appendix F, where we introduce the detailed experiment settings, and explain the acronyms in Tables 2-4
+
+Rotation-invariant Image Classification We test the models with nine different rotations including $0 ^ { \circ }$ . Augmentation related methods only use the $\mathcal { A }$ of “rotation” in synthetic experiments, so the testing scenario goes beyond what the augmentation methods have seen during training. The results in Table $\bigtriangledown$ strongly endorses the efficacy of augmentation-based methods. Interestingly, regularized augmentation methods probably with the benefit of learning the concept of invariance, tend to behave well in the transformations not considered during training. Also, RA outperforms VWA on average.
+
+Texture-perturbed ImageNet classification We also test the performance on the image classification over multiple perturbations. We train the model over standard ImageNet training set and test the model with ImageNet-C data (Hendrycks & Dietterich, 2019), which is a perturbed version of ImageNet by corrupting the original ImageNet validation set with a collection of noises. The results
+
+<table><tr><td></td><td>300</td><td>315</td><td>330</td><td>345</td><td>0</td><td>15</td><td>30</td><td>45</td><td>60</td><td>avg.</td></tr><tr><td>Base</td><td>0.2196</td><td>0.2573</td><td>0.3873</td><td>0.6502</td><td>0.8360</td><td>0.6938</td><td>0.4557</td><td>0.3281</td><td>0.2578</td><td>0.4539</td></tr><tr><td>ST</td><td>0.2391</td><td>0.2748</td><td>0.4214</td><td>0.7049</td><td>0.8251</td><td>0.7147</td><td>0.4398</td><td>0.2838</td><td>0.2300</td><td>0.4593</td></tr><tr><td>GC</td><td>0.1540</td><td>0.1891</td><td>0.2460</td><td>0.3919</td><td>0.5859</td><td>0.4145</td><td>0.2534</td><td>0.1827</td><td>0.1507</td><td>0.2853</td></tr><tr><td>ETN</td><td>0.3855</td><td>0.4844</td><td>0.6324</td><td>0.7576</td><td>0.8276</td><td>0.7730</td><td>0.7324</td><td>0.6245</td><td>0.5060</td><td>0.6358</td></tr><tr><td>VA</td><td>0.2233</td><td>0.2832</td><td>0.4318</td><td>0.6364</td><td>0.8124</td><td>0.6926</td><td>0.5973</td><td>0.7152</td><td>0.7923</td><td>0.5761</td></tr><tr><td>RA</td><td>0.3198</td><td>0.3901</td><td>0.5489</td><td>0.7170</td><td>0.8487</td><td>0.7904</td><td>0.7455</td><td>0.8005</td><td>0.8282</td><td>0.6655</td></tr><tr><td>VWA</td><td>0.3383</td><td>0.3484</td><td>0.3835</td><td>0.4569</td><td>0.7474</td><td>0.866</td><td>0.8776</td><td>0.8738</td><td>0.8629</td><td>0.6394</td></tr><tr><td>RWA</td><td>0.4012</td><td>0.4251</td><td>0.4852</td><td>0.6765</td><td>0.8708</td><td>0.8871</td><td>0.8869</td><td>0.8870</td><td>0.8818</td><td>0.7113</td></tr></table>
+
+Table 2: Comparison to advanced rotation-invariant models. We report the test accuracy on the test sets clockwise rotated, $0 ^ { \circ } \ – 6 0 ^ { \circ }$ and $3 0 0 ^ { \circ } - 3 6 0 ^ { \circ }$ . Average accuracy is also reported. Augmentation methods only consider $0 ^ { \circ } \ – 6 0 ^ { \circ }$ clockwise rotations during training.
+
+Table 3: Summary comparison to advanced models over ImageNet-C data. Performance reported (mCE) follows the standard in ImageNet-C data: clean error and mCE are both the smaller the better.   
+
+<table><tr><td></td><td>Base</td><td>SU</td><td>AA</td><td>MBP</td><td>SIN</td><td>AM</td><td>AMS</td><td>VA</td><td>RA</td><td>VWA</td><td>RWA</td></tr><tr><td>Clean</td><td>23.9</td><td>24.5</td><td>22.8</td><td>23</td><td>27.2</td><td>22.4</td><td>25.2</td><td>23.7</td><td>23.6</td><td>23.3</td><td>22.4</td></tr><tr><td>mCE</td><td>80.6</td><td>74.3</td><td>72.7</td><td>73.4</td><td>73.3</td><td>68.4</td><td>64.9</td><td>76.3</td><td>75.6</td><td>74.8</td><td>64.6</td></tr></table>
+
+<table><tr><td></td><td>Base</td><td>InfoDrop</td><td>HEX</td><td>PAR</td><td>VA</td><td>RA</td><td>VWA</td><td>RWA</td></tr><tr><td>Top-1</td><td>0.1204</td><td>0.1224</td><td>0.1292</td><td>0.1306</td><td>0.1362</td><td>0.1405</td><td>0.1432</td><td>0.1486</td></tr><tr><td>Top-5</td><td>0.2408</td><td>0.256</td><td>0.2564</td><td>0.2627</td><td>0.2715</td><td>0.2793</td><td>0.2846</td><td>0.2933</td></tr></table>
+
+Table 4: Comparison to advanced cross-domain image classification models, over ImageNet-Sketch dataset. We report top-1 and top-5 accuracy following standards on ImageNet related experiments.
+
+are reported in Table $^ { 3 , }$ which shows that our generic method can outperform the current SOTA methods after a continued finetuning process with reducing learning rates.
+
+Cross-domain ImageNet-Sketch Classification We also compare to the methods used for crossdomain evaluation. with the most challenging setup in this scenario: train the models with standard ImageNet training data, and test the model over ImageNet-Sketch data $( \mathbb { W } \mathrm { a n g ~ e t ~ a l . } ] { \underline { { 2 0 1 9 \mathrm { a } } } } )$ , which is a collection of sketches following the structure ImageNet validation set. Similarly, we only augment the samples with a generic augmentation set ( $\mathcal { A }$ of “contrast” in synthetic experiments, Appendix D) The results in Table 4 again support the strength of the correct usage of data augmentation.
+
+# 5 CONCLUSION
+
+In this paper, we conducted a systematic inspection to study the proper regularization techniques that are provably related to the generalization error of a machine learning model, when the test distribution are allowed to be perturbed by a family of transformation functions. With progressively more specific assumptions, we identified progressively simpler methods that can bound the worst case risk. We summarize the main take-home messages below:
+
+• Regularizing a norm distance between the logits of the originals samples and the logits of the augmented samples enjoys several merits: the trained model tend to have good worst cast performance, and can learn the concept of invariance (as shown in our invariance test). Although our theory suggests $\ell _ { 1 }$ norm, but we recommend squared $\ell _ { 2 }$ norm in practice considering the difficulties of passing the (sub)gradient of $\ell _ { 1 }$ norm in backpropagation. • With the vertex assumption held (it usually requires domain knowledge to choose the vertex functions), one can use “regularized training with vertices” method and get good empirical performance in both accuracy and invariance, and the method is at the same complexity order of vanilla training without data augmentation. When we do not have the domain knowledge (thus are not confident in the vertex assumption), we recommend “regularized worst-case augmentation”, which has the best performance overall, but requires extra computations to identify the worst-case augmentated samples at each iteration.
+
+# REFERENCES
+
+Alessandro Achille and Stefano Soatto. Information dropout: Learning optimal representations through noisy computation. IEEE transactions on pattern analysis and machine intelligence, 40 (12):2897–2905, 2018.
+
+Martin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein gan, 2017. ´
+
+Akari Asai and Hannaneh Hajishirzi. Logic-guided data augmentation and regularization for consistent question answering, 2020.
+
+Shai Ben-David, John Blitzer, Koby Crammer, Alex Kulesza, Fernando Pereira, and Jennifer Wortman Vaughan. A theory of learning from different domains. Machine learning, 79(1-2):151–175, 2010.
+
+Sergey Bobkov and Michel Ledoux. One-dimensional empirical measures, order statistics, and Kantorovich transport distances, volume 261. American Mathematical Society, 2019.
+
+Olivier Bousquet, Stephane Boucheron, and G ´ abor Lugosi. Introduction to statistical learning the- ´ ory. In Summer School on Machine Learning, pp. 169–207. Springer, 2003.
+
+Shuxiao Chen, Edgar Dobriban, and Jane H Lee. A group-theoretic framework for data augmentation, 2019.
+
+Taco Cohen and Max Welling. Group equivariant convolutional networks. In International conference on machine learning, pp. 2990–2999, 2016.
+
+Ekin D Cubuk, Barret Zoph, Dandelion Mane, Vijay Vasudevan, and Quoc V Le. Autoaugment: Learning augmentation strategies from data. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 113–123, 2019.
+
+Marco Cuturi and Arnaud Doucet. Fast computation of wasserstein barycenters. 2014.
+
+Tri Dao, Albert Gu, Alexander Ratner, Virginia Smith, Chris De Sa, and Christopher Re. A kernel ´ theory of modern data augmentation. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pp. 1528–1537. PMLR, 2019.
+
+Alhussein Fawzi, Horst Samulowitz, Deepak S. Turaga, and Pascal Frossard. Adaptive data augmentation for image classification. In 2016 IEEE International Conference on Image Processing, ICIP 2016, Phoenix, AZ, USA, September 25-28, 2016, pp. 3688–3692. IEEE, 2016.
+
+Yaroslav Ganin, Evgeniya Ustinova, Hana Ajakan, Pascal Germain, Hugo Larochelle, Franc¸ois Laviolette, Mario Marchand, and Victor Lempitsky. Domain-adversarial training of neural networks. The Journal of Machine Learning Research, 17(1):2096–2030, 2016.
+
+Ian Goodfellow. Nips 2016 tutorial: Generative adversarial networks. arXiv preprint arXiv:1701.00160, 2016.
+
+Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. Improved training of wasserstein gans, 2017.
+
+Hao Guo, Kang Zheng, Xiaochuan Fan, Hongkai Yu, and Song Wang. Visual attention consistency under image transforms for multi-label image classification. In IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2019, Long Beach, CA, USA, June 16-20, 2019, pp. 729– 739. Computer Vision Foundation / IEEE, 2019.
+
+Dan Hendrycks and Thomas Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. Proceedings of the International Conference on Learning Representations, 2019.
+
+Dan Hendrycks, Norman Mu, Ekin Dogus Cubuk, Barret Zoph, Justin Gilmer, and Balaji Lakshminarayanan. Augmix: A simple data processing method to improve robustness and uncertainty. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020.
+
+Alex Hernandez-Garc ´ ´ıa and Peter Konig. Data augmentation instead of explicit regularization, 2018. ¨
+
+Daniel Ho, Eric Liang, Xi Chen, Ion Stoica, and Pieter Abbeel. Population based augmentation: Efficient learning of augmentation policy schedules. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pp. 2731–2741. PMLR, 2019.
+
+Zhiting Hu, Bowen Tan, Russ R Salakhutdinov, Tom M Mitchell, and Eric P Xing. Learning data manipulation for augmentation and weighting. In Advances in Neural Information Processing Systems, pp. 15738–15749, 2019.
+
+Max Jaderberg, Karen Simonyan, Andrew Zisserman, et al. Spatial transformer networks. In Advances in neural information processing systems, pp. 2017–2025, 2015.
+
+Jisoo Jeong, Seungeui Lee, Jeesoo Kim, and Nojun Kwak. Consistency-based semi-supervised learning for object detection. In Advances in Neural Information Processing Systems, pp. 10758– 10767, 2019.
+
+Harini Kannan, Alexey Kurakin, and Ian Goodfellow. Adversarial logit pairing, 2018.
+
+Risi Kondor, Zhen Lin, and Shubhendu Trivedi. Clebsch–gordan nets: a fully fourier space spherical convolutional neural network. In Advances in Neural Information Processing Systems, pp. 10117– 10126, 2018.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Davis Liang, Zhiheng Huang, and Zachary C Lipton. Learning noise-invariant representations for robust speech recognition. In 2018 IEEE Spoken Language Technology Workshop (SLT), pp. 56–63. IEEE, 2018.
+
+Percy Liang. Cs229t/stat231: Statistical learning theory (winter 2016), 2016.
+
+Raphael Gontijo Lopes, Dong Yin, Ben Poole, Justin Gilmer, and Ekin D Cubuk. Improving robustness without sacrificing accuracy with patch gaussian augmentation. arXiv preprint arXiv:1906.02611, 2019.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In 6th International Conference on Learning Representations, ICLR 2018, Vancouver, BC, Canada, April 30 - May 3, 2018, Conference Track Proceedings. OpenReview.net, 2018.
+
+Shashank Rajput, Zhili Feng, Zachary Charles, Po-Ling Loh, and Dimitris Papailiopoulos. Does data augmentation lead to positive margin? In International Conference on Machine Learning, pp. 5321–5330, 2019.
+
+Mehdi Sajjadi, Mehran Javanmardi, and Tolga Tasdizen. Regularization with stochastic transformations and perturbations for deep semi-supervised learning. In Advances in neural information processing systems, pp. 1163–1171, 2016.
+
+Meet Shah, Xinlei Chen, Marcus Rohrbach, and Devi Parikh. Cycle-consistency for robust visual question answering. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2019.
+
+Connor Shorten and Taghi M Khoshgoftaar. A survey on image data augmentation for deep learning. Journal of Big Data, 6(1):60, 2019.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+
+Kai Sheng Tai, Peter Bailis, and Gregory Valiant. Equivariant transformer networks. arXiv preprint arXiv:1901.11399, 2019.
+
+Zhuozhuo Tu, Jingwei Zhang, and Dacheng Tao. Theoretical analysis of adversarial learning: A minimax approach. In Advances in Neural Information Processing Systems, pp. 12259–12269, 2019.
+
+Cedric Villani. ´ Topics in optimal transportation. Number 58. American Mathematical Soc., 2003.
+
+Cedric Villani. ´ Optimal transport: old and new, volume 338. Springer Science & Business Media, 2008.
+
+Haohan Wang, Songwei Ge, Eric P. Xing, and Zachary C. Lipton. Learning robust global representations by penalizing local predictive power, 2019a.
+
+Haohan Wang, Zexue He, Zachary C. Lipton, and Eric P. Xing. Learning robust representations by projecting superficial statistics out. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019b.
+
+Haohan Wang, Xindi Wu, Zeyi Huang, and Eric P. Xing. High frequency component helps explain the generalization of convolutional neural networks. In Computer Vision and Pattern Recognition (CVPR), 2020.
+
+Yulin Wang, Xuran Pan, Shiji Song, Hong Zhang, Gao Huang, and Cheng Wu. Implicit semantic data augmentation for deep networks. In Advances in Neural Information Processing Systems, pp. 12614–12623, 2019c.
+
+Xindi Wu, Yijun Mao, Haohan Wang, Xiangrui Zeng, Xin Gao, Eric P. Xing, and Min Xu. Regularized adversarial training (RAT) for robust cellular electron cryo tomograms classification. In Illhoi Yoo, Jinbo Bi, and Xiaohua Hu (eds.), 2019 IEEE International Conference on Bioinformatics and Biomedicine, BIBM 2019, San Diego, CA, USA, November 18-21, 2019, pp. 1–6. IEEE, 2019.
+
+Qizhe Xie, Zihang Dai, Eduard Hovy, Minh-Thang Luong, and Quoc V Le. Unsupervised data augmentation. arXiv preprint arXiv:1904.12848, 2019.
+
+Saining Xie, Tianbao Yang, Xiaoyu Wang, and Yuanqing Lin. Hyper-class augmented and regularized deep learning for fine-grained image classification. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2645–2654, 2015.
+
+Fanny Yang, Zuowen Wang, and Christina Heinze-Deml. Invariance-inducing regularization using worst-case transformations suffices to boost accuracy and spatial robustness. In Advances in Neural Information Processing Systems, pp. 14757–14768, 2019.
+
+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 Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pp. 7472–7482. PMLR, 2019a.
+
+Richard Zhang. Making convolutional networks shift-invariant again. arXiv preprint arXiv:1904.11486, 2019.
+
+Xinyu Zhang, Qiang Wang, Jian Zhang, and Zhao Zhong. Adversarial autoaugment. In International Conference on Learning Representations, 2020.
+
+Zhirui Zhang, Shuangzhi Wu, Shujie Liu, Mu Li, Ming Zhou, and Tong Xu. Regularizing neural machine translation by target-bidirectional agreement. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 443–450, 2019b.
+
+Stephan Zheng, Yang Song, Thomas Leung, and Ian Goodfellow. Improving the robustness of deep neural networks via stability training. In Proceedings of the ieee conference on computer vision and pattern recognition, pp. 4480–4488, 2016.
+
+Barret Zoph, Ekin D. Cubuk, Golnaz Ghiasi, Tsung-Yi Lin, Jonathon Shlens, and Quoc V. Le. Learning data augmentation strategies for object detection, 2019.

parse/train/QpU7n-6l0n/QpU7n-6l0n_content_list.json

@@ -0,0 +1,1700 @@
+[
+    {
+        "type": "text",
+        "text": "ON THE CONSISTENCY LOSS FOR LEVERAGING AUGMENTED DATA TO LEARN ROBUST AND INVARIANT REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            821,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            195,
+            398,
+            223
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            261,
+            544,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Data augmentation is one of the most popular techniques for improving the robustness of neural networks. In addition to directly training the model with original samples and augmented samples, a torrent of methods regularizing the distance between embeddings/representations of the original samples and their augmented counterparts have been introduced. In this paper, we explore these various regularization choices, seeking to provide a general understanding of how we should regularize the embeddings. Our analysis suggests the ideal choices of regularization correspond to various assumptions. With an invariance test, we argue that regularization is important if the model is to be used in a broader context than accuracy-driven setting because non-regularized approaches are limited in learning the concept of invariance, despite equally high accuracy. Finally, we also show that the generic approach we identified (squared $\\ell _ { 2 }$ norm regularized augmentation) outperforms several recent methods, which are each specially designed for one task and significantly more complicated than ours, over three different tasks. ",
+        "bbox": [
+            233,
+            291,
+            764,
+            486
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            512,
+            336,
+            529
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent advances in deep learning has delivered remarkable empirical performance over i.i.d test data, and the community continues to investigate the more challenging and realistic scenario when models are tested in robustness over non-i.i.d data (e.g., Ben-David et al., 2010; Szegedy et al., $\\boxed { 2 0 1 3 }$ . Recent studies suggest that one cause of the fragility is the model’s tendency in capturing undesired signals $( \\overline { { \\mathbb { W } \\mathrm { a n g ~ e t ~ a l . } } } ) \\textcircled { 2 0 2 0 } )$ , thus combating this tendency may be a key to robust models. ",
+        "bbox": [
+            174,
+            545,
+            823,
+            614
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To help models ignore the undesired signals, data augmentation (i.e., diluting the undesired signals of training samples by applying transformations to existing examples) is often used. Given its widely usage, we seek to answer the question: how should we train with augmented samples so that the assistance of augmentation can be taken to the fullest extent to learn robust and invariant models? ",
+        "bbox": [
+            174,
+            621,
+            823,
+            678
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, We analyze the generalization behaviors of models trained with augmented data and associated regularization techniques. We investigate a set of assumptions and compare the worstcase expected risk over unseen data when i.i.d samples are allowed to be transformed according to a function belonging to a family. We bound the expected risk with terms that can be computed during training, so that our analysis can inspire how to regularize the training procedure. While all the derived methods have an upper bound of the expected risk, with progressively stronger assumptions, we have progressively simpler regularization, allowing practical choices to be made according to the understanding of the application. Our contributions of this paper are as follows: ",
+        "bbox": [
+            174,
+            684,
+            825,
+            796
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "• We offer analyses of the generalization behaviors of augmented models trained with different regularizations: these regularizations require progressively stronger assumptions of the data and the augmentation functions, but progressively less computational efforts. For example, with assumptions pertaining to augmentation transformation functions, the Wasserstein distance over the original and augmented empirical distributions can be calculated through simple $\\ell _ { 1 }$ norm distance. • We test and compare these methods and offer practical guidance on how to choose regularizations in practice. In short, regularizing the squared $\\ell _ { 2 }$ distance of logits between the augmented samples and original samples is a favorable method, suggested by both theoretical and empirical evidence. ",
+        "bbox": [
+            174,
+            808,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "• With an invariance test, we argue that vanilla augmentation does not utilize the augmented samples to the fullest extent, especially in learning invariant representations, thus may not be ideal unless the only goal of augmentation is to improve the accuracy over a specific setting. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK & KEY DIFFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            165,
+            529,
+            183
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Data augmentation has been used effectively for years. Tracing back to the earliest convolutional neural networks, we notice that even the LeNet applied on MNIST dataset has been boosted by mixing the distorted images to the original ones $\\mathrm { ( \\mathbb { L } e C u n \\ e t \\ a l . ) } \\ \\mathrm { [ 9 9 8 ] ) }$ . Later, the rapidly growing machine learning community has seen a proliferate development of data augmentation techniques (e.g., flipping, rotation, blurring etc.) that have helped models climb the ladder of the state-of-theart (one may refer to relevant survey (Shorten & Khoshgoftaar, 2019) for details). Recent advances expanded the conventional concept of data augmentation and invented several new approaches, such as leveraging the information in unlabelled data (Xie et al., 2019), automatically learning augmentation functions (Ho et al., 2019; Hu et al., 2019; Wang et al., 2019c; Zhang et al., 2020; Zoph et al., $\\boxed { 2 0 1 9 }$ , and generating the samples (with constraint) that maximize the training loss along training (Fawzi et al., 2016), which is later widely accepted as adversarial training (Madry et al., 2018). ",
+        "bbox": [
+            173,
+            196,
+            825,
+            352
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "While the above works mainly discuss how to generate the augmented samples, in this paper, we mainly answer the question about how to train the models with augmented samples. For example, instead of directly mixing augmented samples with the original samples, one can consider regularizing the representations (or outputs) of original samples and augmented samples to be close under a distance metric (also known as a consistency loss). Many concrete ideas have been explored in different contexts. For example, $\\ell _ { 2 }$ distance and cosine similarities between internal representations in speech recognition (Liang et al., 2018), squared $\\ell _ { 2 }$ distance between logits (Kannan et al., 2018) , or KL divergence between softmax outputs $( \\mathbb { Z } \\mathrm { h a n g ~ e t ~ a l . } ) , \\underline { 2 0 1 9 \\mathrm { a } } )$ in adversarially robust vision models, Jensen–Shannon divergence (of three distributions) between embeddings for texture invariant image classification (Hendrycks et al., $\\boxed { 2 0 2 0 }$ . These are but a few highlights of the concrete and successful implementations for different applications out of a huge collection (e.g., (Wu et al., 2019; Guo et al., 2019; Zhang et al., 2019b; Shah et al., 2019; Asai & Hajishirzi, $\\boxed { 2 0 2 0 } ;$ Sajjadi et al., 2016; Zheng et al., 2016; Xie et al., 2015)), and one can easily imagine methods permuting these three elements (distance metrics, representation or outputs, and applications) to be invented. Even further, although we are not aware of the following methods in the context of data augmentation, given the popularity of GAN $\\left( \\overline { { \\mathrm { G o o d f e l l o w } } } , \\overline { { \\mathrm { 2 0 1 6 } } } \\right)$ and domain adversarial neural network $\\mathrm { ( } \\mathrm { G a n i n ~ e t ~ a l . , } \\mathrm { ) } \\mathrm { . } \\mathrm { \\overline { { 2 0 1 6 } } \\mathrm { ) } }$ , one can also expect the distance metric generalizes to a specialized discriminator (i.e. a classifier), which can be intuitively understood as a calculated (usually maximized) distance measure, Wasserstein-1 metric as an example (Arjovsky et al., 2017; Gulrajani et al., 2017) ",
+        "bbox": [
+            173,
+            357,
+            825,
+            622
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Key Differences: With this rich collection of regularizing choices, which one method should we consider in general? More importantly, do we actually need the regularization at all? These questions are important for multiple reasons, especially considering that there are paper suggesting that these regularizations may lead to worse results $( \\overbrace { \\mathrm { J e o n g ~ e t ~ a l . } } ^ { \\bullet } ) \\widetilde { \\mathbb { Z } \\mathrm { 0 1 9 } } )$ . In this paper, we answer the first question with a proved upper bound of the worst case generalization error, and our upper bound explicitly describes what regularizations are needed. For the second question, we will show that regularizations can help the model to learn the concept of invariance. ",
+        "bbox": [
+            173,
+            627,
+            825,
+            726
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "There are also several previous discussions regarding the detailed understandings of data augmentation (Yang et al., 2019; Chen et al., 2019; Hernandez-Garc ´ ´ıa & Konig, 2018; Rajput et al., 2019; ¨ $\\boxed { \\mathrm { D a o e t ~ a l . } , \\boxed { 2 0 1 9 } }$ , among which, $\\overline { { \\mathbb { Y } \\mathrm { a n g ~ e t ~ a l . } \\mathrm { | } \\mathrm { \\mathscr { L } 0 1 9 | } } }$ is probably the most relevant as it also defends the usage of regularizations. However, we believe our discussions are more comprehensive and supported theoretically, since our analysis directly suggests the ideal regularization. Also, empirically, we design an invariance test in addition to the worst-case accuracy used in the preceding work. ",
+        "bbox": [
+            174,
+            732,
+            825,
+            815
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 TRAINING STRATEGIES WITH AUGMENTED DATA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            835,
+            616,
+            852
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Notations $( \\mathbf { X } , \\mathbf { Y } )$ denotes the data, where $\\mathbf { X } \\in \\mathcal { R } ^ { n \\times p }$ and $\\mathbf { Y } \\in \\{ 0 , 1 \\} ^ { n \\times k }$ (one-hot vectors for $k$ classes), and $f ( \\cdot , \\theta )$ denotes the model, which takes in the data and outputs the softmax (probabilities of the prediction) and $\\theta$ denotes the corresponding parameters. $g ( \\ u )$ completes the prediction (i.e., mapping softmax to one-hot prediction). $l ( \\cdot , \\cdot )$ denotes a generic loss function. $\\overset { \\cdot } { a } ( \\cdot )$ denotes a transformation that alters the undesired signals of a sample, i.e., the data augmentation method. $a \\in { \\mathcal { A } }$ , which is the set of transformation functions. $\\mathcal { P }$ denotes the distribution of $\\displaystyle ( \\mathbf { x } , \\mathbf { y } )$ . For any sampled $\\displaystyle ( \\mathbf { x } , \\mathbf { y } )$ , we can have $( a ( \\mathbf { x } ) , \\mathbf { y } )$ , and we use $\\mathcal { P } _ { a }$ to denote the distribution of these transformed samples. $r ( \\cdot ; \\theta )$ denotes the risk of model $\\theta . { \\widehat { \\cdot } }$ denotes the estimated term $\\cdot$ . ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 WELL-BEHAVED DATA TRANSFORMATION FUNCTION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            176,
+            586,
+            191
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Despite the strong empirical performance data augmentation has demonstrated, it should be intuitively expected that the performance can only be improved when the augmentation is chosen wisely. Therefore, before we proceed to analyze the behaviors of training with data augmentations, we need first regulate some basic properties of the data transformation functions used. Intuitively, we will consider the following three properties. ",
+        "bbox": [
+            173,
+            204,
+            825,
+            273
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• “Dependence-preservation” with two perspectives: Label-wise, the transformation cannot alter the label of the data, which is a central requirement of almost all the data augmentation practice. Feature-wise, the transformation will not introduce new dependencies between the samples. • “Efficiency”: the augmentation should only generate new samples of the same label as minor perturbations of the original one. If a transformation violates this property, there should exist other simpler transformations that can generate the same target sample. • “Vertices”: There are extreme cases of the transformations. For example, if one needs the model to be invariant to rotations from $0 ^ { \\circ }$ to $6 0 ^ { \\circ }$ , we consider the vertices to be $0 ^ { \\circ }$ rotation function (thus identity map) and $6 0 ^ { \\circ }$ rotation function. In practice, one usually selects the transformation vertices with intuitions and domain knowledge. ",
+        "bbox": [
+            173,
+            286,
+            825,
+            438
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We now formally define these three properties. The definition will depend on the model, thus these properties are not only regulating the transformation functions, but also the model. We introduce the Assumptions A1-A3 corresponding to the properties. ",
+        "bbox": [
+            173,
+            449,
+            826,
+            492
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A1: Dependence-preservation: the transformation function will not alter the dependency regarding the label (i.e., for any $a ( ) \\in { \\mathcal { A } }$ , $a ( \\mathbf { x } )$ will have the same label as $\\mathbf { x }$ ) or the features (i.e., for any $a _ { 1 } ( \\ l ) , a _ { 2 } ( \\ l ) \\in \\mathcal { A } , a _ { 1 } ( \\mathbf { x } _ { 1 } ) \\ \\perp \\ l \\ a _ { 1 } ( \\mathbf { x } _ { 2 } )$ for any $\\mathbf { x } _ { 1 } , \\mathbf { x } _ { 2 } \\in \\mathbf { X }$ that $\\mathbf { x } _ { 1 } \\neq \\mathbf { x } _ { 2 }$ ). ",
+        "bbox": [
+            176,
+            503,
+            821,
+            547
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A2: Efficiency: for $\\widehat { \\theta }$ and any $a ( ) \\in { \\mathcal { A } }$ , $f ( a ( \\mathbf { x } ) ; \\widehat { \\theta } )$ is closer to $\\mathbf { x }$ than any other samples under a distance metric $d _ { e } ( \\cdot , \\cdot )$ , i.e., $\\begin{array} { r } { \\big \\langle d _ { e } \\big ( f \\big ( a ( \\mathbf { x } ) ; \\widehat { \\theta } \\big ) , f ( \\mathbf { x } ; \\widehat { \\theta } ) \\big ) \\leq \\operatorname* { m i n } _ { \\mathbf { x } ^ { \\prime } \\in \\mathbf { X } - \\mathbf { x } } d _ { e } \\big ( f \\big ( a ( \\mathbf { x } ) ; \\widehat { \\theta } \\big ) , f ( \\mathbf { x } ^ { \\prime } ; \\widehat { \\theta } ) \\big ) } \\end{array}$ . ",
+        "bbox": [
+            173,
+            553,
+            820,
+            589
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A3: Vertices: For a model $\\widehat { \\theta }$ and a transformation $a ( )$ , we use $\\mathcal { P } _ { a , \\widehat { \\theta } }$ to denote the distribution of $f ( a ( \\mathbf { x } ) ; \\widehat { \\theta } )$ for $( \\mathbf { x } , \\mathbf { y } ) \\sim \\mathcal { P }$ . “Vertices” argues that exists two extreme elements in $\\mathcal { A }$ , namely $a ^ { + }$ and $a ^ { - }$ , with certain metric $d _ { x } ( \\cdot , \\cdot )$ , we have ",
+        "bbox": [
+            176,
+            593,
+            826,
+            643
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/80d72eeabe4a33a134063857028e586202959f91aa1883d4d1d30bde22c422b7.jpg",
+        "text": "$$\nd _ { x } ( \\mathcal { P } _ { a ^ { + } , \\widehat { \\theta } } , \\mathcal { P } _ { a ^ { - } , \\widehat { \\theta } } ) = \\operatorname* { s u p } _ { a _ { 1 } , a _ { 2 } \\in \\mathcal { A } } d _ { x } ( \\mathcal { P } _ { a _ { 1 } , \\widehat { \\theta } } , \\mathcal { P } _ { a _ { 2 } , \\widehat { \\theta } } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            651,
+            668,
+            678
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note that $d _ { x } ( \\cdot , \\cdot )$ is a metric over two distributions and $d _ { e } ( \\cdot , \\cdot )$ is a metric over two samples. Also, slightly different from the intuitive understanding of “vertices” above, A3 regulates the behavior of embedding instead of raw data. All of our follow-up analysis will require A1 to hold, but with more assumptions held, we can get computationally lighter methods with bounded error. ",
+        "bbox": [
+            173,
+            689,
+            825,
+            746
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 BACKGROUND, ROBUSTNESS, AND INVARIANCE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            763,
+            550,
+            779
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "One central goal of machine learning is to understand the generalization error. When the test data and train data are from the same distribution, many previous analyses can be sketched as: ",
+        "bbox": [
+            173,
+            790,
+            823,
+            819
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cbc37bf83345ec96f1b0175043b2c25b170ecff5ead679e2847002338577046c.jpg",
+        "text": "$$\nr _ { \\mathcal { P } } ( \\widehat { \\theta } ) \\leq \\widehat { r } _ { \\mathcal { P } } ( \\widehat { \\theta } ) + \\phi ( | \\Theta | , n , \\delta )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            825,
+            599,
+            847
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "which states that the expected risk can be bounded by the empirical risk and a function of hypothesis space $| \\Theta |$ and number of samples $n$ ; $\\delta$ accounts for the probability when the bound holds. $\\phi ( )$ is a function of these three terms. Dependent on the details of different analyses, different concrete examples of this generic term will need different assumptions. We use a generic assumption A4 to denote the assumptions required for each example. More concrete discussions are in Appendix A ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Robustness In addition to the generalization error above, we also study the robustness by following the established definition as in the worst case expected risk when the test data is allowed to be shifted to some other distributions by transformation functions in $\\mathcal { A }$ . Formally, we study ",
+        "bbox": [
+            173,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8b698334cf579f32f48f452c9f3ed884cd9031b25802ba783a5b1176ffa9a88f.jpg",
+        "text": "$$\nr _ { \\mathcal { P } ^ { \\prime } } ( \\widehat { \\theta } ) = \\mathbb { E } _ { ( \\mathbf { x } , \\mathbf { y } ) \\sim \\mathcal { P } } \\operatorname* { m a x } _ { a \\sim \\mathcal { A } } \\mathbb { I } ( g ( f ( a ( \\mathbf { x } ) ; \\widehat { \\theta } ) ) \\neq \\mathbf { y } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            148,
+            651,
+            174
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As $r _ { \\mathcal { P } } ( \\widehat { \\theta } ) \\leq r _ { \\mathcal { P ^ { \\prime } } } ( \\widehat { \\theta } )$ , we only need to study $\\textcircled{3}$ . We will analyze $\\textcircled{3}$ in different scenarios involving different assumptions and offer formalizations of the generalization bounds under each scenario. Our bounds shall also immediately inspire the development of methods in each scenario as the terms involved in our bound are all computable within reasonable computational loads. ",
+        "bbox": [
+            174,
+            178,
+            825,
+            236
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Invariance In addition to robustness, we are also interested in whether the model learns to be invariant to the undesired signals. Intuitively, if data augmentation is used to help dilute the undesired signals from data by altering the undesired signals with $a ( ) \\in { \\mathcal { A } }$ , a successfully trained model with augmented data will map the raw data with various undesired signals to the same embedding. Thus, we study the following metric to quantify the model’s ability in learning invariant representations: ",
+        "bbox": [
+            173,
+            242,
+            825,
+            313
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ac9af5daddcdf75669610d6ec623f9e688a87ade6b6aa09d07e4c2d411e62a2d.jpg",
+        "text": "$$\n\\begin{array} { r } { I ( \\widehat { \\theta } , \\mathcal { P } ) = \\underset { a _ { 1 } , a _ { 2 } \\in \\mathcal { A } } { \\operatorname* { s u p } } d _ { x } ( \\mathcal { P } _ { a _ { 1 } , \\widehat { \\theta } } , \\mathcal { P } _ { a _ { 2 } , \\widehat { \\theta } } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            315,
+            617,
+            344
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { P } _ { a , \\widehat { \\theta } }$ to denote the distribution of $f ( a ( \\mathbf { x } ) ; \\widehat { \\theta } )$ for $( \\mathbf { x } , \\mathbf { y } ) \\sim \\mathcal { P } . ~ d _ { x } ( )$ is a distance over two distributions, and we suggest to use Wasserstein metric given its favorable properties (e.g., see practical examples in Figure 1 of (Cuturi & Doucet, $\\boxed { 2 0 1 4 }$ or theoretical discussions in $\\mathrm { ( \\overline { { V i l l a n i } } , \\overline { { 2 0 0 8 } } ) } \\mathrm { ) }$ ). Due to the difficulties in assessing ${ \\widehat { f ( a ( \\mathbf { x } ) ; { \\widehat { \\theta } } ) } }$ (as it depends on $\\widehat { \\theta } _ { . }$ ), we mainly study $( 4 )$ empirically, and argue that models trained with explicit regularization of the empirical counterpart of $\\bar { ( 4 ) }$ will have favorable invariance property. ",
+        "bbox": [
+            173,
+            348,
+            826,
+            440
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 WORST-CASE AUGMENTATION (ADVERSARIAL TRAINING) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            454,
+            622,
+            469
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We consider robustness first. $( 3 )$ can be written equivalently into the expected risk over a pseudo distribution ${ \\mathcal { P } } ^ { \\prime }$ (see Lemma 1 in $\\boxed { \\mathrm { I u ~ e t ~ a l . } } \\boxed { 2 0 1 9 } )$ , which is the distribution that can sample the data leading to the worst expected risk. Thus, equivalently, we can consider $\\operatorname* { s u p } _ { { \\mathcal { P } } ^ { \\prime } \\in T ( { \\mathcal { P } } , A ) } r _ { { \\mathcal { P } } ^ { \\prime } } ( { \\widehat { \\theta } } )$ . With an assumption relating the worst distribution of expected risk and the worst distribution of the empirical risk (namely, A5, in Appendix A), the bound of our interest (i.e., $\\operatorname* { s u p } _ { { \\mathcal { P } } ^ { \\prime } \\in T ( { \\mathcal { P } } , A ) } r _ { { \\mathcal { P } } ^ { \\prime } } ( { \\widehat { \\theta } } ) )$ can be analogously analyzed through $\\begin{array} { r } { \\operatorname* { s u p } _ { \\mathcal { P } ^ { \\prime } \\in T ( \\mathcal { P } , \\mathcal { A } ) } ^ { - } \\widehat { r } _ { \\mathcal { P } ^ { \\prime } } ( \\widehat { \\theta } ) } \\end{array}$ . By the definition of ${ \\mathcal { P } } ^ { \\prime }$ , we can have: ",
+        "bbox": [
+            173,
+            479,
+            826,
+            578
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Lemma 3.1. With Assumptions A1, A4, and A5, with probability at least $1 - \\delta$ , we have ",
+        "bbox": [
+            176,
+            580,
+            753,
+            595
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cca1d53f7fd767a4ac61d0e05e27f10c1de5c638df7707ce38bdc8427a5fe0a1.jpg",
+        "text": "$$\n\\operatorname* { s u p } _ { \\mathcal { P } ^ { \\prime } \\in T ( \\mathcal { P } , A ) } r _ { \\mathcal { P } ^ { \\prime } } ( \\widehat { \\theta } ) \\leq \\frac { 1 } { n } \\sum _ { ( \\mathbf { x } , \\mathbf { y } ) \\sim \\mathcal { P } } \\operatorname* { s u p } _ { a \\in \\mathcal { A } } \\mathbb { I } \\big ( g \\big ( f ( a ( \\mathbf { x } ) ; \\widehat { \\theta } ) ) \\neq \\mathbf { y } \\big ) + \\phi \\big ( | \\Theta | , n , \\delta \\big )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            261,
+            597,
+            736,
+            637
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This result is a straightforward follow-up of the preceding discussions. In practice, it aligns with the adversarial training $\\mathrm { ( } \\mathbf { M a d r y \\ e t \\ a l . } , \\mathbf { \\bar { 2 0 1 8 } } \\mathrm { ) }$ , a method that has demonstrated impressive empirical successes in the robust machine learning community. ",
+        "bbox": [
+            174,
+            646,
+            825,
+            689
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "While the adversarial training has been valued by its empirical superiorities, it may still have the following two directions that can be improved: firstly, it lacks an explicit enforcement of the concept of invariance between the original sample and the transformed sample; secondly, it assumes that elements of $\\mathcal { A }$ are enumerable, thus $\\frac { 1 } { n } \\sum _ { ( \\mathbf { x } , \\mathbf { y } ) \\sim \\mathcal { P } } \\operatorname* { s u p } _ { a \\in \\cal A } \\mathbb { I } ( g ( f ( a ( \\mathbf { x } ) ; \\widehat { \\boldsymbol { \\theta } } ) ) \\neq \\mathbf { y } )$ is computable. The remaining discussions expand along these two directions. ",
+        "bbox": [
+            173,
+            695,
+            825,
+            777
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.4 REGULARIZED WORST-CASE AUGMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            792,
+            534,
+            808
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To force the concept of invariance, the immediate solution might be to apply some regularizations to minimize the distance between the embeddings learned from the original sample and the ones learned from the transformed samples. We have offered a summary of these methods in Section 2. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            861
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To have a model with small invariance score, the direct approach will be regularizing the empirical counterpart of $\\textcircled{4}$ . We notice that existing methods barely consider this regularization, probably because of the computational difficulty of Wasserstein distance. Conveniently, we have the following result that links the $\\ell _ { 1 }$ regularization to the Wasserstein-1 metric in the context of data augmentation. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proposition 3.2. With $A 2$ , and $d _ { e } ( \\cdot , \\cdot )$ in $A 2$ chosen to be $\\ell _ { 1 }$ norm, for any $a \\in { \\mathcal { A } }$ , we have ",
+        "bbox": [
+            171,
+            102,
+            769,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4649b8f44f4bb5a214627d57be2cd8677f6e32900b453f1a35cbebe16461b6a3.jpg",
+        "text": "$$\n\\sum _ { i } | | f ( \\mathbf { x } _ { i } ; \\widehat { \\boldsymbol { \\theta } } ) - f ( a ( \\mathbf { x } _ { i } ) ; \\widehat { \\boldsymbol { \\theta } } ) | | _ { 1 } = W _ { 1 } ( f ( \\mathbf { x } ; \\widehat { \\boldsymbol { \\theta } } ) , f ( a ( \\mathbf { x } ) ; \\widehat { \\boldsymbol { \\theta } } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            305,
+            125,
+            691,
+            157
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This result conveniently allows us to use $\\ell _ { 1 }$ norm distance to replace Wasserstein metric, integrating the advantages of Wasserstein metric while avoiding practical issues such as computational complexity and difficulty to pass the gradient back during backpropagation. ",
+        "bbox": [
+            174,
+            170,
+            823,
+            213
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We continue to discuss the generalization behaviors. Our analysis remains in the scope of multiclass classification, where the risk is evaluated as misclassification rate, and the model is optimized with cross-entropy loss (with the base chosen to be log base in cross-entropy loss). This setup aligns with A4, and should represent the modern neural network studies well enough. ",
+        "bbox": [
+            174,
+            219,
+            825,
+            276
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Before we proceed, we need another technical assumption A6 (details in Appendix A), which can be intuitively considered as a tool that allows us to relax classification error into cross-entropy error, so that we can bound the generalization error with the terms we can directly optimize during training. ",
+        "bbox": [
+            174,
+            281,
+            825,
+            325
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We can now offer another technical result: ",
+        "bbox": [
+            176,
+            332,
+            452,
+            345
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.3. With Assumptions A1, A2, A4, A5, and A6, and $d _ { e } ( \\cdot , \\cdot )$ in $A 2$ is $\\ell _ { 1 }$ norm, with probability at least $1 - \\delta$ , the worst case generalization risk will be bounded as ",
+        "bbox": [
+            174,
+            349,
+            823,
+            378
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/31e1ca068317a38c18f2feb79fe7380da8e6c04c521a83e01481d82b90a308fa.jpg",
+        "text": "$$\n\\operatorname* { s u p } _ { \\mathcal { P } ^ { \\prime } \\in T ( \\mathcal { P } , \\mathcal { A } ) } r _ { \\mathcal { P } ^ { \\prime } } ( \\widehat { \\theta } ) \\leq \\widehat { r } _ { \\mathcal { P } } ( \\widehat { \\theta } ) + \\sum _ { i } | | f ( \\mathbf { x } _ { i } ; \\widehat { \\theta } ) - f ( \\mathbf { x } _ { i } ^ { \\prime } ; \\widehat { \\theta } ) | | _ { 1 } + \\phi ( | \\Theta | , n , \\delta )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            261,
+            383,
+            735,
+            417
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "and $\\mathbf { x } ^ { \\prime } = a ( \\mathbf { x } )$ , where $a = \\arg \\operatorname* { m a x } _ { a \\in \\mathcal { A } } \\mathbf { y } ^ { \\top } f ( a ( \\mathbf { x } ) ; \\widehat { \\theta } ) .$ ",
+        "bbox": [
+            174,
+            424,
+            532,
+            443
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This technical result also immediately inspires the method to guarantee worst case performance, as well as to explicitly enforce the concept of invariance. Notice that $a = \\arg \\operatorname* { m a x } _ { a \\in \\mathcal { A } } \\mathbf { y } ^ { \\top } f ( a ( \\mathbf { x } ) ; \\widehat { \\theta } )$ is simply selecting the augmentation function maximizing the cross-entropy loss, a standard used by many worst case augmenting method (e.g., Madry et al., 2018). ",
+        "bbox": [
+            173,
+            450,
+            826,
+            512
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.5 REGULARIZED TRAINING WITH VERTICES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            526,
+            509,
+            541
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As $\\mathcal { A }$ in practice is usually a set with a large number of (and possibly infinite) elements, we may not always be able to identify the worst case transformation function with reasonable computational efforts. This limitation also prevents us from effective estimating the generalization error as the bound requires the identification of the worst case transformation. ",
+        "bbox": [
+            173,
+            553,
+            825,
+            609
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our final discussion is to leverage the vertex property of the transformation function to bound the worst case generalization error: ",
+        "bbox": [
+            171,
+            616,
+            823,
+            645
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Lemma 3.4. With Assumptions A1-A6, and $d _ { e } ( \\cdot , \\cdot )$ in $A 2$ chosen as $\\ell _ { 1 }$ norm distance, $d _ { x } ( \\cdot , \\cdot )$ in $A 3$ chosen as Wasserstein-1 metric, assuming there is a $a ^ { \\prime } ( ) \\in { \\mathcal { A } }$ where $\\begin{array} { r } { \\widehat { r } _ { \\mathcal { P } _ { a ^ { \\prime } } } ( \\widehat { \\theta } ) = \\frac { 1 } { 2 } \\big ( \\widehat { r } _ { \\mathcal { P } _ { a ^ { + } } } ( \\widehat { \\theta } ) + } \\end{array}$ ${ \\widehat { r } } _ { { \\mathcal { P } } _ { a } - } ( { \\widehat { \\theta } } ) \\big )$ , with probability at least $1 - \\delta$ , we have: ",
+        "bbox": [
+            173,
+            647,
+            825,
+            699
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2c8a71b46bf809bb523dacc9058cf9a248d77938908d0899b1f63f256830198c.jpg",
+        "text": "$$\n\\operatorname* { s u p } _ { \\substack { 2 \\prime \\in T ( P , A ) } } r _ { P ^ { \\prime } } ( \\widehat { \\theta } ) \\leq \\frac { 1 } { 2 } \\big ( \\widehat { r } _ { \\mathcal { P } _ { a } + } ( \\widehat { \\theta } ) + \\widehat { r } _ { \\mathcal { P } _ { a } - } ( \\widehat { \\theta } ) \\big ) + \\sum _ { i } | | f ( a ^ { + } ( \\mathbf { x } _ { i } ) ; \\widehat { \\theta } ) - f ( a ^ { - } ( \\mathbf { x } ^ { \\prime } ) ; \\widehat { \\theta } ) | | _ { 1 } + \\phi ( | \\Theta | , n , \\delta )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            705,
+            823,
+            742
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This result inspires the method that can directly guarantee the worst case generalization result and can be optimized conveniently without searching for the worst-case transformations. However, this method requires a good domain knowledge of the vertices of the transformation functions. ",
+        "bbox": [
+            174,
+            755,
+            825,
+            797
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.6 ENGINEERING SPECIFICATION OF RELEVANT METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            814,
+            602,
+            829
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our theoretical analysis has lead to a line of methods, however, not every method can be effectively implemented, especially due to the difficulties of passing gradient back for optimizations. Therefore, to boost the influence of the loss function through backpropagation, we recommend to adapt the methods with the following two changes: 1) the regularization is enforced on logits instead of softmax; 2) we use squared $\\ell _ { 2 }$ norm instead of $\\ell _ { 1 }$ norm because $\\ell _ { 1 }$ norm is not differentiable everywhere. We discuss the effects of these compromises in ablation studies in Appendix E. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Also, in the cases where we need to identify the worst case transformation functions, we iterate through all the transformation functions and identify the function with the maximum loss. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Overall, our analysis leads to the following main training strategies: ",
+        "bbox": [
+            173,
+            138,
+            617,
+            154
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• VA (vanilla augmentation): mix the augmented samples of a vertex function to the original ones for training (original samples are considered as from another vertex in following experiments). • VWA (vanilla worst-case augmentation): at each iteration, identify the worst-case transformation functions and train with samples generated by them (also known as adversarial training). • RA (regularized augmentation): regularizing the squared $\\ell _ { 2 }$ distance over logits between the original samples and the augmented samples of a fixed vertex transformation function. • RWA (regularized worst-case augmentation): regularizing the squared $\\ell _ { 2 }$ distance over logits between the original samples and the worst-case augmented samples identified at each iteration. ",
+        "bbox": [
+            173,
+            165,
+            826,
+            295
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            315,
+            326,
+            330
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We first use some synthetic experiments to verify our assumptions and inspect the consequences when the assumptions are not met (in Appendix $\\dot { \\mathbf { C } } )$ . Then, in the following paragraphs, we test the methods discussed to support our arguments in learning robustness and invariance. Finally, we show the power of our discussions by competing with advanced methods designed for specific tasks. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            404
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENTS FOR LEARNING ROBUST & INVARIANT REPRESENTATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            420,
+            715,
+            435
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Experiment Setup: We first test our arguments with two data sets and three different sets of the augmentations. We study MNIST dataset with LeNet architecture, and CIFAR10 dataset with ResNet18 architecture. To examine the effects of the augmentation strategies, we disable all the heuristics that are frequently used to boost the test accuracy of models, such as the default augmentation many models trained for CIFAR10 adopted, and the BatchNorm (also due to the recent arguments against the effects of BatchNorm in learning robust features $( \\overline { { \\mathrm { W a n g ~ e t ~ a l . } } } , \\overline { { 2 0 2 0 } } ) )$ , although forgoing these heuristics will result in a lower overall performance than one usually expects. ",
+        "bbox": [
+            174,
+            446,
+            825,
+            545
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We consider three different sets of transformation functions: texture, rotation, and contrast. The details of these transformation functions and the experiment setup are in Appendix D. ",
+        "bbox": [
+            173,
+            551,
+            823,
+            580
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We consider three different evaluation metrics: ",
+        "bbox": [
+            176,
+            587,
+            480,
+            602
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• Clean: test accuracy on the original test data, mainly reported as a reference for other metrics.   \n• Robustness: the worst accuracy when each sample can be transformed with $a \\in { \\mathcal { A } }$ .   \nInvariance: A metric to test whether the models learns the concept of invariance (details to follow). ",
+        "bbox": [
+            171,
+            613,
+            823,
+            667
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Invariance-test: To test whether a model can truly learns the concept of invariance within ${ \\mathcal { A } } =$ $\\{ a _ { 1 } ( ) , a _ { 2 } ( ) , \\ldots , a _ { t } ( ) \\}$ of $t$ elements, we design a new evaluation metric: for a sampled collection of data of the sample label $i$ , denoted as $\\mathbf { X } ^ { ( i ) }$ , we generate the transformed copies of it with $\\mathcal { A }$ , resulting in $\\mathbf { X } _ { a _ { 1 } } ^ { ( i ) } , \\mathbf { X } _ { a _ { 2 } } ^ { ( i ) } , \\ldots , \\mathbf { X } _ { a _ { t } } ^ { ( i ) }$ . We combined these copies into a dataset, denoted as $\\chi ^ { ( i ) }$ . For every sample $\\mathbf { x }$ in $\\chi ^ { ( i ) }$ , we retrieve its $t$ nearest neighbors of other samples in $\\chi ^ { ( i ) }$ , and calculate the overlap of the retrieved samples and $\\{ a _ { 1 } ( \\mathbf { x } ) , a _ { 2 } ( \\mathbf { x } ) , \\ldots , a _ { t } ( \\mathbf { x } ) \\}$ . Since the identify map is in $\\mathcal { A }$ , so the calculated overlap score will be in $[ 1 / t , 1 ]$ . The distance used is $d ( \\cdot , \\cdot ) = | | f ( \\cdot ; \\widehat { \\theta } ) - f ( \\cdot ; \\widehat { \\theta } ) | | _ { 1 }$ , where $\\widehat { \\theta }$ is the model we are interested to examine. Finally, we report the averaged score for every label. Thus, a high overlap score indicates the prediction of model $\\widehat { \\theta }$ is invariant to the augmentation functions in $\\mathcal { A }$ . If we use other distance functions, the reported values may differ, but we notice that the rank of the methods compared in terms of this test barely changes. ",
+        "bbox": [
+            173,
+            679,
+            825,
+            847
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Results: We show the results in Table 1 and Table $\\bigtriangledown$ (in Appendix) for MNIST and CIFAR10 respectively. Table $^ 1$ shows that RWA is generally a superior method, in terms of all the metrics, especially the invariance evaluation as it shows a much higher invariance score than competing methods. We believe this advantage of invariance comes from two sources: regularizations and the fact that RWA has seen all the augmentation functions in $\\boldsymbol { A }$ . In comparison, RA also has regularization but only sees the vertices in $\\mathcal { A }$ , so the invariance score of RA is not compatitable to RWA, although better than VA. Table $\\boxed { 6 }$ roughly tells the same story. More discussions are in Appendix D. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/4d6d2cd72ffd4995ba2d9ff0fb8abd8856e049f6aed1dcd87c3b5ef04b7d83f1.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: Results of MNIST data (“C” stands for clean accuracy, “R” stands for robustness, and “I” stands for invariance score): invariance score shows big differences while accuracy does not. "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"3\">Texture</td><td colspan=\"3\">Rotation</td><td colspan=\"3\">Contrast</td></tr><tr><td>C</td><td>R</td><td>I</td><td>C</td><td>R</td><td>I</td><td>C</td><td>R</td><td>I</td></tr><tr><td>Base</td><td>0.9921</td><td>0.9860</td><td>0.9236</td><td>0.9921</td><td>0.2960</td><td>0.2056</td><td>0.9921</td><td>0.2699</td><td>0.2003</td></tr><tr><td>VA</td><td>0.9928</td><td>0.9906</td><td>0.9876</td><td>0.9884</td><td>0.9336</td><td>0.5628</td><td>0.9922</td><td>0.9837</td><td>0.4153</td></tr><tr><td>RA</td><td>0.9909</td><td>0.9904</td><td>1</td><td>0.9930</td><td>0.9525</td><td>0.6044</td><td>0.9936</td><td>0.9823</td><td>0.4166</td></tr><tr><td>VWA</td><td>0.9922</td><td>0.9903</td><td>0.9940</td><td>0.9466</td><td>0.9408</td><td>0.6284</td><td>0.536</td><td>0.4470</td><td>0.2210</td></tr><tr><td>RWA</td><td>0.9915</td><td>0.9911</td><td>1</td><td>0.9934</td><td>0.9882</td><td>0.8856</td><td>0.994</td><td>0.9893</td><td>0.8786</td></tr></table>",
+        "bbox": [
+            200,
+            101,
+            797,
+            194
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            261,
+            820,
+            290
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Other results (Appendix $\\mathbf { E } )$ : The strength of RWA can also be shown in several other different scenarios, even in the out-of-domain test scenario where the transformation functions are not in $\\mathcal { A }$ . RWA generally performs the best, although not the best in every single test. We also perform ablation test to validate the choice of squared $\\ell _ { 2 }$ norm over logits in contrast to other distance metrics. Our choice performs the best in the worst-case performance. This advantage is expected as our choice is validated by theoretical arguments as well as consideration of engineering convenience. ",
+        "bbox": [
+            174,
+            295,
+            825,
+            380
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Overall, the empirical performances align with our expectation from the theoretical discussion: while all methods discussed have a bounded worst case performance, we do not intend to compare the upper bounds because smaller upper bounds do not necessarily guarantee a smaller risk. However, worst case augmentation methods tend to show a better worst case performances because they have been augmented with all the elements in $\\mathcal { A }$ . Also, there is no clear evidence suggesting the difference between augmentation methods and its regularized versions in terms of the worst case performance, but it is clear that regularization helps to learn the concept of invariance. ",
+        "bbox": [
+            174,
+            387,
+            825,
+            484
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 COMPARISON TO ADVANCED METHODS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            505,
+            490,
+            520
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally, we also compete our generic data augmentation methods against several specifically designed methods in different applications. We use the four generic methods (VA, RA, VWA, and RWA) with generic transformation functions $\\mathcal { A }$ of “rotation”, “contrast”, or ”texture” used in the synthetic experiments). We compare our methods with techniques invented for three different topics of study (rotation invariant, texture perturbation, and cross-domain generalization), and each of these topics has seen a long line of method development. We follow each own tradition (e.g., rotation methods are usually tested in CIFAR10 dataset, seemingly due to the methods’ computational requirements), test over each own most challenging dataset (e.g., ImageNet-Sketch is the most recent and challenging dataset in domain generalization, although less studied), and report each own evaluation metric (e.g., methods tested with ImageNet-C are usually evaluated with mCE). ",
+        "bbox": [
+            174,
+            532,
+            825,
+            672
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Overall, the performances of our generic methods outperform these advanced SOTA techniques. Thus, the main conclusion, as validated by these challenging scenarios, are (1) usage of data augmentation can outperform carefully designed methods; (2) usage of the consistency loss can further improve the performances; (3) regularized worst-case augmentation generally works the best. ",
+        "bbox": [
+            174,
+            679,
+            823,
+            734
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Due to the limitation of space, we leave the background details of these experiments in Appendix F, where we introduce the detailed experiment settings, and explain the acronyms in Tables 2-4 ",
+        "bbox": [
+            174,
+            742,
+            820,
+            771
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Rotation-invariant Image Classification We test the models with nine different rotations including $0 ^ { \\circ }$ . Augmentation related methods only use the $\\mathcal { A }$ of “rotation” in synthetic experiments, so the testing scenario goes beyond what the augmentation methods have seen during training. The results in Table $\\bigtriangledown$ strongly endorses the efficacy of augmentation-based methods. Interestingly, regularized augmentation methods probably with the benefit of learning the concept of invariance, tend to behave well in the transformations not considered during training. Also, RA outperforms VWA on average. ",
+        "bbox": [
+            174,
+            776,
+            823,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Texture-perturbed ImageNet classification We also test the performance on the image classification over multiple perturbations. We train the model over standard ImageNet training set and test the model with ImageNet-C data (Hendrycks & Dietterich, 2019), which is a perturbed version of ImageNet by corrupting the original ImageNet validation set with a collection of noises. The results ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/88369cc9cecec32d282d45597c78e156fcb7c686028c3b206841f565675ff55f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>300</td><td>315</td><td>330</td><td>345</td><td>0</td><td>15</td><td>30</td><td>45</td><td>60</td><td>avg.</td></tr><tr><td>Base</td><td>0.2196</td><td>0.2573</td><td>0.3873</td><td>0.6502</td><td>0.8360</td><td>0.6938</td><td>0.4557</td><td>0.3281</td><td>0.2578</td><td>0.4539</td></tr><tr><td>ST</td><td>0.2391</td><td>0.2748</td><td>0.4214</td><td>0.7049</td><td>0.8251</td><td>0.7147</td><td>0.4398</td><td>0.2838</td><td>0.2300</td><td>0.4593</td></tr><tr><td>GC</td><td>0.1540</td><td>0.1891</td><td>0.2460</td><td>0.3919</td><td>0.5859</td><td>0.4145</td><td>0.2534</td><td>0.1827</td><td>0.1507</td><td>0.2853</td></tr><tr><td>ETN</td><td>0.3855</td><td>0.4844</td><td>0.6324</td><td>0.7576</td><td>0.8276</td><td>0.7730</td><td>0.7324</td><td>0.6245</td><td>0.5060</td><td>0.6358</td></tr><tr><td>VA</td><td>0.2233</td><td>0.2832</td><td>0.4318</td><td>0.6364</td><td>0.8124</td><td>0.6926</td><td>0.5973</td><td>0.7152</td><td>0.7923</td><td>0.5761</td></tr><tr><td>RA</td><td>0.3198</td><td>0.3901</td><td>0.5489</td><td>0.7170</td><td>0.8487</td><td>0.7904</td><td>0.7455</td><td>0.8005</td><td>0.8282</td><td>0.6655</td></tr><tr><td>VWA</td><td>0.3383</td><td>0.3484</td><td>0.3835</td><td>0.4569</td><td>0.7474</td><td>0.866</td><td>0.8776</td><td>0.8738</td><td>0.8629</td><td>0.6394</td></tr><tr><td>RWA</td><td>0.4012</td><td>0.4251</td><td>0.4852</td><td>0.6765</td><td>0.8708</td><td>0.8871</td><td>0.8869</td><td>0.8870</td><td>0.8818</td><td>0.7113</td></tr></table>",
+        "bbox": [
+            173,
+            99,
+            828,
+            218
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Comparison to advanced rotation-invariant models. We report the test accuracy on the test sets clockwise rotated, $0 ^ { \\circ } \\ – 6 0 ^ { \\circ }$ and $3 0 0 ^ { \\circ } - 3 6 0 ^ { \\circ }$ . Average accuracy is also reported. Augmentation methods only consider $0 ^ { \\circ } \\ – 6 0 ^ { \\circ }$ clockwise rotations during training. ",
+        "bbox": [
+            174,
+            228,
+            823,
+            271
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/b73f5792c7e07bdcfa8f045c4fab9abc76d3dbe59f7238bd33fed7b74ee71bf3.jpg",
+        "table_caption": [
+            "Table 3: Summary comparison to advanced models over ImageNet-C data. Performance reported (mCE) follows the standard in ImageNet-C data: clean error and mCE are both the smaller the better. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Base</td><td>SU</td><td>AA</td><td>MBP</td><td>SIN</td><td>AM</td><td>AMS</td><td>VA</td><td>RA</td><td>VWA</td><td>RWA</td></tr><tr><td>Clean</td><td>23.9</td><td>24.5</td><td>22.8</td><td>23</td><td>27.2</td><td>22.4</td><td>25.2</td><td>23.7</td><td>23.6</td><td>23.3</td><td>22.4</td></tr><tr><td>mCE</td><td>80.6</td><td>74.3</td><td>72.7</td><td>73.4</td><td>73.3</td><td>68.4</td><td>64.9</td><td>76.3</td><td>75.6</td><td>74.8</td><td>64.6</td></tr></table>",
+        "bbox": [
+            204,
+            285,
+            794,
+            327
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/1cadba0d39693607b1929f5ca7d563209a7de6b5bf6786a19ecbf531754b88a2.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Base</td><td>InfoDrop</td><td>HEX</td><td>PAR</td><td>VA</td><td>RA</td><td>VWA</td><td>RWA</td></tr><tr><td>Top-1</td><td>0.1204</td><td>0.1224</td><td>0.1292</td><td>0.1306</td><td>0.1362</td><td>0.1405</td><td>0.1432</td><td>0.1486</td></tr><tr><td>Top-5</td><td>0.2408</td><td>0.256</td><td>0.2564</td><td>0.2627</td><td>0.2715</td><td>0.2793</td><td>0.2846</td><td>0.2933</td></tr></table>",
+        "bbox": [
+            220,
+            380,
+            774,
+            424
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Comparison to advanced cross-domain image classification models, over ImageNet-Sketch dataset. We report top-1 and top-5 accuracy following standards on ImageNet related experiments. ",
+        "bbox": [
+            173,
+            433,
+            821,
+            462
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "are reported in Table $^ { 3 , }$ which shows that our generic method can outperform the current SOTA methods after a continued finetuning process with reducing learning rates. ",
+        "bbox": [
+            174,
+            489,
+            821,
+            518
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Cross-domain ImageNet-Sketch Classification We also compare to the methods used for crossdomain evaluation. with the most challenging setup in this scenario: train the models with standard ImageNet training data, and test the model over ImageNet-Sketch data $( \\mathbb { W } \\mathrm { a n g ~ e t ~ a l . } ] { \\underline { { 2 0 1 9 \\mathrm { a } } } } )$ , which is a collection of sketches following the structure ImageNet validation set. Similarly, we only augment the samples with a generic augmentation set ( $\\mathcal { A }$ of “contrast” in synthetic experiments, Appendix D) The results in Table 4 again support the strength of the correct usage of data augmentation. ",
+        "bbox": [
+            174,
+            525,
+            825,
+            609
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            631,
+            318,
+            648
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we conducted a systematic inspection to study the proper regularization techniques that are provably related to the generalization error of a machine learning model, when the test distribution are allowed to be perturbed by a family of transformation functions. With progressively more specific assumptions, we identified progressively simpler methods that can bound the worst case risk. We summarize the main take-home messages below: ",
+        "bbox": [
+            174,
+            665,
+            825,
+            734
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• Regularizing a norm distance between the logits of the originals samples and the logits of the augmented samples enjoys several merits: the trained model tend to have good worst cast performance, and can learn the concept of invariance (as shown in our invariance test). Although our theory suggests $\\ell _ { 1 }$ norm, but we recommend squared $\\ell _ { 2 }$ norm in practice considering the difficulties of passing the (sub)gradient of $\\ell _ { 1 }$ norm in backpropagation. • With the vertex assumption held (it usually requires domain knowledge to choose the vertex functions), one can use “regularized training with vertices” method and get good empirical performance in both accuracy and invariance, and the method is at the same complexity order of vanilla training without data augmentation. When we do not have the domain knowledge (thus are not confident in the vertex assumption), we recommend “regularized worst-case augmentation”, which has the best performance overall, but requires extra computations to identify the worst-case augmentated samples at each iteration. ",
+        "bbox": [
+            173,
+            750,
+            826,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alessandro Achille and Stefano Soatto. Information dropout: Learning optimal representations through noisy computation. IEEE transactions on pattern analysis and machine intelligence, 40 (12):2897–2905, 2018. ",
+        "bbox": [
+            176,
+            127,
+            825,
+            169
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Martin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein gan, 2017. ´ ",
+        "bbox": [
+            174,
+            180,
+            684,
+            195
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Akari Asai and Hannaneh Hajishirzi. Logic-guided data augmentation and regularization for consistent question answering, 2020. ",
+        "bbox": [
+            171,
+            207,
+            820,
+            236
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shai Ben-David, John Blitzer, Koby Crammer, Alex Kulesza, Fernando Pereira, and Jennifer Wortman Vaughan. A theory of learning from different domains. Machine learning, 79(1-2):151–175, 2010. ",
+        "bbox": [
+            174,
+            247,
+            825,
+            289
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sergey Bobkov and Michel Ledoux. One-dimensional empirical measures, order statistics, and Kantorovich transport distances, volume 261. American Mathematical Society, 2019. ",
+        "bbox": [
+            171,
+            301,
+            825,
+            330
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Olivier Bousquet, Stephane Boucheron, and G ´ abor Lugosi. Introduction to statistical learning the- ´ ory. In Summer School on Machine Learning, pp. 169–207. Springer, 2003. ",
+        "bbox": [
+            173,
+            342,
+            823,
+            371
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shuxiao Chen, Edgar Dobriban, and Jane H Lee. A group-theoretic framework for data augmentation, 2019. ",
+        "bbox": [
+            174,
+            382,
+            821,
+            410
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Taco Cohen and Max Welling. Group equivariant convolutional networks. In International conference on machine learning, pp. 2990–2999, 2016. ",
+        "bbox": [
+            173,
+            421,
+            823,
+            452
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ekin D Cubuk, Barret Zoph, Dandelion Mane, Vijay Vasudevan, and Quoc V Le. Autoaugment: Learning augmentation strategies from data. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 113–123, 2019. ",
+        "bbox": [
+            174,
+            462,
+            825,
+            506
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marco Cuturi and Arnaud Doucet. Fast computation of wasserstein barycenters. 2014. ",
+        "bbox": [
+            173,
+            516,
+            741,
+            531
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tri Dao, Albert Gu, Alexander Ratner, Virginia Smith, Chris De Sa, and Christopher Re. A kernel ´ theory of modern data augmentation. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pp. 1528–1537. PMLR, 2019. ",
+        "bbox": [
+            174,
+            542,
+            825,
+            613
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alhussein Fawzi, Horst Samulowitz, Deepak S. Turaga, and Pascal Frossard. Adaptive data augmentation for image classification. In 2016 IEEE International Conference on Image Processing, ICIP 2016, Phoenix, AZ, USA, September 25-28, 2016, pp. 3688–3692. IEEE, 2016. ",
+        "bbox": [
+            174,
+            625,
+            825,
+            667
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yaroslav Ganin, Evgeniya Ustinova, Hana Ajakan, Pascal Germain, Hugo Larochelle, Franc¸ois Laviolette, Mario Marchand, and Victor Lempitsky. Domain-adversarial training of neural networks. The Journal of Machine Learning Research, 17(1):2096–2030, 2016. ",
+        "bbox": [
+            174,
+            678,
+            823,
+            722
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow. Nips 2016 tutorial: Generative adversarial networks. arXiv preprint arXiv:1701.00160, 2016. ",
+        "bbox": [
+            173,
+            732,
+            823,
+            761
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. Improved training of wasserstein gans, 2017. ",
+        "bbox": [
+            173,
+            773,
+            823,
+            803
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hao Guo, Kang Zheng, Xiaochuan Fan, Hongkai Yu, and Song Wang. Visual attention consistency under image transforms for multi-label image classification. In IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2019, Long Beach, CA, USA, June 16-20, 2019, pp. 729– 739. Computer Vision Foundation / IEEE, 2019. ",
+        "bbox": [
+            174,
+            813,
+            825,
+            869
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks and Thomas Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. Proceedings of the International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks, Norman Mu, Ekin Dogus Cubuk, Barret Zoph, Justin Gilmer, and Balaji Lakshminarayanan. Augmix: A simple data processing method to improve robustness and uncertainty. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Hernandez-Garc ´ ´ıa and Peter Konig. Data augmentation instead of explicit regularization, 2018. ¨ ",
+        "bbox": [
+            173,
+            170,
+            821,
+            185
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Daniel Ho, Eric Liang, Xi Chen, Ion Stoica, and Pieter Abbeel. Population based augmentation: Efficient learning of augmentation policy schedules. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pp. 2731–2741. PMLR, 2019. ",
+        "bbox": [
+            173,
+            195,
+            825,
+            265
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhiting Hu, Bowen Tan, Russ R Salakhutdinov, Tom M Mitchell, and Eric P Xing. Learning data manipulation for augmentation and weighting. In Advances in Neural Information Processing Systems, pp. 15738–15749, 2019. ",
+        "bbox": [
+            174,
+            276,
+            821,
+            319
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Max Jaderberg, Karen Simonyan, Andrew Zisserman, et al. Spatial transformer networks. In Advances in neural information processing systems, pp. 2017–2025, 2015. ",
+        "bbox": [
+            171,
+            328,
+            823,
+            358
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jisoo Jeong, Seungeui Lee, Jeesoo Kim, and Nojun Kwak. Consistency-based semi-supervised learning for object detection. In Advances in Neural Information Processing Systems, pp. 10758– 10767, 2019. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            410
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Harini Kannan, Alexey Kurakin, and Ian Goodfellow. Adversarial logit pairing, 2018. ",
+        "bbox": [
+            173,
+            420,
+            736,
+            436
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Risi Kondor, Zhen Lin, and Shubhendu Trivedi. Clebsch–gordan nets: a fully fourier space spherical convolutional neural network. In Advances in Neural Information Processing Systems, pp. 10117– 10126, 2018. ",
+        "bbox": [
+            174,
+            445,
+            825,
+            488
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            173,
+            500,
+            823,
+            529
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Davis Liang, Zhiheng Huang, and Zachary C Lipton. Learning noise-invariant representations for robust speech recognition. In 2018 IEEE Spoken Language Technology Workshop (SLT), pp. 56–63. IEEE, 2018. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            580
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Percy Liang. Cs229t/stat231: Statistical learning theory (winter 2016), 2016. ",
+        "bbox": [
+            173,
+            590,
+            678,
+            607
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Raphael Gontijo Lopes, Dong Yin, Ben Poole, Justin Gilmer, and Ekin D Cubuk. Improving robustness without sacrificing accuracy with patch gaussian augmentation. arXiv preprint arXiv:1906.02611, 2019. ",
+        "bbox": [
+            173,
+            616,
+            825,
+            659
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In 6th International Conference on Learning Representations, ICLR 2018, Vancouver, BC, Canada, April 30 - May 3, 2018, Conference Track Proceedings. OpenReview.net, 2018. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            727
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shashank Rajput, Zhili Feng, Zachary Charles, Po-Ling Loh, and Dimitris Papailiopoulos. Does data augmentation lead to positive margin? In International Conference on Machine Learning, pp. 5321–5330, 2019. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            779
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mehdi Sajjadi, Mehran Javanmardi, and Tolga Tasdizen. Regularization with stochastic transformations and perturbations for deep semi-supervised learning. In Advances in neural information processing systems, pp. 1163–1171, 2016. ",
+        "bbox": [
+            174,
+            789,
+            823,
+            832
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Meet Shah, Xinlei Chen, Marcus Rohrbach, and Devi Parikh. Cycle-consistency for robust visual question answering. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2019. ",
+        "bbox": [
+            173,
+            842,
+            823,
+            885
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Connor Shorten and Taghi M Khoshgoftaar. A survey on image data augmentation for deep learning. Journal of Big Data, 6(1):60, 2019. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kai Sheng Tai, Peter Bailis, and Gregory Valiant. Equivariant transformer networks. arXiv preprint arXiv:1901.11399, 2019. ",
+        "bbox": [
+            174,
+            142,
+            823,
+            171
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhuozhuo Tu, Jingwei Zhang, and Dacheng Tao. Theoretical analysis of adversarial learning: A minimax approach. In Advances in Neural Information Processing Systems, pp. 12259–12269, 2019. ",
+        "bbox": [
+            173,
+            181,
+            825,
+            224
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Cedric Villani. ´ Topics in optimal transportation. Number 58. American Mathematical Soc., 2003. ",
+        "bbox": [
+            173,
+            234,
+            816,
+            250
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Cedric Villani. ´ Optimal transport: old and new, volume 338. Springer Science & Business Media, 2008. ",
+        "bbox": [
+            174,
+            258,
+            823,
+            289
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Haohan Wang, Songwei Ge, Eric P. Xing, and Zachary C. Lipton. Learning robust global representations by penalizing local predictive power, 2019a. ",
+        "bbox": [
+            171,
+            297,
+            823,
+            328
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Haohan Wang, Zexue He, Zachary C. Lipton, and Eric P. Xing. Learning robust representations by projecting superficial statistics out. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019b. ",
+        "bbox": [
+            173,
+            337,
+            825,
+            381
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Haohan Wang, Xindi Wu, Zeyi Huang, and Eric P. Xing. High frequency component helps explain the generalization of convolutional neural networks. In Computer Vision and Pattern Recognition (CVPR), 2020. ",
+        "bbox": [
+            171,
+            390,
+            825,
+            433
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yulin Wang, Xuran Pan, Shiji Song, Hong Zhang, Gao Huang, and Cheng Wu. Implicit semantic data augmentation for deep networks. In Advances in Neural Information Processing Systems, pp. 12614–12623, 2019c. ",
+        "bbox": [
+            174,
+            443,
+            825,
+            486
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xindi Wu, Yijun Mao, Haohan Wang, Xiangrui Zeng, Xin Gao, Eric P. Xing, and Min Xu. Regularized adversarial training (RAT) for robust cellular electron cryo tomograms classification. In Illhoi Yoo, Jinbo Bi, and Xiaohua Hu (eds.), 2019 IEEE International Conference on Bioinformatics and Biomedicine, BIBM 2019, San Diego, CA, USA, November 18-21, 2019, pp. 1–6. IEEE, 2019. ",
+        "bbox": [
+            173,
+            496,
+            825,
+            566
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Qizhe Xie, Zihang Dai, Eduard Hovy, Minh-Thang Luong, and Quoc V Le. Unsupervised data augmentation. arXiv preprint arXiv:1904.12848, 2019. ",
+        "bbox": [
+            169,
+            577,
+            825,
+            607
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Saining Xie, Tianbao Yang, Xiaoyu Wang, and Yuanqing Lin. Hyper-class augmented and regularized deep learning for fine-grained image classification. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2645–2654, 2015. ",
+        "bbox": [
+            173,
+            616,
+            823,
+            660
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Fanny Yang, Zuowen Wang, and Christina Heinze-Deml. Invariance-inducing regularization using worst-case transformations suffices to boost accuracy and spatial robustness. In Advances in Neural Information Processing Systems, pp. 14757–14768, 2019. ",
+        "bbox": [
+            173,
+            669,
+            825,
+            712
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "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 Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pp. 7472–7482. PMLR, 2019a. ",
+        "bbox": [
+            173,
+            722,
+            825,
+            792
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard Zhang. Making convolutional networks shift-invariant again. arXiv preprint arXiv:1904.11486, 2019. ",
+        "bbox": [
+            169,
+            803,
+            823,
+            832
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xinyu Zhang, Qiang Wang, Jian Zhang, and Zhao Zhong. Adversarial autoaugment. In International Conference on Learning Representations, 2020. ",
+        "bbox": [
+            169,
+            842,
+            823,
+            871
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhirui Zhang, Shuangzhi Wu, Shujie Liu, Mu Li, Ming Zhou, and Tong Xu. Regularizing neural machine translation by target-bidirectional agreement. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 443–450, 2019b. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stephan Zheng, Yang Song, Thomas Leung, and Ian Goodfellow. Improving the robustness of deep neural networks via stability training. In Proceedings of the ieee conference on computer vision and pattern recognition, pp. 4480–4488, 2016. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph, Ekin D. Cubuk, Golnaz Ghiasi, Tsung-Yi Lin, Jonathon Shlens, and Quoc V. Le. Learning data augmentation strategies for object detection, 2019. ",
+        "bbox": [
+            173,
+            155,
+            821,
+            184
+        ],
+        "page_idx": 11
+    }
+]

parse/train/SJlPOCEKvH/SJlPOCEKvH.md

@@ -0,0 +1,268 @@
+# COMPRESSING BERT: STUDYING THE EFFECTSOF WEIGHT PRUNING ON TRANSFER LEARNING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Universal feature extractors, such as BERT for natural language processing and VGG for computer vision, have become effective methods for improving deep learning models without requiring more labeled data. A common paradigm is to pre-train a feature extractor on large amounts of data then fine-tune it as part of a deep learning model on some downstream task (i.e. transfer learning). While effective, feature extractors like BERT may be prohibitively large for some deployment scenarios. We explore weight pruning for BERT and ask: how does compression during pre-training affect transfer learning? We find that pruning affects transfer learning in three broad regimes. Low levels of pruning $( 3 0 \% )$ do not affect pre-training loss or transfer to downstream tasks at all. Medium levels of pruning increase the pre-training loss and prevent useful pre-training information from being transferred to downstream tasks. High levels of pruning additionally prevent models from fitting downstream datasets, leading to further degradation. Finally, we observe that fine-tuning BERT on a specific task does not improve its prunability. We conclude that BERT can be pruned once during pre-training rather than separately for each task without affecting performance.
+
+# 1 INTRODUCTION
+
+Pre-trained feature extractors, such as BERT (Devlin et al., 2018) for natural language processing and VGG (Simonyan & Zisserman, 2014) for computer vision, have become effective methods for improving the performance of deep learning models. In the last year, models similar to BERT have become state-of-the-art in many NLP tasks, including natural language inference (NLI), named entity recognition (NER), sentiment analysis, etc. These models follow a pre-training paradigm: they are trained on a large amount of unlabeled text via a task that resembles language modeling (Yang et al., 2019; Chan et al., 2019) and are then fine-tuned on a smaller amount of downstream data, which is labeled for a specific task. Pre-trained models usually achieve higher accuracy than any model trained on downstream data alone.
+
+The pre-training paradigm, while effective, still has some problems. While some claim that language model pre-training is a “universal language learning task” (Radford et al., 2019), there is no theoretical justification for this, only empirical evidence. Second, due to the size of the pre-training dataset, BERT models tend to be slow and require impractically large amounts of GPU memory. BERT-Large can only be used with access to a Google TPU, and BERT-Base requires some optimization tricks such as gradient checkpointing or gradient accumulation to be trained effectively on consumer hardware (Sohoni et al., 2019). Training BERT-Base from scratch costs ${ \sim } \$ 7 k$ and emits ${ \sim } 1 4 3 8$ pounds of $\mathrm { C O _ { 2 } }$ (Strubell et al., 2019).
+
+Model compression (Bucila et al., 2006), which attempts to shrink a model without losing accuracy, is a viable approach to decreasing GPU usage. It might also be used to trade accuracy for memory in some low-resource cases, such as deploying to smartphones for real-time prediction. The main questions this paper attempts to answer are: Does compressing BERT impede it’s ability to transfer to new tasks? And does fine-tuning make BERT more or less compressible?
+
+To explore these questions, we compressed English BERT using magnitude weight pruning (Han et al., 2015) and observed the results on transfer learning to the General Language Understanding Evaluation (GLUE) benchmark (Wang et al., 2019), a diverse set of natural language understanding tasks including sentiment analysis, NLI, and textual similarity evaluation. We chose magnitude weight pruning, which compresses models by removing weights close to 0, because it is one of the most fine-grained and effective compression methods and because there are many interesting ways to view pruning, which we explore in the next section.
+
+Our findings are as follows: Low levels of pruning $( 3 0 - 4 0 \% )$ do not increase pre-training loss or affect transfer to downstream tasks at all. Medium levels of pruning increase the pre-training loss and prevent useful pre-training information from being transferred to downstream tasks. This information is not equally useful to each task; tasks degrade linearly with pre-train loss, but at different rates. High levels of pruning, depending on the size of the downstream dataset, may additionally degrade performance by preventing models from fitting downstream datasets. Finally, we observe that fine-tuning BERT on a specific task does not improve its prunability or change the order of pruning by a meaningful amount.
+
+To our knowledge, prior work had not shown whether BERT could be compressed in a task-generic way, keeping the benefits of pre-training while avoiding costly experimentation associated with compressing and re-training BERT multiple times. Nor had it shown whether BERT could be overpruned for a memory / accuracy trade-off for deployment to low-resource devices. In this work, we conclude that BERT can be pruned prior to distribution without affecting it’s universality, and that BERT may be over-pruned during pre-training for a reasonable accuracy trade-off for certain tasks.
+
+2 PRUNING: COMPRESSION, REGULARIZATION, ARCHITECTURE SEARCH
+
+Neural network pruning involves examining a trained network and removing parts deemed to be unnecessary by some heuristic saliency criterion. One might remove weights, neurons, layers, channels, attention heads, etc. depending on which heuristic is used. Below, we describe three different lenses through which we might interpret pruning.
+
+Compression Pruning a neural network decreases the number of parameters required to specify the model, which decreases the disk space required to store it. This allows large models to be deployed on edge computing devices like smartphones. Pruning can also increase inference speed if whole neurons or convolutional channels are pruned, which reduces GPU usage.1
+
+Regularization Pruning a neural network also regularizes it. We might consider pruning to be a form of permanent dropout (Molchanov et al., 2017) or a heuristic-based L0 regularizer (Louizos et al., 2018). Through this lens, pruning decreases the complexity of the network and therefore narrows the range of possible functions it can express.2 The main difference between L0 or L1 regularization and weight pruning is that the former induce sparsity via a penalty on the loss function, which is learned during gradient descent via stochastic relaxation. It’s not clear which approach is more principled or preferred. (Gale et al., 2019)
+
+Sparse Architecture Search Finally, we can view neural network pruning as a type of sparse architecture search. Liu et al. (2019b) and Frankle & Carbin (2019) show that they can train carefully re-initialized pruned architectures to similar performance levels as dense networks. Under this lens, stochastic gradient descent (SGD) induces network sparsity, and pruning simply makes that sparsity explicit. These sparse architectures, along with the appropriate initializations, are sometimes referred to as lottery tickets.3
+
+# 2.1 MAGNITUDE WEIGHT PRUNING
+
+In this work, we focus on weight magnitude pruning because it is one of the most fine-grained and effective pruning methods. It also has a compelling saliency criterion (Han et al., 2015): if a weight is close to zero, then its input is effectively ignored, which means the weight can be pruned.
+
+Magnitude weight pruning itself is a simple procedure: 1. Pick a target percentage of weights to be pruned, say $50 \%$ . 2. Calculate a threshold such that $50 \%$ of weight magnitudes are under that threshold. 3. Remove those weights. 4. Continue training the network to recover any lost accuracy. 5. Optionally, return to step 1 and increase the percentage of weights pruned. This procedure is conveniently implemented in a Tensorflow (Abadi et al., 2016) package4, which we use (Zhu & Gupta, 2017).
+
+Calculating a threshold and pruning can be done for all network parameters holistically (global pruning) or for each weight matrix individually (matrix-local pruning). Both methods will prune to the same sparsity, but in global pruning the sparsity might be unevenly distributed across weight matrices. We use matrix-local pruning because it is more popular in the community.5 For information on other pruning techniques, we recommend Gale et al. (2019) and Liu et al. (2019b).
+
+# 3 EXPERIMENTAL SETUP
+
+BERT is a large Transformer encoder; for background, we refer readers to Vaswani et al. (2017) or one of these excellent tutorials (Alammar, 2018; Klein et al., 2017).
+
+# 3.1 IMPLEMENTING BERT PRUNING
+
+BERT-Base consists of 12 encoder layers, each of which contains 6 prunable matrices: 4 for the multi-headed self-attention and 2 for the layer’s output feed-forward network.
+
+Recall that self-attention first projects layer inputs into key, query, and value embeddings via linear projections. While there is a separate key, query, and value projection matrix for each attention head, implementations typically stack matrices from each attention head, resulting in only 3 parameter matrices: one for key projections, one for value projections, and one for query projections. We prune each of these matrices separately, calculating a threshold for each. We also prune the linear output projection, which combines outputs from each attention head into a single embedding.6
+
+We prune word embeddings in the same way we prune feed-foward networks and self-attention parameters.7 The justification is similar: if a word embedding value is close to zero, we can assume it’s zero and store the rest in a sparse matrix. This is useful because token / subword embeddings tend to account for a large portion of a natural language model’s memory. In BERT-Base specifically, the embeddings account for ${ \sim } 2 1 \%$ of the model’s memory.
+
+Our experimental code for pruning BERT, based on the public BERT repository, is available here.8
+
+# 3.2 PRUNING DURING PRE-TRAINING
+
+We perform weight magnitude pruning on a pre-trained BERT-Base model.9 We select sparsities from $0 \%$ to $90 \%$ in increments of $10 \%$ and gradually prune BERT to this sparsity over the first 10k steps of training. We continue pre-training on English Wikipedia and BookCorpus for another 90k steps to regain any lost accuracy.10 The resulting pre-training losses are shown in Table 1.
+
+We then fine-tune these pruned models on tasks from the General Language Understanding Evaluation (GLUE) benchmark, which is a standard set of 9 tasks that include sentiment analysis, natural language inference, etc. We avoid WNLI, which is known to be problematic.11 We also avoid tasks with less than 5k training examples because the results tend to be noisy (RTE, MRPC, STS-B). We fine-tune a separate model on each of the remaining 5 GLUE tasks for 3 epochs and try 4 learning rates: $[ 2 , 3 , 4 , 5 ] \times 1 0 ^ { - 5 }$ . The best evaluation accuracies are averaged and plotted in Figure 1. Individual task results are in Table 1.
+
+BERT can be used as a static feature-extractor or as a pre-trained model which is fine-tuned end-toend. In all experiments, we fine-tune weights in all layers of BERT on downstream tasks.
+
+# 3.3 DISENTANGLING COMPLEXITY RESTRICTION AND INFORMATION DELETION
+
+Pruning involves two steps: it deletes the information stored in a weight by setting it to 0 and then regularizes the model by preventing that weight from changing during further training.
+
+To disentangle these two effects (model complexity restriction and information deletion), we repeat the experiments from Section 3.2 with an identical pre-training setup, but instead of pruning we simply set the weights to 0 and allow them to vary during downstream training. This deletes the pre-training information associated with the weight but does not prevent the model from fitting downstream datasets by keeping the weight at zero during downstream training. We also fine-tune on downstream tasks until training loss becomes comparable to models with no pruning. We trained most models for 13 epochs rather than 3. Models with $70 – 9 0 \%$ information deletion required 15 epochs to fit the training data. The results are also included in Figure 1 and Table 1.
+
+# 3.4 PRUNING AFTER DOWNSTREAM FINE-TUNING
+
+We might expect that BERT would be more compressible after downstream fine-tuning. Intuitively, the information needed for downstream tasks is a subset of the information learned during pretraining; some tasks require more semantic information than syntactic, and vice-versa. We should be able to discard the “extra” information and only keep what we need for, say, parsing (Li & Eisner, 2019).
+
+For magnitude weight pruning specifically, we might expect downstream training to change the distribution of weights in the parameter matrices. This, in turn, changes the sort-order of the absolute values of those weights, which changes the order that we prune them in. This new pruning order, hypothetically, would be less degrading to our specific downstream task.
+
+To test this, we fine-tuned pre-trained BERT-Base on downstream data for 3 epochs. We then pruned at various sparsity levels and continued training for 5 more epochs (7 for $80 \%$ sparsity), at which point the training losses became comparable to those of models pruned during pre-training. We repeat this for learning rates in $[ 2 , 3 , \dot { 4 } , 5 ] \times 1 0 ^ { - 5 }$ and show the results with the best development accuracy in Figure 1 / Table 1. We also measure the difference in which weights are selected for pruning during pre-training vs. downstream fine-tuning and plot the results in Figure 3.
+
+# 4 PRUNING REGIMES
+
+# 4.1 $30 \%$ OF WEIGHTS ARE NOT USEFUL
+
+Figure 1 shows that the first $3 0 { - } 4 0 \%$ of weights pruned by magnitude weight pruning do not impact pre-training loss or inference on any downstream task. These weights can be pruned either before or after fine-tuning. This makes sense from the perspective of pruning as sparse architecture search: when we initialize BERT-Base, we initialize many possible subnetworks. SGD selects the best one for pre-training and pushes the rest of the weights to 0. We can then prune those weights without affecting the output of the network.12
+
+![](images/126a8d6285a5aa1c9b3ddfd023b21b476c6ebdfb913e2c76911696e4c101bcd5.jpg)  
+Figure 1: (Blue) The best GLUE dev accuracy and training losses for models pruned during pretraining, averaged over 5 tasks. Also shown are models with information deletion during pre-training (orange), models pruned after downstream fine-tuning (green), and models pruned randomly during pre-training instead of by lowest magnitude (red). $3 0 { - } 4 0 \%$ of weights can be pruned using magnitude weight pruning without decreasing dowsntream accuracy. Notice that information deletion fits the training data better than un-pruned models at all sparsity levels but does not fully recover evaluation accuracy. Also, models pruned after downstream fine-tuning have the same or worse development accuracy, despite achieving lower training losses. Note: none of the pruned models are overfitting because un-pruned models have the lowest training loss and the highest development accuracy. While the results for individual tasks are in Table 1, each task does not vary much from the average trend, with an exception discussed in Section 4.3.
+
+![](images/eb29624447852c44f05ab4d7dd759d35fbf8b8b78deaedbbcee992c9991959f4.jpg)  
+Figure 2: (Left) Pre-training loss predicts information deletion GLUE accuracy linearly as sparsity increases. We believe the slope of each line tells us how much a bit of BERT is worth to each task. (CoLA at $90 \%$ is excluded from the line of best fit.) (Right) The cosine similarities of features extracted for a subset of the pre-training development data before and after pruning. Features are extracted from activations of all 12 layers of BERT and compared layer-wise to a model that has not been pruned. As performance degrades, cosine similarities of features decreases.
+
+# 4.2 MEDIUM PRUNING LEVELS PREVENT INFORMATION TRANSFER
+
+Past $40 \%$ pruning, performance starts to degrade. Pre-training loss increases as we prune weights necessary for fitting the pre-training data (Table 1). Feature activations of the hidden layers start to diverge from models with low levels of pruning (Figure 2).13 Downstream accuracy also begins to degrade at this point.
+
+Why does pruning at these levels hurt downstream performance? On one hand, pruning deletes pretraining information by setting weights to 0, preventing the transfer of the useful inductive biases learned during pre-training. On the other hand, pruning regularizes the model by keeping certain weights at zero, which might prevent fitting downstream datasets.
+
+Figure 1 and Table 1 show information deletion is the main cause of performance degradation between $40 \text{‰}$ sparsity, since pruning and information deletion degrade models by the same amount. Information deletion would not be a problem if pre-training and downstream datasets contained similar information. However, pre-training is effective precisely because the pre-training dataset is much larger than the labeled downstream dataset, which allows learning of more robust representations.
+
+We see that the main obstacle to compressing pre-trained models is maintaining the inductive bias of the model learned during pre-training. Encoding this bias requires many more weights than fitting downstream datasets, and it cannot be recovered due to a fundamental information gap between pre-training and downstream datasets.14 The amount a model can be pruned is limited by the largest dataset the model has been trained on: in this case, the pre-training dataset. Practitioners should be aware of this; pruning may subtly harm downstream generalization without affecting training loss.
+
+4.3 HIGH PRUNING LEVELS ALSO PREVENT FITTING DOWNSTREAM DATASETS
+
+At $70 \%$ sparsity and above, models with information deletion recover some accuracy w.r.t. pruned models, so complexity restriction is a secondary cause of performance degradation. However, these models do not recover all evaluation accuracy, despite matching un-pruned model’s training loss.
+
+Table 1 shows that on the MNLI and QQP tasks, which have the largest amount of training data, information deletion performs much better than pruning. In contrast, models do not recover as well on SST-2 and CoLA, which have less data. We believe this is because the larger datasets require larger models to fit, so complexity restriction becomes an issue earlier.
+
+We might be concerned that poorly performing models are over-fitting, since they have lower training losses than unpruned models. But the best performing information-deleted models have the lowest training error of all, so overfitting seems unlikely.15
+
+# 4.4 HOW MUCH IS A BIT OF BERT WORTH?
+
+We’ve seen that over-pruning BERT deletes information useful for downstream tasks. Is this information equally useful to all tasks? We might consider the pre-training loss as a proxy for how much pre-training information we’ve deleted in total. Similarly, the performance of information-deletion models is a proxy for how much of that information was useful for each task. Figure 2 shows that the pre-training loss linearly predicts the effects of information deletion on downstream accuracy.
+
+For every bit of information we delete from BERT, it appears only a fraction is useful for CoLA, and an even smaller fraction useful for QQP.16 This relationship should be taken into account when considering the memory $/$ accuracy trade-off of over-pruning. Pruning an extra $30 \%$ of BERT’s weights is worth only one accuracy point on QQP but 10 points on CoLA. It’s unclear, however, whether this is because the pre-training task is less relevant to QQP or whether QQP simply has a bigger dataset with more information content.17
+
+![](images/bba4d7a4c01c881257682f6fa81c9e8169f1f458be950922f1b0282621640535.jpg)  
+Figure 3: (Left) The measured difference in pruning masks between models pruned during pretraining and models pruned during downstream fine-tuning. As predicted, the differences are less than $6 \%$ , since fine-tuning only changes the magnitude sorting order of weights locally, not globally. (Right) The average GLUE development accuracy and pruning mask difference for models trained on downstream datasets before pruning $60 \%$ at learning rate 5e-5. After pruning, models are trained for an additional 2 epochs to regain accuracy. We see that training between 3 and 12 epochs before pruning does not change which weights are pruned or improve performance.
+
+# 5 DOWNSTREAM FINE-TUNING DOES NOT IMPROVE PRUNABILITY
+
+Since pre-training information deletion plays a central role in performance degradation while overpruning, we might expect that downstream fine-tuning would improve prunability by making important weights more salient (increasing their magnitude). However, Figure 1 shows that models pruned after downstream fine-tuning do not surpass the development accuracies of models pruned during pre-training, despite achieving similar training losses. Figure 3 shows fine-tuning changes which weights are pruned by less than $6 \%$ .
+
+Why doesn’t fine-tuning change which weights are pruned much? Table 2 shows that the magnitude sorting order of weights is mostly preserved; weights move on average $0 . 4 \%$ away from their starting positions in the sort order. We also see that high magnitude weights are more stable than lower ones (Figure 7).
+
+Our experiments suggest that training on downstream data before pruning is too blunt an instrument to improve prunability. Even so, we might consider simply training on the downstream tasks for much longer, which would increase the difference in weights pruned. However, Figure 4 shows that even after an epoch of downstream fine-tuning, weights quickly re-stabilize in a new sorting order, meaning longer downstream training will have only a marginal effect on which weights are pruned. Indeed, Figure 3 shows that the weights selected for $60 \%$ pruning quickly stabilize and evaluation accuracy does not improve with more training before pruning.
+
+# 6 RELATED WORK
+
+Compressing BERT for Specific Tasks Section 5 showed that downstream fine-tuning does not increase prunability. However, several alternative compression approaches have been proposed to discard non-task-specific information. Li & Eisner (2019) used an information bottleneck to discard non-syntactic information. Tang et al. (2019) used BERT as a knowledge distillation teacher to compress relevant information into smaller Bi-LSTMs, while Kuncoro et al. (2019) took a similar distillation approach. While fine-tuning does not increase prunability, task-specific knowledge might be extracted from BERT with other methods.
+
+![](images/9db120c5dae01a2a9a43e7edf5bfc48741670d1eb6ca6cc5e39314ed571749f6.jpg)  
+Figure 4: (Left) The average, min, and max percentage of individual attention heads pruned at each sparsity level. We see at $60 \%$ sparsity, each attention head individually is pruned strictly between $55 \%$ and $65 \%$ . (Right) We compute the magnitude sorting order of each weight before and after downstream fine-tuning. If a weight’s original position is $5 9 / 1 0 0$ before fine-tuning and $6 3 / 1 0 0$ after fine-tuning, then that weight moved $4 \%$ in the sorting order. After even an epoch of downstream fine-tuning, weights quickly stabilize in a new sorting order which is not far from the original sorting order. Variances level out similarly.
+
+Attention Head Pruning Voita et al. (2019) previously showed redundancy in transformer models by pruning entire attention heads. Michel et al. (2019) showed that after fine-tuning on MNLI, up to $40 \%$ of attention heads can be pruned from BERT without affecting test accuracy. They show redundancy in BERT after fine-tuning on a single downstream task; in contrast, our work emphasizes the interplay between compression and transfer learning to many tasks, pruning both before and after fine-tuning. Also, magnitude weight pruning allows us to additionally prune the feed-foward networks and sub-word embeddings in BERT (not just self-attention), which account for ${ \sim } 7 2 \%$ of BERT’s total memory usage.
+
+We suspect that attention head pruning and weight pruning remove different redundancies from BERT. Figure 4 shows that weight pruning does not prune any specific attention head much more than the pruning rate for the whole model. It is not clear, however, whether weight pruning and recovery training makes attention heads less prunable by distributing functionality to unused heads.
+
+# 7 CONCLUSION AND FUTURE WORK
+
+We’ve shown that encoding BERT’s inductive bias requires many more weights than are required to fit downstream data. Future work on compressing pre-trained models should focus on maintaining that inductive bias and quantifying its relevance to various tasks during accuracy/memory trade-offs.
+
+For magnitude weight pruning, we’ve shown that $3 0 { - } 4 0 \%$ of the weights do not encode any useful inductive bias and can be discarded without affecting BERT’s universality. The relevance of the rest of the weights vary from task to task, and fine-tuning on downstream tasks does not change the nature of this trade-off by changing which weights are pruned. In future work, we will investigate the factors that influence language modeling’s relevance to downstream tasks and how to improve compression in a task-general way.
+
+It’s reasonable to believe that these conclusions will generalize to other pre-trained language models such as Kermit (Chan et al., 2019), XLNet (Yang et al., 2019), GPT-2 (Radford et al., 2019), RoBERTa (Liu et al., 2019a) or ELMO (Peters et al., 2018). All of these learn some variant of language modeling, and most use Transformer architectures. While it remains to be shown in future work, viewing pruning as architecture search implies these models will be prunable due to the training dynamics inherent to neural networks.
+
+# REFERENCES
+
+Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Gregory S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian J. Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz ´ Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Mane, Rajat Monga, Sherry Moore, Derek Gor- ´ don Murray, Chris Olah, Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul A. Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda B. Viegas, Oriol Vinyals, ´ Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. CoRR, abs/1603.04467, 2016. URL http://arxiv.org/abs/1603.04467.
+
+Jay Alammar. The illustrated transformer, 2018. URL http://jalammar.github.io/ illustrated-transformer/.
+
+Sanjeev Arora, Rong Ge, Behnam Neyshabur, and Yi Zhang. Stronger generalization bounds for deep nets via a compression approach. CoRR, abs/1802.05296, 2018. URL http://arxiv. org/abs/1802.05296.
+
+Mikhail Belkin, Daniel Hsu, Siyuan Ma, and Soumik Mand al. Reconciling modern machine learning practice and the bias-variance trade-off. arXiv e-prints, art. arXiv:1812.11118, Dec 2018.
+
+Cristian Bucila, Rich Caruana, and Alexandru Niculescu-Mizil. Model compression. In Proceedings of the Twelfth ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, Philadelphia, PA, USA, August 20-23, 2006, pp. 535–541, 2006. doi: 10.1145/1150402. 1150464. URL https://doi.org/10.1145/1150402.1150464.
+
+William Chan, Nikita Kitaev, Kelvin Guu, Mitchell Stern, and Jakob Uszkoreit. KERMIT: generative insertion-based modeling for sequences. CoRR, abs/1906.01604, 2019. URL http: //arxiv.org/abs/1906.01604.
+
+Tim Dettmers and Luke S. Zettlemoyer. Sparse networks from scratch: Faster training without losing performance. ArXiv, abs/1907.04840, 2019.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. CoRR, abs/1810.04805, 2018.
+
+Utku Evci, Fabian Pedregosa, Aidan N. Gomez, and Erich Elsen. The difficulty of training sparse neural networks. CoRR, abs/1906.10732, 2019. URL http://arxiv.org/abs/1906. 10732.
+
+Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In International Conference on Learning Representations, 2019. URL https:// openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ rJl-b3RcF7.
+
+Trevor Gale, Erich Elsen, and Sara Hooker. The state of sparsity in deep neural networks. CoRR, abs/1902.09574, 2019. URL http://arxiv.org/abs/1902.09574.
+
+Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett (eds.), Advances in Neural Information Processing Systems 28, pp. 1135– 1143. Curran Associates, Inc., 2015. URL http://papers.nips.cc/paper/ 5784-learning-both-weights-and-connections-for-efficient-neural-network. pdf.
+
+Song Han, Xingyu Liu, Huizi Mao, Jing Pu, Ardavan Pedram, Mark A. Horowitz, and William J. Dally. Eie: Efficient inference engine on compressed deep neural network. In Proceedings of the 43rd International Symposium on Computer Architecture, ISCA ’16, pp. 243–254, Piscataway, NJ, USA, 2016. IEEE Press. ISBN 978-1-4673-8947-1. doi: 10.1109/ISCA.2016.30. URL https://doi.org/10.1109/ISCA.2016.30.
+
+Dan Hendrycks, Kimin Lee, and Mantas Mazeika. Using pre-training can improve model robustness and uncertainty. In ICML, pp. 2712–2721, 2019. URL http://proceedings.mlr. press/v97/hendrycks19a.html.
+
+Guillaume Klein, Yoon Kim, Yuntian Deng, Jean Senellart, and Alexander M. Rush. Opennmt: Open-source toolkit for neural machine translation. In Proc. ACL, 2017. doi: 10.18653/v1/ P17-4012. URL https://doi.org/10.18653/v1/P17-4012.
+
+Adhiguna Kuncoro, Chris Dyer, Laura Rimell, Stephen Clark, and Phil Blunsom. Scalable syntaxaware language models using knowledge distillation. CoRR, abs/1906.06438, 2019. URL http: //arxiv.org/abs/1906.06438.
+
+Xiang Lisa Li and Jason Eisner. Specializing word embeddings (for parsing) by information bottleneck. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and 9th International Joint Conference on Natural Language Processing, Hong Kong, November 2019. URL http://cs.jhu.edu/˜jason/papers/#li-eisner-2019.
+
+Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized BERT pretraining approach. CoRR, abs/1907.11692, 2019a. URL http://arxiv.org/abs/1907.11692.
+
+Zhuang Liu, Mingjie Sun, Tinghui Zhou, Gao Huang, and Trevor Darrell. Rethinking the value of network pruning. In International Conference on Learning Representations, 2019b. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ rJlnB3C5Ym.
+
+Christos Louizos, Max Welling, and Diederik P. Kingma. Learning sparse neural networks through l0 regularization. In International Conference on Learning Representations, 2018. URL https: //openreview.net/forum?id ${ . } = { }$ H1Y8hhg0b.
+
+Paul Michel, Omer Levy, and Graham Neubig. Are sixteen heads really better than one? ArXiv, abs/1905.10650, 2019.
+
+Dmitry Molchanov, Arsenii Ashukha, and Dmitry Vetrov. Variational dropout sparsifies deep neural networks. In Proceedings of the 34th International Conference on Machine Learning - Volume 70, ICML’17, pp. 2498–2507. JMLR.org, 2017. URL http://dl.acm.org/citation. cfm?id=3305890.3305939.
+
+Ari S. Morcos, Haonan Yu, Michela Paganini, and Yuand ong Tian. One ticket to win them all: generalizing lottery ticket initializations across datasets and optimizers. arXiv e-prints, art. arXiv:1906.02773, Jun 2019.
+
+Hesham Mostafa and Xin Wang. Parameter efficient training of deep convolutional neural networks by dynamic sparse reparameterization, 2019. URL https://openreview.net/forum? id=S1xBioR5KX.
+
+Matthew E. Peters, Mark Neumann, Mohit Iyyer, Matt Gardner, Christopher Clark, Kenton Lee, and Luke Zettlemoyer. Deep contextualized word representations. CoRR, abs/1802.05365, 2018. URL http://arxiv.org/abs/1802.05365.
+
+Alec Radford, Jeff Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. Language models are unsupervised multitask learners. 2019.
+
+Karen Simonyan and Andrew Zisserman. Very Deep Convolutional Networks for Large-Scale Image Recognition. arXiv e-prints, art. arXiv:1409.1556, Sep 2014.
+
+Nimit Sharad Sohoni, Christopher Richard Aberger, Megan Leszczynski, Jian Zhang, and Christopher Re. Low-memory neural network training: A technical report. ´ CoRR, abs/1904.10631, 2019. URL http://arxiv.org/abs/1904.10631.
+
+Emma Strubell, Ananya Ganesh, and Andrew McCallum. Energy and policy considerations for deep learning in NLP. CoRR, abs/1906.02243, 2019. URL http://arxiv.org/abs/1906. 02243.
+
+Raphael Tang, Yao Lu, Linqing Liu, Lili Mou, Olga Vechtomova, and Jimmy Lin. Distilling taskspecific knowledge from BERT into simple neural networks. CoRR, abs/1903.12136, 2019. URL http://arxiv.org/abs/1903.12136.
+
+Yuandong Tian, Tina Jiang, Qucheng Gong, and Ari S. Morcos. Luck matters: Understanding training dynamics of deep relu networks. CoRR, abs/1905.13405, 2019. URL http://arxiv. org/abs/1905.13405.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. CoRR, abs/1706.03762, 2017. URL http://arxiv.org/abs/1706.03762.
+
+Elena Voita, David Talbot, Fedor Moiseev, Rico Sennrich, and Ivan Titov. Analyzing multi-head self-attention: Specialized heads do the heavy lifting, the rest can be pruned. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pp. 5797–5808, Florence, Italy, July 2019. Association for Computational Linguistics. doi: 10.18653/v1/P19-1580. URL https://www.aclweb.org/anthology/P19-1580.
+
+Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. GLUE: A multi-task benchmark and analysis platform for natural language understanding. In International Conference on Learning Representations, 2019. URL https://openreview. net/forum?id $=$ rJ4km2R5t7.
+
+Zhilin Yang, Zihang Dai, Yiming Yang, Jaime G. Carbonell, Ruslan Salakhutdinov, and Quoc V. Le. Xlnet: Generalized autoregressive pretraining for language understanding. CoRR, abs/1906.08237, 2019. URL http://arxiv.org/abs/1906.08237.
+
+Haonan Yu, Sergey Edunov, Yuandong Tian, and Ari S. Morcos. Playing the lottery with rewards and multiple languages: lottery tickets in RL and NLP. arXiv e-prints, art. arXiv:1906.02768, Jun 2019.
+
+Michael Zhu and Suyog Gupta. To prune, or not to prune: exploring the efficacy of pruning for model compression. arXiv e-prints, art. arXiv:1710.01878, Oct 2017.
+
+# A APPENDIX
+
+<table><tr><td rowspan="2">Pruned</td><td rowspan="2">Pre-train Loss</td><td rowspan="2">MNLI 392k</td><td rowspan="2">QQP 363k</td><td rowspan="2">QNLI 108k</td><td rowspan="2">SST-2 67k</td><td rowspan="2">CoLA 8.5k</td><td rowspan="2">AVG</td></tr><tr><td></td></tr><tr><td>0</td><td>1.82</td><td>83.1|0.25</td><td>90.5|0.10</td><td>91.1|0.12</td><td>92.1|0.06</td><td>79.1|0.26</td><td>87.2 215.7</td></tr><tr><td>10</td><td>1.82</td><td>83.3|0.21</td><td>90.4|0.10</td><td>91.0j0.12</td><td>91.6|0.07</td><td>79.4|0.30</td><td>87.2| |16.0</td></tr><tr><td>20</td><td>1.83</td><td>83.3|0.24</td><td>90.5|0.11</td><td>91.1|0.11</td><td>91.6|0.05</td><td>79.1|0.30</td><td>87.1 |16.0</td></tr><tr><td>30</td><td>1.86</td><td>83.3|0.23</td><td>90.2|0.12</td><td>90.7|0.12</td><td>91.9|0.06</td><td>79.5|0.31</td><td>87.1 |16.9</td></tr><tr><td>40</td><td>1.93</td><td>83.0|0.25</td><td>90.1|0.12</td><td>90.4|0.12</td><td>91.5|0.06</td><td>78.4|0.23</td><td>86.7 |15.6</td></tr><tr><td>50</td><td>2.03</td><td>82.6|0.27</td><td>89.8|0.13</td><td>90.2|0.13</td><td>90.9|0.07</td><td>77.4|0.30</td><td>86.2j |18.0</td></tr><tr><td>60</td><td>2.25</td><td>81.8|0.32</td><td>89.4|0.16</td><td>89.3 310.16</td><td>91.4|0.07</td><td>75.9|0.44</td><td>85.6/ |23.0</td></tr><tr><td>70</td><td>2.62</td><td>79.5|0.40</td><td>88.6|0.18</td><td>88.4j 40.21</td><td>90.1|0.10</td><td>72.7|0.47</td><td>83.9 |27.1</td></tr><tr><td>80</td><td>3.44</td><td>75.9|0.49</td><td>86.9|0.24</td><td>85.3|0.29</td><td>88.1|0.12</td><td>69.1|0.61</td><td>81.1|34.8</td></tr><tr><td>90</td><td>5.83</td><td>64.8|0.76</td><td>81.1|0.36</td><td>71.7|0.52</td><td>80.3|0.25</td><td>69.1|0.61</td><td>73.4|49.8</td></tr><tr><td></td><td></td><td></td><td>90.60.06</td><td>Information Deletion</td><td>92.1|0.03</td><td></td><td></td></tr><tr><td>0 10</td><td>1.82 1.82</td><td>83.0|0.20 82.8|0.01</td><td>90.5|0.05</td><td>90.0|0.10 90.5|0.09</td><td>92.2|0.05</td><td>80.6|0.18</td><td>87.3|11.6 87.4|07.2</td></tr><tr><td>20</td><td>1.83</td><td>82.9|0.01</td><td>90.5|0.05</td><td>90.5 50.09</td><td>91.510.05</td><td>80.8|0.16</td><td>87.2|07.3</td></tr><tr><td>30</td><td></td><td>82.3|0.01</td><td>90.6|0.04</td><td>90.5|0.10</td><td>90.8|0.05</td><td>80.3|0.16</td><td></td></tr><tr><td>40</td><td>1.86 1.93</td><td>82.2|0.19</td><td>90.5|0.05</td><td>90.1|0.10</td><td>92.0|0.05</td><td>80.0|0.18</td><td>86.9|07.7</td></tr><tr><td>50</td><td>2.03</td><td>82.5|0.19</td><td>90.3|0.05</td><td>90.2 210.10</td><td></td><td>79.0|0.17</td><td>86.7|11.1</td></tr><tr><td>60</td><td>2.25</td><td>81.9|0.20</td><td>90.1|0.05</td><td>89.5 510.10</td><td>91.2|0.05 90.8|0.05</td><td>77.9|0.19</td><td>86.4|11.6</td></tr><tr><td>70</td><td></td><td>80.8|0.01</td><td>90.2|0.01</td><td>88.7|0.10</td><td></td><td>76.4|0.23</td><td>85.7|12.6</td></tr><tr><td>80</td><td>2.62</td><td>78.6|0.01</td><td>89.3|0.02</td><td></td><td>90.3|0.06</td><td>74.4|0.28</td><td>84.9109.3</td></tr><tr><td>90</td><td>3.44</td><td></td><td></td><td>86.0j0.02</td><td>88.8|0.07</td><td>70.0|0.45</td><td>82.5|11.5</td></tr><tr><td></td><td>5.83</td><td>72.9|0.01</td><td>87.5|0.02 Prunedafter]</td><td>76.810.06 ：Downstream</td><td>83.0|0.09 n Fine-tuning</td><td>69.1|0.61</td><td>77.9|15.7</td></tr><tr><td colspan="8"></td></tr><tr><td>0</td><td></td><td>82.60.15</td><td>90.60.06</td><td>90.10.10</td><td>92.10.04</td><td>78.7|0.25</td><td>86.812.0</td></tr><tr><td>10</td><td></td><td>82.9|0.19</td><td>90.6|0.06</td><td>90.3|0.10</td><td>91.6|0.05</td><td>79.0|0.11</td><td>86.9|10.3</td></tr><tr><td>20</td><td></td><td>82.7|0.15</td><td>90.6|0.07</td><td>90.2|0.07</td><td>92.0|0.04</td><td>79.0|0.22</td><td>86.9|10.7</td></tr><tr><td>30</td><td></td><td>82.710.23</td><td>90.4|0.07</td><td>89.710.07</td><td>91.6|0.04</td><td>78.5|0.23</td><td>86.6|12.8</td></tr><tr><td>40</td><td></td><td>82.7|0.25</td><td>90.5|0.11</td><td>89.9j |0.12</td><td>91.7|0.05</td><td>78.8|0.17</td><td>86.7|13.9</td></tr><tr><td>50</td><td></td><td>82.6|0.19</td><td>90.3|0.08</td><td>89.7|0.11</td><td>90.8|0.06</td><td>78.0|0.22</td><td>86.3|13.0</td></tr><tr><td>60</td><td></td><td>81.8|0.22</td><td>90.2|0.10</td><td>89.3|0.12</td><td>90.6|0.06</td><td>76.1|0.31</td><td>85.6|16.4</td></tr><tr><td>70</td><td></td><td>80.5|0.30</td><td>89.4|0.14</td><td>86.2|0.19</td><td>88.2|0.07</td><td>69.5|0.58</td><td>82.7|25.8</td></tr><tr><td>80</td><td></td><td>73.7|0.53</td><td>87.8|0.12</td><td>80.4|0.21</td><td>86.4|0.07</td><td>69.1|0.59</td><td>79.5|30.5</td></tr><tr><td>90</td><td></td><td>58.710.86</td><td>82.5|0.26</td><td>65.2|0.52</td><td>81.5|0.16</td><td>69.1|0.61</td><td>71.4|47.9</td></tr><tr><td colspan="8">Random Pruning</td></tr><tr><td>0</td><td>1.82</td><td>83.3|0.26</td><td>90.5|0.10</td><td>90.6|0.15</td><td>92.4|0.07</td><td>78.7|0.18</td><td>87.115.3</td><td></td></tr><tr><td>10</td><td>2.09</td><td>82.0|0.27</td><td>90.1|0.12</td><td>90.3|0.13</td><td>92.3|0.05</td><td>77.0|0.32</td><td>86.3|18.0</td><td>|20.8</td></tr><tr><td>20</td><td>2.46</td><td>80.6|0.32</td><td>89.8|0.12</td><td>88.5|0.14</td><td>91.1|0.07</td><td>73.5|0.39</td><td>84.7</td><td>3|25.9</td></tr><tr><td>30</td><td>2.98</td><td>79.1|0.36 75.4|0.45</td><td>89.2|0.14</td><td>86.9|0.23</td><td>89.3|0.10</td><td>71.8|0.47</td><td>83.3|</td><td>2|30.3</td></tr><tr><td>40</td><td>3.76</td><td></td><td>88.2|0.16</td><td>84.5j 510.23</td><td>88.6|0.09</td><td>69.3|0.57</td><td>81.2</td><td></td></tr><tr><td>50</td><td>4.73</td><td>71.6|0.60</td><td>86.6|0.20</td><td>81.5 50.28</td><td>85.0|0.10</td><td>69.1|0.61</td><td>78.8</td><td>3|35.8</td></tr><tr><td>60</td><td>5.63</td><td>70.4|0.60</td><td>85.2|0.24</td><td>71.7|0.45</td><td>81.5|0.21</td><td>69.1|0.61</td><td>75.6|42.3</td><td></td></tr><tr><td>70</td><td>6.22</td><td>64.1|0.76</td><td>81.4|0.34</td><td>63.0|0.62</td><td>80.6|0.20</td><td>69.1|0.61</td><td></td><td>71.6|50.3</td></tr><tr><td>80</td><td>6.87</td><td>58.8|0.84</td><td>76.6|0.46</td><td>61.1|0.64</td><td>80.610.23</td><td>69.1|0.61</td><td></td><td>69.3|55.6</td></tr><tr><td>90</td><td>7.37</td><td>49.8|0.98</td><td>74.3|0.51</td><td>60.2|0.65</td><td>75.1|0.33</td><td>69.1|0.61</td><td></td><td>65.7|61.4</td></tr></table>
+
+Table 1: Pre-training development losses and GLUE task development accuracies for various levels of pruning. Each development accuracy is accompanied on its right by the achieved training loss, evaluated on the entire training set. Averages are summarized in Figure 1. Pre-training losses are omitted for models pruned after downstream fine-tuning because it is not clear how to measure their performance on the pre-training task in a fair way.
+
+![](images/55986f8fba7bc1db4160373c141b02cf54a91934ee90b50c02b23f2a9a37ad0b.jpg)  
+Figure 5: The sum of weights pruned at each sparsity level for one shot pruning of BERT. Given the motivation for our saliency criterion, it seems strange that such a large magnitude of weights can be pruned without decreasing accuracy.
+
+<table><tr><td>LR</td><td>MNLI</td><td>QQP</td><td>QNL</td><td>SST-2</td><td>CoLA</td></tr><tr><td>2e-5</td><td>1.91 ± 1.81</td><td>1.82 ± 1.72</td><td>1.27 ± 1.22</td><td>1.06 ± 1.03</td><td>0.79 ± 0.77</td></tr><tr><td>3e-5</td><td>2.68 ± 2.51</td><td>2.56 ± 2.40</td><td>1.79 ± 1.69</td><td>1.54 ± 1.47</td><td>1.06 ± 1.03</td></tr><tr><td>4e-5</td><td>3.41 ± 3.18</td><td>3.30 ± 3.10</td><td>2.31 ± 2.19</td><td>1.99 ± 1.89</td><td>1.11 ± 1.09</td></tr><tr><td>5e-5</td><td>4.12 ± 3.83</td><td>4.02 ± 3.74</td><td>2.77 ± 2.62</td><td>2.38 ± 2.29</td><td>1.47 ± 1.43</td></tr></table>
+
+Table 2: We compute the magnitude sorting order of each weight before and after downstream finetuning. If a weight’s original position is $5 9 / 1 0 0$ before fine-tuning and $6 3 / 1 0 0$ after fine-tuning, then that weight moved $4 \%$ in the sorting order. We then list the average movement of weights in each model, along with the standard deviation. Sorting order changes mostly locally across tasks: a weight moves, on average, $0 . 4 \%$ away from its starting position. As expected, larger datasets and larger learning rates have more movement (per epoch). We also see that higher magnitude weights are more stable than lower weights, see Figure 7.
+
+![](images/712d15b2eb41b6c8f90fd047b451f99e97f9bae4c3655c97c43a12ecfc99374c.jpg)  
+Figure 6   
+Figure 7: We show how weight sort order movements are distributed during fine-tuning, given a weight’s starting magnitude. We see that higher magnitude weights are more stable than lower magnitude weights and do not move as much in the sort order. This plot is nearly identical for every model and learning rate, so we only show it once.
+
+![](images/292b9458511a53c32328f5daf5105562b918de0fac28710439ae9fafa9039cdd.jpg)  
+Figure 8: A heatmap of the weight magnitudes of the 12 horizontally stacked self-attention key projection matrices for layer 1. A banding pattern can be seen: the highest values of the matrix tend to cluster in certain attention heads. This pattern appears in most of the self-attention parameter matrices, but it does not cause pruning to prune one head more than another. However, it may prove to be a useful heuristic for attention head pruning, which would not require making many passes over the training data.
+
+![](images/be10eb168c40cd3193e57bffc5edcf0bd0fbdbdcce84dd71ec6ff2d96dca5efd.jpg)  
+Figure 9: A heatmap of the weight magnitudes of BERT’s subword embeddings. Interestingly, pruning BERT embeddings are more interpretable; we can see shorter subwords (top rows) have smaller magnitude values and thus will be pruned earlier than other subword embeddings.
+
+<table><tr><td>Weight Matrix</td><td>Weight Mean</td><td>Weight STD</td></tr><tr><td>embeddings word embeddings</td><td>-0.0282</td><td>0.042</td></tr><tr><td>layer O attention output FC</td><td>-0.0000</td><td>0.029</td></tr><tr><td> layer O self attn key</td><td>0.0000</td><td>0.043</td></tr><tr><td>layer O self attn query</td><td>0.0000</td><td>0.043</td></tr><tr><td>layer O self attn value</td><td>-0.0000</td><td>0.029</td></tr><tr><td>layer O intermediate FC</td><td>-0.0000</td><td>0.037</td></tr><tr><td>layer O output FC</td><td>-0.0012</td><td>0.036</td></tr><tr><td>layer 1 attention output FC</td><td>0.0001</td><td>0.028</td></tr><tr><td>layer 1 self attn key</td><td>0.0000</td><td>0.043</td></tr><tr><td>layer 1 self attn query</td><td>-0.0003</td><td>0.043</td></tr><tr><td>layer 1 self attn value</td><td>-0.0000</td><td>0.029</td></tr><tr><td>layer 1 intermediate FC</td><td>0.0001</td><td>0.039</td></tr><tr><td>layer 1 output FC</td><td>-0.0014</td><td>0.038</td></tr><tr><td>layer 10 attention output FC</td><td>-0.0000</td><td>0.033</td></tr><tr><td>layer 10 self attn key</td><td>-0.0000</td><td>0.046</td></tr><tr><td>layer 10 self attn query</td><td>0.0002</td><td>0.046</td></tr><tr><td>layer 10 self attn value</td><td>-0.0000</td><td>0.036</td></tr><tr><td>layer 10 intermediate FC</td><td>0.0000</td><td>0.039</td></tr><tr><td>layer 10 output FC</td><td>-0.0011</td><td>0.038</td></tr><tr><td>layer 11 attention output FC</td><td>-0.0000</td><td>0.037</td></tr><tr><td> layer 11 self attn key</td><td>0.0002</td><td>0.044</td></tr><tr><td>layer 11 self attn query</td><td>-0.0001</td><td>0.045</td></tr><tr><td>layer 11 self attn value</td><td>-0.0000</td><td>0.039</td></tr><tr><td> layer 11 intermediate FC</td><td>0.0004</td><td>0.039</td></tr><tr><td>layer 11 output FC</td><td>-0.0008</td><td>0.036</td></tr><tr><td>layer 2 attention output FC</td><td>0.0000</td><td>0.027</td></tr><tr><td>layer 2 self attn key</td><td>0.0000</td><td>0.047</td></tr><tr><td>layer 2 self attn query</td><td>0.0000</td><td>0.048</td></tr><tr><td>layer 2 self attn value</td><td>-0.0000</td><td>0.028</td></tr><tr><td>layer 2 intermediate FC</td><td>0.0001</td><td>0.040</td></tr><tr><td>layer 2 output FC</td><td>-0.0015</td><td>0.038</td></tr><tr><td>layer 3 attention output FC</td><td>0.0001</td><td>0.029</td></tr><tr><td>layer 3 self attn key</td><td>0.0000</td><td>0.043</td></tr><tr><td>layer 3 self attn query</td><td>0.0003</td><td>0.043</td></tr><tr><td>layer 3 self attn value</td><td>-0.0001</td><td>0.031</td></tr><tr><td>layer 3 intermediate FC</td><td>-0.0001</td><td>0.040</td></tr><tr><td>layer 3 output FC</td><td>-0.0014</td><td>0.039</td></tr><tr><td>layer 4 attention output FC</td><td>0.0000</td><td>0.033</td></tr><tr><td> layer 4 self attn key</td><td>0.0000</td><td>0.042</td></tr><tr><td>layer 4 self attn query</td><td>-0.0001</td><td>0.042</td></tr><tr><td>layer 4 self attn value</td><td>0.0001</td><td>0.035</td></tr><tr><td>layer 4 intermediate FC</td><td>0.0001</td><td>0.041</td></tr><tr><td>layer 4 output FC</td><td>-0.0014</td><td>0.040</td></tr><tr><td>layer 5 attention output FC</td><td>-0.0000</td><td>0.033</td></tr><tr><td> layer 5 self attn key</td><td>-0.0001</td><td>0.043</td></tr><tr><td>layer 5 self attn query</td><td>-0.0000</td><td>0.043</td></tr><tr><td>layer 5 self attn value</td><td>-0.0000</td><td>0.035</td></tr><tr><td>layer 5 intermediate FC</td><td>0.0000</td><td>0.041</td></tr><tr><td>layer 5 output FC</td><td>-0.0014</td><td>0.039</td></tr></table>
+
+layer 6 attention output FC 0.0001 0.032   
+layer 6 self attn key -0.0000 0.043   
+layer 6 self attn query 0.0001 0.043   
+layer 6 self attn value 0.0000 0.034   
+layer 6 intermediate FC -0.0000 0.041   
+layer 6 output FC -0.0014 0.039   
+layer 7 attention output FC 0.0000 0.032   
+layer 7 self attn key -0.0000 0.044   
+layer 7 self attn query -0.0000 0.044   
+layer 7 self attn value 0.0001 0.033   
+layer 7 intermediate FC 0.0003 0.039   
+layer 7 output FC -0.0013 0.038   
+layer 8 attention output FC 0.0000 0.034   
+layer 8 self attn key -0.0000 0.044   
+layer 8 self attn query 0.0001 0.044   
+layer 8 self attn value 0.0000 0.035   
+layer 8 intermediate FC 0.0004 0.039   
+layer 8 output FC -0.0013 0.037   
+layer 9 attention output FC 0.0001 0.033   
+layer 9 self attn key 0.0000 0.046   
+layer 9 self attn query -0.0001 0.046   
+layer 9 self attn value 0.0000 0.035   
+layer 9 intermediate FC 0.0005 0.040   
+layer 9 output FC -0.0012 0.039   
+pooler FC 0.0000 0.029

parse/train/SJlPOCEKvH/SJlPOCEKvH_content_list.json

@@ -0,0 +1,1404 @@
+[
+    {
+        "type": "text",
+        "text": "COMPRESSING BERT: STUDYING THE EFFECTSOF WEIGHT PRUNING ON TRANSFER LEARNING",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            751,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Universal feature extractors, such as BERT for natural language processing and VGG for computer vision, have become effective methods for improving deep learning models without requiring more labeled data. A common paradigm is to pre-train a feature extractor on large amounts of data then fine-tune it as part of a deep learning model on some downstream task (i.e. transfer learning). While effective, feature extractors like BERT may be prohibitively large for some deployment scenarios. We explore weight pruning for BERT and ask: how does compression during pre-training affect transfer learning? We find that pruning affects transfer learning in three broad regimes. Low levels of pruning $( 3 0 \\% )$ do not affect pre-training loss or transfer to downstream tasks at all. Medium levels of pruning increase the pre-training loss and prevent useful pre-training information from being transferred to downstream tasks. High levels of pruning additionally prevent models from fitting downstream datasets, leading to further degradation. Finally, we observe that fine-tuning BERT on a specific task does not improve its prunability. We conclude that BERT can be pruned once during pre-training rather than separately for each task without affecting performance. ",
+        "bbox": [
+            233,
+            265,
+            764,
+            486
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            510,
+            336,
+            526
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Pre-trained feature extractors, such as BERT (Devlin et al., 2018) for natural language processing and VGG (Simonyan & Zisserman, 2014) for computer vision, have become effective methods for improving the performance of deep learning models. In the last year, models similar to BERT have become state-of-the-art in many NLP tasks, including natural language inference (NLI), named entity recognition (NER), sentiment analysis, etc. These models follow a pre-training paradigm: they are trained on a large amount of unlabeled text via a task that resembles language modeling (Yang et al., 2019; Chan et al., 2019) and are then fine-tuned on a smaller amount of downstream data, which is labeled for a specific task. Pre-trained models usually achieve higher accuracy than any model trained on downstream data alone. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            665
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The pre-training paradigm, while effective, still has some problems. While some claim that language model pre-training is a “universal language learning task” (Radford et al., 2019), there is no theoretical justification for this, only empirical evidence. Second, due to the size of the pre-training dataset, BERT models tend to be slow and require impractically large amounts of GPU memory. BERT-Large can only be used with access to a Google TPU, and BERT-Base requires some optimization tricks such as gradient checkpointing or gradient accumulation to be trained effectively on consumer hardware (Sohoni et al., 2019). Training BERT-Base from scratch costs ${ \\sim } \\$ 7 k$ and emits ${ \\sim } 1 4 3 8$ pounds of $\\mathrm { C O _ { 2 } }$ (Strubell et al., 2019). ",
+        "bbox": [
+            174,
+            672,
+            825,
+            784
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Model compression (Bucila et al., 2006), which attempts to shrink a model without losing accuracy, is a viable approach to decreasing GPU usage. It might also be used to trade accuracy for memory in some low-resource cases, such as deploying to smartphones for real-time prediction. The main questions this paper attempts to answer are: Does compressing BERT impede it’s ability to transfer to new tasks? And does fine-tuning make BERT more or less compressible? ",
+        "bbox": [
+            174,
+            791,
+            823,
+            861
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To explore these questions, we compressed English BERT using magnitude weight pruning (Han et al., 2015) and observed the results on transfer learning to the General Language Understanding Evaluation (GLUE) benchmark (Wang et al., 2019), a diverse set of natural language understanding tasks including sentiment analysis, NLI, and textual similarity evaluation. We chose magnitude weight pruning, which compresses models by removing weights close to 0, because it is one of the most fine-grained and effective compression methods and because there are many interesting ways to view pruning, which we explore in the next section. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our findings are as follows: Low levels of pruning $( 3 0 - 4 0 \\% )$ do not increase pre-training loss or affect transfer to downstream tasks at all. Medium levels of pruning increase the pre-training loss and prevent useful pre-training information from being transferred to downstream tasks. This information is not equally useful to each task; tasks degrade linearly with pre-train loss, but at different rates. High levels of pruning, depending on the size of the downstream dataset, may additionally degrade performance by preventing models from fitting downstream datasets. Finally, we observe that fine-tuning BERT on a specific task does not improve its prunability or change the order of pruning by a meaningful amount. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            263
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To our knowledge, prior work had not shown whether BERT could be compressed in a task-generic way, keeping the benefits of pre-training while avoiding costly experimentation associated with compressing and re-training BERT multiple times. Nor had it shown whether BERT could be overpruned for a memory / accuracy trade-off for deployment to low-resource devices. In this work, we conclude that BERT can be pruned prior to distribution without affecting it’s universality, and that BERT may be over-pruned during pre-training for a reasonable accuracy trade-off for certain tasks. ",
+        "bbox": [
+            174,
+            271,
+            825,
+            354
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PRUNING: COMPRESSION, REGULARIZATION, ARCHITECTURE SEARCH ",
+        "bbox": [
+            171,
+            377,
+            802,
+            395
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Neural network pruning involves examining a trained network and removing parts deemed to be unnecessary by some heuristic saliency criterion. One might remove weights, neurons, layers, channels, attention heads, etc. depending on which heuristic is used. Below, we describe three different lenses through which we might interpret pruning. ",
+        "bbox": [
+            174,
+            411,
+            823,
+            468
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Compression Pruning a neural network decreases the number of parameters required to specify the model, which decreases the disk space required to store it. This allows large models to be deployed on edge computing devices like smartphones. Pruning can also increase inference speed if whole neurons or convolutional channels are pruned, which reduces GPU usage.1 ",
+        "bbox": [
+            174,
+            474,
+            825,
+            530
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Regularization Pruning a neural network also regularizes it. We might consider pruning to be a form of permanent dropout (Molchanov et al., 2017) or a heuristic-based L0 regularizer (Louizos et al., 2018). Through this lens, pruning decreases the complexity of the network and therefore narrows the range of possible functions it can express.2 The main difference between L0 or L1 regularization and weight pruning is that the former induce sparsity via a penalty on the loss function, which is learned during gradient descent via stochastic relaxation. It’s not clear which approach is more principled or preferred. (Gale et al., 2019) ",
+        "bbox": [
+            174,
+            537,
+            825,
+            636
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Sparse Architecture Search Finally, we can view neural network pruning as a type of sparse architecture search. Liu et al. (2019b) and Frankle & Carbin (2019) show that they can train carefully re-initialized pruned architectures to similar performance levels as dense networks. Under this lens, stochastic gradient descent (SGD) induces network sparsity, and pruning simply makes that sparsity explicit. These sparse architectures, along with the appropriate initializations, are sometimes referred to as lottery tickets.3 ",
+        "bbox": [
+            174,
+            642,
+            825,
+            726
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 MAGNITUDE WEIGHT PRUNING",
+        "text_level": 1,
+        "bbox": [
+            176,
+            746,
+            434,
+            760
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we focus on weight magnitude pruning because it is one of the most fine-grained and effective pruning methods. It also has a compelling saliency criterion (Han et al., 2015): if a weight is close to zero, then its input is effectively ignored, which means the weight can be pruned. ",
+        "bbox": [
+            174,
+            773,
+            825,
+            815
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Magnitude weight pruning itself is a simple procedure: 1. Pick a target percentage of weights to be pruned, say $50 \\%$ . 2. Calculate a threshold such that $50 \\%$ of weight magnitudes are under that threshold. 3. Remove those weights. 4. Continue training the network to recover any lost accuracy. 5. Optionally, return to step 1 and increase the percentage of weights pruned. This procedure is conveniently implemented in a Tensorflow (Abadi et al., 2016) package4, which we use (Zhu & Gupta, 2017). ",
+        "bbox": [
+            174,
+            103,
+            823,
+            188
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Calculating a threshold and pruning can be done for all network parameters holistically (global pruning) or for each weight matrix individually (matrix-local pruning). Both methods will prune to the same sparsity, but in global pruning the sparsity might be unevenly distributed across weight matrices. We use matrix-local pruning because it is more popular in the community.5 For information on other pruning techniques, we recommend Gale et al. (2019) and Liu et al. (2019b). ",
+        "bbox": [
+            174,
+            194,
+            825,
+            263
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            286,
+            398,
+            303
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "BERT is a large Transformer encoder; for background, we refer readers to Vaswani et al. (2017) or one of these excellent tutorials (Alammar, 2018; Klein et al., 2017). ",
+        "bbox": [
+            174,
+            320,
+            823,
+            348
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 IMPLEMENTING BERT PRUNING ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            367,
+            442,
+            382
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "BERT-Base consists of 12 encoder layers, each of which contains 6 prunable matrices: 4 for the multi-headed self-attention and 2 for the layer’s output feed-forward network. ",
+        "bbox": [
+            176,
+            395,
+            823,
+            422
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Recall that self-attention first projects layer inputs into key, query, and value embeddings via linear projections. While there is a separate key, query, and value projection matrix for each attention head, implementations typically stack matrices from each attention head, resulting in only 3 parameter matrices: one for key projections, one for value projections, and one for query projections. We prune each of these matrices separately, calculating a threshold for each. We also prune the linear output projection, which combines outputs from each attention head into a single embedding.6 ",
+        "bbox": [
+            174,
+            430,
+            825,
+            513
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We prune word embeddings in the same way we prune feed-foward networks and self-attention parameters.7 The justification is similar: if a word embedding value is close to zero, we can assume it’s zero and store the rest in a sparse matrix. This is useful because token / subword embeddings tend to account for a large portion of a natural language model’s memory. In BERT-Base specifically, the embeddings account for ${ \\sim } 2 1 \\%$ of the model’s memory. ",
+        "bbox": [
+            174,
+            521,
+            823,
+            590
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our experimental code for pruning BERT, based on the public BERT repository, is available here.8 ",
+        "bbox": [
+            173,
+            597,
+            816,
+            612
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 PRUNING DURING PRE-TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            631,
+            450,
+            646
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We perform weight magnitude pruning on a pre-trained BERT-Base model.9 We select sparsities from $0 \\%$ to $90 \\%$ in increments of $10 \\%$ and gradually prune BERT to this sparsity over the first 10k steps of training. We continue pre-training on English Wikipedia and BookCorpus for another 90k steps to regain any lost accuracy.10 The resulting pre-training losses are shown in Table 1. ",
+        "bbox": [
+            174,
+            659,
+            823,
+            715
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We then fine-tune these pruned models on tasks from the General Language Understanding Evaluation (GLUE) benchmark, which is a standard set of 9 tasks that include sentiment analysis, natural language inference, etc. We avoid WNLI, which is known to be problematic.11 We also avoid tasks with less than 5k training examples because the results tend to be noisy (RTE, MRPC, STS-B). We fine-tune a separate model on each of the remaining 5 GLUE tasks for 3 epochs and try 4 learning rates: $[ 2 , 3 , 4 , 5 ] \\times 1 0 ^ { - 5 }$ . The best evaluation accuracies are averaged and plotted in Figure 1. Individual task results are in Table 1. ",
+        "bbox": [
+            176,
+            722,
+            825,
+            750
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "BERT can be used as a static feature-extractor or as a pre-trained model which is fine-tuned end-toend. In all experiments, we fine-tune weights in all layers of BERT on downstream tasks. ",
+        "bbox": [
+            171,
+            180,
+            823,
+            208
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 DISENTANGLING COMPLEXITY RESTRICTION AND INFORMATION DELETION",
+        "text_level": 1,
+        "bbox": [
+            176,
+            228,
+            745,
+            243
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Pruning involves two steps: it deletes the information stored in a weight by setting it to 0 and then regularizes the model by preventing that weight from changing during further training. ",
+        "bbox": [
+            173,
+            256,
+            823,
+            285
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To disentangle these two effects (model complexity restriction and information deletion), we repeat the experiments from Section 3.2 with an identical pre-training setup, but instead of pruning we simply set the weights to 0 and allow them to vary during downstream training. This deletes the pre-training information associated with the weight but does not prevent the model from fitting downstream datasets by keeping the weight at zero during downstream training. We also fine-tune on downstream tasks until training loss becomes comparable to models with no pruning. We trained most models for 13 epochs rather than 3. Models with $70 – 9 0 \\%$ information deletion required 15 epochs to fit the training data. The results are also included in Figure 1 and Table 1. ",
+        "bbox": [
+            174,
+            291,
+            825,
+            404
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.4 PRUNING AFTER DOWNSTREAM FINE-TUNING",
+        "text_level": 1,
+        "bbox": [
+            176,
+            422,
+            537,
+            438
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We might expect that BERT would be more compressible after downstream fine-tuning. Intuitively, the information needed for downstream tasks is a subset of the information learned during pretraining; some tasks require more semantic information than syntactic, and vice-versa. We should be able to discard the “extra” information and only keep what we need for, say, parsing (Li & Eisner, 2019). ",
+        "bbox": [
+            174,
+            450,
+            825,
+            520
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For magnitude weight pruning specifically, we might expect downstream training to change the distribution of weights in the parameter matrices. This, in turn, changes the sort-order of the absolute values of those weights, which changes the order that we prune them in. This new pruning order, hypothetically, would be less degrading to our specific downstream task. ",
+        "bbox": [
+            174,
+            527,
+            823,
+            583
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To test this, we fine-tuned pre-trained BERT-Base on downstream data for 3 epochs. We then pruned at various sparsity levels and continued training for 5 more epochs (7 for $80 \\%$ sparsity), at which point the training losses became comparable to those of models pruned during pre-training. We repeat this for learning rates in $[ 2 , 3 , \\dot { 4 } , 5 ] \\times 1 0 ^ { - 5 }$ and show the results with the best development accuracy in Figure 1 / Table 1. We also measure the difference in which weights are selected for pruning during pre-training vs. downstream fine-tuning and plot the results in Figure 3. ",
+        "bbox": [
+            174,
+            590,
+            825,
+            674
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 PRUNING REGIMES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            698,
+            366,
+            713
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 $30 \\%$ OF WEIGHTS ARE NOT USEFUL",
+        "text_level": 1,
+        "bbox": [
+            174,
+            731,
+            493,
+            746
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 shows that the first $3 0 { - } 4 0 \\%$ of weights pruned by magnitude weight pruning do not impact pre-training loss or inference on any downstream task. These weights can be pruned either before or after fine-tuning. This makes sense from the perspective of pruning as sparse architecture search: when we initialize BERT-Base, we initialize many possible subnetworks. SGD selects the best one for pre-training and pushes the rest of the weights to 0. We can then prune those weights without affecting the output of the network.12 ",
+        "bbox": [
+            173,
+            758,
+            825,
+            842
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/126a8d6285a5aa1c9b3ddfd023b21b476c6ebdfb913e2c76911696e4c101bcd5.jpg",
+        "image_caption": [
+            "Figure 1: (Blue) The best GLUE dev accuracy and training losses for models pruned during pretraining, averaged over 5 tasks. Also shown are models with information deletion during pre-training (orange), models pruned after downstream fine-tuning (green), and models pruned randomly during pre-training instead of by lowest magnitude (red). $3 0 { - } 4 0 \\%$ of weights can be pruned using magnitude weight pruning without decreasing dowsntream accuracy. Notice that information deletion fits the training data better than un-pruned models at all sparsity levels but does not fully recover evaluation accuracy. Also, models pruned after downstream fine-tuning have the same or worse development accuracy, despite achieving lower training losses. Note: none of the pruned models are overfitting because un-pruned models have the lowest training loss and the highest development accuracy. While the results for individual tasks are in Table 1, each task does not vary much from the average trend, with an exception discussed in Section 4.3. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            159,
+            776,
+            324
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/eb29624447852c44f05ab4d7dd759d35fbf8b8b78deaedbbcee992c9991959f4.jpg",
+        "image_caption": [
+            "Figure 2: (Left) Pre-training loss predicts information deletion GLUE accuracy linearly as sparsity increases. We believe the slope of each line tells us how much a bit of BERT is worth to each task. (CoLA at $90 \\%$ is excluded from the line of best fit.) (Right) The cosine similarities of features extracted for a subset of the pre-training development data before and after pruning. Features are extracted from activations of all 12 layers of BERT and compared layer-wise to a model that has not been pruned. As performance degrades, cosine similarities of features decreases. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            604,
+            799,
+            772
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 MEDIUM PRUNING LEVELS PREVENT INFORMATION TRANSFER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            658,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Past $40 \\%$ pruning, performance starts to degrade. Pre-training loss increases as we prune weights necessary for fitting the pre-training data (Table 1). Feature activations of the hidden layers start to diverge from models with low levels of pruning (Figure 2).13 Downstream accuracy also begins to degrade at this point. ",
+        "bbox": [
+            174,
+            131,
+            823,
+            185
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Why does pruning at these levels hurt downstream performance? On one hand, pruning deletes pretraining information by setting weights to 0, preventing the transfer of the useful inductive biases learned during pre-training. On the other hand, pruning regularizes the model by keeping certain weights at zero, which might prevent fitting downstream datasets. ",
+        "bbox": [
+            174,
+            193,
+            825,
+            248
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 and Table 1 show information deletion is the main cause of performance degradation between $40 \\text{‰}$ sparsity, since pruning and information deletion degrade models by the same amount. Information deletion would not be a problem if pre-training and downstream datasets contained similar information. However, pre-training is effective precisely because the pre-training dataset is much larger than the labeled downstream dataset, which allows learning of more robust representations. ",
+        "bbox": [
+            174,
+            256,
+            825,
+            339
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We see that the main obstacle to compressing pre-trained models is maintaining the inductive bias of the model learned during pre-training. Encoding this bias requires many more weights than fitting downstream datasets, and it cannot be recovered due to a fundamental information gap between pre-training and downstream datasets.14 The amount a model can be pruned is limited by the largest dataset the model has been trained on: in this case, the pre-training dataset. Practitioners should be aware of this; pruning may subtly harm downstream generalization without affecting training loss. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            430
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 HIGH PRUNING LEVELS ALSO PREVENT FITTING DOWNSTREAM DATASETS",
+        "bbox": [
+            176,
+            449,
+            738,
+            463
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "At $70 \\%$ sparsity and above, models with information deletion recover some accuracy w.r.t. pruned models, so complexity restriction is a secondary cause of performance degradation. However, these models do not recover all evaluation accuracy, despite matching un-pruned model’s training loss. ",
+        "bbox": [
+            176,
+            474,
+            825,
+            517
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1 shows that on the MNLI and QQP tasks, which have the largest amount of training data, information deletion performs much better than pruning. In contrast, models do not recover as well on SST-2 and CoLA, which have less data. We believe this is because the larger datasets require larger models to fit, so complexity restriction becomes an issue earlier. ",
+        "bbox": [
+            174,
+            523,
+            825,
+            580
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We might be concerned that poorly performing models are over-fitting, since they have lower training losses than unpruned models. But the best performing information-deleted models have the lowest training error of all, so overfitting seems unlikely.15 ",
+        "bbox": [
+            174,
+            588,
+            825,
+            630
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.4 HOW MUCH IS A BIT OF BERT WORTH? ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            648,
+            503,
+            662
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We’ve seen that over-pruning BERT deletes information useful for downstream tasks. Is this information equally useful to all tasks? We might consider the pre-training loss as a proxy for how much pre-training information we’ve deleted in total. Similarly, the performance of information-deletion models is a proxy for how much of that information was useful for each task. Figure 2 shows that the pre-training loss linearly predicts the effects of information deletion on downstream accuracy. ",
+        "bbox": [
+            174,
+            674,
+            825,
+            744
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For every bit of information we delete from BERT, it appears only a fraction is useful for CoLA, and an even smaller fraction useful for QQP.16 This relationship should be taken into account when considering the memory $/$ accuracy trade-off of over-pruning. Pruning an extra $30 \\%$ of BERT’s weights is worth only one accuracy point on QQP but 10 points on CoLA. It’s unclear, however, whether this is because the pre-training task is less relevant to QQP or whether QQP simply has a bigger dataset with more information content.17 ",
+        "bbox": [
+            174,
+            752,
+            823,
+            780
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/bba4d7a4c01c881257682f6fa81c9e8169f1f458be950922f1b0282621640535.jpg",
+        "image_caption": [
+            "Figure 3: (Left) The measured difference in pruning masks between models pruned during pretraining and models pruned during downstream fine-tuning. As predicted, the differences are less than $6 \\%$ , since fine-tuning only changes the magnitude sorting order of weights locally, not globally. (Right) The average GLUE development accuracy and pruning mask difference for models trained on downstream datasets before pruning $60 \\%$ at learning rate 5e-5. After pruning, models are trained for an additional 2 epochs to regain accuracy. We see that training between 3 and 12 epochs before pruning does not change which weights are pruned or improve performance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            111,
+            799,
+            277
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            419,
+            825,
+            474
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 DOWNSTREAM FINE-TUNING DOES NOT IMPROVE PRUNABILITY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            494,
+            743,
+            511
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Since pre-training information deletion plays a central role in performance degradation while overpruning, we might expect that downstream fine-tuning would improve prunability by making important weights more salient (increasing their magnitude). However, Figure 1 shows that models pruned after downstream fine-tuning do not surpass the development accuracies of models pruned during pre-training, despite achieving similar training losses. Figure 3 shows fine-tuning changes which weights are pruned by less than $6 \\%$ . ",
+        "bbox": [
+            174,
+            527,
+            823,
+            611
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Why doesn’t fine-tuning change which weights are pruned much? Table 2 shows that the magnitude sorting order of weights is mostly preserved; weights move on average $0 . 4 \\%$ away from their starting positions in the sort order. We also see that high magnitude weights are more stable than lower ones (Figure 7). ",
+        "bbox": [
+            174,
+            618,
+            825,
+            674
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our experiments suggest that training on downstream data before pruning is too blunt an instrument to improve prunability. Even so, we might consider simply training on the downstream tasks for much longer, which would increase the difference in weights pruned. However, Figure 4 shows that even after an epoch of downstream fine-tuning, weights quickly re-stabilize in a new sorting order, meaning longer downstream training will have only a marginal effect on which weights are pruned. Indeed, Figure 3 shows that the weights selected for $60 \\%$ pruning quickly stabilize and evaluation accuracy does not improve with more training before pruning. ",
+        "bbox": [
+            174,
+            681,
+            825,
+            779
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            799,
+            344,
+            815
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Compressing BERT for Specific Tasks Section 5 showed that downstream fine-tuning does not increase prunability. However, several alternative compression approaches have been proposed to discard non-task-specific information. Li & Eisner (2019) used an information bottleneck to discard non-syntactic information. Tang et al. (2019) used BERT as a knowledge distillation teacher to compress relevant information into smaller Bi-LSTMs, while Kuncoro et al. (2019) took a similar distillation approach. While fine-tuning does not increase prunability, task-specific knowledge might be extracted from BERT with other methods. ",
+        "bbox": [
+            174,
+            830,
+            823,
+            887
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/9db120c5dae01a2a9a43e7edf5bfc48741670d1eb6ca6cc5e39314ed571749f6.jpg",
+        "image_caption": [
+            "Figure 4: (Left) The average, min, and max percentage of individual attention heads pruned at each sparsity level. We see at $60 \\%$ sparsity, each attention head individually is pruned strictly between $55 \\%$ and $65 \\%$ . (Right) We compute the magnitude sorting order of each weight before and after downstream fine-tuning. If a weight’s original position is $5 9 / 1 0 0$ before fine-tuning and $6 3 / 1 0 0$ after fine-tuning, then that weight moved $4 \\%$ in the sorting order. After even an epoch of downstream fine-tuning, weights quickly stabilize in a new sorting order which is not far from the original sorting order. Variances level out similarly. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            111,
+            782,
+            277
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            421,
+            825,
+            463
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Attention Head Pruning Voita et al. (2019) previously showed redundancy in transformer models by pruning entire attention heads. Michel et al. (2019) showed that after fine-tuning on MNLI, up to $40 \\%$ of attention heads can be pruned from BERT without affecting test accuracy. They show redundancy in BERT after fine-tuning on a single downstream task; in contrast, our work emphasizes the interplay between compression and transfer learning to many tasks, pruning both before and after fine-tuning. Also, magnitude weight pruning allows us to additionally prune the feed-foward networks and sub-word embeddings in BERT (not just self-attention), which account for ${ \\sim } 7 2 \\%$ of BERT’s total memory usage. ",
+        "bbox": [
+            174,
+            469,
+            825,
+            582
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We suspect that attention head pruning and weight pruning remove different redundancies from BERT. Figure 4 shows that weight pruning does not prune any specific attention head much more than the pruning rate for the whole model. It is not clear, however, whether weight pruning and recovery training makes attention heads less prunable by distributing functionality to unused heads. ",
+        "bbox": [
+            174,
+            588,
+            825,
+            645
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            666,
+            495,
+            683
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We’ve shown that encoding BERT’s inductive bias requires many more weights than are required to fit downstream data. Future work on compressing pre-trained models should focus on maintaining that inductive bias and quantifying its relevance to various tasks during accuracy/memory trade-offs. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            742
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For magnitude weight pruning, we’ve shown that $3 0 { - } 4 0 \\%$ of the weights do not encode any useful inductive bias and can be discarded without affecting BERT’s universality. The relevance of the rest of the weights vary from task to task, and fine-tuning on downstream tasks does not change the nature of this trade-off by changing which weights are pruned. In future work, we will investigate the factors that influence language modeling’s relevance to downstream tasks and how to improve compression in a task-general way. ",
+        "bbox": [
+            173,
+            750,
+            823,
+            833
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "It’s reasonable to believe that these conclusions will generalize to other pre-trained language models such as Kermit (Chan et al., 2019), XLNet (Yang et al., 2019), GPT-2 (Radford et al., 2019), RoBERTa (Liu et al., 2019a) or ELMO (Peters et al., 2018). All of these learn some variant of language modeling, and most use Transformer architectures. While it remains to be shown in future work, viewing pruning as architecture search implies these models will be prunable due to the training dynamics inherent to neural networks. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            285,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Gregory S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian J. Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz ´ Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Mane, Rajat Monga, Sherry Moore, Derek Gor- ´ don Murray, Chris Olah, Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul A. Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda B. Viegas, Oriol Vinyals, ´ Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. CoRR, abs/1603.04467, 2016. URL http://arxiv.org/abs/1603.04467. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            251
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jay Alammar. The illustrated transformer, 2018. URL http://jalammar.github.io/ illustrated-transformer/. ",
+        "bbox": [
+            171,
+            258,
+            821,
+            287
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sanjeev Arora, Rong Ge, Behnam Neyshabur, and Yi Zhang. Stronger generalization bounds for deep nets via a compression approach. CoRR, abs/1802.05296, 2018. URL http://arxiv. org/abs/1802.05296. ",
+        "bbox": [
+            173,
+            296,
+            823,
+            338
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mikhail Belkin, Daniel Hsu, Siyuan Ma, and Soumik Mand al. Reconciling modern machine learning practice and the bias-variance trade-off. arXiv e-prints, art. arXiv:1812.11118, Dec 2018. ",
+        "bbox": [
+            171,
+            345,
+            820,
+            376
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Cristian Bucila, Rich Caruana, and Alexandru Niculescu-Mizil. Model compression. In Proceedings of the Twelfth ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, Philadelphia, PA, USA, August 20-23, 2006, pp. 535–541, 2006. doi: 10.1145/1150402. 1150464. URL https://doi.org/10.1145/1150402.1150464. ",
+        "bbox": [
+            173,
+            382,
+            825,
+            440
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "William Chan, Nikita Kitaev, Kelvin Guu, Mitchell Stern, and Jakob Uszkoreit. KERMIT: generative insertion-based modeling for sequences. CoRR, abs/1906.01604, 2019. URL http: //arxiv.org/abs/1906.01604. ",
+        "bbox": [
+            174,
+            448,
+            821,
+            491
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tim Dettmers and Luke S. Zettlemoyer. Sparse networks from scratch: Faster training without losing performance. ArXiv, abs/1907.04840, 2019. ",
+        "bbox": [
+            173,
+            498,
+            821,
+            527
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. CoRR, abs/1810.04805, 2018. ",
+        "bbox": [
+            173,
+            535,
+            823,
+            564
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Utku Evci, Fabian Pedregosa, Aidan N. Gomez, and Erich Elsen. The difficulty of training sparse neural networks. CoRR, abs/1906.10732, 2019. URL http://arxiv.org/abs/1906. 10732. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            614
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In International Conference on Learning Representations, 2019. URL https:// openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ rJl-b3RcF7. ",
+        "bbox": [
+            174,
+            623,
+            825,
+            665
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Trevor Gale, Erich Elsen, and Sara Hooker. The state of sparsity in deep neural networks. CoRR, abs/1902.09574, 2019. URL http://arxiv.org/abs/1902.09574. ",
+        "bbox": [
+            174,
+            674,
+            825,
+            703
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett (eds.), Advances in Neural Information Processing Systems 28, pp. 1135– 1143. Curran Associates, Inc., 2015. URL http://papers.nips.cc/paper/ 5784-learning-both-weights-and-connections-for-efficient-neural-network. pdf. ",
+        "bbox": [
+            173,
+            710,
+            900,
+            794
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Xingyu Liu, Huizi Mao, Jing Pu, Ardavan Pedram, Mark A. Horowitz, and William J. Dally. Eie: Efficient inference engine on compressed deep neural network. In Proceedings of the 43rd International Symposium on Computer Architecture, ISCA ’16, pp. 243–254, Piscataway, NJ, USA, 2016. IEEE Press. ISBN 978-1-4673-8947-1. doi: 10.1109/ISCA.2016.30. URL https://doi.org/10.1109/ISCA.2016.30. ",
+        "bbox": [
+            174,
+            803,
+            825,
+            873
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks, Kimin Lee, and Mantas Mazeika. Using pre-training can improve model robustness and uncertainty. In ICML, pp. 2712–2721, 2019. URL http://proceedings.mlr. press/v97/hendrycks19a.html. ",
+        "bbox": [
+            174,
+            882,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Klein, Yoon Kim, Yuntian Deng, Jean Senellart, and Alexander M. Rush. Opennmt: Open-source toolkit for neural machine translation. In Proc. ACL, 2017. doi: 10.18653/v1/ P17-4012. URL https://doi.org/10.18653/v1/P17-4012. ",
+        "bbox": [
+            178,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adhiguna Kuncoro, Chris Dyer, Laura Rimell, Stephen Clark, and Phil Blunsom. Scalable syntaxaware language models using knowledge distillation. CoRR, abs/1906.06438, 2019. URL http: //arxiv.org/abs/1906.06438. ",
+        "bbox": [
+            176,
+            156,
+            820,
+            199
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiang Lisa Li and Jason Eisner. Specializing word embeddings (for parsing) by information bottleneck. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and 9th International Joint Conference on Natural Language Processing, Hong Kong, November 2019. URL http://cs.jhu.edu/˜jason/papers/#li-eisner-2019. ",
+        "bbox": [
+            173,
+            208,
+            825,
+            266
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized BERT pretraining approach. CoRR, abs/1907.11692, 2019a. URL http://arxiv.org/abs/1907.11692. ",
+        "bbox": [
+            176,
+            275,
+            821,
+            319
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhuang Liu, Mingjie Sun, Tinghui Zhou, Gao Huang, and Trevor Darrell. Rethinking the value of network pruning. In International Conference on Learning Representations, 2019b. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ rJlnB3C5Ym. ",
+        "bbox": [
+            174,
+            328,
+            823,
+            372
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christos Louizos, Max Welling, and Diederik P. Kingma. Learning sparse neural networks through l0 regularization. In International Conference on Learning Representations, 2018. URL https: //openreview.net/forum?id ${ . } = { }$ H1Y8hhg0b. ",
+        "bbox": [
+            174,
+            381,
+            821,
+            424
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Paul Michel, Omer Levy, and Graham Neubig. Are sixteen heads really better than one? ArXiv, abs/1905.10650, 2019. ",
+        "bbox": [
+            173,
+            434,
+            821,
+            463
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dmitry Molchanov, Arsenii Ashukha, and Dmitry Vetrov. Variational dropout sparsifies deep neural networks. In Proceedings of the 34th International Conference on Machine Learning - Volume 70, ICML’17, pp. 2498–2507. JMLR.org, 2017. URL http://dl.acm.org/citation. cfm?id=3305890.3305939. ",
+        "bbox": [
+            173,
+            472,
+            825,
+            530
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ari S. Morcos, Haonan Yu, Michela Paganini, and Yuand ong Tian. One ticket to win them all: generalizing lottery ticket initializations across datasets and optimizers. arXiv e-prints, art. arXiv:1906.02773, Jun 2019. ",
+        "bbox": [
+            171,
+            540,
+            823,
+            582
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hesham Mostafa and Xin Wang. Parameter efficient training of deep convolutional neural networks by dynamic sparse reparameterization, 2019. URL https://openreview.net/forum? id=S1xBioR5KX. ",
+        "bbox": [
+            173,
+            592,
+            823,
+            635
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthew E. Peters, Mark Neumann, Mohit Iyyer, Matt Gardner, Christopher Clark, Kenton Lee, and Luke Zettlemoyer. Deep contextualized word representations. CoRR, abs/1802.05365, 2018. URL http://arxiv.org/abs/1802.05365. ",
+        "bbox": [
+            173,
+            645,
+            826,
+            688
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Jeff Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. Language models are unsupervised multitask learners. 2019. ",
+        "bbox": [
+            173,
+            696,
+            823,
+            727
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very Deep Convolutional Networks for Large-Scale Image Recognition. arXiv e-prints, art. arXiv:1409.1556, Sep 2014. ",
+        "bbox": [
+            171,
+            736,
+            825,
+            766
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nimit Sharad Sohoni, Christopher Richard Aberger, Megan Leszczynski, Jian Zhang, and Christopher Re. Low-memory neural network training: A technical report. ´ CoRR, abs/1904.10631, 2019. URL http://arxiv.org/abs/1904.10631. ",
+        "bbox": [
+            176,
+            775,
+            823,
+            819
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Emma Strubell, Ananya Ganesh, and Andrew McCallum. Energy and policy considerations for deep learning in NLP. CoRR, abs/1906.02243, 2019. URL http://arxiv.org/abs/1906. 02243. ",
+        "bbox": [
+            173,
+            828,
+            823,
+            871
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Raphael Tang, Yao Lu, Linqing Liu, Lili Mou, Olga Vechtomova, and Jimmy Lin. Distilling taskspecific knowledge from BERT into simple neural networks. CoRR, abs/1903.12136, 2019. URL http://arxiv.org/abs/1903.12136. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yuandong Tian, Tina Jiang, Qucheng Gong, and Ari S. Morcos. Luck matters: Understanding training dynamics of deep relu networks. CoRR, abs/1905.13405, 2019. URL http://arxiv. org/abs/1905.13405. ",
+        "bbox": [
+            174,
+            103,
+            821,
+            145
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. CoRR, abs/1706.03762, 2017. URL http://arxiv.org/abs/1706.03762. ",
+        "bbox": [
+            178,
+            155,
+            823,
+            196
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Elena Voita, David Talbot, Fedor Moiseev, Rico Sennrich, and Ivan Titov. Analyzing multi-head self-attention: Specialized heads do the heavy lifting, the rest can be pruned. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pp. 5797–5808, Florence, Italy, July 2019. Association for Computational Linguistics. doi: 10.18653/v1/P19-1580. URL https://www.aclweb.org/anthology/P19-1580. ",
+        "bbox": [
+            173,
+            207,
+            826,
+            277
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. GLUE: A multi-task benchmark and analysis platform for natural language understanding. In International Conference on Learning Representations, 2019. URL https://openreview. net/forum?id $=$ rJ4km2R5t7. ",
+        "bbox": [
+            173,
+            285,
+            825,
+            342
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhilin Yang, Zihang Dai, Yiming Yang, Jaime G. Carbonell, Ruslan Salakhutdinov, and Quoc V. Le. Xlnet: Generalized autoregressive pretraining for language understanding. CoRR, abs/1906.08237, 2019. URL http://arxiv.org/abs/1906.08237. ",
+        "bbox": [
+            176,
+            351,
+            821,
+            393
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Haonan Yu, Sergey Edunov, Yuandong Tian, and Ari S. Morcos. Playing the lottery with rewards and multiple languages: lottery tickets in RL and NLP. arXiv e-prints, art. arXiv:1906.02768, Jun 2019. ",
+        "bbox": [
+            174,
+            402,
+            823,
+            444
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael Zhu and Suyog Gupta. To prune, or not to prune: exploring the efficacy of pruning for model compression. arXiv e-prints, art. arXiv:1710.01878, Oct 2017. ",
+        "bbox": [
+            171,
+            454,
+            823,
+            483
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            299,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/8d23fca893dec1edeb44c6e5f2c6594c2410ce738b08685589154adc1329e0e5.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Pruned</td><td rowspan=\"2\">Pre-train Loss</td><td rowspan=\"2\">MNLI 392k</td><td rowspan=\"2\">QQP 363k</td><td rowspan=\"2\">QNLI 108k</td><td rowspan=\"2\">SST-2 67k</td><td rowspan=\"2\">CoLA 8.5k</td><td rowspan=\"2\">AVG</td></tr><tr><td></td></tr><tr><td>0</td><td>1.82</td><td>83.1|0.25</td><td>90.5|0.10</td><td>91.1|0.12</td><td>92.1|0.06</td><td>79.1|0.26</td><td>87.2 215.7</td></tr><tr><td>10</td><td>1.82</td><td>83.3|0.21</td><td>90.4|0.10</td><td>91.0j0.12</td><td>91.6|0.07</td><td>79.4|0.30</td><td>87.2| |16.0</td></tr><tr><td>20</td><td>1.83</td><td>83.3|0.24</td><td>90.5|0.11</td><td>91.1|0.11</td><td>91.6|0.05</td><td>79.1|0.30</td><td>87.1 |16.0</td></tr><tr><td>30</td><td>1.86</td><td>83.3|0.23</td><td>90.2|0.12</td><td>90.7|0.12</td><td>91.9|0.06</td><td>79.5|0.31</td><td>87.1 |16.9</td></tr><tr><td>40</td><td>1.93</td><td>83.0|0.25</td><td>90.1|0.12</td><td>90.4|0.12</td><td>91.5|0.06</td><td>78.4|0.23</td><td>86.7 |15.6</td></tr><tr><td>50</td><td>2.03</td><td>82.6|0.27</td><td>89.8|0.13</td><td>90.2|0.13</td><td>90.9|0.07</td><td>77.4|0.30</td><td>86.2j |18.0</td></tr><tr><td>60</td><td>2.25</td><td>81.8|0.32</td><td>89.4|0.16</td><td>89.3 310.16</td><td>91.4|0.07</td><td>75.9|0.44</td><td>85.6/ |23.0</td></tr><tr><td>70</td><td>2.62</td><td>79.5|0.40</td><td>88.6|0.18</td><td>88.4j 40.21</td><td>90.1|0.10</td><td>72.7|0.47</td><td>83.9 |27.1</td></tr><tr><td>80</td><td>3.44</td><td>75.9|0.49</td><td>86.9|0.24</td><td>85.3|0.29</td><td>88.1|0.12</td><td>69.1|0.61</td><td>81.1|34.8</td></tr><tr><td>90</td><td>5.83</td><td>64.8|0.76</td><td>81.1|0.36</td><td>71.7|0.52</td><td>80.3|0.25</td><td>69.1|0.61</td><td>73.4|49.8</td></tr><tr><td></td><td></td><td></td><td>90.60.06</td><td>Information Deletion</td><td>92.1|0.03</td><td></td><td></td></tr><tr><td>0 10</td><td>1.82 1.82</td><td>83.0|0.20 82.8|0.01</td><td>90.5|0.05</td><td>90.0|0.10 90.5|0.09</td><td>92.2|0.05</td><td>80.6|0.18</td><td>87.3|11.6 87.4|07.2</td></tr><tr><td>20</td><td>1.83</td><td>82.9|0.01</td><td>90.5|0.05</td><td>90.5 50.09</td><td>91.510.05</td><td>80.8|0.16</td><td>87.2|07.3</td></tr><tr><td>30</td><td></td><td>82.3|0.01</td><td>90.6|0.04</td><td>90.5|0.10</td><td>90.8|0.05</td><td>80.3|0.16</td><td></td></tr><tr><td>40</td><td>1.86 1.93</td><td>82.2|0.19</td><td>90.5|0.05</td><td>90.1|0.10</td><td>92.0|0.05</td><td>80.0|0.18</td><td>86.9|07.7</td></tr><tr><td>50</td><td>2.03</td><td>82.5|0.19</td><td>90.3|0.05</td><td>90.2 210.10</td><td></td><td>79.0|0.17</td><td>86.7|11.1</td></tr><tr><td>60</td><td>2.25</td><td>81.9|0.20</td><td>90.1|0.05</td><td>89.5 510.10</td><td>91.2|0.05 90.8|0.05</td><td>77.9|0.19</td><td>86.4|11.6</td></tr><tr><td>70</td><td></td><td>80.8|0.01</td><td>90.2|0.01</td><td>88.7|0.10</td><td></td><td>76.4|0.23</td><td>85.7|12.6</td></tr><tr><td>80</td><td>2.62</td><td>78.6|0.01</td><td>89.3|0.02</td><td></td><td>90.3|0.06</td><td>74.4|0.28</td><td>84.9109.3</td></tr><tr><td>90</td><td>3.44</td><td></td><td></td><td>86.0j0.02</td><td>88.8|0.07</td><td>70.0|0.45</td><td>82.5|11.5</td></tr><tr><td></td><td>5.83</td><td>72.9|0.01</td><td>87.5|0.02 Prunedafter]</td><td>76.810.06 ：Downstream</td><td>83.0|0.09 n Fine-tuning</td><td>69.1|0.61</td><td>77.9|15.7</td></tr><tr><td colspan=\"8\"></td></tr><tr><td>0</td><td></td><td>82.60.15</td><td>90.60.06</td><td>90.10.10</td><td>92.10.04</td><td>78.7|0.25</td><td>86.812.0</td></tr><tr><td>10</td><td></td><td>82.9|0.19</td><td>90.6|0.06</td><td>90.3|0.10</td><td>91.6|0.05</td><td>79.0|0.11</td><td>86.9|10.3</td></tr><tr><td>20</td><td></td><td>82.7|0.15</td><td>90.6|0.07</td><td>90.2|0.07</td><td>92.0|0.04</td><td>79.0|0.22</td><td>86.9|10.7</td></tr><tr><td>30</td><td></td><td>82.710.23</td><td>90.4|0.07</td><td>89.710.07</td><td>91.6|0.04</td><td>78.5|0.23</td><td>86.6|12.8</td></tr><tr><td>40</td><td></td><td>82.7|0.25</td><td>90.5|0.11</td><td>89.9j |0.12</td><td>91.7|0.05</td><td>78.8|0.17</td><td>86.7|13.9</td></tr><tr><td>50</td><td></td><td>82.6|0.19</td><td>90.3|0.08</td><td>89.7|0.11</td><td>90.8|0.06</td><td>78.0|0.22</td><td>86.3|13.0</td></tr><tr><td>60</td><td></td><td>81.8|0.22</td><td>90.2|0.10</td><td>89.3|0.12</td><td>90.6|0.06</td><td>76.1|0.31</td><td>85.6|16.4</td></tr><tr><td>70</td><td></td><td>80.5|0.30</td><td>89.4|0.14</td><td>86.2|0.19</td><td>88.2|0.07</td><td>69.5|0.58</td><td>82.7|25.8</td></tr><tr><td>80</td><td></td><td>73.7|0.53</td><td>87.8|0.12</td><td>80.4|0.21</td><td>86.4|0.07</td><td>69.1|0.59</td><td>79.5|30.5</td></tr><tr><td>90</td><td></td><td>58.710.86</td><td>82.5|0.26</td><td>65.2|0.52</td><td>81.5|0.16</td><td>69.1|0.61</td><td>71.4|47.9</td></tr><tr><td colspan=\"8\">Random Pruning</td></tr><tr><td>0</td><td>1.82</td><td>83.3|0.26</td><td>90.5|0.10</td><td>90.6|0.15</td><td>92.4|0.07</td><td>78.7|0.18</td><td>87.115.3</td><td></td></tr><tr><td>10</td><td>2.09</td><td>82.0|0.27</td><td>90.1|0.12</td><td>90.3|0.13</td><td>92.3|0.05</td><td>77.0|0.32</td><td>86.3|18.0</td><td>|20.8</td></tr><tr><td>20</td><td>2.46</td><td>80.6|0.32</td><td>89.8|0.12</td><td>88.5|0.14</td><td>91.1|0.07</td><td>73.5|0.39</td><td>84.7</td><td>3|25.9</td></tr><tr><td>30</td><td>2.98</td><td>79.1|0.36 75.4|0.45</td><td>89.2|0.14</td><td>86.9|0.23</td><td>89.3|0.10</td><td>71.8|0.47</td><td>83.3|</td><td>2|30.3</td></tr><tr><td>40</td><td>3.76</td><td></td><td>88.2|0.16</td><td>84.5j 510.23</td><td>88.6|0.09</td><td>69.3|0.57</td><td>81.2</td><td></td></tr><tr><td>50</td><td>4.73</td><td>71.6|0.60</td><td>86.6|0.20</td><td>81.5 50.28</td><td>85.0|0.10</td><td>69.1|0.61</td><td>78.8</td><td>3|35.8</td></tr><tr><td>60</td><td>5.63</td><td>70.4|0.60</td><td>85.2|0.24</td><td>71.7|0.45</td><td>81.5|0.21</td><td>69.1|0.61</td><td>75.6|42.3</td><td></td></tr><tr><td>70</td><td>6.22</td><td>64.1|0.76</td><td>81.4|0.34</td><td>63.0|0.62</td><td>80.6|0.20</td><td>69.1|0.61</td><td></td><td>71.6|50.3</td></tr><tr><td>80</td><td>6.87</td><td>58.8|0.84</td><td>76.6|0.46</td><td>61.1|0.64</td><td>80.610.23</td><td>69.1|0.61</td><td></td><td>69.3|55.6</td></tr><tr><td>90</td><td>7.37</td><td>49.8|0.98</td><td>74.3|0.51</td><td>60.2|0.65</td><td>75.1|0.33</td><td>69.1|0.61</td><td></td><td>65.7|61.4</td></tr></table>",
+        "bbox": [
+            194,
+            135,
+            803,
+            780
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Pre-training development losses and GLUE task development accuracies for various levels of pruning. Each development accuracy is accompanied on its right by the achieved training loss, evaluated on the entire training set. Averages are summarized in Figure 1. Pre-training losses are omitted for models pruned after downstream fine-tuning because it is not clear how to measure their performance on the pre-training task in a fair way. ",
+        "bbox": [
+            173,
+            785,
+            825,
+            856
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/55986f8fba7bc1db4160373c141b02cf54a91934ee90b50c02b23f2a9a37ad0b.jpg",
+        "image_caption": [
+            "Figure 5: The sum of weights pruned at each sparsity level for one shot pruning of BERT. Given the motivation for our saliency criterion, it seems strange that such a large magnitude of weights can be pruned without decreasing accuracy. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            351,
+            114,
+            643,
+            289
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/e174867fb858fc6b80f2c03c3442f530c62ca453b2b772e4f7cbfcde16f15856.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>LR</td><td>MNLI</td><td>QQP</td><td>QNL</td><td>SST-2</td><td>CoLA</td></tr><tr><td>2e-5</td><td>1.91 ± 1.81</td><td>1.82 ± 1.72</td><td>1.27 ± 1.22</td><td>1.06 ± 1.03</td><td>0.79 ± 0.77</td></tr><tr><td>3e-5</td><td>2.68 ± 2.51</td><td>2.56 ± 2.40</td><td>1.79 ± 1.69</td><td>1.54 ± 1.47</td><td>1.06 ± 1.03</td></tr><tr><td>4e-5</td><td>3.41 ± 3.18</td><td>3.30 ± 3.10</td><td>2.31 ± 2.19</td><td>1.99 ± 1.89</td><td>1.11 ± 1.09</td></tr><tr><td>5e-5</td><td>4.12 ± 3.83</td><td>4.02 ± 3.74</td><td>2.77 ± 2.62</td><td>2.38 ± 2.29</td><td>1.47 ± 1.43</td></tr></table>",
+        "bbox": [
+            238,
+            444,
+            759,
+            518
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 2: We compute the magnitude sorting order of each weight before and after downstream finetuning. If a weight’s original position is $5 9 / 1 0 0$ before fine-tuning and $6 3 / 1 0 0$ after fine-tuning, then that weight moved $4 \\%$ in the sorting order. We then list the average movement of weights in each model, along with the standard deviation. Sorting order changes mostly locally across tasks: a weight moves, on average, $0 . 4 \\%$ away from its starting position. As expected, larger datasets and larger learning rates have more movement (per epoch). We also see that higher magnitude weights are more stable than lower weights, see Figure 7. ",
+        "bbox": [
+            173,
+            535,
+            826,
+            633
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/712d15b2eb41b6c8f90fd047b451f99e97f9bae4c3655c97c43a12ecfc99374c.jpg",
+        "image_caption": [
+            "Figure 6 ",
+            "Figure 7: We show how weight sort order movements are distributed during fine-tuning, given a weight’s starting magnitude. We see that higher magnitude weights are more stable than lower magnitude weights and do not move as much in the sort order. This plot is nearly identical for every model and learning rate, so we only show it once. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            354,
+            675,
+            619,
+            833
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/292b9458511a53c32328f5daf5105562b918de0fac28710439ae9fafa9039cdd.jpg",
+        "image_caption": [
+            "Figure 8: A heatmap of the weight magnitudes of the 12 horizontally stacked self-attention key projection matrices for layer 1. A banding pattern can be seen: the highest values of the matrix tend to cluster in certain attention heads. This pattern appears in most of the self-attention parameter matrices, but it does not cause pruning to prune one head more than another. However, it may prove to be a useful heuristic for attention head pruning, which would not require making many passes over the training data. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            362,
+            161,
+            616,
+            373
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/be10eb168c40cd3193e57bffc5edcf0bd0fbdbdcce84dd71ec6ff2d96dca5efd.jpg",
+        "image_caption": [
+            "Figure 9: A heatmap of the weight magnitudes of BERT’s subword embeddings. Interestingly, pruning BERT embeddings are more interpretable; we can see shorter subwords (top rows) have smaller magnitude values and thus will be pruned earlier than other subword embeddings. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            366,
+            599,
+            612,
+            803
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/b8ce1453ecc1d09e6b956f45ffda1e1cd49898180c4bc60631f0a55c9d166150.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Weight Matrix</td><td>Weight Mean</td><td>Weight STD</td></tr><tr><td>embeddings word embeddings</td><td>-0.0282</td><td>0.042</td></tr><tr><td>layer O attention output FC</td><td>-0.0000</td><td>0.029</td></tr><tr><td> layer O self attn key</td><td>0.0000</td><td>0.043</td></tr><tr><td>layer O self attn query</td><td>0.0000</td><td>0.043</td></tr><tr><td>layer O self attn value</td><td>-0.0000</td><td>0.029</td></tr><tr><td>layer O intermediate FC</td><td>-0.0000</td><td>0.037</td></tr><tr><td>layer O output FC</td><td>-0.0012</td><td>0.036</td></tr><tr><td>layer 1 attention output FC</td><td>0.0001</td><td>0.028</td></tr><tr><td>layer 1 self attn key</td><td>0.0000</td><td>0.043</td></tr><tr><td>layer 1 self attn query</td><td>-0.0003</td><td>0.043</td></tr><tr><td>layer 1 self attn value</td><td>-0.0000</td><td>0.029</td></tr><tr><td>layer 1 intermediate FC</td><td>0.0001</td><td>0.039</td></tr><tr><td>layer 1 output FC</td><td>-0.0014</td><td>0.038</td></tr><tr><td>layer 10 attention output FC</td><td>-0.0000</td><td>0.033</td></tr><tr><td>layer 10 self attn key</td><td>-0.0000</td><td>0.046</td></tr><tr><td>layer 10 self attn query</td><td>0.0002</td><td>0.046</td></tr><tr><td>layer 10 self attn value</td><td>-0.0000</td><td>0.036</td></tr><tr><td>layer 10 intermediate FC</td><td>0.0000</td><td>0.039</td></tr><tr><td>layer 10 output FC</td><td>-0.0011</td><td>0.038</td></tr><tr><td>layer 11 attention output FC</td><td>-0.0000</td><td>0.037</td></tr><tr><td> layer 11 self attn key</td><td>0.0002</td><td>0.044</td></tr><tr><td>layer 11 self attn query</td><td>-0.0001</td><td>0.045</td></tr><tr><td>layer 11 self attn value</td><td>-0.0000</td><td>0.039</td></tr><tr><td> layer 11 intermediate FC</td><td>0.0004</td><td>0.039</td></tr><tr><td>layer 11 output FC</td><td>-0.0008</td><td>0.036</td></tr><tr><td>layer 2 attention output FC</td><td>0.0000</td><td>0.027</td></tr><tr><td>layer 2 self attn key</td><td>0.0000</td><td>0.047</td></tr><tr><td>layer 2 self attn query</td><td>0.0000</td><td>0.048</td></tr><tr><td>layer 2 self attn value</td><td>-0.0000</td><td>0.028</td></tr><tr><td>layer 2 intermediate FC</td><td>0.0001</td><td>0.040</td></tr><tr><td>layer 2 output FC</td><td>-0.0015</td><td>0.038</td></tr><tr><td>layer 3 attention output FC</td><td>0.0001</td><td>0.029</td></tr><tr><td>layer 3 self attn key</td><td>0.0000</td><td>0.043</td></tr><tr><td>layer 3 self attn query</td><td>0.0003</td><td>0.043</td></tr><tr><td>layer 3 self attn value</td><td>-0.0001</td><td>0.031</td></tr><tr><td>layer 3 intermediate FC</td><td>-0.0001</td><td>0.040</td></tr><tr><td>layer 3 output FC</td><td>-0.0014</td><td>0.039</td></tr><tr><td>layer 4 attention output FC</td><td>0.0000</td><td>0.033</td></tr><tr><td> layer 4 self attn key</td><td>0.0000</td><td>0.042</td></tr><tr><td>layer 4 self attn query</td><td>-0.0001</td><td>0.042</td></tr><tr><td>layer 4 self attn value</td><td>0.0001</td><td>0.035</td></tr><tr><td>layer 4 intermediate FC</td><td>0.0001</td><td>0.041</td></tr><tr><td>layer 4 output FC</td><td>-0.0014</td><td>0.040</td></tr><tr><td>layer 5 attention output FC</td><td>-0.0000</td><td>0.033</td></tr><tr><td> layer 5 self attn key</td><td>-0.0001</td><td>0.043</td></tr><tr><td>layer 5 self attn query</td><td>-0.0000</td><td>0.043</td></tr><tr><td>layer 5 self attn value</td><td>-0.0000</td><td>0.035</td></tr><tr><td>layer 5 intermediate FC</td><td>0.0000</td><td>0.041</td></tr><tr><td>layer 5 output FC</td><td>-0.0014</td><td>0.039</td></tr></table>",
+        "bbox": [
+            186,
+            156,
+            596,
+            859
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "layer 6 attention output FC 0.0001 0.032   \nlayer 6 self attn key -0.0000 0.043   \nlayer 6 self attn query 0.0001 0.043   \nlayer 6 self attn value 0.0000 0.034   \nlayer 6 intermediate FC -0.0000 0.041   \nlayer 6 output FC -0.0014 0.039   \nlayer 7 attention output FC 0.0000 0.032   \nlayer 7 self attn key -0.0000 0.044   \nlayer 7 self attn query -0.0000 0.044   \nlayer 7 self attn value 0.0001 0.033   \nlayer 7 intermediate FC 0.0003 0.039   \nlayer 7 output FC -0.0013 0.038   \nlayer 8 attention output FC 0.0000 0.034   \nlayer 8 self attn key -0.0000 0.044   \nlayer 8 self attn query 0.0001 0.044   \nlayer 8 self attn value 0.0000 0.035   \nlayer 8 intermediate FC 0.0004 0.039   \nlayer 8 output FC -0.0013 0.037   \nlayer 9 attention output FC 0.0001 0.033   \nlayer 9 self attn key 0.0000 0.046   \nlayer 9 self attn query -0.0001 0.046   \nlayer 9 self attn value 0.0000 0.035   \nlayer 9 intermediate FC 0.0005 0.040   \nlayer 9 output FC -0.0012 0.039   \npooler FC 0.0000 0.029 ",
+        "bbox": [
+            181,
+            316,
+            490,
+            664
+        ],
+        "page_idx": 15
+    }
+]

parse/train/r1efr3C9Ym/r1efr3C9Ym.md

@@ -0,0 +1,305 @@
+# INTERPOLATION-PREDICTION NETWORKS FORIRREGULARLY SAMPLED TIME SERIES
+
+Satya Narayan Shukla College of Information and Computer Sciences University of Massachusetts Amherst snshukla@cs.umass.edu
+
+Benjamin M. Marlin   
+College of Information and Computer Sciences   
+University of Massachusetts Amherst   
+marlin@cs.umass.edu
+
+# ABSTRACT
+
+In this paper, we present a new deep learning architecture for addressing the problem of supervised learning with sparse and irregularly sampled multivariate time series. The architecture is based on the use of a semi-parametric interpolation network followed by the application of a prediction network. The interpolation network allows for information to be shared across multiple dimensions of a multivariate time series during the interpolation stage, while any standard deep learning model can be used for the prediction network. This work is motivated by the analysis of physiological time series data in electronic health records, which are sparse, irregularly sampled, and multivariate. We investigate the performance of this architecture on both classification and regression tasks, showing that our approach outperforms a range of baseline and recently proposed models.1
+
+# 1 INTRODUCTION
+
+Over the last several years, there has been significant progress in developing specialized models and architectures that can accommodate sparse and irregularly sampled time series as input (Marlin et al., 2012; Li & Marlin, 2015; 2016; Lipton et al., 2016; Futoma et al., 2017; Che et al., 2018a). An irregularly sampled time series is a sequence of samples with irregular intervals between their observation times. Irregularly sampled data are considered to be sparse when the intervals between successive observations are often large. Of particular interest in the supervised learning setting are methods that perform end-to-end learning directly using multivariate sparse and irregularly sampled time series as input without the need for a separate interpolation or imputation step.
+
+In this work, we present a new model architecture for supervised learning with multivariate sparse and irregularly sampled data: Interpolation-Prediction Networks. The architecture is based on the use of several semi-parametric interpolation layers organized into an interpolation network, followed by the application of a prediction network that can leverage any standard deep learning model. In this work, we use GRU networks (Chung et al., 2014) as the prediction network.
+
+The interpolation network allows for information contained in each input time series to contribute to the interpolation of all other time series in the model. The parameters of the interpolation and prediction networks are learned end-to-end via a composite objective function consisting of supervised and unsupervised components. The interpolation network serves the same purpose as the multivariate Gaussian process used in the work of Futoma et al. (2017), but remove the restrictions associated with the need for a positive definite covariance matrix.
+
+Our approach also allows us to compute an explicit multi-timescale representation of the input time series, which we use to isolate information about transients (short duration events) from broader trends. Similar to the work of Lipton et al. (2016) and Che et al. (2018a), our architecture also explicitly leverages a separate information channel related to patterns of observation times. However, our representation uses a semi-parametric intensity function representation of this information that is more closely related to the work of Lasko (2014) on modeling medical event point processes.
+
+Our architecture thus produces three output time series for each input time series: a smooth interpolation modeling broad trends in the input, a short time-scale interpolation modeling transients, and an intensity function modeling local observation frequencies.
+
+This work is motivated by problems in the analysis of electronic health records (EHRs) (Marlin et al., 2012; Lipton et al., 2016; Futoma et al., 2017; Che et al., 2018a). It remains rare for hospital systems to capture dense physiological data streams. Instead, it is common for the physiological time series data in electronic health records to be both sparse and irregularly sampled. The additional issue of the lack of alignment in the observation times across physiological variables is also very common.
+
+We evaluate the proposed architecture on two datasets for both classification and regression tasks. Our approach outperforms a variety of simple baseline models as well as the basic and advanced GRU models introduced by Che et al. (2018a) across several metrics. We also compare our model with to the Gaussian process adapter (Li & Marlin, 2016) and multi-task Gaussian process RNN classifier (Futoma et al., 2017). Further, we perform full ablation testing of the information channels our architecture can produce to assess their impact on classification and regression performance.
+
+# 2 RELATED WORK
+
+The problem of interest in this work is learning supervised machine learning models from sparse and irregularly sampled multivariate time series. As described in the introduction, a sparse and irregularly sampled time series is a sequence of samples with large and irregular intervals between their observation times.
+
+Such data commonly occur in electronic health records, where they can represent a significant problem for both supervised and unsupervised learning methods (Yadav et al., 2018). Sparse and irregularly sampled time series data also occur in a range of other areas with similarly complex observation processes including climate science (Schulz & Stattegger, 1997), ecology (Clark & Bjørnstad, 2004), biology (Ruf, 1999), and astronomy (Scargle, 1982).
+
+A closely related (but distinct) problem is performing supervised learning in the presence of missing data (Batista & Monard, 2003). The primary difference is that the missing data problem is generally defined with respect to a fixed-dimensional feature space (Little & Rubin, 2014). In the irregularly sampled time series problem, observations typically occur in continuous time and there may be no notion of a “normal” or “expected” sampling frequency for some domains.
+
+Methods for dealing with missing data in supervised learning include the pre-application of imputation methods (Sterne et al., 2009), and learning joint models of features and labels (Williams et al., 2005). Joint models can either be learned generatively to optimize the joint likelihood of features and labels, or discriminately to optimize the conditional likelihood of the labels. The problem of irregular sampling can be converted to a missing data problem by discretizing the time axis into non-overlapping intervals. Intervals with no observations are then said to contain missing values.
+
+This is the approach taken to deal with irregular sampling by Marlin et al. (2012) as well as Lipton et al. (2016). This approach forces a choice of discretization interval length. When the intervals are long, there will be less missing data, but there can also be multiple observations in the same interval, which must be accounted for using ad-hoc methods. When the intervals are shorter, most intervals will contain at most one value, but many intervals may be empty. Learning is generally harder as the amount of missing data increases, so choosing a discretization interval length must be dealt with as a hyper-parameter of such a method.
+
+One important feature of missing data problems is the potential for the sequence of observation times to itself be informative (Little & Rubin, 2014). Since the set of missing data indicators is always observed, this information is typically easy to condition on. This technique has been used successfully to improve models in the domain of recommender systems (Salakhutdinov et al., 2007). It was also used by Lipton et al. (2016) to improve performance of their GRU model.
+
+The alternative to pre-discretizing irregularly sampled time series to convert the problem of irregular sampling into the problem of missing data is to construct models with the ability to directly use an irregularly sampled time series as input. The machine learning and statistics literature include several models with this ability. In the probabilistic setting, Gaussian process models have the ability to represent continuous time data via the use of mean and covariance functions (Rasmussen, 2006). These models have non-probabilistic analogues that are similarly defined in terms of kernels.
+
+For example, Lu et al. (2008) present a kernel-based method that can be used to produce a similarity function between two irregularly sampled time series. Li & Marlin (2015) subsequently provided a generalization of this approach to the case of kernels between Gaussian process models. Li & Marlin (2016) showed how the re-parameterization trick (Kingma et al., 2015) could be used to extend these ideas to enable end-to-end training of a deep neural network model (feed-forward, convolutional, or recurrent) stacked on top of a Gaussian process layer. While the basic model of Li & Marlin (2016) was only applied to univariate time series, in follow-up work the model was extended to multivariate time series using a multi-output Gaussian process regression model (Futoma et al., 2017). However, modeling multivariate time series within this framework is quite challenging due to the constraints on the covariance function used in the GP layer. Futoma et al. (2017) deal with this problem using a sum of separable kernel functions (Bonilla et al., 2008), which limit the expressiveness of the model.
+
+An important property of the above models is that they allow for incorporating all of the information from all available time points into a global interpolation model. Variants differ in terms of whether they only leverage the posterior mean when the final supervised problem is solved, or whether the whole posterior is used. A separate line of work has looked at the use of more local interpolation methods while still operating directly over continuous time inputs.
+
+For example, Che et al. (2018a) presented several methods based on gated recurrent unit (GRU) networks (Chung et al., 2014) combined with simple imputation methods including mean imputation and forward filling with past values. Che et al. (2018a) additionally considered an approach that takes as input a sequence consisting of both the observed values and the timestamps at which those values were observed. The previously observed input value is decayed over time toward the overall mean. In another variant the hidden states are similarly decayed toward zero. Yoon et al. (2017) presented another similar approach based on multi-directional RNN which operate across streams in addition to within streams. However, these models are limited to using global information about the structure of the time series via its empirical mean value, and current or past information about observed values. The global structure of the time series is not directly taken into account.
+
+Che et al. (2018b) focus on a similar problem of modeling multi-rate multivariate time series data. This is similar to the problem of interest in that the observations across time series can be unaligned. The difference is that the observations in each time series are uniformly spaced, which is a simpler case. In the case of missing data, they use forward or linear interpolation, which again does not capture the global structure of time series. Similarly, Binkowski et al. (2018) presented an autoregressive framework for regression tasks with irregularly sampled time series data. It is not clear how it can be extended for classification.
+
+The model proposed in this work is similar to that of Li & Marlin (2016) and Futoma et al. (2017) in the sense that it consists of global interpolation layers. The primary difference is that these prior approaches used Gaussian process representations within the interpolation layers. The resulting computations can be expensive and, as noted, the design of covariance functions in the multivariate case can be challenging. By contrast, our proposed model uses semi-parametric, deterministic, feed-forward interpolation layers. These layers do not encode uncertainty, but they do allow for very flexible interpolation both within and across layers.
+
+Also similar to Li & Marlin (2016) and Futoma et al. (2017), the interpolation layers in our architecture produce regularly sampled interpolants that can serve as inputs for arbitrary, unmodified, deep classification and regression networks. This is in contrast to the approach of Che et al. (2018a), where a recurrent network architecture was directly modified, reducing the modularity of the approach. Finally, similar to Lipton et al. (2016), our model includes information about the times at which observations occur. However, instead of pre-discretizing the inputs and viewing this information in terms of a binary observation mask or set of missing data indicators, we directly model the sequence of observation events as a point process in continuous time using a semi-parametric intensity function (Lasko, 2014).
+
+![](images/89f8aa1252eaf18bd0408dbfb937d5324ab23247418c862e99a4d92c1223d6e2.jpg)  
+Figure 1: Architecture of the proposed model
+
+# 3 MODEL FRAMEWORK
+
+In this section, we present the proposed modeling framework. We begin by presenting notation, followed by the model architecture and learning criteria.
+
+# 3.1 NOTATION
+
+We let $\mathcal { D } = \{ ( \mathbf { s } _ { n } , y _ { n } ) | n = 1 , . . . , N \}$ represent a data set containing $N$ data cases. An individual data case consists of a single target value $y _ { n }$ (discrete for classification and real-valued in the case of regression), as well as a $D$ -dimensional, sparse and irregularly sampled multivariate time series ${ \bf s } _ { n }$ . Different dimensions $d$ of the multivariate time series can have observations at different times, as well as different total numbers of observations $L _ { d n }$ . Thus, we represent time series $d$ for data case $n$ as a tuple $\mathbf { s } _ { d n } = ( \mathbf { t } _ { d n } , \mathbf { x } _ { d n } )$ where $\mathbf t _ { d n } = [ t _ { 1 d n } , . . . , t _ { L _ { d n } d n } ]$ is the list of time points at which observations are defined and $\mathbf { x } _ { d n } = [ x _ { 1 d n } , . . . , x _ { L _ { d n } d n } ]$ is the corresponding list of observed values.
+
+# 3.2 MODEL ARCHITECTURE
+
+The overall model architecture consists of two main components: an interpolation network and a prediction network. The interpolation network interpolates the multivariate, sparse, and irregularly sampled input time series against a set of reference time points $\mathbf { r } = [ r _ { 1 } , . . . , r _ { T } ]$ . We assume that all of the time series are defined within a common time interval (for example, the first 24 or 48 hours after admission for MIMIC-III dataset). The $T$ reference time points $r _ { t }$ are chosen to be evenly spaced within that interval. In this work, we propose a two-layer interpolation network with each layer performing a different type of interpolation.
+
+The second component, the prediction network, takes the output of the interpolation network as its input and produces a prediction ${ \hat { y } } _ { n }$ for the target variable. The prediction network can consist of any standard supervised neural network architecture (fully-connected feedforward, convolutional, recurrent, etc). Thus, the architecture is fully modular with respect to the use of different prediction networks. In order to train the interpolation network, the architecture also includes an auto-encoding component to provide an unsupervised learning signal in addition to the supervised learning signal from the prediction network. Figure 1 shows the architecture of the proposed model. We describe the components of the model in detail below.
+
+# 3.2.1 INTERPOLATION NETWORK
+
+We begin by describing the interpolation network. The goal of the interpolation network is to provide a collection of interpolants of each of the $D$ dimensions of an input multivariate time series defined at the $T$ reference time points $\mathbf { r } = [ r _ { 1 } , . . . , r _ { T } ]$ . In this work, we use a total of $C = 3$ outputs for each of the $D$ input time series. The three outputs (discussed in detail below) capture smooth trends, transients, and observation intensity information. We define $f _ { \boldsymbol { \theta } } ( { \bf r } , { \bf s } _ { n } )$ to be the function computing the output $\hat { \mathbf { s } } _ { n }$ of the interpolation network. The output $\hat { \mathbf { s } } _ { n }$ is a fixed-sized array with dimensions $( D C ) \times T$ for all inputs ${ \bf s } _ { n }$ .
+
+The first layer in the interpolation network separately performs three semi-parametric univariate transformations for each of the $D$ time series. Each transformation is based on a radial basis function (RBF) network to accommodate continuous time observations. The transformations are a low-pass (or smooth) interpolation $\pmb { \sigma } _ { d }$ , a high-pass (or non-smooth) interpolation $\gamma _ { d }$ and an intensity function $\lambda _ { d }$ . These transformations are computed at reference time point $r _ { k }$ for each data case and each input time series $d$ as shown in Equations 1, 2, 3 and 4.2 The smooth interpolation $\sigma _ { d }$ uses a squared exponential kernel with parameter $\alpha _ { d }$ , while the non-smooth interpolation $\gamma _ { d }$ uses a squared exponential kernel with parameter $\kappa \alpha _ { d }$ for $\kappa > 1$ .
+
+$$
+\begin{array} { l } { \displaystyle { Z ( r , \mathbf { t } , \alpha ) = \sum _ { t \in \mathbf { t } } w ( r , t , \alpha ) , \quad w ( r , t , \alpha ) = \exp ( - \alpha ( r - t ) ^ { 2 } ) } } \\ { \displaystyle { \ } \lambda _ { k d } = h _ { \theta } ^ { \lambda } ( r _ { k } , \mathbf { t } _ { d } , \mathbf { x } _ { d } ) = Z ( r _ { k } , \mathbf { t } _ { d } , \alpha _ { d } ) } \\ { \displaystyle { \ \sigma _ { k d } = h _ { \theta } ^ { \sigma } ( r _ { k } , \mathbf { t } _ { d } , \mathbf { x } _ { d } ) = \frac { 1 } { Z ( r _ { k } , \mathbf { t } _ { d } , \alpha _ { d } ) } \sum _ { j = 1 } ^ { L _ { d n } } w ( r _ { k } , t _ { j d } , \alpha _ { d } ) x _ { j d } } } \\ { \displaystyle { \ } \gamma _ { k d } = h _ { \theta } ^ { \gamma } ( r _ { k } , \mathbf { t } _ { d } , \mathbf { x } _ { d } ) = \frac { 1 } { Z ( r _ { k } , \mathbf { t } _ { d } , \kappa \alpha _ { d } ) } \sum _ { j = 1 } ^ { L _ { d n } } w ( r _ { k } , t _ { j d } , \kappa \alpha _ { d } ) x _ { j d } } \end{array}
+$$
+
+The second interpolation layer merges information across all $D$ time series at each reference time point by taking into account learnable correlations $\rho _ { d d ^ { \prime } }$ across all time series. This results in a crossdimension interpolation $x d$ for each input dimension $d$ . We further define a transient component $\tau _ { d }$ for each input dimension $d$ as the difference between the high-pass (or non-smooth) interpolation $\gamma _ { d }$ from the first layer and the smooth cross-dimension interpolation $x d$ , as shown in Equation 5.
+
+$$
+\chi _ { k d } = h _ { \theta } ^ { \chi } ( r _ { k } , \mathbf { s } ) = \frac { \sum _ { d ^ { \prime } } \rho _ { d d ^ { \prime } } \lambda _ { k d ^ { \prime } } \sigma _ { k d ^ { \prime } } } { \sum _ { d ^ { \prime } } \lambda _ { k d ^ { \prime } } } , \qquad \quad \tau _ { k d } = h _ { \theta } ^ { \tau } ( r _ { k } , \mathbf { s } ) = \gamma _ { k d } - \chi _ { k d } .
+$$
+
+In the experiments presented in the next section, we use a total of three interpolation network outputs per dimension $d$ as the input to the prediction network. We use the smooth, cross-channel interpolants $x d$ to capture smooth trends, the transient components $\tau _ { d }$ to capture transients, and the intensity functions $\lambda _ { d }$ to capture information about where observations occur in time.
+
+# 3.2.2 PREDICTION NETWORK
+
+Following the application of the interpolation network, all $D$ dimensions of the input multivariate time series have been re-represented in terms of $C$ outputs defined on the regularly spaced set of reference time points $r _ { 1 } , . . . , r _ { T }$ (in our experiments, we use $C = 3$ as described above). Again, we refer to the complete set of interpolation network outputs as $\hat { \mathbf { s } } _ { n } ~ = ~ f _ { \theta } ( \mathbf { r } , \mathbf { s } _ { n } )$ , which can be represented as a matrix of size $( D C ) \times T$ .
+
+The prediction network must take $\hat { \mathbf { s } } _ { n }$ as input and output a prediction $\hat { y } _ { n } = g _ { \phi } ( \hat { \mathbf { s } } _ { n } ) = g _ { \phi } ( f _ { \theta } ( \mathbf { r } , \mathbf { s } _ { n } ) )$ of the target value $y _ { n }$ for data case $n$ . There are many possible choices for this component of the model. For example, the matrix $\hat { \mathbf { s } } _ { n }$ can be converted into a single long vector and provided as input to a standard multi-layer feedforward network. A temporal convolutional model or a recurrent model like a GRU or LSTM can instead be applied to time slices of the matrix $\hat { \mathbf { s } } _ { n }$ . In this work, we conduct experiments leveraging a GRU network as the prediction network.
+
+# 3.2.3 LEARNING
+
+To learn the model parameters, we use a composite objective function consisting of a supervised component and an unsupervised component. This is due to the fact that the supervised component alone is insufficient to learn reasonable parameters for the interpolation network parameters given the amount of available training data. The unsupervised component used corresponds to an autoencoder-like loss function. However, the semi-parametric RBF interpolation layers have the ability to exactly fit the input points by setting the RBF kernel parameters to very large values.
+
+To avoid this solution and force the interpolation layers to learn to properly interpolate the input data, it is necessary to hold out some observed data points $x _ { j d n }$ during learning and then to compute the reconstruction loss only for these data points. This is a well-known problem with high-capacity autoencoders, and past work has used similar strategies to avoid the problem of trivially memorizing the input data without learning useful structure.
+
+To implement the autoencoder component of the loss, we introduce a set of masking variables $m _ { j d n }$ for each data point $\left( t _ { j d n } , x _ { j d n } \right)$ . If $m _ { j d n } = 1$ , then we remove the data point $\left( t _ { j d n } , x _ { j d n } \right)$ as an input to the interpolation network, and include the predicted value of this time point when assessing the autoencoder loss. We use the shorthand notation $\mathbf { m } _ { n } \odot \mathbf { s } _ { n }$ to represent the subset of values of ${ \bf s } _ { n }$ that are masked out, and $\left( 1 - \mathbf { m } _ { n } \right) \odot \mathbf { s } _ { n }$ to represent the subset of values of ${ \bf s } _ { n }$ that are not masked out. The value $\hat { x } _ { j d n }$ that we predict for a masked input at time point $t _ { j d n }$ is the value of the smooth cross-channel interpolant at that time point, calculated based on the un-masked input values: $\hat { x } _ { j d n } = h _ { \theta } ^ { \chi } ( t _ { j d n } , ( 1 - \mathbf { m } _ { n } ) ^ { \top } \odot \mathbf { s } _ { n } )$ .
+
+We can now define the learning objective for the proposed framework. We let $\ell _ { P }$ be the loss for the prediction network (we use cross-entropy loss for classification and squared error for regression). We let $\ell _ { I }$ be the interpolation network autoencoder loss (we use standard squared error). We also include $\ell _ { 2 }$ regularizers for both the interpolation and prediction networks parameters. $\delta _ { I } , \delta _ { P }$ , and $\delta _ { R }$ are hyper-parameters that control the trade-off between the components of the objective function.
+
+$$
+\begin{array} { r l r } {  { \theta _ { * } , \phi _ { * } = \arg \operatorname* { m i n } _ { \theta , \phi } \sum _ { n = 1 } ^ { N } \ell _ { P } \big ( y _ { n } , g _ { \phi } \big ( f _ { \theta } ( \mathbf { s } _ { n } ) \big ) + \delta _ { I } \| \theta \| _ { 2 } ^ { 2 } + \delta _ { P } \| \phi \| _ { 2 } ^ { 2 } } } \\ & { } & { + \delta _ { R } \sum _ { n = 1 } ^ { N } \sum _ { d = 1 } ^ { D } \sum _ { j = 1 } ^ { L _ { d n } } m _ { j d n } \ell _ { I } \big ( x _ { j d n } , h _ { \theta } ^ { \chi } \big ( t _ { j d n } , \big ( 1 - \mathbf { m } _ { n } \big ) \odot \mathbf { s } _ { n } \big ) \big ) } \end{array}
+$$
+
+# 4 EXPERIMENTS AND RESULTS
+
+In this section, we present experiments based on both classification and regression tasks with sparse and irregularly sampled multivariate time series. In both cases, the input to the prediction network is a sparse and irregularly sampled time series, and the output is a single scalar representing either the predicted class or the regression target variable. We test the model framework on two publicly available real-world datasets: MIMIC-III 3 − a multivariate time series dataset consisting of sparse and irregularly sampled physiological signals collected at Beth Israel Deaconess Medical Center from 2001 to 2012 (Johnson et al., 2016), and UWaveGesture 4 − a univariate time series data set consisting of simple gesture patterns divided into eight categories (Liu et al., 2009). Details of each dataset can be found in the Appendix A.1. We use the MIMIC-III mortality and length of stay prediction tasks as example classification and regression tasks with multivariate time series. We use the UWave gesture classification task for assessing training time and performance relative to univariate baseline models.
+
+# 4.1 BASELINE MODELS
+
+We compare our proposed model to a number of baseline approaches including off-the-shelf classification and regression models learned using basic features, as well as more recent approaches based on customized neural network models.
+
+# 4.1.1 NON-NEURAL NETWORK BASELINES
+
+For non-neural network baselines, we evaluate Logistic Regression (Hosmer Jr et al., 2013), Support Vector Machines (SVM) (Cortes & Vapnik, 1995), Random Forests (RF) (Breiman, 2001) and AdaBoost (Freund & Schapire, 1997) for the classification task.
+
+For the length of stay prediction task, we apply Linear Regression (Hastie et al., 2001), Support Vector Regression (SVR), AdaBoost Regression (Drucker, 1997) and Random Forest Regression.
+
+Standard instances of all of these models require fixed-size feature representations. We use temporal discretization with forward filling to create fixed-size representation in case of missing data and use this representation as feature set for non-neural network baselines.
+
+# 4.1.2 NEURAL NETWORK MODELS
+
+We compare to several existing deep learning baselines built on GRUs using simple interpolation or imputation approaches. In addition, we compare to current state-of-the-art models for mortality prediction including the work of Che et al. (2018a). Their work proposed to handle irregularly sampled and missing data using recurrent neural networks (RNNs) by introducing temporal decays in the input and/or hidden layers. We also evaluate the scalable end-to-end Gaussian process adapter (Li & Marlin, 2016) as well as multi-task Gaussian process RNN classifier (Futoma et al., 2017) for irregularly sampled univariate and multivariate time series classification respectively. This work is discussed in detail in Section 2. The complete set of models that we compare to is as follows:
+
+• GP-GRU: End-to-end Gaussian process with GRU as classifier. GRU-M: Missing observations replaced with the global mean of the variable across the training examples. GRU-F: Missing values set to last observed measurement within that time series (referred to as forward filling). GRU-S: Missing values replaced with the global mean. Input is concatenated with masking variable and time interval indicating how long the particular variable is missing. GRU-D: In order to capture richer information, decay is introduced in the input as well as hidden layer of a GRU. Instead of replacing missing values with the last measurement, missing values are decayed over time towards the empirical mean.   
+• GRU-HD: A variation of GRU-D where decay in only introduced in the hidden layer.
+
+# 4.2 RESULTS
+
+In this section, we present the results of the classification and regression experiments, as well as the results of ablation testing of the internal structure of the interpolation network for the proposed model. We use the UWaveGesture dataset to assess the training time and classification performance relative to the baseline models. We use the standard train and test sets (details are given in appendix A.1). We report the training time taken for convergence along with accuracy on test set.
+
+For MIMIC-III, we create our own dataset (appendix A.1) and report the results of a 5-fold cross validation experiment in terms of the average area under the ROC curve (AUC score), average area under the precision-recall curve (AUPRC score), and average cross-entropy loss for the classification task. For the regression task, we use average median absolute error and average fraction of explained variation (EV) as metrics. We also report the standard deviation over cross validation folds for all metrics.
+
+Training and implementation details can be found in appendix A.2. Figure 2 shows the classification performance on the UWaveGesture dataset. The proposed model and the Gaussian process adapter (Li & Marlin, 2016) significantly outperform the rest of the baselines. However, the proposed model achieves similar performance to the Gaussian process adapter, but with a $5 0 \mathrm { x }$ speed up (note the log scale on the training time axis). On the other hand, the training time of the proposed model is approximately the same order as other GRU-based models, but it achieves much better accuracy.
+
+Table 1 compares the predictive performance of the mortality and length of stay prediction task on MIMIC-III. We note that in highly skewed datasets as is the case of MIMIC-III, AUPRC (Davis & Goadrich, 2006) can give better insights about the classification performance as compared to AUC score. The proposed model consistently achieves the best average score over all the metrics. We note that a paired t-test indicates that the proposed model results in statistically significant improvements over all baseline models $\mathit { p } < 0 . 0 1 )$ with respect to all the metrics except median absolute error. The version of the proposed model used in this experiment includes all three interpolation network outputs (smooth interpolation, transients, and intensity function).
+
+An ablation study shows that the results on the regression task can be further improved by using only two outputs (transients, and intensity function), achieving statistically significant improvements over all the baselines. Results for the ablation study are given in Appendix A.3. Finally, we compare the proposed model with multiple baselines on a previous MIMIC-III benchmark dataset (Harutyunyan et al., 2017), which uses a reduced number of cohorts as compared to the one used in our experiments. Appendix A.4 shows the results on this benchmark dataset, where our proposed approach again outperforms prior approaches.
+
+![](images/5331d46a12cd0f0943254f08b11a5859ab3a993940de5f7fe3cdbdddf41b0801.jpg)  
+Figure 2: Classification performance on the UWaveGesture dataset. Models with almost same performance are shown with the same dot e.g. (GRU-M, GRU-F ) and (GRU-D, GRU-HD).
+
+Table 1: Performance on Mortality (classification) and Length of stay prediction (regression) tasks on MIMIC-III. Loss: Cross-Entropy Loss, MedAE: Median Absolute Error (in days), EV: Explained variance   
+
+<table><tr><td>Model</td><td colspan="3">Classification</td><td colspan="2">Regression</td></tr><tr><td></td><td>AUC</td><td>AUPRC</td><td>Loss</td><td>MedAE</td><td>EV score</td></tr><tr><td>Log/LinReg</td><td>0.772 ± 0.013</td><td>0.303 ±0.018</td><td>0.240±0.003</td><td>3.528 ± 0.072</td><td>0.043 ± 0.012</td></tr><tr><td>SVM</td><td>0.671 ± 0.005</td><td>0.300 ± 0.011</td><td>0.260±0.002</td><td>3.523 ± 0.071</td><td>0.042 ± 0.011</td></tr><tr><td>AdaBoost</td><td>0.829 ±0.007</td><td>0.345 ± 0.007</td><td>0.663 ±0.000</td><td>4.517 ± 0.234</td><td>0.100 ±0.012</td></tr><tr><td>RF</td><td>0.826 ±0.008</td><td>0.356 ± 0.010</td><td>0.315 ± 0.025</td><td>3.113 ± 0.125</td><td>0.117 ±0.035</td></tr><tr><td>GRU-M</td><td>0.831± 0.007</td><td>0.376 ± 0.022</td><td>0.220±0.004</td><td>3.140 ± 0.196</td><td>0.131 ± 0.044</td></tr><tr><td>GRU-F</td><td>0.821 ± 0.007</td><td>0.360 ± 0.013</td><td>0.224±0.003</td><td>3.064±0.247</td><td>0.126 ± 0.025</td></tr><tr><td>GRU-S</td><td>0.843±0.007</td><td>0.376 ± 0.014</td><td>0.218 ± 0.005</td><td>2.900±0.129</td><td>0.161 ± 0.025</td></tr><tr><td>GRU-D</td><td>0.835 ± 0.013</td><td>0.359 ± 0.025</td><td>0.225 ±0.009</td><td>2.891±0.103</td><td>0.146 ± 0.051</td></tr><tr><td>GRU-HD</td><td>0.845 ± 0.006</td><td>0.390 ± 0.010</td><td>0.215 ±0.004</td><td>2.893±0.155</td><td>0.158 ± 0.037</td></tr><tr><td>GP-GRU</td><td>0.847 ± 0.007</td><td>0.377 ± 0.017</td><td>0.215 ± 0.004</td><td>2.847 ± 0.079</td><td>0.217 ±0.020</td></tr><tr><td>Proposed</td><td>0.853 ±0.007</td><td>0.418 ± 0.022</td><td>0.210±0.004</td><td>2.862±0.166</td><td>0.245 ± 0.019</td></tr></table>
+
+# 5 DISCUSSION AND CONCLUSIONS
+
+In this paper, we have presented a new framework for dealing with the problem of supervised learning in the presence of sparse and irregularly sampled time series. The proposed framework is fully modular. It uses an interpolation network to accommodate the complexity that results from using sparse and irregularly sampled data as supervised learning inputs, followed by the application of a prediction network that operates over the regularly spaced and fully observed, multi-channel output provided by the interpolation network. The proposed approach also addresses some difficulties with prior approaches including the complexity of the Gaussian process interpolation layers used in (Li & Marlin, 2016; Futoma et al., 2017), and the lack of modularity in the approach of Che et al. (2018a). Our framework also introduces novel elements including the use of semi-parametric, feed-forward interpolation layers, and the decomposition of an irregularly sampled input time series into multiple distinct information channels. Our results show statistically significant improvements for both classification and regression tasks over a range of baseline and state-of-the-art methods.
+
+# ACKNOWLEDGEMENTS
+
+This work was supported by the National Science Foundation under Grant No. IIS-1350522.
+
+# REFERENCES
+
+Gustavo EAPA Batista and Maria Carolina Monard. An analysis of four missing data treatment methods for supervised learning. Applied artificial intelligence, 17(5-6):519–533, 2003.
+
+Mikolaj Binkowski, Gautier Marti, and Philippe Donnat. Autoregressive convolutional neural networks for asynchronous time series. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 580–589, Stockholmsmassan, Stockholm Sweden, 10–15 Jul 2018. ¨ PMLR. URL http://proceedings.mlr.press/v80/binkowski18a.html.
+
+Edwin V Bonilla, Kian M Chai, and Christopher Williams. Multi-task gaussian process prediction. In Advances in neural information processing systems, pp. 153–160, 2008.
+
+Leo Breiman. Random forests. Mach. Learn., 45(1):5–32, October 2001. ISSN 0885-6125. doi: 10.1023/A:1010933404324. URL https://doi.org/10.1023/A:1010933404324.
+
+Zhengping Che, Sanjay Purushotham, Kyunghyun Cho, David Sontag, and Yan Liu. Recurrent neural networks for multivariate time series with missing values. Scientific Reports, 8(1):6085, 2018a. URL https://doi.org/10.1038/s41598-018-24271-9.
+
+Zhengping Che, Sanjay Purushotham, Guangyu Li, Bo Jiang, and Yan Liu. Hierarchical deep generative models for multi-rate multivariate time series. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 784–793, Stockholmsmassan, Stockholm Sweden, 10–15 ¨ Jul 2018b. PMLR. URL http://proceedings.mlr.press/v80/che18a.html.
+
+Junyoung Chung, C¸ aglar G ˘ ulc¸ehre, Kyunghyun Cho, and Yoshua Bengio. Empirical evaluation ¨ of gated recurrent neural networks on sequence modeling. arXiv e-prints, abs/1412.3555, 2014. URL https://arxiv.org/abs/1412.3555. Presented at the Deep Learning workshop at NIPS2014.
+
+J.S. Clark and O.N. Bjørnstad. Population time series: process variability, observation errors, missing values, lags, and hidden states. Ecology, 85(11):3140–3150, 2004.
+
+Corinna Cortes and Vladimir Vapnik. Support-vector networks. Machine Learning, 20(3):273– 297, Sep 1995. ISSN 1573-0565. doi: 10.1007/BF00994018. URL https://doi.org/10. 1007/BF00994018.
+
+Jesse Davis and Mark Goadrich. The relationship between precision-recall and roc curves. In Proceedings of the 23rd International Conference on Machine Learning, ICML ’06, pp. 233– 240, New York, NY, USA, 2006. ACM. ISBN 1-59593-383-2. doi: 10.1145/1143844.1143874. URL http://doi.acm.org/10.1145/1143844.1143874.
+
+Harris Drucker. Improving regressors using boosting techniques. In Proceedings of the Fourteenth International Conference on Machine Learning, ICML ’97, pp. 107–115, San Francisco, CA, USA, 1997. Morgan Kaufmann Publishers Inc. ISBN 1-55860-486-3. URL http://dl.acm. org/citation.cfm?id=645526.657132.
+
+Yoav Freund and Robert E Schapire. A decision-theoretic generalization of on-line learning and an application to boosting. J. Comput. Syst. Sci., 55(1):119–139, August 1997. ISSN 0022-0000. doi: 10.1006/jcss.1997.1504. URL http://dx.doi.org/10.1006/jcss.1997.1504.
+
+Joseph Futoma, Sanjay Hariharan, and Katherine A. Heller. Learning to detect sepsis with a multitask gaussian process RNN classifier. In Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, pp. 1174–1182, 2017. URL http://proceedings.mlr.press/v70/futoma17a.html.
+
+Hrayr Harutyunyan, Hrant Khachatrian, David Kale, and Aram Galstyan. Multitask learning and benchmarking with clinical time series data. 03 2017.
+
+Trevor Hastie, Robert Tibshirani, and Jerome Friedman. The Elements of Statistical Learning. Springer Series in Statistics. Springer New York Inc., New York, NY, USA, 2001.
+
+David W Hosmer Jr, Stanley Lemeshow, and Rodney X Sturdivant. Applied logistic regression, volume 398. John Wiley & Sons, 2013.
+
+Alistair EW Johnson, Tom J Pollard, Lu Shen, H Lehman Li-wei, Mengling Feng, Mohammad Ghassemi, Benjamin Moody, Peter Szolovits, Leo Anthony Celi, and Roger G Mark. Mimic-iii, a freely accessible critical care database. Scientific data, 3:160035, 2016.
+
+Diederik P Kingma, Tim Salimans, and Max Welling. Variational dropout and the local reparameterization trick. arXiv preprint arXiv:1506.02557, 2015.
+
+Thomas A Lasko. Efficient inference of gaussian-process-modulated renewal processes with application to medical event data. In Uncertainty in artificial intelligence: proceedings of the... conference. Conference on Uncertainty in Artificial Intelligence, volume 2014, pp. 469. NIH Public Access, 2014.
+
+Steven Cheng-Xian Li and Benjamin M Marlin. A scalable end-to-end gaussian process adapter for irregularly sampled time series classification. In Advances In Neural Information Processing Systems, pp. 1804–1812, 2016.
+
+Steven Cheng-Xian Li and Benjmain M. Marlin. Classification of sparse and irregularly sampled time series with mixtures of expected Gaussian kernels and random features. In 31st Conference on Uncertainty in Artificial Intelligence, 2015.
+
+Zachary C Lipton, David Kale, and Randall Wetzel. Directly modeling missing data in sequences with rnns: Improved classification of clinical time series. In Machine Learning for Healthcare Conference, pp. 253–270, 2016.
+
+Roderick JA Little and Donald B Rubin. Statistical analysis with missing data, volume 333. John Wiley & Sons, 2014.
+
+Jiayang Liu, Zhen Wang, Lin Zhong, Jehan Wickramasuriya, and Venu Vasudevan. uwave: Accelerometer-based personalized gesture recognition and its applications. In Proceedings of the 2009 IEEE International Conference on Pervasive Computing and Communications, PERCOM ’09, pp. 1–9, Washington, DC, USA, 2009. IEEE Computer Society. ISBN temp-isbn. doi: 10.1109/PERCOM.2009.4912759. URL https://doi.org/10.1109/PERCOM.2009. 4912759.
+
+Zhengdong Lu, Todd K. Leen, Yonghong Huang, and Deniz Erdogmus. A reproducing kernel hilbert space framework for pairwise time series distances. In Proceedings of the 25th International Conference on Machine Learning, ICML ’08, pp. 624–631, New York, NY, USA, 2008. ACM. ISBN 978-1-60558-205-4. doi: 10.1145/1390156.1390235. URL http://doi.acm.org/ 10.1145/1390156.1390235.
+
+Benjamin M. Marlin, David C. Kale, Robinder G. Khemani, and Randall C. Wetzel. Unsupervised pattern discovery in electronic health care data using probabilistic clustering models. In Proceedings of the 2nd ACM SIGHIT International Health Informatics Symposium, pp. 389–398, 2012.
+
+Carl Edward Rasmussen. Gaussian processes for machine learning. 2006.
+
+T. Ruf. The lomb-scargle periodogram in biological rhythm research: analysis of incomplete and unequally spaced time-series. Biological Rhythm Research, 30(2):178–201, 1999.
+
+Ruslan Salakhutdinov, Andriy Mnih, and Geoffrey Hinton. Restricted boltzmann machines for collaborative filtering. In Proceedings of the 24th international conference on Machine learning, pp. 791–798. ACM, 2007.
+
+Jeffrey D Scargle. Studies in astronomical time series analysis. ii-statistical aspects of spectral analysis of unevenly spaced data. The Astrophysical Journal, 263:835–853, 1982.
+
+M. Schulz and K. Stattegger. Spectrum: Spectral analysis of unevenly spaced paleoclimatic time series. Computers & Geosciences, 23(9):929–945, 1997.
+
+Jonathan AC Sterne, Ian R White, John B Carlin, Michael Spratt, Patrick Royston, Michael G Kenward, Angela M Wood, and James R Carpenter. Multiple imputation for missing data in epidemiological and clinical research: potential and pitfalls. Bmj, 338:b2393, 2009.
+
+David Williams, Xuejun Liao, Ya Xue, and Lawrence Carin. Incomplete-data classification using logistic regression. In Proceedings of the 22nd International Conference on Machine learning, pp. 972–979. ACM, 2005.
+
+Pranjul Yadav, Michael Steinbach, Vipin Kumar, and Gyorgy Simon. Mining electronic health records (ehrs): A survey. ACM Computing Surveys (CSUR), 50(6):85, 2018.
+
+Jinsung Yoon, William R. Zame, and Mihaela van der Schaar. Multi-directional recurrent neural networks : A novel method for estimating missing data. 2017.
+
+# A APPENDIX
+
+# A.1 DATASET DESCRIPTIONS
+
+# A.1.1 MIMIC-III DATASET
+
+We evaluate our model framework on the publicly available MIMIC-III dataset (Johnson et al., 2016). MIMIC-III is a de-identified dataset collected at Beth Israel Deaconess Medical Center from 2001 to 2012. It consists of approximately 58,000 hospital admission records. This data set contains sparse and irregularly sampled physiological signals, medications, diagnostic codes, inhospital mortality, length of stay and more. We focus on predicting in-hospital mortality and length of stay using the first 48 hours of data. We extracted 12 standard physiological variables from each of the 53,211 records obtained after removing hospital admission records with length of stay less than 48 hours. Table 2 shows the features, sampling rates (per hour) and their missingness information computed using the union of all time stamps that exist in any dimension of the input time series.
+
+Table 2: Features extracted from MIMIC III for our experiments   
+
+<table><tr><td>feature</td><td>#Missing</td><td> Sampling Rate</td></tr><tr><td>SpO2</td><td>31.35%</td><td>0.80</td></tr><tr><td>HR</td><td>23.23%</td><td>0.90</td></tr><tr><td>RR</td><td>59.48%</td><td>0.48</td></tr><tr><td>SBP</td><td>49.76%</td><td>0.59</td></tr><tr><td>DBP</td><td>48.73%</td><td>0.60</td></tr><tr><td>Temp</td><td>83.80%</td><td>0.19</td></tr></table>
+
+<table><tr><td>feature</td><td>#Missing</td><td> Sampling Rate</td></tr><tr><td>TGCS</td><td>87.94%</td><td>0.14</td></tr><tr><td>CRR</td><td>95.08%</td><td>0.06</td></tr><tr><td>UO</td><td>82.47%</td><td>0.20</td></tr><tr><td>FiO2</td><td>94.82%</td><td>0.06</td></tr><tr><td>Glucose</td><td>91.47%</td><td>0.10</td></tr><tr><td>pH</td><td>96.25%</td><td>0.04</td></tr></table>
+
+Prediction Tasks
+
+In our experiments, each admission record corresponds to one data case $( \mathbf { s } _ { \mathbf { n } } , y _ { n } )$ . Each data case $n$ consists of a sparse and irregularly sampled time series ${ \bf s } _ { n }$ with $D \ = \ 1 2$ dimensions. Each dimension $d$ of ${ \bf s } _ { n }$ corresponds to one of the 12 vital sign time series mentioned above. In the case of classification, $y _ { n }$ is a binary indicator where $y _ { n } = 1$ indicates that the patient died at any point within the hospital stay following the first 48 hours and $y _ { n } ~ = ~ 0$ indicates that the patient was discharged at any point after the first 48 hours. There are 4310 $( 8 . 1 \% )$ patients with a $y _ { n } = 1$ mortality label. The complete data set is $\mathcal { D } = \{ ( \mathbf { s _ { n } } , y _ { n } ) | n = 1 , . . . , N \}$ , and there are $N = 5 3 , 2 1 1$ data cases. The goal in the classification task is to learn a classification function $g$ of the form $\hat { y } _ { n } \gets g ( \mathbf { s } _ { n } )$ where ${ \hat { y } } _ { n }$ is a discrete value.
+
+In the case of regression, $y _ { n }$ is a real-valued regression target corresponding to the length of stay. Since the data set includes some very long stay durations, we let $y _ { n }$ represent the log of the length of stay in days for all models. We convert back from the log number of days to the number of days when reporting results. The complete data set is again $\mathcal { D } = \{ ( \mathbf { s _ { n } } , y _ { n } ) | n = 1 , . . . , N \}$ with $N = 5 3$ , 211 data cases (we again require 48 hours worth of data). The goal in the regression task is to learn a regression function $g$ of the form ${ \hat { y } } _ { n } \gets g ( \mathbf { s } _ { n } )$ where ${ \hat { y } } _ { n }$ is a continuous value.
+
+# A.1.2 UWAVE DATASET
+
+UWave dataset is an univariate time series data consisting of simple gesture patterns divided into eight categories. The dataset has been split into 3582 train and 896 test instances. Out of the training data, $30 \%$ is used for validation. Each time series contains 945 observations. We follow the same data preparation method as in Li & Marlin (2016) where we randomly sample $10 \%$ of the observations points from each time series to create a sparse and irregularly sampled data.
+
+# A.2 IMPLEMENTATION DETAILS
+
+# A.2.1 PROPOSED MODEL
+
+The model is learned using the Adam optimization method in TensorFlow with gradients provided via automatic differentiation. However, the actual multivariate time series representation used during learning is based on the union of all time stamps that exist in any dimension of the input time series. Undefined observations are represented as zeros and a separate missing data mask is used to keep track of which time series have observations at each time point. Equations 1 to 5 are modified such that data that are not available are not taken into account at all. This implementation is exactly equivalent to the computations described, but supports parallel computation across all dimensions of the time series for a given data case.
+
+Finally, we note that the learning problem can be solved using a doubly stochastic gradient based on the use of mini batches combined with re-sampling the artificial missing data masks used in the interpolation loss. In practice, we randomly select $2 0 \%$ of the observed data points to hold out from every input time series.
+
+For the time series missing entirely, our interpolation network assigns the starting point (time $\scriptstyle { \mathrm { t } } = 0$ ) value of the time series to the global mean before applying the two-layer interpolation network. In such cases, the first interpolation layer just outputs the global mean for that channel, but the second interpolation layer performs a more meaningful interpolation using the learned correlations from other channels.
+
+# A.2.2 BASELINES
+
+The Logistic Regression model is trained with cross entropy loss with regularization strength set to 1. The support vector classifier is used with a RBF kernel and trained to minimize the soft margin loss. We use the cross entropy loss on the validation set to select the optimal number of estimators in case of Adaboost and Random Forest. Similar to the classification setting, the optimal number of estimators for regression task in Adaboost and Random Forest is chosen on the basis of squared error on validation set.
+
+# MIMIC-III DATASET
+
+We evaluate all models using a five-fold cross-validation estimate of generalization performance. In the classification setting, all the deep learning baselines are trained to minimize the cross entropy loss while the proposed model uses a composite loss consisting of cross-entropy loss and interpolation loss (with $\delta _ { R } = 1 \mathrm { \Delta }$ ) as described in section 3.2.3. In the case of the regression task, all baseline models are trained to minimize squared error and the proposed model is again trained with a composite loss consisting of squared error and interpolation loss.
+
+We follow the multi-task Gaussian process implementation given by Futoma et al. (2017) and treat the number of hidden units and hidden layers as hyper-parameters. For all of the GRU-based models, we use the already specified parameters (Che et al., 2018a). The models are learned using the Adam optimization. Early stopping is used on a validation set sub-sampled from the training folds. In the classification case, the final outputs of the GRU hidden units are used in a logistic layer that predicts the class. In the regression case, the final outputs of the GRU hidden units are used as input for a dense hidden layer with 50 units, followed by a linear output layer.
+
+# UWAVE DATASET
+
+We independently tune the hyper-parameters of each baseline method. For GRU-based methods, hidden units are searched over the range $\{ 2 ^ { 5 } , 2 ^ { 6 } , \cdots , 2 ^ { 1 1 } \}$ . Learning is done in same way as described above. We evaluate all the baseline models on the test set and compare the training time and accuracy. For the Gaussian process model, we use the squared exponential covariance function. We use the same number of inducing points for both the Gaussian process and the proposed model. The Gaussian process model is jointly trained with the GRU using stochastic gradient descent with Nesterov momentum. We apply early stopping based on the validation set.
+
+# A.3 ADDITIONAL EXPERIMENTS
+
+In this section, we address the question of the relative information content of the different outputs produced by the interpolation network used in the proposed model for MIMIC-III dataset. Recall that for each of the $D = 1 2$ vital sign time series, the interpolation network produces three outputs: a smooth interpolation output (SI), a non-smooth or transient output (T), and an intensity function (I). The above results use all three of these outputs.
+
+To assess the impact of each of the interpolation network outputs, we conduct a set of ablation experiments where we consider using all sub-sets of outputs for both the classification task and for the regression task.
+
+Table 3 shows the results from five-fold cross validation mortality and length of stay prediction experiments. When using each output individually, smooth interpolation (SI) provides the best performance in terms of classification. Interestingly, the intensity output is the best single information source for the regression task and provides at least slightly better mean performance than any of the baseline methods shown in Table 1. Also interesting is the fact that the transients output performs significantly worse when used alone than either the smooth interpolation or the intensity outputs in the classification task.
+
+Table 3: Performance of all subsets of the interpolation network outputs on Mortality (classification) and Length of stay prediction (regression) tasks. SI: Smooth Interpolation, I: Intensity, T: Transients, Loss: Cross-Entropy Loss, MedAE: Median Absolute Error, EV: Explained variance   
+
+<table><tr><td>Model</td><td colspan="3">Classification</td><td colspan="2">Regression</td></tr><tr><td></td><td>AUC</td><td>AUPRC</td><td>Loss</td><td>MedAE</td><td>EV score</td></tr><tr><td>SI, T,I</td><td>0.853 ± 0.007</td><td>0.418 ± 0.022</td><td>0.210 ± 0.004</td><td>2.862 ±0.166</td><td>0.245 ± 0.019</td></tr><tr><td>SI,I</td><td>0.852 ± 0.005</td><td>0.408 ± 0.017</td><td>0.210± 0.004</td><td>2.745 ±0.062</td><td>0.224±0.010</td></tr><tr><td>SI,T</td><td>0.820 ±0.008</td><td>0.355 ± 0.024</td><td>0.226 ±0.005</td><td>2.911 ± 0.073</td><td>0.182 ± 0.009</td></tr><tr><td>SI</td><td>0.816 ±0.009</td><td>0.354±0.018</td><td>0.226 ±0.005</td><td>3.035 ± 0.063</td><td>0.183 ± 0.016</td></tr><tr><td>I</td><td>0.786 ± 0.010</td><td>0.250 ±0.012</td><td>0.241±0.003</td><td>2.697± 0.072</td><td>0.251±0.009</td></tr><tr><td>I,T</td><td>0.755 ± 0.012</td><td>0.236 ± 0.014</td><td>0.272 ±0.010</td><td>2.738 ±0.101</td><td>0.290 ±0.010</td></tr><tr><td>T</td><td>0.705 ± 0.009</td><td>0.192 ±0.008</td><td>0.281±0.004</td><td>2.995±0.130</td><td>0.207±0.024</td></tr></table>
+
+When considering combinations of interpolation network components, we can see that the best performance is obtained when all three outputs are used simultaneously in classification tasks. For the regression task, the intensity output provides better performance in terms of median absolute error while a combination of intensity and transients output provide better explained variance score. However, the use of the transients output contributes almost no improvement in the case of the AUC and cross entropy loss for classification relative to using only smooth interpolation and intensity. Interestingly, in the classification case, there is a significant boost in performance by combining smooth interpolation and intensity relative to using either output on its own. In the regression setting, smooth interpolation appears to carry little information.
+
+# A.4 BENCHMARK MIMIC-III DATASET
+
+In this section, we compare the performance of the proposed model on a previous MIMIC-III benchmark dataset (Harutyunyan et al., 2017). This dataset only consists of patients with age $> 1 8$ . Again, we focus on predicting in-hospital mortality using the first 48 hours of data. This yields training and test sets of size 17,903 and 3,236 records respectively.
+
+We compare the proposed model to multiple baselines from Harutyunyan et al. (2017). In all the baselines, the sparse and irregularly sampled time-series data has been discretized into 1-hour intervals. If there are multiple observations in an interval, the mean or last observation is assigned to that interval, depending on the baseline method. Similarly, if an interval contains no observations, the mean or forward filling approach is used to assign a value depending on the baseline method. We compare with a logistic regression model and a standard LSTM network. In the multitask setting, multiple tasks are predicted jointly. Unlike the standard LSTM network where the output/hiddenstate from the last time step is used for prediction, we provide supervision to the model at each time step. In this experiment, we use an LSTM as the prediction network in the proposed model to match the baselines.
+
+Table 4: Classification performance for in-hospital mortality prediction task on benchmark dataset   
+
+<table><tr><td>Model</td><td>AUC score</td><td>AUPRC score</td></tr><tr><td>Logistic Regression</td><td>0.8485</td><td>0.4744</td></tr><tr><td>LSTM</td><td>0.8547</td><td>0.4848</td></tr><tr><td>LSTM+ Deep Supervision</td><td>0.8558</td><td>0.4928</td></tr><tr><td>MultitaskLSTM</td><td>0.8607</td><td>0.4933</td></tr><tr><td>Interpolation Network +LSTM</td><td>0.8610</td><td>0.5370</td></tr></table>

parse/train/rJfHoM-C-/rJfHoM-C-.md

@@ -0,0 +1,283 @@
+# FEW-SHOT LEARNING WITH SIMPLEX
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Deep learning has made remarkable achievement in many fields. However, learning the parameters of neural networks usually demands a large amount of labeled data. The algorithms of deep learning, therefore, encounter difficulties when applied to supervised learning where only little data are available. This specific task is called few-shot learning. To address it, we propose a novel algorithm for fewshot learning using discrete geometry, in the sense that the samples in a class are modeled as a reduced simplex. The volume of the simplex is used for the measurement of class scatter. During testing, combined with the test sample and the points in the class, a new simplex is formed. Then the similarity between the test sample and the class can be quantized with the ratio of volumes of the new simplex to the original class simplex. Moreover, we present an approach to constructing simplices using local regions of feature maps yielded by convolutional neural networks. Experiments on Omniglot and miniImageNet verify the effectiveness of our simplex algorithm on few-shot learning.
+
+# 1 INTRODUCTION
+
+Deep learning has exhibited outstanding ability in various disciplines including computer vision, natural language processing and speech recognition (LeCun et al., 2015). For instance, AlexNet has made a breakthrough on recognizing millions of imagery objects by means of deep Convolutional Neural Network (CNN) (Krizhevsky et al., 2012). In the past five years, the algorithmic capability of comprehending visual concepts has been significantly improved by elaborately well-designed deep learning architectures (He et al., 2015a; Szegedy et al., 2014). However, training deep neural networks such as the widely employed CNNs of AlexNet (Krizhevsky et al., 2012), Inception (Szegedy et al., 2015), VGG (Simonyan & Zisserman, 2014), and ResNet (He et al., 2015b), needs the supervision of many class labels which are handcrafted. For example, the number of samples of each class in the ImageNet of object recognition benchmark (Russakovsky et al., 2015) is more than one thousand. In fact, the number of labelled samples used for learning parameters of CNNs is far more than that because data augmentation is usually applied. This kind of learning obviously deviates from the manner of human cognition. A child can recognize a new object that she/he has never seen only by several examples, from simple shapes like rectangles to highly semantic animals like tigers. However, deep learning algorithms encounter difficulty in such scenarios where only very sparse data are available for learning to recognize a new category, thus raising the research topic of one-shot learning or few-shot learning (Fei-Fei et al., 2003; Tenenbaum et al., 2011).
+
+The seminal work Fei-Fei et al. (2006) models few-shot learning with the Bayesian framework. Empirical knowledge of available categories is learned and parameterized as a probability density function. The unseen class with a handful of examples is modeled as the posterior by updating the prior. Bayesian theory provides a simple and elegant idea for solving learning problems with little data. If decomposed into parts or programs, an object can be described by the joint distribution of Bayesian criterion. In this manner, human-level performance on one-shot learning has been derived for discovering simple visual concepts such as ancient handwritten characters (Lake et al., 2015).
+
+With the prevalence of deep learning, the recent work for few-shot learning focuses on the application of deep neural networks that have more capacity to accommodate the complexity of object representations. Siamese neural network facilitates the performance of few-shot recognition by means of twin networks of sharing parameters, optimizing the distances of representative features in intraclasses (Koch et al., 2015). The counterpart of learning data structures by distance is also formulated by triplet loss in Lin et al. (2017). Researchers in Lin et al. (2017) assert that the distance metrics can learn the intrinsic manifold structures of training data such that the network is more general and robust when employed for untrained objects. A very recent work pertaining to distance-based optimization, named Prototypical Networks (Snell et al., 2017), significantly improves the capability of few-shot recognition. Prototypical Networks attempt to minimize the distance of the test sample to the center of each class and are learned in the end-to-end manner.
+
+Memory-augmented architectures are also proposed to help assimilate new classes with more accurate inference (Santoro et al., 2016). Matching network embeds metric learning in neural network in the light of attention mechanism which is embodied by softmax (Vinyals et al., 2016). In a very recent work, the large-scale memory without the need of resetting during training is formulated as an embedded module for arbitrary neural networks to remember the information of rare events (Kaiser et al., 2017). In order to obtain rapid learning with limited samples, meta learning is exploited both in memory network and matching network. This “learning to learn” technique is extended to deal with few-shot learning from the point of view of optimization (Ravi & Larochelle, 2017). To be specific, a LSTM-based meta learner learns to mimic the exact optimization algorithm and then harnesses the acquired capability to train the learner applied for the few-shot cases. The latest meta learning algorithms also deal with few-shot learning from different angles, e.g. the fast adaptation of neural networks (Finn et al., 2017), and temporal convolution (Mishra et al., 2017).
+
+In addition to the application of memory module or attention model in LSTM, there is another type of algorithms digging the effective way of transferring the discriminative power of pre-trained models to few-shot circumstances. Resorting to the correlation between the activations in the last feature layers and the associated parameters for softmax, a transformation is learned to derive the parameters for predicting new classes from corresponding activations (Qiao et al., 2017).
+
+The algorithms based on deep learning can learn more expressive representations for objects, essentially boosting the quality of feature extraction. However, the softmax classifier discriminates all categories by class boundaries, bypassing the steps that carefully characterize the structure of each class. Thus the algorithmic performance will deteriorate grossly if the distribution of new class cannot be accurately modeled by trained networks. Besides softmax, another commonly applied method, $k$ nearest neighbors (KNN), is a point-to-point measurement and is incapable of conveying global structural information.
+
+To address this issue, we propose a geometric method for few-shot learning. Our perspective is that accurate geometric characterization for each class is essential when only a handful of samples are available, because such sparse data are usually insufficient to fit well-converged parameterized classifier. To this end, we harness convex polytope to fit a class, in the sense that we construct a convex polytope by selecting the samples in the class as the vertices of the polytope. The volume of the polytope is taken as the measurement of class scatter. Thus the polytopal volume may be improved after including the query sample in the test set during the testing trial. The normalized volume with respect to the original counterpart is applied to compute the distance from the test sample to the test set. To highlight the structural details of object parts, we present the construction of polytope based on convolutional feature maps as well.
+
+To the best of our understanding, however, there is no exact formula to calculating the volume of general convex polytope. To make our algorithm feasible, therefore, we use the simplest convex polytope — simplex instead. The volume of a simplex can be expressed by the Cayley-Menger determinant (Cayley, 2009), thus casting the problem of few-shot recognition as a simple calculation of linear algebra. Experiments on Omniglot and miniImageNet datasets verify the effectiveness of our simple algorithm.
+
+# 2 MODELING CLASS WITH SIMPLEX
+
+It is known that by proper embedding, the feature representations of images or documents in the same class spatially cluster together. Each feature vector with a length of $d$ , in its nature, corresponds to a point in $d$ -dimensional space. We model each class as a polytope, with feature representation of each data point in this class as its vertex.
+
+Our approach is based on the idea that feature vectors of the test sample will be close to the polytope of its own class, formed by feature vectors of the corresponding examples, and distant from the others. Hence, we can perform the classification by finding the ’nearest’ class polytope to which the test point belongs, using carefully designed distance metrics associated with the content of polytope.
+
+As we point out in the introduction, there is no exact solution to computing the volume of a polytope. Therefore, we resort to the simplex to accomplish our idea. The simplex is the simplest counterpart of convex polytope and its volume admits a closed form expression. So we focus our attention on simplex to develop our algorithm.
+
+# 2.1 SIMPLEX
+
+A simplex is the conceptual extension of a triangle in high-dimensional spaces. To be formal, let $\hat { \mathcal { Y } } = \{ y _ { 0 } , y _ { 1 } , \dotsc , y _ { n } \}$ denote a set of points in $\mathbb { R } ^ { d }$ . A simplex is the convex polytope with the condition of $n = d$ , implying that there needs exact $d + 1$ points to constitute a simplex in the $d$ -dimensional space. For convenience, we call such a simplex the $d$ -simplex. For instance, a line is a 1-simplex, a triangle is a 2-simplex, and a tetrahedron is a 3-simplex. Moreover, a line has the length, a triangle has the area, and a tetrahedron has the volume. In convention, we use the contents to represent the length, the area, and the volume (Weisstein, 2002).
+
+A particularly intriguing property of the simplex is that its content can be written in a closed form by virtue of the Cayley-Menger determinant (Cayley, 2009). To show this, let $A = [ y _ { 1 } - y _ { 0 } , \dotsc , y _ { n } - y _ { 0 } ]$ and the Cayley-Menger matrix
+
+$$
+{ \hat { P } } = \left[ { \begin{array} { c c } { 0 } & { e ^ { T } } \\ { e } & { P } \end{array} } \right] ,
+$$
+
+where $e$ denotes the all-one column vector of length $n + 1$ , $T$ presents the transpose of a matrix or a vector, and the entry $P _ { i j }$ of the distance matrix $P$ is of form $P _ { i j } = \| y _ { i } - y _ { j } \| ^ { 2 }$ . The content of simplex $\hat { \mathcal { V } }$ has two expressions that coincide with each other, showing that
+
+$$
+C ^ { 2 } ( \hat { \mathcal { V } } ) = \frac { 1 } { ( n ! ) ^ { 2 } } \operatorname* { d e t } ( A ^ { T } A ) = \frac { - 1 } { ( - 2 ) ^ { n } ( n ! ) ^ { 2 } } \operatorname* { d e t } ( \hat { P } ) ,
+$$
+
+where $\operatorname* { d e t } ( A ^ { T } A )$ is the Gram determinant and $\operatorname* { d e t } ( \hat { P } )$ is the Cayley-Menger determinant. Our analysis is based on the application of formula (2).
+
+# 2.2 DISTANCE MEASUREMENT WITH SIMPLEX
+
+Let $\mathcal { V } = \{ y _ { 1 } , \ldots , y _ { n } \}$ be the feature set of an arbitrary class. These features can be derived from outputs of deep neural networks, e.g., CNN. It is clear that $\hat { Y } = \{ { \mathcal { Y } } \cup y _ { 0 } \}$ . Let $t$ denote a test sample. It is clear the content $C ( \mathcal { V } )$ of the corresponding simplex1 will be large if data points in $\mathcal { V }$ are sparse and small if compact. Therefore, $C ( \boldsymbol { y } )$ is a plausible measurement for the class scatter.
+
+An exact $d$ -simplex will be formed during testing process if the test sample is merged into $\mathcal { V }$ . Then the associated content will be improved from $C ( \boldsymbol { y } )$ to $C ( \mathcal { y } \cup t )$ . The incremental content will be marginal if the feature point of the test sample is close to the class simplex, meaning the high correlation of the spatial proximity. Then the dissimilarity measurement of one test sample to one class can be written as
+
+$$
+\left( \ell ( t , \mathcal { Y } ) \right) ^ { \frac { 1 } { 2 } } = \frac { C ( \mathcal { Y } \cup t ) } { C ( \mathcal { Y } ) } .
+$$
+
+Here the numerator $C ( \mathcal { V } )$ serves to eliminating the quantitative influence of the class scatter. The normalization is indispensable because for a large $C ( \boldsymbol { y } )$ , the incremental content $C ( \mathcal { Y } \cup t ) - C ( \mathcal { Y } )$ will be prone to be relatively large even if the test sample is close to the simplex.
+
+To make it clear, we explicitly write $\ell ( t , \mathcal { Y } )$ . Let the Cayley-Menger matrix pertaining to simplex $\mathcal { V }$ be
+
+$$
+{ \hat { Q } } = \left[ { \begin{array} { c c } { 0 } & { e ^ { T } } \\ { e } & { Q } \end{array} } \right] ,
+$$
+
+![](images/d78e7e1230bc4b362348ac57a67af30b6f90896023ffe132a2539c9865b3fbad.jpg)  
+Figure 1: Visualization of simplices formed during a test episode in a $\mathbf { k }$ -way n-shot classification task, where $k { = } 5$ and $\scriptstyle n = 3$ . The points with the same color correspond to the same category and cluster together. Within each class, $k$ vertices form a $( k - 1 )$ -simplex (a triangle in the 2-dimensional plane). With the same embedding function, the test sample point $t$ is also mapped to this space. Combined with one class, a new simplex (tetrahedron in the 3-dimensional space) is obtained, located in the space of one dimension higher than the original one. It is not surprising that the test sample point $t$ is close to its own class while distant from the others, representing a certain degree of intra-class similarities and inter-class diversities.
+
+where $Q _ { i j } = \| y _ { i } - y _ { j } \| ^ { 2 }$ and $i , j = 1 , \ldots , n$ . Then the content of the simplex formed by $\mathcal { V }$ can be written as
+
+$$
+C ^ { 2 } ( \mathcal { Y } ) = \frac { - 1 } { ( - 2 ) ^ { n - 1 } ( ( n - 1 ) ! ) ^ { 2 } } \operatorname* { d e t } ( \hat { Q } ) .
+$$
+
+Substituting (2) and (5) into (3), we derive
+
+$$
+\ell ( t , \mathcal { Y } ) = - \frac { 1 } { 2 n ^ { 2 } } \frac { \operatorname* { d e t } ( \hat { P } ) } { \operatorname* { d e t } ( \hat { Q } ) } ,
+$$
+
+where $y _ { 0 } = t$ is implicitly assumed for $\hat { P }$ . It is straightforward to know that the smaller $\ell ( t , \mathcal { { y } } )$ is, the closer the test point to the class simplex.
+
+To help intuitively understand our algorithm, a visual schematic example is shown in Figure 1, where the complete procedure is figuratively demonstrated.
+
+# 2.3 ISOMETRIC EMBEDDING OF SIMPLEX
+
+It is obvious that $\mathcal { V }$ cannot form a $d$ -simplex due to the number $| \mathcal { V } |$ of data points in $\mathcal { V }$ satisfies $| { \mathcal { y } } | = d$ , violating the definition of the $d$ -simplex. However, our model for the few-shot learning can proceed without any modification. To make this clear, we need to introduce the isometric embedding of the simplex.
+
+The points on a geometric entity $\mathbb { R } ^ { d _ { e } }$ (manifolds or polytopes) can be expressed with coordinates when the entity is placed in an ambient space $\mathbb { R } ^ { d _ { a } }$ . Usually, the intrinsic dimension $d _ { e }$ is much less than the ambient dimension $d _ { a }$ , especially when $d _ { a }$ is large. Formally, there exists a function
+
+$$
+\begin{array} { r } { f : \mathcal { R } ^ { d _ { e } } \to \mathbb { R } ^ { d _ { a } } } \\ { \tau \to f ( \tau ) } \end{array}
+$$
+
+![](images/ca009cbefcb422188ad2f4d4cc661e0b6cbd78e05cd82b9d83bfed569d1b2c3b.jpg)  
+Figure 2: Isometric embedding preserves the geometric properties of a simplex.
+
+For the question that we are interested in, $\mathcal { R } ^ { d _ { e } }$ is a simplex. Both $\mathcal { R } ^ { d _ { e } }$ and $\mathbb { R } ^ { d _ { a } }$ are Euclidean. The isometric embedding means $\lVert \boldsymbol { \tau } _ { i } - \boldsymbol { \tau } _ { j } \rVert = \lVert \boldsymbol { f } ( \boldsymbol { \tau } _ { i } ) - \dot { \boldsymbol { f } } ( \boldsymbol { \tau } _ { j } ) \rVert$ for an arbitrary pair of vertices. For a simplex $s$ in $\mathcal { R } ^ { d _ { e } }$ , therefore, the contents of $C ( S )$ and $C ( f ( S ) )$ satisfy the identity $C ( S ) =$ $C ( f ( S ) )$ under isometric embedding. That is to say, we can correlate the dimension of the simplex with the number of vertices under isometric embedding in the case where the number of vertices is insufficient to construct a $d _ { a }$ -simplex. This reduced simplex in the $\mathbb { R } ^ { d _ { a } }$ is obvious a low-dimensional one.
+
+Two visual instances are illustrated in Figure 2, where a segment line of fixed length is a 1-simplex. It can be embedded in the 1-dimensional, 2-dimensional and 3-dimensional spaces, respectively. Certainly, we can apply the coordinates of different dimensions for these two endpoints. However, its length is constant in different ambient spaces due to the isometric embedding. When a simplex is mapped into a higher dimensional space by an isometric embedding, the coordinates of its vertices vary, whereas its geometric properties pertaining to distance remain unchanged. Therefore we can employ formula (6) to perform our algorithm.
+
+For few-shot classification tasks, such reduced simplices are ubiquitous because feature representations of data points embedded by variously parameterized functions are always of high dimension while the number of available examples for a class is quite few. For example, images classification tasks generally require deep convolutional networks (such as VGGs or Inception) as the embedding function. The VGG16 network produces a long vector of 4096 dimensions after the final fully-connected layer. For a five-shot learning, however, there are only five examples in each class. Hence, the reduced simplices we actually exploit are of dimension four for the computation of $C ( \boldsymbol { y } )$ and dimension five for that of $C ( \mathcal { Y } \cup t )$ .
+
+The above geometric analysis is reminiscent of the theoretic assumption in manifold learning (Tenenbaum et al., 2000; Roweis & Saul, 2000), especially the Isomap algorithm (Tenenbaum et al., 2000). Interested readers may refer to these two seminal papers in manifold learning for further understanding.
+
+# 2.4 METRIC ANALYSIS
+
+It is known that matching network is the extension of metric learning via attention model. Here we analyze the metric characteristic of our algorithm. This angle of analysis may be useful for digging deep insights of few-shot learning. To this end, we need to reveal the details of formula (6), which is described in Theorem 1.
+
+Theorem 1. The geometric dissimilarity measurement $\ell ( t , \mathcal { { y } } )$ from point $t$ to $\mathcal { V }$ can be expanded as the following form
+
+$$
+ \ell ( t , \mathcal { Y } ) = - \frac { 1 } { 2 n ^ { 2 } } \frac { e ^ { T } P ^ { - 1 } e } { e ^ { T } Q ^ { - 1 } e } p ^ { T } Q ^ { - 1 } p ,
+$$
+
+where $p _ { i } = \| y _ { i } - t \| ^ { 2 }$ and
+
+$$
+P = \left[ \begin{array} { c c } { { 0 } } & { { p ^ { T } } } \\ { { p } } & { { Q } } \end{array} \right] .
+$$
+
+Proof. For matrices $S _ { 1 1 } , S _ { 1 2 } , S _ { 2 1 }$ , and $S _ { 2 2 }$ , the Schur’s determinant identity is the form
+
+$$
+\operatorname* { d e t } { \left[ \begin{array} { l l } { S _ { 1 1 } } & { S _ { 1 2 } } \\ { S _ { 2 1 } } & { S _ { 2 2 } } \end{array} \right] } = \operatorname* { d e t } ( S _ { 2 2 } ) \operatorname* { d e t } ( S _ { 1 1 } - S _ { 1 2 } ( S _ { 2 2 } ) ^ { - 1 } S _ { 2 1 } ) .
+$$
+
+Applying the Schur’s determinant identity twice, we can obtain the expanded form of $\operatorname* { d e t } ( \hat { P } )$
+
+$$
+\operatorname* { d e t } ( \hat { P } ) = - e ^ { T } P ^ { - 1 } e \operatorname* { d e t } ( P ) = e ^ { T } P ^ { - 1 } e p ^ { T } Q ^ { - 1 } p \operatorname* { d e t } ( Q ) .
+$$
+
+By the same way, we can also obtain the analogous form of $\operatorname* { d e t } ( { \hat { Q } } )$
+
+$$
+\mathrm { d e t } ( \hat { Q } ) = - e ^ { T } Q ^ { - 1 } e \mathrm { d e t } ( Q ) .
+$$
+
+Substituting equations (10) and (11) into equation (6), we achieve the expansion of the measurement $\ell ( t , \mathcal { { y } } )$ in (7). This concludes the proof of Theorem 1. □
+
+It is readily to know that both $Q$ and $P$ are not positive definite matrices. Hence $Q ^ { - 1 }$ and $P ^ { - 1 }$ cannot be viewed as metric matrices in (7) because there are negative eigenvalues. However, there still exists the explicit algebraic meaning. The first factor $w _ { 1 } = { \check { e } } ^ { T } P ^ { - 1 } e \left/ { \check { e } } ^ { T } Q ^ { - 1 } e \right.$ is an incremental ratio with respect to the class and the second factor $w _ { 2 } = p ^ { T } Q ^ { - 1 } p$ is equivalent to the summation of a kind of scale-normalized distance transformation.
+
+# 3 FEATURE REPRESENTATION BY LOCAL REGIONS
+
+Motivated by the success of applying the decomposed parts in (Lake et al., 2015), we present an approach to constructing a simplex using the spatial feature maps of CNNs. Moreover, the convolutional feature maps have been effectively employed for visual relational reasoning in (Santoro et al., 2017).
+
+While applying deep convolutional networks in classification tasks, the tensor (feature maps) will be flatten to be a 1-D feature vector in the last convolution layer and then it is fed into the fully connected layers. This process makes the feature maps lose adjacency information of spatial structures in the 2-D image.
+
+Although flattening seems inevitable in conventional classification pipeline, for few-shot tasks, it is necessary to collect information more effectively from multiple local regions for making an accurate classification decision. In order to play down the negative effect of flattening operation, besides the flattened feature vectors, we take fully advantage of feature maps by applying various scales of attention windows for the last convolution layer. Within each local region, a $3 \times 3$ region on $5 \times 5$ feature maps for instance, we perform the same flattening operation, generating a feature vector containing local information. Using this strategy, we are able to generate more feature vectors for simplex construction with few samples. Figure 3 clearly displays the operation of sampling feature vectors on feature maps with local regions.
+
+To further carry out this idea of preserving the adjacency information, we tag the $l ^ { 2 }$ $d$ -dimensional cells with their corresponding coordinates indicating their relative spatial locations. With the extra 2 dimensions, we are able to restrain these cells on an underlying manifold, retaining their relative positions as in the original image. With such a simple manipulation, our model shows an appreciable improvement in performance.
+
+![](images/3fb8674af5df71d677aa273fe3d6f257ab12cf93c775c634901e2956298d78aa.jpg)  
+Figure 3: Illustration of sampling feature vectors from feature maps in the last convolution layer. The feature maps corresponding to the different local regions are flattened to be 1-D feature vectors as the vertices of the simplex for the associated class.
+
+![](images/1ba0970d414dc892d44dcce41d279b71d08e82cd63db87b56787cfe0fbcbd6fc.jpg)  
+Figure 4: The architecture of the 4-block CNN used in our experiments.
+
+# 4 EXPERIMENTS
+
+In regard to the experiment setup, the number of examples in each class should be constrained so as to fit the“few-shot” scenario. A typical experiment setting is the $N$ -way $k$ -shot task (Vinyals et al., 2016): for each of the $N$ new categories, $k$ examples are provided. Given a set of unlabeled test samples, the model needs to classify them into these $N$ categories. Since the number of available examples is limited (e.g. 1 or 5), training deep convolutional networks either from the scratch or with fine-tuning on new class data will generally lead to over-fitting. We performed our model on two different datasets: miniImageNet (Vinyals et al., 2016) and Omniglot (Lake et al., 2015).
+
+The algorithms to be compared fall into two categories: conventional methods and deep learning methods. For deep learning methods, we compare our simplex algorithm with three state-of-the-art ones: matching networks (Vinyals et al., 2016), Meta-Learner LSTM (Ravi & Larochelle, 2017), and prototypical networks (Snell et al., 2017). Essentially, our algorithm is to measure the distance between a data point and a data set. For conventional methods, therefore, we take the Mahalanobis distance (Mahalanobis, 1936) and Minimum Incremental Coding Length (MICL) (Wright et al., 2008) for comparison. The MICL algorithm can be used to measure the structural similarity by coding theory of multivariate Gaussian data.
+
+A simple four-block CNN is employed to learn the representations of data both for miniImageNet and Omniglot. The architecture follows the learner network proposed by Ravi & Larochelle (2017), which contains four $3 \times 3$ convolutional layers with 64 filters. Each is followed by batch normalization, ReLU activation and $2 \times 2$ max-pooling. Following all the above layers is one fully connected layer, and lastly a softmax layer with the number equal to the number of classes being trained upon. The output is optimized with a cross-entropy loss function by the Adam optimizer with a learning rate of 0.001. The architecture is shown in Figure 4. The traditional algorithms compared are all performed on features extracted by this four-layer CNN.
+
+Table 1: Few-shot validation of different local regions on miniImageNet $9 5 \%$ confidence interval).   
+
+<table><tr><td>Size of local regions</td><td>5-way 1-shot Acc.</td><td>5-way5-shot Acc.</td></tr><tr><td>1×1</td><td>40.88%± 0.44%</td><td></td></tr><tr><td>2×2</td><td>42.66%± 0.48%</td><td>58.21% ± 0.47%</td></tr><tr><td>3×3</td><td>42.34%±0.42%</td><td>58.98%±0.40%</td></tr><tr><td>4×4</td><td>40.76%± 0.43%</td><td>58.02% ± 0.44%</td></tr><tr><td>5×5</td><td>32.85% ± 0.70%</td><td>58.63% ±0.68%</td></tr></table>
+
+Table 2: Few-shot accuracy on miniImageNet on $9 5 \%$ confidence interval. \*Reported by Ravi & Larochelle (2017)   
+
+<table><tr><td>Model</td><td>Fine Tune</td><td>5-way 1-shot Acc.</td><td>5-way 5-shot Acc.</td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td>Baseline KNN</td><td>N</td><td>32.69% ± 0.75%</td><td>40.32% ± 0.68%</td></tr><tr><td>Mahalanobis Distance MICL (Wright et al., 2008)</td><td>N</td><td>32.39% ± 0.70% 42.59%±0.46%</td><td>60.09%± 0.39% 61.06% ± 0.36%</td></tr><tr><td></td><td>N</td><td></td><td></td></tr><tr><td>Matching networks*</td><td>N</td><td>43.40% ± 0.78%</td><td>51.09% ± 0.71%</td></tr><tr><td>Matching networks FCE*</td><td>N</td><td>43.56% ± 0.84%</td><td>55.31% ± 0.73%</td></tr><tr><td>Meta-Learner LSTM*</td><td>N</td><td>43.44% ± 0.77%</td><td>60.60% ± 0.71%</td></tr><tr><td>Prototypical networks (Snell et al.,2017)</td><td>N</td><td>49.42% ± 0.78%</td><td>68.20% ±0.66%</td></tr><tr><td>Simplex (ours)</td><td>N</td><td>46.93% ± 0.43%</td><td>62.00%± 0.26%</td></tr></table>
+
+# 4.1 MINIIMAGENET
+
+ImageNet is a large-scale image database designed for multiple computer vision tasks. Since it would be extremely time-consuming to test the few-shot performance on the full ImageNet, we turn to miniImageNet instead (Vinyals et al., 2016), the subset of ImageNet with 100 categories selected. For each category, 600 images with size $8 4 \times 8 4$ are provided. Following the same split as Ravi & Larochelle (2017), miniImageNet is divided into a 64-class training set, a 16-class validation set and a 20-class test set. We train the embedding network on the 64-class training set and validate the result based on the 16-class validation set. The 20-class test set is only for the few-shot experiments.
+
+For each image fed into the 4-block CNN, the last feature map $( 6 4 @ 5 \times 5 )$ is retrieved for simplex modeling. In order to choose a proper local region for conducting the few-shot experiments, we first test the $N$ -way $k \mathrm { . }$ -shot accuracy of different sizes of regions on the validation set. The size of the local regions varies from $2 \times 2$ to $5 \times 5$ . 2 The result is shown in Table 1. On the validation set, the models with $2 \times 2$ and $3 \times 3$ regions perform the best on the 1-shot and 5-shot tasks, respectively. We take them to compare with other models on the test set.
+
+Following the same splits proposed by Ravi & Larochelle (2017), we compare the performance of our model on miniImageNet directly with other models. We also conduct the $K$ -nearest neighbor on the feature vectors generated from the 4-block model as a comparison (Baseline KNN). The results are shown in Table 2. Using the same pre-trained 4-block CNN, our model performs much better than the baseline KNN, meanwhile outperforms the matching networks and Meta-learner LSTM. However, the prototypical networks are better than our simplex algorithm.
+
+# 4.2 OMNIGLOT
+
+Omniglot dataset for one-shot learning (Lake et al., 2015) contains characters from 50 alphabets ranging from Korean to ancient Greek. Each character is provided with 20 examples handwritten by
+
+Table 3: Few-shot accuracy on Omniglot.   
+
+<table><tr><td rowspan="2">Model</td><td colspan="2"> 5-way</td><td colspan="2">20-way</td></tr><tr><td>1-shot</td><td> 5-shot</td><td>1-shot</td><td>5-shot</td></tr><tr><td>Baseline KNN</td><td>94.1%</td><td>98.7%</td><td>85.1%</td><td>95.8%</td></tr><tr><td>Mahalanobis distance</td><td>94.5%</td><td>99.1%</td><td>85.8%</td><td>96.9%</td></tr><tr><td>MICL (Wright et al., 2008)</td><td>95.4%</td><td>99.1%</td><td>87.3%</td><td>96.9%</td></tr><tr><td>Siamese networks (Koch et al., 2015)</td><td>97.3%</td><td>98.4%</td><td></td><td>97.0%</td></tr><tr><td>Matching networks (Vinyals et al., 2016)</td><td>98.1%</td><td>98.9%</td><td>88.2% 93.8%</td><td>98.5%</td></tr><tr><td>Prototypical networks (Snell et al., 2017)</td><td>97.4%</td><td>99.3%</td><td>96.0%</td><td>98.9%</td></tr><tr><td>Simplex (ours)</td><td>94.6%</td><td>99.1%</td><td>85.7%</td><td>97.0%</td></tr></table>
+
+20 online contributors. Omniglot fits the few-shot scenario well: comparing with the large number of categories (1623), the examples (20) are relatively limited, making it difficult to be trained upon with conventional parametric networks.
+
+Following the training setting in Vinyals et al. (2016), we split Omniglot into two parts: 1200 characters for training and the rest for validation and few-shot testing. The embedding 4-layer CNN is almost the same as used for training miniImageNet, except that the output feature map is changed to $6 4 @ 1 \times 1$ due to the decrease in image size. We compare the $N$ -way $k$ -shot performance of our model with others. The results are shown in Table 3. Our models are overall comparable to the other state-of-the-art works.
+
+# 4.3 ROBUSTNESS OF SIMPLEX METHOD
+
+Besides, we conduct more experiments on MICL and our model for a further comparison on robustness. MICL has a distortion parameter $\epsilon ^ { 2 }$ in the coding length, i.e. (Wright et al., 2008)
+
+$$
+L _ { \epsilon } ( \chi ) = \frac { n + d } { 2 } \log _ { 2 } \operatorname * { d e t } \Big ( I + \frac { d } { \epsilon ^ { 2 } } \Sigma ( \chi ) \Big ) + \frac { d } { 2 } \log _ { 2 } \big ( 1 + \frac { \mu ^ { T } \mu } { \epsilon ^ { 2 } } \big ) ,
+$$
+
+where $\Sigma ( \mathcal { X } )$ is the corresponding covariance matrix and $\mu$ is the center of $\mathcal { X }$ . Through adjusting the parameter, the optimal performance of the model can be obtained on the validation set. We follow the same way as MICL and set up the free parameter in our simplex model. To be specific, let $\lambda _ { 1 } , \ldots , \lambda _ { n }$ denote the eigenvalues of $\hat { Q }$ . It is easy to write $\begin{array} { r } { \operatorname* { d e t } ( \hat { Q } ) = \prod _ { i = 1 } ^ { n } \lambda _ { i } } \end{array}$ . To include the free parameter, we employ the following expression instead
+
+$$
+\operatorname * { d e t } { \Bigl ( } I + { \frac { d } { \epsilon ^ { 2 } } } { \hat { Q } } { \Bigr ) } = \prod _ { i = 1 } ^ { n } { \Bigl ( } 1 + { \frac { d } { \epsilon ^ { 2 } } } \lambda _ { i } { \Bigr ) } .
+$$
+
+The same computation is also performed for $\operatorname* { d e t } ( \hat { P } )$ .
+
+The experiment is conducted on the different values of distortion $\epsilon ^ { 2 }$ . According to the results in Figure 5, it is clear that our model is far more robust than MICL. Although for some value of $\epsilon ^ { 2 }$ , the accuracy of MICL is close to our model, the overall performance of MICL is instable with respect to $\epsilon ^ { 2 }$ . On the contrary, the performance of our model almost keeps invariant in a wide spectrum of $\epsilon ^ { 2 }$ .
+
+# 4.4 ANALYSIS AND DISCUSS
+
+It is worth noting that our simplex metric can also be combined with very recently published works including prototypical networks (Snell et al., 2017) and meta-learning methods, such as (Finn et al., 2017) and (Mishra et al., 2017). For example, the distance measure in prototypical networks can be replaced with our simplex metric and the associated networks can be learned in the end-to-end manner by the supervision of simplex volumes. For few-shot cases, the number of examples in each class is quite limited. So the computational complexity can be well managed. Besides, the meta learning methods are to learn models between tasks instead of data points. Therefore, they are applicable to improve performance based on the simplex metric. We leave these for further explorations.
+
+![](images/d210674bacd3f5ab12b615c6d7d174e1909258d97d06d9021ec59faa6ec80cb1.jpg)  
+Figure 5: Comparison of robustness between our simplex algorithm and MICL with respect to free parameters $\epsilon ^ { 2 }$ .
+
+On the other hand, MICL (Wright et al., 2008) and our algorithm directly exploit the features of new classes yielded by CNNs that are not retrained, fine-tuned, or performed any relevant refinement of model parameters on new classes. Even so, these two approaches achieve better performance on 5-shot recognition than matching network (Vinyals et al., 2016) and one of meta-learning algorithms (Ravi & Larochelle, 2017) that apply more information of new classes and high-level learning techniques. Both MICL and our simplex algorithm harness the geometric characterization of class structures 3. Therefore, our work might inspire the interest of exploring geometry to solve few-shot learning problems, which is paid little attention in the field.
+
+# 5 CONCLUSION
+
+In this paper, we designed a novel method to deal with few-shot learning problems. Our idea was from the point of view of high dimensional convex geometry and transformed the learning problem to the study of volumes of simplices. The relation between a test sample and a class was investigated via the volumes of different polytopes. By harnessing the power of simplex, we gave a rigorous mathematical formulation for our approach. We also conduced extensive simulations to validate our method. The results on various datasets showed the accuracy and robustness of the geometry-based method, compared to the state-of-the-art results in the literature.
+
+# REFERENCES
+
+Arthur Cayley. On a theorem in the geometry of position, volume 1 of Cambridge Library Collection - Mathematics, pp. 14. Cambridge University Press, 2009. doi: 10.1017/CBO9780511703676. 002.
+
+Li Fei-Fei, Rob Fergus, and Pietro Perona. A Bayesian approach to unsupervised one-shot learning of object categories. In ICCV, 2003.
+
+Li Fei-Fei, Rob Fergus, and Pietro Perona. One-shot learning of object categories. IEEE Transactions on Pattern Analysis and Machine Intelligence, 28:594–611, 2006.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. CoRR, abs/1703.03400, 2017. URL http://arxiv.org/abs/1703. 03400.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. CoRR, abs/1502.01852, 2015a. URL http://arxiv.org/abs/1502.01852.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CoRR, abs/1512.03385, 2015b. URL http://arxiv.org/abs/1512.03385.
+
+Lukasz Kaiser, Ofir Nachum, Aurko Roy, and Samy Bengio. Learning to remember rare events. CoRR, abs/1703.03129, 2017. URL http://arxiv.org/abs/1703.03129.
+
+Gregory Koch, Richard Zemel, and Ruslan Salakhutdinov. Siamese neural networks for one-shot image recognition. 2015.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In F. Pereira, C. J. C. Burges, L. Bottou, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 25, pp. 1097– 1105. Curran Associates, Inc., 2012. URL http://papers.nips.cc/paper/ 4824-imagenet-classification-with-deep-convolutional-neural-networks. pdf.
+
+Brenden M. Lake, Ruslan Salakhutdinov, and Joshua B. Tenenbaum. Human-level concept learning through probabilistic program induction. Science, 350(6266):1332–1338, 2015. ISSN 0036-8075. doi: 10.1126/science.aab3050. URL http://science.sciencemag.org/content/ 350/6266/1332.
+
+Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444, 05 2015. URL http://dx.doi.org/10.1038/nature14539.
+
+Xingyu Lin, Hao Wang, Zhihao Li, Yimeng Zhang, Alan L. Yuille, and Tai Sing Lee. Transfer of view-manifold learning to similarity perception of novel objects. CoRR, abs/1704.00033, 2017. URL http://arxiv.org/abs/1704.00033.
+
+Prasanta Chandra Mahalanobis. On the generalised distance in statistics. Proceedings of the National Institute of Sciences of India, 1936, pp. 49–55, 1936.
+
+Nikhil Mishra, Mostafa Rohaninejad, Xi Chen, and Pieter Abbeel. Meta-learning with temporal convolutions. CoRR, abs/1707.03141, 2017. URL http://arxiv.org/abs/1707.03141.
+
+Siyuan Qiao, Chenxi Liu, Wei Shen, and Alan L. Yuille. Few-shot image recognition by predicting parameters from activations. CoRR, abs/1706.03466, 2017. URL http://arxiv.org/abs/ 1706.03466.
+
+Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. International Conference on Learning Representations, 2017.
+
+Sam T. Roweis and Lawrence K. Saul. Nonlinear dimensionality reduction by locally linear embedding. Science, 290(5500):2323–2326, 2000. ISSN 0036-8075. doi: 10.1126/science.290.5500. 2323. URL http://science.sciencemag.org/content/290/5500/2323.
+
+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 FeiFei. ImageNet large scale visual recognition challenge. International Journal of Computer Vision (IJCV), 115(3):211–252, 2015. doi: 10.1007/s11263-015-0816-y.
+
+Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy P. Lillicrap. Oneshot learning with memory-augmented neural networks. CoRR, abs/1605.06065, 2016. URL http://arxiv.org/abs/1605.06065.
+
+Adam Santoro, David Raposo, David G.T. Barrett, Mateusz Malinowski, Razvan Pascanu, Peter Battaglia, and Timothy Lillicrap. A simple neural network module for relational reasoning. In arXiv:1706.01427, 2017.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. CoRR, abs/1409.1556, 2014. URL http://arxiv.org/abs/1409.1556.
+
+Jake Snell, Kevin Swersky, and Richard S. Zemel. Prototypical networks for few-shot learning. CoRR, abs/1703.05175, 2017. URL http://arxiv.org/abs/1703.05175.   
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott E. Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. CoRR, abs/1409.4842, 2014. URL http://arxiv.org/abs/1409.4842.   
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. CoRR, abs/1512.00567, 2015. URL http://arxiv.org/abs/1512.00567.   
+Joshua B Tenenbaum, Vin De Silva, and John C Langford. A global geometric framework for nonlinear dimensionality reduction. Science, 290(5500):2319–2323, 2000.   
+Joshua B Tenenbaum, Charles Kemp, Thomas L Griffiths, and Noah D Goodman. How to grow a mind: Statistics, structure, and abstraction. Science, 331 6022:1279–85, 2011.   
+Oriol Vinyals, Charles Blundell, Timothy P. Lillicrap, Koray Kavukcuoglu, and Daan Wierstra. Matching networks for one shot learning. CoRR, abs/1606.04080, 2016. URL http://arxiv. org/abs/1606.04080.   
+Eric W. Weisstein. CRC concise encyclopedia of mathematics, second edition. CRC Press, 2002.   
+John Wright, Yangyu Tao, Zhouchen Lin, Yi Ma, and Heung-Yeung Shum. Classification via minimum incremental coding length (MICL). In Advances in Neural Information Processing Systems, pp. 1633–1640, 2008.

parse/train/rJfHoM-C-/rJfHoM-C-_content_list.json

@@ -0,0 +1,1423 @@
+[
+    {
+        "type": "text",
+        "text": "FEW-SHOT LEARNING WITH SIMPLEX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            629,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            145,
+            398,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            210,
+            544,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning has made remarkable achievement in many fields. However, learning the parameters of neural networks usually demands a large amount of labeled data. The algorithms of deep learning, therefore, encounter difficulties when applied to supervised learning where only little data are available. This specific task is called few-shot learning. To address it, we propose a novel algorithm for fewshot learning using discrete geometry, in the sense that the samples in a class are modeled as a reduced simplex. The volume of the simplex is used for the measurement of class scatter. During testing, combined with the test sample and the points in the class, a new simplex is formed. Then the similarity between the test sample and the class can be quantized with the ratio of volumes of the new simplex to the original class simplex. Moreover, we present an approach to constructing simplices using local regions of feature maps yielded by convolutional neural networks. Experiments on Omniglot and miniImageNet verify the effectiveness of our simplex algorithm on few-shot learning. ",
+        "bbox": [
+            233,
+            241,
+            764,
+            435
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            462,
+            334,
+            477
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning has exhibited outstanding ability in various disciplines including computer vision, natural language processing and speech recognition (LeCun et al., 2015). For instance, AlexNet has made a breakthrough on recognizing millions of imagery objects by means of deep Convolutional Neural Network (CNN) (Krizhevsky et al., 2012). In the past five years, the algorithmic capability of comprehending visual concepts has been significantly improved by elaborately well-designed deep learning architectures (He et al., 2015a; Szegedy et al., 2014). However, training deep neural networks such as the widely employed CNNs of AlexNet (Krizhevsky et al., 2012), Inception (Szegedy et al., 2015), VGG (Simonyan & Zisserman, 2014), and ResNet (He et al., 2015b), needs the supervision of many class labels which are handcrafted. For example, the number of samples of each class in the ImageNet of object recognition benchmark (Russakovsky et al., 2015) is more than one thousand. In fact, the number of labelled samples used for learning parameters of CNNs is far more than that because data augmentation is usually applied. This kind of learning obviously deviates from the manner of human cognition. A child can recognize a new object that she/he has never seen only by several examples, from simple shapes like rectangles to highly semantic animals like tigers. However, deep learning algorithms encounter difficulty in such scenarios where only very sparse data are available for learning to recognize a new category, thus raising the research topic of one-shot learning or few-shot learning (Fei-Fei et al., 2003; Tenenbaum et al., 2011). ",
+        "bbox": [
+            174,
+            492,
+            825,
+            728
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The seminal work Fei-Fei et al. (2006) models few-shot learning with the Bayesian framework. Empirical knowledge of available categories is learned and parameterized as a probability density function. The unseen class with a handful of examples is modeled as the posterior by updating the prior. Bayesian theory provides a simple and elegant idea for solving learning problems with little data. If decomposed into parts or programs, an object can be described by the joint distribution of Bayesian criterion. In this manner, human-level performance on one-shot learning has been derived for discovering simple visual concepts such as ancient handwritten characters (Lake et al., 2015). ",
+        "bbox": [
+            174,
+            736,
+            825,
+            833
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "With the prevalence of deep learning, the recent work for few-shot learning focuses on the application of deep neural networks that have more capacity to accommodate the complexity of object representations. Siamese neural network facilitates the performance of few-shot recognition by means of twin networks of sharing parameters, optimizing the distances of representative features in intraclasses (Koch et al., 2015). The counterpart of learning data structures by distance is also formulated by triplet loss in Lin et al. (2017). Researchers in Lin et al. (2017) assert that the distance metrics can learn the intrinsic manifold structures of training data such that the network is more general and robust when employed for untrained objects. A very recent work pertaining to distance-based optimization, named Prototypical Networks (Snell et al., 2017), significantly improves the capability of few-shot recognition. Prototypical Networks attempt to minimize the distance of the test sample to the center of each class and are learned in the end-to-end manner. ",
+        "bbox": [
+            174,
+            840,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Memory-augmented architectures are also proposed to help assimilate new classes with more accurate inference (Santoro et al., 2016). Matching network embeds metric learning in neural network in the light of attention mechanism which is embodied by softmax (Vinyals et al., 2016). In a very recent work, the large-scale memory without the need of resetting during training is formulated as an embedded module for arbitrary neural networks to remember the information of rare events (Kaiser et al., 2017). In order to obtain rapid learning with limited samples, meta learning is exploited both in memory network and matching network. This “learning to learn” technique is extended to deal with few-shot learning from the point of view of optimization (Ravi & Larochelle, 2017). To be specific, a LSTM-based meta learner learns to mimic the exact optimization algorithm and then harnesses the acquired capability to train the learner applied for the few-shot cases. The latest meta learning algorithms also deal with few-shot learning from different angles, e.g. the fast adaptation of neural networks (Finn et al., 2017), and temporal convolution (Mishra et al., 2017). ",
+        "bbox": [
+            174,
+            180,
+            825,
+            347
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In addition to the application of memory module or attention model in LSTM, there is another type of algorithms digging the effective way of transferring the discriminative power of pre-trained models to few-shot circumstances. Resorting to the correlation between the activations in the last feature layers and the associated parameters for softmax, a transformation is learned to derive the parameters for predicting new classes from corresponding activations (Qiao et al., 2017). ",
+        "bbox": [
+            174,
+            354,
+            825,
+            424
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The algorithms based on deep learning can learn more expressive representations for objects, essentially boosting the quality of feature extraction. However, the softmax classifier discriminates all categories by class boundaries, bypassing the steps that carefully characterize the structure of each class. Thus the algorithmic performance will deteriorate grossly if the distribution of new class cannot be accurately modeled by trained networks. Besides softmax, another commonly applied method, $k$ nearest neighbors (KNN), is a point-to-point measurement and is incapable of conveying global structural information. ",
+        "bbox": [
+            174,
+            431,
+            825,
+            527
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To address this issue, we propose a geometric method for few-shot learning. Our perspective is that accurate geometric characterization for each class is essential when only a handful of samples are available, because such sparse data are usually insufficient to fit well-converged parameterized classifier. To this end, we harness convex polytope to fit a class, in the sense that we construct a convex polytope by selecting the samples in the class as the vertices of the polytope. The volume of the polytope is taken as the measurement of class scatter. Thus the polytopal volume may be improved after including the query sample in the test set during the testing trial. The normalized volume with respect to the original counterpart is applied to compute the distance from the test sample to the test set. To highlight the structural details of object parts, we present the construction of polytope based on convolutional feature maps as well. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            674
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To the best of our understanding, however, there is no exact formula to calculating the volume of general convex polytope. To make our algorithm feasible, therefore, we use the simplest convex polytope — simplex instead. The volume of a simplex can be expressed by the Cayley-Menger determinant (Cayley, 2009), thus casting the problem of few-shot recognition as a simple calculation of linear algebra. Experiments on Omniglot and miniImageNet datasets verify the effectiveness of our simple algorithm. ",
+        "bbox": [
+            174,
+            681,
+            825,
+            765
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 MODELING CLASS WITH SIMPLEX ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            795,
+            486,
+            810
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "It is known that by proper embedding, the feature representations of images or documents in the same class spatially cluster together. Each feature vector with a length of $d$ , in its nature, corresponds to a point in $d$ -dimensional space. We model each class as a polytope, with feature representation of each data point in this class as its vertex. ",
+        "bbox": [
+            174,
+            832,
+            825,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our approach is based on the idea that feature vectors of the test sample will be close to the polytope of its own class, formed by feature vectors of the corresponding examples, and distant from the others. Hence, we can perform the classification by finding the ’nearest’ class polytope to which the test point belongs, using carefully designed distance metrics associated with the content of polytope. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As we point out in the introduction, there is no exact solution to computing the volume of a polytope. Therefore, we resort to the simplex to accomplish our idea. The simplex is the simplest counterpart of convex polytope and its volume admits a closed form expression. So we focus our attention on simplex to develop our algorithm. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            195
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 SIMPLEX ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            214,
+            279,
+            228
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A simplex is the conceptual extension of a triangle in high-dimensional spaces. To be formal, let $\\hat { \\mathcal { Y } } = \\{ y _ { 0 } , y _ { 1 } , \\dotsc , y _ { n } \\}$ denote a set of points in $\\mathbb { R } ^ { d }$ . A simplex is the convex polytope with the condition of $n = d$ , implying that there needs exact $d + 1$ points to constitute a simplex in the $d$ -dimensional space. For convenience, we call such a simplex the $d$ -simplex. For instance, a line is a 1-simplex, a triangle is a 2-simplex, and a tetrahedron is a 3-simplex. Moreover, a line has the length, a triangle has the area, and a tetrahedron has the volume. In convention, we use the contents to represent the length, the area, and the volume (Weisstein, 2002). ",
+        "bbox": [
+            173,
+            239,
+            825,
+            340
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A particularly intriguing property of the simplex is that its content can be written in a closed form by virtue of the Cayley-Menger determinant (Cayley, 2009). To show this, let $A = [ y _ { 1 } - y _ { 0 } , \\dotsc , y _ { n } - y _ { 0 } ]$ and the Cayley-Menger matrix ",
+        "bbox": [
+            174,
+            347,
+            823,
+            388
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/283cf2c811d08ce4e53a11978d8ef689103cc52221f4dc81000f6f838ed0a56a.jpg",
+        "text": "$$\n{ \\hat { P } } = \\left[ { \\begin{array} { c c } { 0 } & { e ^ { T } } \\\\ { e } & { P } \\end{array} } \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            446,
+            390,
+            550,
+            425
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $e$ denotes the all-one column vector of length $n + 1$ , $T$ presents the transpose of a matrix or a vector, and the entry $P _ { i j }$ of the distance matrix $P$ is of form $P _ { i j } = \\| y _ { i } - y _ { j } \\| ^ { 2 }$ . The content of simplex $\\hat { \\mathcal { V } }$ has two expressions that coincide with each other, showing that ",
+        "bbox": [
+            174,
+            429,
+            825,
+            474
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4b8ec7339c5beee4133059b5f0c481870a676c7c11f96609af3370bdb4831e51.jpg",
+        "text": "$$\nC ^ { 2 } ( \\hat { \\mathcal { V } } ) = \\frac { 1 } { ( n ! ) ^ { 2 } } \\operatorname* { d e t } ( A ^ { T } A ) = \\frac { - 1 } { ( - 2 ) ^ { n } ( n ! ) ^ { 2 } } \\operatorname* { d e t } ( \\hat { P } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            482,
+            668,
+            516
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\operatorname* { d e t } ( A ^ { T } A )$ is the Gram determinant and $\\operatorname* { d e t } ( \\hat { P } )$ is the Cayley-Menger determinant. Our analysis is based on the application of formula (2). ",
+        "bbox": [
+            174,
+            525,
+            826,
+            556
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 DISTANCE MEASUREMENT WITH SIMPLEX ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            574,
+            506,
+            588
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $\\mathcal { V } = \\{ y _ { 1 } , \\ldots , y _ { n } \\}$ be the feature set of an arbitrary class. These features can be derived from outputs of deep neural networks, e.g., CNN. It is clear that $\\hat { Y } = \\{ { \\mathcal { Y } } \\cup y _ { 0 } \\}$ . Let $t$ denote a test sample. It is clear the content $C ( \\mathcal { V } )$ of the corresponding simplex1 will be large if data points in $\\mathcal { V }$ are sparse and small if compact. Therefore, $C ( \\boldsymbol { y } )$ is a plausible measurement for the class scatter. ",
+        "bbox": [
+            173,
+            599,
+            825,
+            660
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "An exact $d$ -simplex will be formed during testing process if the test sample is merged into $\\mathcal { V }$ . Then the associated content will be improved from $C ( \\boldsymbol { y } )$ to $C ( \\mathcal { y } \\cup t )$ . The incremental content will be marginal if the feature point of the test sample is close to the class simplex, meaning the high correlation of the spatial proximity. Then the dissimilarity measurement of one test sample to one class can be written as ",
+        "bbox": [
+            173,
+            666,
+            825,
+            736
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b1bbd64f42eab21190c0a4644213b917f8180a0151da2c5cf4c0f05e8df0e713.jpg",
+        "text": "$$\n\\left( \\ell ( t , \\mathcal { Y } ) \\right) ^ { \\frac { 1 } { 2 } } = \\frac { C ( \\mathcal { Y } \\cup t ) } { C ( \\mathcal { Y } ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            416,
+            734,
+            583,
+            768
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here the numerator $C ( \\mathcal { V } )$ serves to eliminating the quantitative influence of the class scatter. The normalization is indispensable because for a large $C ( \\boldsymbol { y } )$ , the incremental content $C ( \\mathcal { Y } \\cup t ) - C ( \\mathcal { Y } )$ will be prone to be relatively large even if the test sample is close to the simplex. ",
+        "bbox": [
+            174,
+            773,
+            825,
+            818
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To make it clear, we explicitly write $\\ell ( t , \\mathcal { Y } )$ . Let the Cayley-Menger matrix pertaining to simplex $\\mathcal { V }$ be ",
+        "bbox": [
+            171,
+            823,
+            826,
+            851
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cedf253463d29c22c7646dc51d961676b0e94d07f6de1858db799d6887be0ae4.jpg",
+        "text": "$$\n{ \\hat { Q } } = \\left[ { \\begin{array} { c c } { 0 } & { e ^ { T } } \\\\ { e } & { Q } \\end{array} } \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            446,
+            849,
+            550,
+            885
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/d78e7e1230bc4b362348ac57a67af30b6f90896023ffe132a2539c9865b3fbad.jpg",
+        "image_caption": [
+            "Figure 1: Visualization of simplices formed during a test episode in a $\\mathbf { k }$ -way n-shot classification task, where $k { = } 5$ and $\\scriptstyle n = 3$ . The points with the same color correspond to the same category and cluster together. Within each class, $k$ vertices form a $( k - 1 )$ -simplex (a triangle in the 2-dimensional plane). With the same embedding function, the test sample point $t$ is also mapped to this space. Combined with one class, a new simplex (tetrahedron in the 3-dimensional space) is obtained, located in the space of one dimension higher than the original one. It is not surprising that the test sample point $t$ is close to its own class while distant from the others, representing a certain degree of intra-class similarities and inter-class diversities. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            225,
+            111,
+            772,
+            372
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $Q _ { i j } = \\| y _ { i } - y _ { j } \\| ^ { 2 }$ and $i , j = 1 , \\ldots , n$ . Then the content of the simplex formed by $\\mathcal { V }$ can be written as ",
+        "bbox": [
+            176,
+            535,
+            821,
+            563
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9b6cae7f75c870906f9f07d00c7e61fa460fb0d7aa8110f41e0b107582251989.jpg",
+        "text": "$$\nC ^ { 2 } ( \\mathcal { Y } ) = \\frac { - 1 } { ( - 2 ) ^ { n - 1 } ( ( n - 1 ) ! ) ^ { 2 } } \\operatorname* { d e t } ( \\hat { Q } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            560,
+            632,
+            593
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Substituting (2) and (5) into (3), we derive ",
+        "bbox": [
+            176,
+            595,
+            454,
+            611
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/65efb46a4548d8e5c5de0190aae432733764920bfd6510182bbf6b369014bbe3.jpg",
+        "text": "$$\n\\ell ( t , \\mathcal { Y } ) = - \\frac { 1 } { 2 n ^ { 2 } } \\frac { \\operatorname* { d e t } ( \\hat { P } ) } { \\operatorname* { d e t } ( \\hat { Q } ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            617,
+            583,
+            656
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $y _ { 0 } = t$ is implicitly assumed for $\\hat { P }$ . It is straightforward to know that the smaller $\\ell ( t , \\mathcal { { y } } )$ is, the closer the test point to the class simplex. ",
+        "bbox": [
+            173,
+            665,
+            823,
+            694
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To help intuitively understand our algorithm, a visual schematic example is shown in Figure 1, where the complete procedure is figuratively demonstrated. ",
+        "bbox": [
+            173,
+            700,
+            823,
+            729
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 ISOMETRIC EMBEDDING OF SIMPLEX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            746,
+            470,
+            761
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "It is obvious that $\\mathcal { V }$ cannot form a $d$ -simplex due to the number $| \\mathcal { V } |$ of data points in $\\mathcal { V }$ satisfies $| { \\mathcal { y } } | = d$ , violating the definition of the $d$ -simplex. However, our model for the few-shot learning can proceed without any modification. To make this clear, we need to introduce the isometric embedding of the simplex. ",
+        "bbox": [
+            174,
+            772,
+            825,
+            829
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The points on a geometric entity $\\mathbb { R } ^ { d _ { e } }$ (manifolds or polytopes) can be expressed with coordinates when the entity is placed in an ambient space $\\mathbb { R } ^ { d _ { a } }$ . Usually, the intrinsic dimension $d _ { e }$ is much less than the ambient dimension $d _ { a }$ , especially when $d _ { a }$ is large. Formally, there exists a function ",
+        "bbox": [
+            174,
+            834,
+            825,
+            878
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/93e523d97d67801c2a8d5a47d8189a1761bf8d2fefd1855a02ab47f493842fb1.jpg",
+        "text": "$$\n\\begin{array} { r } { f : \\mathcal { R } ^ { d _ { e } } \\to \\mathbb { R } ^ { d _ { a } } } \\\\ { \\tau \\to f ( \\tau ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            442,
+            883,
+            553,
+            922
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/ca009cbefcb422188ad2f4d4cc661e0b6cbd78e05cd82b9d83bfed569d1b2c3b.jpg",
+        "image_caption": [
+            "Figure 2: Isometric embedding preserves the geometric properties of a simplex. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            102,
+            758,
+            335
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For the question that we are interested in, $\\mathcal { R } ^ { d _ { e } }$ is a simplex. Both $\\mathcal { R } ^ { d _ { e } }$ and $\\mathbb { R } ^ { d _ { a } }$ are Euclidean. The isometric embedding means $\\lVert \\boldsymbol { \\tau } _ { i } - \\boldsymbol { \\tau } _ { j } \\rVert = \\lVert \\boldsymbol { f } ( \\boldsymbol { \\tau } _ { i } ) - \\dot { \\boldsymbol { f } } ( \\boldsymbol { \\tau } _ { j } ) \\rVert$ for an arbitrary pair of vertices. For a simplex $s$ in $\\mathcal { R } ^ { d _ { e } }$ , therefore, the contents of $C ( S )$ and $C ( f ( S ) )$ satisfy the identity $C ( S ) =$ $C ( f ( S ) )$ under isometric embedding. That is to say, we can correlate the dimension of the simplex with the number of vertices under isometric embedding in the case where the number of vertices is insufficient to construct a $d _ { a }$ -simplex. This reduced simplex in the $\\mathbb { R } ^ { d _ { a } }$ is obvious a low-dimensional one. ",
+        "bbox": [
+            174,
+            412,
+            825,
+            512
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Two visual instances are illustrated in Figure 2, where a segment line of fixed length is a 1-simplex. It can be embedded in the 1-dimensional, 2-dimensional and 3-dimensional spaces, respectively. Certainly, we can apply the coordinates of different dimensions for these two endpoints. However, its length is constant in different ambient spaces due to the isometric embedding. When a simplex is mapped into a higher dimensional space by an isometric embedding, the coordinates of its vertices vary, whereas its geometric properties pertaining to distance remain unchanged. Therefore we can employ formula (6) to perform our algorithm. ",
+        "bbox": [
+            174,
+            518,
+            825,
+            617
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For few-shot classification tasks, such reduced simplices are ubiquitous because feature representations of data points embedded by variously parameterized functions are always of high dimension while the number of available examples for a class is quite few. For example, images classification tasks generally require deep convolutional networks (such as VGGs or Inception) as the embedding function. The VGG16 network produces a long vector of 4096 dimensions after the final fully-connected layer. For a five-shot learning, however, there are only five examples in each class. Hence, the reduced simplices we actually exploit are of dimension four for the computation of $C ( \\boldsymbol { y } )$ and dimension five for that of $C ( \\mathcal { Y } \\cup t )$ . ",
+        "bbox": [
+            173,
+            623,
+            825,
+            736
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The above geometric analysis is reminiscent of the theoretic assumption in manifold learning (Tenenbaum et al., 2000; Roweis & Saul, 2000), especially the Isomap algorithm (Tenenbaum et al., 2000). Interested readers may refer to these two seminal papers in manifold learning for further understanding. ",
+        "bbox": [
+            174,
+            742,
+            825,
+            799
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.4 METRIC ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            830,
+            344,
+            844
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "It is known that matching network is the extension of metric learning via attention model. Here we analyze the metric characteristic of our algorithm. This angle of analysis may be useful for digging deep insights of few-shot learning. To this end, we need to reveal the details of formula (6), which is described in Theorem 1. ",
+        "bbox": [
+            174,
+            863,
+            825,
+            919
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. The geometric dissimilarity measurement $\\ell ( t , \\mathcal { { y } } )$ from point $t$ to $\\mathcal { V }$ can be expanded as the following form ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fcda46d383dfbf73fdc6500dc53f3882691cd0ddf372783c77430a85b12f3c15.jpg",
+        "text": "$$\n \\ell ( t , \\mathcal { Y } ) = - \\frac { 1 } { 2 n ^ { 2 } } \\frac { e ^ { T } P ^ { - 1 } e } { e ^ { T } Q ^ { - 1 } e } p ^ { T } Q ^ { - 1 } p ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            132,
+            614,
+            167
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $p _ { i } = \\| y _ { i } - t \\| ^ { 2 }$ and ",
+        "bbox": [
+            174,
+            172,
+            348,
+            190
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8755bc0953ae4918ccf1746ca4c26e520e61fb61097b199a9e679bc39a305fcf.jpg",
+        "text": "$$\nP = \\left[ \\begin{array} { c c } { { 0 } } & { { p ^ { T } } } \\\\ { { p } } & { { Q } } \\end{array} \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            446,
+            189,
+            552,
+            224
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Proof. For matrices $S _ { 1 1 } , S _ { 1 2 } , S _ { 2 1 }$ , and $S _ { 2 2 }$ , the Schur’s determinant identity is the form ",
+        "bbox": [
+            169,
+            243,
+            751,
+            261
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fdac24f713bc4392071657c393564d0b256ab2a58727cd6372409ac6f3acd069.jpg",
+        "text": "$$\n\\operatorname* { d e t } { \\left[ \\begin{array} { l l } { S _ { 1 1 } } & { S _ { 1 2 } } \\\\ { S _ { 2 1 } } & { S _ { 2 2 } } \\end{array} \\right] } = \\operatorname* { d e t } ( S _ { 2 2 } ) \\operatorname* { d e t } ( S _ { 1 1 } - S _ { 1 2 } ( S _ { 2 2 } ) ^ { - 1 } S _ { 2 1 } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            267,
+            689,
+            303
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Applying the Schur’s determinant identity twice, we can obtain the expanded form of $\\operatorname* { d e t } ( \\hat { P } )$ ",
+        "bbox": [
+            173,
+            313,
+            784,
+            329
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3fb57c53ffbac2d5f3eeff9b09beffbf7d8a4338719402a7c434207f6a30edd0.jpg",
+        "text": "$$\n\\operatorname* { d e t } ( \\hat { P } ) = - e ^ { T } P ^ { - 1 } e \\operatorname* { d e t } ( P ) = e ^ { T } P ^ { - 1 } e p ^ { T } Q ^ { - 1 } p \\operatorname* { d e t } ( Q ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            337,
+            691,
+            357
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "By the same way, we can also obtain the analogous form of $\\operatorname* { d e t } ( { \\hat { Q } } )$ ",
+        "bbox": [
+            171,
+            367,
+            617,
+            383
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a5e4a545b8e7cfc6edd61b401edb35a7b9b83b708cdfda569cc15a632a7a8e94.jpg",
+        "text": "$$\n\\mathrm { d e t } ( \\hat { Q } ) = - e ^ { T } Q ^ { - 1 } e \\mathrm { d e t } ( Q ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            391,
+            598,
+            411
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Substituting equations (10) and (11) into equation (6), we achieve the expansion of the measurement $\\ell ( t , \\mathcal { { y } } )$ in (7). This concludes the proof of Theorem 1. □ ",
+        "bbox": [
+            176,
+            420,
+            825,
+            449
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "It is readily to know that both $Q$ and $P$ are not positive definite matrices. Hence $Q ^ { - 1 }$ and $P ^ { - 1 }$ cannot be viewed as metric matrices in (7) because there are negative eigenvalues. However, there still exists the explicit algebraic meaning. The first factor $w _ { 1 } = { \\check { e } } ^ { T } P ^ { - 1 } e \\left/ { \\check { e } } ^ { T } Q ^ { - 1 } e \\right.$ is an incremental ratio with respect to the class and the second factor $w _ { 2 } = p ^ { T } Q ^ { - 1 } p$ is equivalent to the summation of a kind of scale-normalized distance transformation. ",
+        "bbox": [
+            173,
+            469,
+            825,
+            540
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 FEATURE REPRESENTATION BY LOCAL REGIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            564,
+            607,
+            579
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Motivated by the success of applying the decomposed parts in (Lake et al., 2015), we present an approach to constructing a simplex using the spatial feature maps of CNNs. Moreover, the convolutional feature maps have been effectively employed for visual relational reasoning in (Santoro et al., 2017). ",
+        "bbox": [
+            174,
+            595,
+            825,
+            651
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "While applying deep convolutional networks in classification tasks, the tensor (feature maps) will be flatten to be a 1-D feature vector in the last convolution layer and then it is fed into the fully connected layers. This process makes the feature maps lose adjacency information of spatial structures in the 2-D image. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            715
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Although flattening seems inevitable in conventional classification pipeline, for few-shot tasks, it is necessary to collect information more effectively from multiple local regions for making an accurate classification decision. In order to play down the negative effect of flattening operation, besides the flattened feature vectors, we take fully advantage of feature maps by applying various scales of attention windows for the last convolution layer. Within each local region, a $3 \\times 3$ region on $5 \\times 5$ feature maps for instance, we perform the same flattening operation, generating a feature vector containing local information. Using this strategy, we are able to generate more feature vectors for simplex construction with few samples. Figure 3 clearly displays the operation of sampling feature vectors on feature maps with local regions. ",
+        "bbox": [
+            173,
+            722,
+            825,
+            847
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To further carry out this idea of preserving the adjacency information, we tag the $l ^ { 2 }$ $d$ -dimensional cells with their corresponding coordinates indicating their relative spatial locations. With the extra 2 dimensions, we are able to restrain these cells on an underlying manifold, retaining their relative positions as in the original image. With such a simple manipulation, our model shows an appreciable improvement in performance. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/3fb8674af5df71d677aa273fe3d6f257ab12cf93c775c634901e2956298d78aa.jpg",
+        "image_caption": [
+            "Figure 3: Illustration of sampling feature vectors from feature maps in the last convolution layer. The feature maps corresponding to the different local regions are flattened to be 1-D feature vectors as the vertices of the simplex for the associated class. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            98,
+            813,
+            277
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/1ba0970d414dc892d44dcce41d279b71d08e82cd63db87b56787cfe0fbcbd6fc.jpg",
+        "image_caption": [
+            "Figure 4: The architecture of the 4-block CNN used in our experiments. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            361,
+            823,
+            483
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            551,
+            326,
+            568
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In regard to the experiment setup, the number of examples in each class should be constrained so as to fit the“few-shot” scenario. A typical experiment setting is the $N$ -way $k$ -shot task (Vinyals et al., 2016): for each of the $N$ new categories, $k$ examples are provided. Given a set of unlabeled test samples, the model needs to classify them into these $N$ categories. Since the number of available examples is limited (e.g. 1 or 5), training deep convolutional networks either from the scratch or with fine-tuning on new class data will generally lead to over-fitting. We performed our model on two different datasets: miniImageNet (Vinyals et al., 2016) and Omniglot (Lake et al., 2015). ",
+        "bbox": [
+            174,
+            589,
+            825,
+            688
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The algorithms to be compared fall into two categories: conventional methods and deep learning methods. For deep learning methods, we compare our simplex algorithm with three state-of-the-art ones: matching networks (Vinyals et al., 2016), Meta-Learner LSTM (Ravi & Larochelle, 2017), and prototypical networks (Snell et al., 2017). Essentially, our algorithm is to measure the distance between a data point and a data set. For conventional methods, therefore, we take the Mahalanobis distance (Mahalanobis, 1936) and Minimum Incremental Coding Length (MICL) (Wright et al., 2008) for comparison. The MICL algorithm can be used to measure the structural similarity by coding theory of multivariate Gaussian data. ",
+        "bbox": [
+            173,
+            694,
+            825,
+            805
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A simple four-block CNN is employed to learn the representations of data both for miniImageNet and Omniglot. The architecture follows the learner network proposed by Ravi & Larochelle (2017), which contains four $3 \\times 3$ convolutional layers with 64 filters. Each is followed by batch normalization, ReLU activation and $2 \\times 2$ max-pooling. Following all the above layers is one fully connected layer, and lastly a softmax layer with the number equal to the number of classes being trained upon. The output is optimized with a cross-entropy loss function by the Adam optimizer with a learning rate of 0.001. The architecture is shown in Figure 4. The traditional algorithms compared are all performed on features extracted by this four-layer CNN. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/32ee466f2b0bcec0c5bd91eca76230c42d951c36e5ed700e780f1025adc88bac.jpg",
+        "table_caption": [
+            "Table 1: Few-shot validation of different local regions on miniImageNet $9 5 \\%$ confidence interval). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Size of local regions</td><td>5-way 1-shot Acc.</td><td>5-way5-shot Acc.</td></tr><tr><td>1×1</td><td>40.88%± 0.44%</td><td></td></tr><tr><td>2×2</td><td>42.66%± 0.48%</td><td>58.21% ± 0.47%</td></tr><tr><td>3×3</td><td>42.34%±0.42%</td><td>58.98%±0.40%</td></tr><tr><td>4×4</td><td>40.76%± 0.43%</td><td>58.02% ± 0.44%</td></tr><tr><td>5×5</td><td>32.85% ± 0.70%</td><td>58.63% ±0.68%</td></tr></table>",
+        "bbox": [
+            269,
+            132,
+            730,
+            234
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/29f92a1eef11fb619fbbf7998da75794c6846420ef168baa7dff6af5238f7d46.jpg",
+        "table_caption": [
+            "Table 2: Few-shot accuracy on miniImageNet on $9 5 \\%$ confidence interval. \\*Reported by Ravi & Larochelle (2017) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Fine Tune</td><td>5-way 1-shot Acc.</td><td>5-way 5-shot Acc.</td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td>Baseline KNN</td><td>N</td><td>32.69% ± 0.75%</td><td>40.32% ± 0.68%</td></tr><tr><td>Mahalanobis Distance MICL (Wright et al., 2008)</td><td>N</td><td>32.39% ± 0.70% 42.59%±0.46%</td><td>60.09%± 0.39% 61.06% ± 0.36%</td></tr><tr><td></td><td>N</td><td></td><td></td></tr><tr><td>Matching networks*</td><td>N</td><td>43.40% ± 0.78%</td><td>51.09% ± 0.71%</td></tr><tr><td>Matching networks FCE*</td><td>N</td><td>43.56% ± 0.84%</td><td>55.31% ± 0.73%</td></tr><tr><td>Meta-Learner LSTM*</td><td>N</td><td>43.44% ± 0.77%</td><td>60.60% ± 0.71%</td></tr><tr><td>Prototypical networks (Snell et al.,2017)</td><td>N</td><td>49.42% ± 0.78%</td><td>68.20% ±0.66%</td></tr><tr><td>Simplex (ours)</td><td>N</td><td>46.93% ± 0.43%</td><td>62.00%± 0.26%</td></tr></table>",
+        "bbox": [
+            173,
+            308,
+            838,
+            479
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.1 MINIIMAGENET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            511,
+            328,
+            525
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ImageNet is a large-scale image database designed for multiple computer vision tasks. Since it would be extremely time-consuming to test the few-shot performance on the full ImageNet, we turn to miniImageNet instead (Vinyals et al., 2016), the subset of ImageNet with 100 categories selected. For each category, 600 images with size $8 4 \\times 8 4$ are provided. Following the same split as Ravi & Larochelle (2017), miniImageNet is divided into a 64-class training set, a 16-class validation set and a 20-class test set. We train the embedding network on the 64-class training set and validate the result based on the 16-class validation set. The 20-class test set is only for the few-shot experiments. ",
+        "bbox": [
+            174,
+            536,
+            825,
+            633
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For each image fed into the 4-block CNN, the last feature map $( 6 4 @ 5 \\times 5 )$ is retrieved for simplex modeling. In order to choose a proper local region for conducting the few-shot experiments, we first test the $N$ -way $k \\mathrm { . }$ -shot accuracy of different sizes of regions on the validation set. The size of the local regions varies from $2 \\times 2$ to $5 \\times 5$ . 2 The result is shown in Table 1. On the validation set, the models with $2 \\times 2$ and $3 \\times 3$ regions perform the best on the 1-shot and 5-shot tasks, respectively. We take them to compare with other models on the test set. ",
+        "bbox": [
+            174,
+            641,
+            825,
+            724
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Following the same splits proposed by Ravi & Larochelle (2017), we compare the performance of our model on miniImageNet directly with other models. We also conduct the $K$ -nearest neighbor on the feature vectors generated from the 4-block model as a comparison (Baseline KNN). The results are shown in Table 2. Using the same pre-trained 4-block CNN, our model performs much better than the baseline KNN, meanwhile outperforms the matching networks and Meta-learner LSTM. However, the prototypical networks are better than our simplex algorithm. ",
+        "bbox": [
+            174,
+            731,
+            825,
+            815
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 OMNIGLOT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            833,
+            292,
+            847
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Omniglot dataset for one-shot learning (Lake et al., 2015) contains characters from 50 alphabets ranging from Korean to ancient Greek. Each character is provided with 20 examples handwritten by ",
+        "bbox": [
+            176,
+            858,
+            821,
+            887
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/af7aeba8a70c0a3f03c7682471c3ef1072eb5ed8733d061060bc5c646e0eacfc.jpg",
+        "table_caption": [
+            "Table 3: Few-shot accuracy on Omniglot. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td colspan=\"2\"> 5-way</td><td colspan=\"2\">20-way</td></tr><tr><td>1-shot</td><td> 5-shot</td><td>1-shot</td><td>5-shot</td></tr><tr><td>Baseline KNN</td><td>94.1%</td><td>98.7%</td><td>85.1%</td><td>95.8%</td></tr><tr><td>Mahalanobis distance</td><td>94.5%</td><td>99.1%</td><td>85.8%</td><td>96.9%</td></tr><tr><td>MICL (Wright et al., 2008)</td><td>95.4%</td><td>99.1%</td><td>87.3%</td><td>96.9%</td></tr><tr><td>Siamese networks (Koch et al., 2015)</td><td>97.3%</td><td>98.4%</td><td></td><td>97.0%</td></tr><tr><td>Matching networks (Vinyals et al., 2016)</td><td>98.1%</td><td>98.9%</td><td>88.2% 93.8%</td><td>98.5%</td></tr><tr><td>Prototypical networks (Snell et al., 2017)</td><td>97.4%</td><td>99.3%</td><td>96.0%</td><td>98.9%</td></tr><tr><td>Simplex (ours)</td><td>94.6%</td><td>99.1%</td><td>85.7%</td><td>97.0%</td></tr></table>",
+        "bbox": [
+            230,
+            132,
+            769,
+            303
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "20 online contributors. Omniglot fits the few-shot scenario well: comparing with the large number of categories (1623), the examples (20) are relatively limited, making it difficult to be trained upon with conventional parametric networks. ",
+        "bbox": [
+            174,
+            333,
+            823,
+            375
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Following the training setting in Vinyals et al. (2016), we split Omniglot into two parts: 1200 characters for training and the rest for validation and few-shot testing. The embedding 4-layer CNN is almost the same as used for training miniImageNet, except that the output feature map is changed to $6 4 @ 1 \\times 1$ due to the decrease in image size. We compare the $N$ -way $k$ -shot performance of our model with others. The results are shown in Table 3. Our models are overall comparable to the other state-of-the-art works. ",
+        "bbox": [
+            174,
+            381,
+            825,
+            465
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3 ROBUSTNESS OF SIMPLEX METHOD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            482,
+            460,
+            496
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Besides, we conduct more experiments on MICL and our model for a further comparison on robustness. MICL has a distortion parameter $\\epsilon ^ { 2 }$ in the coding length, i.e. (Wright et al., 2008) ",
+        "bbox": [
+            173,
+            507,
+            823,
+            536
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7587c60a11fa68b16ae6f88e669cba67d9883819c28b0e0cbaedffa3a6242213.jpg",
+        "text": "$$\nL _ { \\epsilon } ( \\chi ) = \\frac { n + d } { 2 } \\log _ { 2 } \\operatorname * { d e t } \\Big ( I + \\frac { d } { \\epsilon ^ { 2 } } \\Sigma ( \\chi ) \\Big ) + \\frac { d } { 2 } \\log _ { 2 } \\big ( 1 + \\frac { \\mu ^ { T } \\mu } { \\epsilon ^ { 2 } } \\big ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            542,
+            709,
+            574
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "where $\\Sigma ( \\mathcal { X } )$ is the corresponding covariance matrix and $\\mu$ is the center of $\\mathcal { X }$ . Through adjusting the parameter, the optimal performance of the model can be obtained on the validation set. We follow the same way as MICL and set up the free parameter in our simplex model. To be specific, let $\\lambda _ { 1 } , \\ldots , \\lambda _ { n }$ denote the eigenvalues of $\\hat { Q }$ . It is easy to write $\\begin{array} { r } { \\operatorname* { d e t } ( \\hat { Q } ) = \\prod _ { i = 1 } ^ { n } \\lambda _ { i } } \\end{array}$ . To include the free parameter, we employ the following expression instead ",
+        "bbox": [
+            173,
+            579,
+            825,
+            651
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7c7384200b84a602a4d09f22585ecadf96451b962d156fd2bc73493a5df8a546.jpg",
+        "text": "$$\n\\operatorname * { d e t } { \\Bigl ( } I + { \\frac { d } { \\epsilon ^ { 2 } } } { \\hat { Q } } { \\Bigr ) } = \\prod _ { i = 1 } ^ { n } { \\Bigl ( } 1 + { \\frac { d } { \\epsilon ^ { 2 } } } \\lambda _ { i } { \\Bigr ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            656,
+            617,
+            698
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The same computation is also performed for $\\operatorname* { d e t } ( \\hat { P } )$ . ",
+        "bbox": [
+            173,
+            705,
+            521,
+            720
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The experiment is conducted on the different values of distortion $\\epsilon ^ { 2 }$ . According to the results in Figure 5, it is clear that our model is far more robust than MICL. Although for some value of $\\epsilon ^ { 2 }$ , the accuracy of MICL is close to our model, the overall performance of MICL is instable with respect to $\\epsilon ^ { 2 }$ . On the contrary, the performance of our model almost keeps invariant in a wide spectrum of $\\epsilon ^ { 2 }$ . ",
+        "bbox": [
+            173,
+            727,
+            825,
+            797
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 ANALYSIS AND DISCUSS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            814,
+            385,
+            828
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "It is worth noting that our simplex metric can also be combined with very recently published works including prototypical networks (Snell et al., 2017) and meta-learning methods, such as (Finn et al., 2017) and (Mishra et al., 2017). For example, the distance measure in prototypical networks can be replaced with our simplex metric and the associated networks can be learned in the end-to-end manner by the supervision of simplex volumes. For few-shot cases, the number of examples in each class is quite limited. So the computational complexity can be well managed. Besides, the meta learning methods are to learn models between tasks instead of data points. Therefore, they are applicable to improve performance based on the simplex metric. We leave these for further explorations. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/d210674bacd3f5ab12b615c6d7d174e1909258d97d06d9021ec59faa6ec80cb1.jpg",
+        "image_caption": [
+            "Figure 5: Comparison of robustness between our simplex algorithm and MICL with respect to free parameters $\\epsilon ^ { 2 }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            101,
+            800,
+            277
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            342,
+            823,
+            383
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, MICL (Wright et al., 2008) and our algorithm directly exploit the features of new classes yielded by CNNs that are not retrained, fine-tuned, or performed any relevant refinement of model parameters on new classes. Even so, these two approaches achieve better performance on 5-shot recognition than matching network (Vinyals et al., 2016) and one of meta-learning algorithms (Ravi & Larochelle, 2017) that apply more information of new classes and high-level learning techniques. Both MICL and our simplex algorithm harness the geometric characterization of class structures 3. Therefore, our work might inspire the interest of exploring geometry to solve few-shot learning problems, which is paid little attention in the field. ",
+        "bbox": [
+            174,
+            390,
+            825,
+            502
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            523,
+            318,
+            540
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we designed a novel method to deal with few-shot learning problems. Our idea was from the point of view of high dimensional convex geometry and transformed the learning problem to the study of volumes of simplices. The relation between a test sample and a class was investigated via the volumes of different polytopes. By harnessing the power of simplex, we gave a rigorous mathematical formulation for our approach. We also conduced extensive simulations to validate our method. The results on various datasets showed the accuracy and robustness of the geometry-based method, compared to the state-of-the-art results in the literature. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            655
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            679,
+            285,
+            694
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Arthur Cayley. On a theorem in the geometry of position, volume 1 of Cambridge Library Collection - Mathematics, pp. 14. Cambridge University Press, 2009. doi: 10.1017/CBO9780511703676. 002. ",
+        "bbox": [
+            174,
+            703,
+            823,
+            744
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Li Fei-Fei, Rob Fergus, and Pietro Perona. A Bayesian approach to unsupervised one-shot learning of object categories. In ICCV, 2003. ",
+        "bbox": [
+            174,
+            758,
+            823,
+            787
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Li Fei-Fei, Rob Fergus, and Pietro Perona. One-shot learning of object categories. IEEE Transactions on Pattern Analysis and Machine Intelligence, 28:594–611, 2006. ",
+        "bbox": [
+            173,
+            801,
+            821,
+            830
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. CoRR, abs/1703.03400, 2017. URL http://arxiv.org/abs/1703. 03400. ",
+        "bbox": [
+            178,
+            843,
+            823,
+            885
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. CoRR, abs/1502.01852, 2015a. URL http://arxiv.org/abs/1502.01852. ",
+        "bbox": [
+            176,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CoRR, abs/1512.03385, 2015b. URL http://arxiv.org/abs/1512.03385. ",
+        "bbox": [
+            171,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lukasz Kaiser, Ofir Nachum, Aurko Roy, and Samy Bengio. Learning to remember rare events. CoRR, abs/1703.03129, 2017. URL http://arxiv.org/abs/1703.03129. ",
+        "bbox": [
+            173,
+            191,
+            823,
+            220
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gregory Koch, Richard Zemel, and Ruslan Salakhutdinov. Siamese neural networks for one-shot image recognition. 2015. ",
+        "bbox": [
+            173,
+            229,
+            825,
+            258
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In F. Pereira, C. J. C. Burges, L. Bottou, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 25, pp. 1097– 1105. Curran Associates, Inc., 2012. URL http://papers.nips.cc/paper/ 4824-imagenet-classification-with-deep-convolutional-neural-networks. pdf. ",
+        "bbox": [
+            173,
+            266,
+            862,
+            351
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Brenden M. Lake, Ruslan Salakhutdinov, and Joshua B. Tenenbaum. Human-level concept learning through probabilistic program induction. Science, 350(6266):1332–1338, 2015. ISSN 0036-8075. doi: 10.1126/science.aab3050. URL http://science.sciencemag.org/content/ 350/6266/1332. ",
+        "bbox": [
+            173,
+            359,
+            826,
+            416
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444, 05 2015. URL http://dx.doi.org/10.1038/nature14539. ",
+        "bbox": [
+            173,
+            424,
+            825,
+            454
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xingyu Lin, Hao Wang, Zhihao Li, Yimeng Zhang, Alan L. Yuille, and Tai Sing Lee. Transfer of view-manifold learning to similarity perception of novel objects. CoRR, abs/1704.00033, 2017. URL http://arxiv.org/abs/1704.00033. ",
+        "bbox": [
+            173,
+            462,
+            825,
+            505
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Prasanta Chandra Mahalanobis. On the generalised distance in statistics. Proceedings of the National Institute of Sciences of India, 1936, pp. 49–55, 1936. ",
+        "bbox": [
+            173,
+            512,
+            823,
+            542
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nikhil Mishra, Mostafa Rohaninejad, Xi Chen, and Pieter Abbeel. Meta-learning with temporal convolutions. CoRR, abs/1707.03141, 2017. URL http://arxiv.org/abs/1707.03141. ",
+        "bbox": [
+            173,
+            550,
+            823,
+            579
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Siyuan Qiao, Chenxi Liu, Wei Shen, and Alan L. Yuille. Few-shot image recognition by predicting parameters from activations. CoRR, abs/1706.03466, 2017. URL http://arxiv.org/abs/ 1706.03466. ",
+        "bbox": [
+            173,
+            588,
+            825,
+            630
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            171,
+            638,
+            823,
+            669
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sam T. Roweis and Lawrence K. Saul. Nonlinear dimensionality reduction by locally linear embedding. Science, 290(5500):2323–2326, 2000. ISSN 0036-8075. doi: 10.1126/science.290.5500. 2323. URL http://science.sciencemag.org/content/290/5500/2323. ",
+        "bbox": [
+            174,
+            676,
+            820,
+            719
+        ],
+        "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, Alexander C. Berg, and Li FeiFei. ImageNet large scale visual recognition challenge. International Journal of Computer Vision (IJCV), 115(3):211–252, 2015. doi: 10.1007/s11263-015-0816-y. ",
+        "bbox": [
+            173,
+            727,
+            825,
+            785
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy P. Lillicrap. Oneshot learning with memory-augmented neural networks. CoRR, abs/1605.06065, 2016. URL http://arxiv.org/abs/1605.06065. ",
+        "bbox": [
+            173,
+            792,
+            821,
+            835
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adam Santoro, David Raposo, David G.T. Barrett, Mateusz Malinowski, Razvan Pascanu, Peter Battaglia, and Timothy Lillicrap. A simple neural network module for relational reasoning. In arXiv:1706.01427, 2017. ",
+        "bbox": [
+            171,
+            843,
+            821,
+            887
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. CoRR, abs/1409.1556, 2014. URL http://arxiv.org/abs/1409.1556. ",
+        "bbox": [
+            173,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jake Snell, Kevin Swersky, and Richard S. Zemel. Prototypical networks for few-shot learning. CoRR, abs/1703.05175, 2017. URL http://arxiv.org/abs/1703.05175.   \nChristian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott E. Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. CoRR, abs/1409.4842, 2014. URL http://arxiv.org/abs/1409.4842.   \nChristian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. CoRR, abs/1512.00567, 2015. URL http://arxiv.org/abs/1512.00567.   \nJoshua B Tenenbaum, Vin De Silva, and John C Langford. A global geometric framework for nonlinear dimensionality reduction. Science, 290(5500):2319–2323, 2000.   \nJoshua B Tenenbaum, Charles Kemp, Thomas L Griffiths, and Noah D Goodman. How to grow a mind: Statistics, structure, and abstraction. Science, 331 6022:1279–85, 2011.   \nOriol Vinyals, Charles Blundell, Timothy P. Lillicrap, Koray Kavukcuoglu, and Daan Wierstra. Matching networks for one shot learning. CoRR, abs/1606.04080, 2016. URL http://arxiv. org/abs/1606.04080.   \nEric W. Weisstein. CRC concise encyclopedia of mathematics, second edition. CRC Press, 2002.   \nJohn Wright, Yangyu Tao, Zhouchen Lin, Yi Ma, and Heung-Yeung Shum. Classification via minimum incremental coding length (MICL). In Advances in Neural Information Processing Systems, pp. 1633–1640, 2008. ",
+        "bbox": [
+            169,
+            102,
+            826,
+            439
+        ],
+        "page_idx": 11
+    }
+]