Add files using upload-large-folder tool

parse/train/Hye_V0NKwr/Hye_V0NKwr.md

@@ -0,0 +1,416 @@
+# LOCALITY AND COMPOSITIONALITY IN ZERO-SHOT LEARNING
+
+Tristan Sylvain ∗   
+Mila, Universite de Montr ´ eal ´   
+Montreal, Canada   
+tristan.sylvain@gmail.com
+
+Linda Petrini ∗ University of Amsterdam Amsterdam, Netherlands lindapetrini@gmail.com
+
+R Devon Hjelm   
+Microsoft Research, Mila   
+Redmond, USA   
+devon.hjelm@microsoft.com
+
+# ABSTRACT
+
+In this work we study locality and compositionality in the context of learning representations for Zero Shot Learning (ZSL). In order to well-isolate the importance of these properties in learned representations, we impose the additional constraint that, differently from most recent work in ZSL, no pre-training on different datasets (e.g. ImageNet) is performed. The results of our experiments show how locality, in terms of small parts of the input, and compositionality, i.e. how well can the learned representations be expressed as a function of a smaller vocabulary, are both deeply related to generalization and motivate the focus on more local-aware models in future research directions for representation learning.
+
+# 1 INTRODUCTION
+
+A crucial property of a useful model is to generalize, that is to perform well on test settings given learning on a training setting. While what is most commonly meant by generalization is being robust to having a limited number of training examples in distributionally-matched settings (Zhang et al., 2016), many tasks are designed to address variations in the data between when a model is trained and when it is evaluated. For instance, some classification tasks address distributional changes in the input: from lacking guarantees of distributional match between train and test (e.g., covariate shift, Shimodaira, 2000) to having fundamental domain differences (e.g., domain adaptation, Crammer et al., 2007; Ben-David et al., 2007). A number of tasks have also been designed specifically to understand models in terms of their ability to generalize to test situations that are poorly represented during training (e.g., Few-Show learning, Li et al., 2006), or even consist of a diverse and entirely novel set of sub-tasks (Zamir et al., 2018). For supervised classification, Zero-Shot Learning (ZSL, Larochelle et al., 2008) is among the most difficult of these tasks, as it requires the model to make useful inferences about (e.g., correctly label) unseen concepts, given parameters learned only from seen training concepts and additional high-level semantic information.
+
+The fundamental question we wish to address in this work is: What are the principles that contribute to learning good representations for ZSL? While the most successful ZSL models (Atzmon & Chechik, 2019; Wang et al., 2019) use pretrained features from Imagenet (Krizhevsky et al., 2012; Russakovsky et al., 2015), we wish to understand how these features can emerge given only the data provided from the ZSL task. Specifically, we explore the role of compositionality and locality (Tokmakov et al., 2018; Stone et al., 2017) as two principles that lead to good generalization. Our study focuses on image representations, so we explore various means of learning representations that are local and compositional for convolutional neural networks (CNNs). We also leverage the structure of CNNs and available annotations from ZSL datasets as a means of interpreting various models in terms of these factors. Overall, our results support the hypothesis that compositionality and locality are crucial principles for training models that generalize well.
+
+Finally, in order to provide a cleaner framework for understanding the relationship between the above principles and generalization, we re-introduce Zero-Shot Learning from scratch (ZFS). In this setting, the model is not allowed to be pretrained on another dataset, such as Imagenet, and is evaluated on its ability to perform classification using auxiliary attributes and labels trained only using the data available from the training split of the target dataset. We believe that ZFS will provide researchers with a better experimental framework to understand which principles are important for Zero-Shot generalization.
+
+The contributions of our work are as follows:
+
+• We introduce Zero-Shot Learning from scratch (ZFS), an extension to ZSL, which we believe will be an important benchmark for understanding which learning principles lead to better generalization.   
+• We evaluate several supervised and unsupervised methods on their ability to learn features that generalize in the ZFS setting by training a prototypical network on top of those features (in a similar way to what was done in Snell et al., 2017, with Imagenet features). We then relate this generalization performance with different proxies for locality and compositionality of the given representations, and show that both concepts contribute heavily.   
+• We introduce a novel version of Deep InfoMax (DIM, Hjelm et al., 2018) which draws local patch representations from other images with the same label as positive samples.   
+• We introduce a novel visualization technique based on Mutual Information, that allows to investigate local properties of the learned representations.
+
+# 2 PRINCIPLES THAT LEAD TO GOOD ZSL PERFORMANCE
+
+Zero-Shot Learning (ZSL, Larochelle et al., 2008) is an important learning framework for understanding a model’s capacity to be used in real world scenarios where many relevant test cases (e.g., classes) are not known or are infeasible to sample at training time. An important component of ZSL, particularly in Deep Learning, is learning features directly from raw data (e.g., pixels), that generalize to these test cases. While there are a number of commonly-used strategies for learning generalizable features for various tasks in Deep Learning (Neyshabur et al., 2017), we believe that ZSL in particular requires thinking beyond normal classification by incorporating principles such as compositionality (Boole, 1854) and locality (Fukushima, 1980).
+
+How we formulate, exploit, and analyze these principles to learn models that solve image ZSL tasks will depend on our use of convolutional neural networks (CNNs) as the network architecture for encoding images as well as properties of the data, such as input statistics and available annotations. We will broadly define compositionality and locality, then relate these principles to the tools we have at our disposal from the network architecture and data.
+
+# 2.1 COMPOSITIONALITY
+
+Compositional representations have been a focus in the cognitive science literature (Biederman, 1987; Hoffman & Richards, 1984) with regards to the ability of intelligent agents to generalize to new concepts. Applications are found in computational linguistics (Tian et al., 2016), generative models (Higgins et al., 2017b), and Meta Learning (Alet et al., 2018; Tokmakov et al., 2018), to name a few, with approaches to encourage compositionality varying from introducing penalties (Tokmakov et al., 2018) to using modular architectures (Alet et al., 2018).
+
+In what follows, we will consider a representation to be compositional if it can be expressed as a combination of simpler parts (Andreas, 2019; Montague, 1974). Let $\mathcal { P }$ denote the set of possible parts, $\mathcal { R }$ the representation space and $\mathcal { X }$ the input space. For each $x \in \mathcal { X }$ , we assume the existence of a function $D$ mapping $x$ to $\mathcal { P } ^ { \prime } \subseteq \mathcal { P }$ , the set of its parts. These parts could be local image features (e.g., wings or beaks), or other generative factors (e.g., size, color, etc). Let $g : \mathcal { P }  \mathcal { R }$ be a function that maps the parts to representations. Formally, $f ( x ) \in \mathcal { R }$ is compositional if it can be expressed as a combination of the elements of $\{ g ( p ) | p \in D ( x ) \}$ . The combination operator used is commonly a weighted sum (Brendel $\&$ Bethge, 2019b), although some works learn more complex combinations (Higgins et al., 2017b). As we consider representations that are implicitly compositional, the above formalism might be approximately true which motivates our later use of the TRE metric.
+
+# 2.2 LOCALITY
+
+Local features have been used extensively in representation learning. CNNs exploit local information by design, and locally-aware architectures have been shown to be useful for non-image dataset, such as graphs (Kipf & Welling, 2016) and natural language processing (Yu et al., 2018). For supervised image classification, a bag of local features processed independently can do surprisingly well compared to processing the local features together (Brendel & Bethge, 2019a). Attention over local features is commonly used in image captioning (Li et al., 2017), visual question answering (Kim et al., 2018) and fine-grained classification (Sun et al., 2018). Self-attention over local features resulted in large improvements in generative models (Zhang et al., 2018a). Self-supervised methods often exploit local information to learn useful representations: Doersch et al. (2015) proposes to learn representations by predicting the relative location of image patches, Noroozi & Favaro (2016) solves jigsaw puzzles of local patches, and Deep InfoMax (DIM, Hjelm et al., 2018) maximizes the mutual information between local and global features.
+
+For our purposes with image data, we loosely define a local representation as one that has information that is specific to a patch. This helps motivate choices in architecture and learning principles that encourage locality. In this work, we take the most straightforward approach, and use features of CNNs which have receptive fields that are small compared to the size of the full image. This is similar to the motivations in Bachman et al. (2019), where the architecture is carefully designed to ensure that the receptive fields do not grow too large. However, this choice in architecture does not guarantee locality, as CNN representations might hypothetically contain only global information, such as the class or color of the object, despite having a limited receptive field. Therefore, we will evaluate a number of different models on their ability to encode only information specific to those locations. We will discuss relevant evaluation in Sections 4.2 and 4.3.
+
+Note also that compositionality as discussed above and locality are not necessarily independent concepts, nor are they necessarily the same. The set of compositional factors could include local factors, such as parts of an object, but also be more “global” factors, such as general properties of a class (e.g., size, color, shape, etc).
+
+# 2.3 COMPOSITIONALITY AND LOCALITY WITH IMAGE DATA
+
+We focus on three common ZSL dataset that allow us to explore compositionality and locality, namely Animals with Attributes 2 (AwA2, Xian et al., 2018), Caltech-UCSD-Birds-200-2011 (CUB, Wah et al., 2011), SUN Attribute (SUN, Patterson & Hays, 2012). Typical images from these datasets are shown in Fig. 1: CUB is a fine-grained dataset, where the object of interest is small relative to the total image. This is in contrast to AwA2, where subjects have variable size in relation to the total image. SUN is a scenes dataset, meaning that the object of interest is often the whole image.
+
+![](images/8a44abcee6655a8f39efb44c7ab13903344062fa7a017d6440cf43ad167a175d.jpg)  
+Figure 1: Typical samples show how compositionality and locality are expressed differently in the datasets we consider in this study.
+
+In our evaluation of compositionality, we can leverage different annotations provided by the datasets. All of these datasets provide attributes, which roughly correspond to high-level semantic information composed of a set of underlying factors. For CUB, these attributes describe visual characteristics such as wing colour or shape. For AwA2, these describe both visual and behavioral characteristics, such as the animal’s ability to swim or its habitat. For SUN, the attributes are more diverse, ranging from describing the function of the scene, such as playing, to the spatial envelope, for instance man-made. As in Xian et al. (2017), we used $\ell _ { 2 }$ normalized versions of these attributes as semantic class representations. In addition to attributes, CUB comes with bounding boxes for the whole subject and parts locations for 15 different parts, e.g. beak, tail, belly. These can also be used to assess both locality and compositionality, with the compositional factors being the same as the local ones. The details of each dataset are in the Appendix (Table 1).
+
+# 3 ZERO-SHOT LEARNING FROM SCRATCH
+
+While the original ZSL setting introduced in Larochelle et al. (2008) was agnostic to the exact methodology, more recent image ZSL approaches almost uniformly use features from very large “backbone” neural networks such as InceptionV2 (Szegedy et al., 2016) and ResNet101 (He et al., 2016) pretrained on the Imagenet dataset. In terms of absolute performance, this approach appears to be well-justified, as state-of-the-art results on various ZSL (Yosinski et al., 2014; Sun et al., 2017; Huh et al., 2016; Azizpour et al., 2015) and non-ZSL benchmarks (Li et al., 2019; Zhang et al., 2018b; He & Peng, 2017) all learn on top of similar pretrained backbones.
+
+However, we have many concerns with this approach towards our goal of understanding the principles that contribute to good generalization. First, relative success in transfer learning has been shown to be highly dependent on the precise instantiation of the pretrained backbone encoder (Xian et al., 2018) or the pre-training dataset (Cui et al., 2018). Next, while Imagenet features have been shown to work well for ZSL tasks with similar image datasets, there are no guarantees that a suitable pre-training framework would be available in general ZSL settings. Conversely, it can be hard in practice to meaningfully evaluate a Zero-Shot learner, as performance on specific classes is impacted by their presence in the pre-training dataset (Xian et al., 2017).
+
+Finally, we believe this approach misses the point, in such a way that makes understanding the learning principles that contribute to good generalization difficult. We believe that ZSL should first and foremost be used as a framework for training, understanding, and evaluating models on their ability to reason about new, unseen concepts. Despite the absolute performance gains of the methods above that use Imagenet features, the use of backbones hyper-optimized for supervised performance on Imagenet and the Imagenet dataset itself represent nuisance variables in a larger effort to understand how to learn generalizable concepts from scratch.
+
+In addition to the ZSL task framework outlined in Larochelle et al. (2008), ZFS simply adds one additional additional requirement: No model parameters can contain information about (e.g., can be learned from) data outside that from the training split of the target dataset.
+
+# 4 METHODS
+
+Given our hypothesis on the importance of locality and compositionality, we consider a wide range of representation learning methods trained using the ZFS setting described in Section 3. To showcase the role of these principles, we will introduce a set of proxies for compositionality and locality below. We will also consider auxiliary losses that emphasize locality in the learned representation. Finally, we will introduce a visualization tool that can help identify which local representations are assigned higher importance by each method.
+
+# 4.1 GENERAL APPROACH
+
+In this work, we train convolutional image encoders (CNN) using either supervised or unsupervised learning, then use prototypical networks to perform ZSL transfer on these fixed representations. Prototypical networks are chosen as they require minimal parameters or hyper-parameters tuning, are well-studied (Huang et al., 2019; Finn et al., 2017), and performance is very close to the state of the art for Imagenet-pretrained benchmarks. Our setup is representative of the current state of ZSL models, most of which (Akata et al., 2015; Changpinyo et al., 2016; Kodirov et al., 2017; Zhang et al., 2017; Sung et al., 2018) rely on metric learning by applying two steps: (1) learning a suitable embedding function that maps data samples and class attributes to a common subspace, (2) performing nearest neighbor classification at test-time with respect to the embedded class attributes.
+
+For our study, we compare pre-training the image encoder with a diverse, yet representative set of models:
+
+• Fully supervised: Fully supervised label classifier (FC)   
+• Unsupervised / reconstruction based / generative: Variational auto-encoders(VAE, Kingma & Welling, 2013), $\beta$ -VAE (Higgins et al., 2017a), Adversarial auto-encoders (AAE, Makhzani et al., 2015),   
+• Local self-supervision and variants: Augmented Multiscale Deep InfoMax (AMDIM, Bachman et al., 2019) and Class Matching DIM (CMDIM).
+
+We pick variants of DIM (Hjelm et al., 2018) as opposed to other self-supervision methods (Doersch & Zisserman, 2017; Noroozi & Favaro, 2016) because extensions have achieved state-of-the-art on numerous related tasks (Velickovi ˇ c et al., 2018; Bachman et al., 2019). ´
+
+We introduce Class-Matching DIM (CMDIM), a novel version of DIM that draws positive samples from other images from the same class. The goal is to learn representations that focus less on the information content of a single input, while extracting information that is discriminative between classes. The hyperparameter $p$ determines the probability of performing intra-class matching, we experiment with $p \in \{ 1 , 0 . 5 , 0 . 1 \}$ . A more detailed description is provided in Appendix G.
+
+Local classification and attribute auxiliary loss We encourage the image encoder to extract semantically relevant features at earlier stages of the network by introducing an auxiliary local loss to the local feature vectors of a convolutional layer (whose receptive field covers a small patch of the image). When used, this auxiliary loss is either from an attribute-based classifier (AC) or a label-based classifier (LC) using the attributes or the labels as supervised signal, respectively. A schematic explanation can been seen in Fig. 7 in the appendix.
+
+# 4.2 PARTS CLASSIFICATION FOR CUB EVALUATION
+
+For each of the 15 parts labelled in the CUB dataset, we use the MTurk worker annotations to construct 15 boolean map for each local feature. We project these boolean maps through the CNN to generate ground truth variables that indicate whether the given part is present and visible at a location specific to the CNN encoder features. We then train a linear probe for each part, without back-propagating through the encoder, and measure the average F1 score across all locations and parts. This gives us a measurement on how well the encoder represents the parts of the image at the correct locations. For more details, please refer to Section F in the Appendix.
+
+# 4.3 MEASURING MUTUAL INFORMATION BETWEEN LOCAL FEATURES OF DIFFERENT IMAGES
+
+As a tool for local interpretability, we propose estimating the mutual information (MI) between global features given from one image and local features from a second image. A schematic explanation is provided in Fig. 8 in the Appendix. In order to do this, we rely on MINE (Belghazi et al., 2018) which uses a statistics network, $T _ { \phi }$ , with parameters $\phi$ to formulate a lower bound to MI, which is effective for high dimensional, continuous random variables. In our case, the statistics network takes two inputs: a global and local feature vector either sampled from the joint, where each comes from the same image, or from the product of marginals, where the global and local features are sampled independently from each other. The statistics network optimizes a lower bound to the MI:
+
+$$
+\widehat { I } ( G _ { \theta } ( X ) ; L _ { \theta } ( X ) ) \geq \mathbb { E } _ { p ( X ) } [ \widehat { T _ { \phi } } \big ( ( G _ { \theta } ( X ) , L _ { \theta } ( X ) ) \big ] - \log \mathbb { E } _ { p ( X ) \otimes p ( X ^ { \prime } ) } [ e ^ { T _ { \phi } ( ( G _ { \theta } ( X ) , L _ { \theta } ( X ^ { \prime } ) ) ) } ] 
+$$
+
+Where $p ( X ) = p ( X ^ { \prime } )$ is the data distribution, and $L$ and $G$ random variables corresponding to the local and global feature vectors of the encoder. At optimum, the output of the statistics network, $T _ { \phi }$ provides an estimate for the Pointwise Mutual Information (PMI), defined as log p(G,L)p(G)p(L $\begin{array} { r } { \log \frac { p ( G , L ) } { p ( G ) p ( L ) } = \log \frac { p ( L | G ) } { p ( L ) } } \end{array}$ ) = log p(L|G)p(L) , which roughly gives us a measure of how similar the global and local representations are in terms of information content. Normally, we could try to estimate the marginal term $p ( L )$ to get an estimate for the conditional density, but we will normalize our score across the local patches of the target image to get a relative score of the relatedness of each local feature to a given global feature. This analysis is similar to that done in Bachman et al. (2019), which looks at different augmentations of the same image using the same MI estimator used to train the encoder.
+
+# 4.4 TRE EVALUATION
+
+We focus on a metric of compositionality introduced in Andreas (2019), the Tree Reconstruction Error (TRE), as a proxy for compositionality. We will write TRE $^ { ( \mathcal { X } , \mathbf { a } ) }$ for the TRE computed on a dataset $\mathcal { X }$ over the set of primitives a. For details on its definition, see Section $_ \mathrm { H }$ in the Appendix.
+
+As we mostly care about the compositionality with respect to attributes in the context of zero-shot learning and some representations are inherently more decomposable than others (such as VAEs due to the gaussian prior), we consider instead the ratio of the TRE computed with respect to attributes and the TRE computed with respect to uninformative variables (random assignment). We define the TRE ratio as: $\frac { \mathrm { T R E } ( \mathcal { X } , \hat { \mathbf { a } } ) } { \mathrm { T R E } ( \mathcal { X } , \tilde { \mathbf { a } } ) }$ , where $\tilde { \mathbf { a } }$ is a random binary matrix (random cluster assignment), and aˆ are the actual visual primitives, attributes in our case.
+
+# 4.5 EXPERIMENTAL SETUP
+
+Image encoders We considered both an encoder derived from the DCGAN architecture (Radford et al., 2015) and similar in capacity to those used in early Few Shot Learning models such as MAML (Finn et al., 2017). We also consider a larger AlexNet (Krizhevsky et al., 2012) based architecture to gain insight on the impact of the encoder backbone. It is important to note that overall the encoders we use are significantly smaller than the “standard” backbones common in state-of-the-art Imagenetpretrained ZSL methods (note that similarly to most recent ZSL methods, the encoder is fixed after pre-training, and used as a feature extractor). We believe restricting the encoder’s capacity decreases the performance, but does not hinder our ability to extract understanding of what methods work from our experiments. A detailed description of the architectures can be found in the Appendix (Tables 2 and 3).
+
+Evaluation Protocol We used the ZSL splits constructed in Xian et al. (2017), as they are the most commonly used in the literature. All models are evaluated on Top-1 accuracy. We pretrain the encoder using each of the previously mentioned methods (strictly on the considered dataset, as per the ZSF requirement). We then train a Prototypical Network on top of the (fixed) learned representation. All the implementation details are available in the Appendix, in Section B.
+
+![](images/7a85a73ae277f50d1cd48868aa0438b3bd0dd68fa4975801e334bf05539aa6be.jpg)  
+Figure 2: Parts F1 score for all models on CUB with a DCGAN-based encoder plotted against ZSL accuracy. There is a clear relationship between the two: encoders that have a good understanding of local information (as measured by the parts F1 score) perform better in zero-shot learning. The addition of a local loss increases parts F1 score for all models. This improves generalization for all models except those trained with a reconstruction objective.
+
+# 5 RESULTS AND DISCUSSION
+
+In this section, we describe in more detail our experiments and analyize the results. The full numerical results and plots for all considered models can be found in the Appendix.
+
+# 5.1 DOES LOCALITY HELP ZSL, AND CAN LOCAL REPRESENTATIONS BE LEARNED?
+
+Representations that predict parts at the correct location tend to perform better at ZSL. We hypothesize that if the encoder represents information that is descriptive of parts, it should also be able to generalize better. To test this, we compare ZSL performance to the part classification F1 score described in 4.2. In Fig. 2, the average F1 scores across the 15 classifiers is plotted against the ZSL accuracy for each model. The two measures are clearly correlated (Person’s correlation of 0.73). This relationship doesn’t hold for reconstruction-based methods such as VAEs, which could be due to these models needing to represent information related to all pixels, including the background, in order to reconstruct well.
+
+Encouraging local representations to contain similar information improves ZSL performance For variants of Deep InfoMax (DIM, Hjelm et al., 2018), AMDIM and CMDIM, the local representations are encouraged to be similar to a global representation through the mutual information maximization objective. While locally specified, this is somewhat contrary to our definition of locality in 2.2. Among the models we tested, these variants generally perform very well, with CMDIM performing the best overall.
+
+This indicates that, while important, locality by itself is not sufficient to learn good ZSL representations. The local representations must also share information, e.g., through a global representation or the class. We hypothesize that such constraints help the encoder learn information that is present locally, but relevant to discriminating the class or important high-level semantic meaning. The above observation also holds for the local losses (AC and LC introduced in 4.1). These losses both encourage the model to rely on local information (local features must capture important semantic information), and for these representations to share information (by having high mutual information with either the attributes or labels).
+
+![](images/ce277fe089e2ae1bf6509bbf17a4530316135aa37d9c5aef559fcb81a079a094.jpg)  
+Figure 3: Relative improvement in terms of ZSL accuracy with respect to models trained without the auxiliary loss. Attribute information results in a bigger improvement. Surprisingly, for certain models label information results in a decrease in generalization performance.
+
+Adding local losses helps supervised and self-supervised models. We investigate in more detail the effect of encouraging the model to take into account different types of local information. As can be seen in Fig. 2, the addition of a local loss improves both ZSL and parts score for all models except the generative ones (VAE, AAE). Interestingly, for these models the parts score also increases, indicating more locality, but this does not translate to better ZSL performance.
+
+To better investigate why local losses improve generalization for supervised and self-supervised models, in Fig. 3 we show the relative improvement of each type of local classifier over the performance of the encoder only trained with its global loss. We can see how for the supervised model, the attribute based auxiliary loss has a much bigger impact, which indicates that label information is already exploited by the model, while attributes actually provide more information. For AMDIM, both losses seem to have a consistent positive effect, possibly because the model is unsupervised and hence any label-related information is useful. For CMDIM, the LC auxiliary loss actually hurts performance. This is likely due to the fact that both CMDIM and the LC loss focus on discriminating classes at the local level, and that the LC objective is inherently less effective than the CMDIM formulation for this task (in terms of downstream ZSL performance). As a result, forcing the model to account for both terms lowers downstream performance. DIM and AMDIM discriminate instances and not classes so adding class and attribute information in the form of the AC and LC losses helps performance. CMDIM is already exposed to class information, so only gains from being exposed to the (more informative) attribute information in the form of AC.
+
+# 5.2 HOW DO DIFFERENT MODELS ENCODE INFORMATION LOCALLY?
+
+In Fig. 4 we apply the PMI-based visualization technique introduced in Section 4.3 to pairs of images from the CUB dataset. In this case, we are examining the global representation extracted by each model for the top left image (the Pacific Loon) and comparing it with local features from images of various classes. By noticing which patches each model pays attention to (have higher mutual information), we can infer how information is coded locally. The main take-aways are the following:
+
+• Supervised models. The fully supervised model in the first row seems to be able to focus on relevant semantic details, such as the tail of the Horned Grebe and the head of the Back Tern. • Unsupervised models. In the second and third row we can see how models based on a reconstruction loss seem to fail at highlighting semantic information: for images with patterns and colours similar to the Pacific Loon, such as the other Pacific Loon or the White breasted Kingfisher, PMI is high across all local features, while scores are very low for the Tree Swallow with the uniform green background. This could possibly indicate that these models focus more on pixel statistics necessary for reconstruction, and are unable to extract as much semantic information. Self-Supervised models. AMDIM manages to recover some semantic structure, e.g. for the other Pacific Loon or for the Rusty Blackbird, but fails in some other cases. CMDIM on the other hand, especially for high matching probability $p$ , produces heatmaps that are very similar to those of the supervised models, hence managing to recover what is discriminative between classes.
+
+Models that encode semantic information well perform well on ZSL generalization. Models that reconstruct pixels well perform worse. To confirm our intuitions on how some families of models focus more on semantic information, while others are more sensitive to pixel statistics, we rely again on the parts binary maps described in 4.2. For each pair of images, we compute the ratio between the score assigned to patches containing any part (i.e., a logical OR computed across all binary maps) and the overall score of all features. We refer to this measure as the Parts ratio. This ratio is sensitive to both how highly the model scores the relevant parts and to whether the rest of the features are assigned a lower score. We then compute two different types of similarity between the considered images: a semantic one, defined as the cosine distance between the attributes associated to the images’ classes, and an pixelwise one, by measuring the Structural Similarity index (SSIM) between the images. We then measure correlation between the Parts ratio and these measures of similarity. Our interpretation is the following:
+
+![](images/60b84255891fc874de3461111ebe8094c6bc104131d652b1078f2556e6680bdd.jpg)  
+Figure 4: Mutual Information heatmaps allow to understand which local patches contributed the most to the final representation. For each heatmap we plot the absolute values in the rightmost plot and the superposition of the heatmap and the original image on the left, to increase interpretability. Yellow corresponds to higher scores.
+
+• Positive correlation with attribute similarity: If two images are semantically similar, the part ratio should be higher if the model manages to extract the common semantically relevant patches (and we know that they are the parts for CUB). • Negative correlation with SSIM score: If a model is too sensitive to pixel similarity, the parts score will be higher for images that are very different, where the only thing in common (pixel-wise) is to depict a bird, while for very similar images the model will just assign a high score to all local features.
+
+We find that for VAEs, the ratio and the attribute similarity are not correlated, but the ratio and the SSIM scores correlate negatively. The effect is reversed for Supervised and Self-Supervised models. This confirms our intuition that VAEs and reconstruction models are not well suited to learn representations that generalize in our context. More details about this experiment and the correlation coefficients are reported in the Appendix, in Fig. 10.
+
+# 5.3 DO COMPOSITIONAL REPRESENTATIONS PERFORM BETTER FOR ZSL?
+
+Intuitively, we expect compositionality to be an advantage: if a model has a good understanding of how parts map to representations, it can learn to combine known concepts to describe new classes. The experiments show:
+
+• Measures of implicit compositionality correlate strongly with ZSL performance. Fig. 5 shows the relationship between the TRE ratio introduced in 4.4, and ZSL accuracy. The Pearson correlation coefficients between the TRE Ratio and ZSL Accuracy are the following: -0.90 for CUB, -0.60 for AwA2 and -0.30 for SUN. • The relation is strongest when the attributes are strongly relevant to the image. For the AWA2 and CUB, datasets for which the attributes are semantically very meaningful, we observe that there is a direct relationship between TRE ratio and ZSL performance. This relationship degrades for
+
+![](images/175d4def7011797a54cab48afcbe15998c7ccf9191f3921506a2c0e8e5eb6320.jpg)  
+Figure 5: Relationship between TRE ratio and ZSL accuracy for each dataset (lower TRE ratio is better).
+
+SUN, for which the attributes are per-image, and averaged over classes, meaning that they are less likely to map to information actually present in a given image.
+
+We also consider the effect of combining local representations directly (instead of relying on the global output of the model). Given local representations, there are several ways to employ them to perform classification: one option is to create a final representation by averaging the local ones, another option is to classify each patch separately and then average this predictions.
+
+An explicitely compostional model based on local features helps ZSL. The results for this comparison are shown in Fig. 6. Averaging representations can be seen as directly enforcing a notion of compositionality: the representation of the whole input is directly built as a weighted sum of the patch representations (that we can imagine being more similar across different data points) and where the weights are uniform. For CUB, and to a lesser extent AwA2, where only few patches encode important information such as beaks, tails, the effect is quite pronounced. There is less of a difference for SUN, where the object is usually the whole scene, meaning all patches are expected to contribute.
+
+![](images/d888336614e4f6bd6f12f0bf29e3e64af32d3e3aa24882f6ef27ad9f3bd29a8e.jpg)  
+Figure 6: Comparison between averaging representations and averaging predictions. We can see how, for the more local model families, this notion of compositionality is most useful for CUB, where the object of interest is likely only present in few patches.
+
+# 6 CONCLUSION AND FUTURE WORK
+
+Motivated by the need for more realistic evaluation settings for Zero-Shot Learning methods, we proposed a new evaluation framework where training is strictly performed only on the benchmark data, with no pre-training on additional datasets. In the proposed setting, we hypothesize that locality and compositionality are fundamental ingredients for successful zero-shot generalization. We perform a series of tests of the relationship between these two aspects and zero-shot performance of a diverse set of representations. We find that models that encourage both these aspects, either explicitly (through a penalty per instance) or implicitly by construction, tend to perform better at zero-shot learning. We also find that models that focus on reconstruction tasks fail at capturing the semantic information necessary for good generalization, calling into question their applicability as general representation learning methods.
+
+# REFERENCES
+
+Zeynep Akata, Scott Reed, Daniel Walter, Honglak Lee, and Bernt Schiele. Evaluation of output embeddings for fine-grained image classification. 2015 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), Jun 2015. doi: 10.1109/cvpr.2015.7298911. URL http://dx.doi.org/10.1109/CVPR.2015.7298911.
+
+Ferran Alet, Tomas Lozano-P ´ erez, and Leslie P Kaelbling. Modular meta-learning. ´ arXiv preprint arXiv:1806.10166, 2018.
+
+Jacob Andreas. Measuring compositionality in representation learning. arXiv preprint arXiv:1902.07181, 2019.
+
+Yuval Atzmon and Gal Chechik. Adaptive confidence smoothing for generalized zero-shot learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 11671–11680, 2019.
+
+Hossein Azizpour, Ali Sharif Razavian, Josephine Sullivan, Atsuto Maki, and Stefan Carlsson. Factors of transferability for a generic convnet representation. IEEE transactions on pattern analysis and machine intelligence, 38(9):1790–1802, 2015.
+
+Philip Bachman, R Devon Hjelm, and William Buchwalter. Learning representations by maximizing mutual information across views. arXiv preprint arXiv:1906.00910, 2019.
+
+Mohamed Ishmael Belghazi, Aristide Baratin, Sai Rajeshwar, Sherjil Ozair, Yoshua Bengio, Aaron Courville, and R. Devon Hjelm. Mutual information neural estimation. 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. 531–540, Stockholmsmssan, Stockholm Sweden, 10–15 Jul 2018. PMLR. URL http://proceedings.mlr.press/v80/belghazi18a.html.
+
+Shai Ben-David, John Blitzer, Koby Crammer, and Fernando Pereira. Analysis of representations for domain adaptation. In Advances in neural information processing systems, pp. 137–144, 2007.
+
+Irving Biederman. Recognition-by-components: a theory of human image understanding. Psychological review, 94(2):115, 1987.
+
+George Boole. An investigation of the laws of thought, on which are founded mathematical theories of logic and probabilities. New York, Dover, 1 edition, 1854.
+
+Wieland Brendel and Matthias Bethge. Approximating cnns with bag-of-local-features models works surprisingly well on imagenet. CoRR, abs/1904.00760, 2019a. URL http://arxiv.org/abs/1904.00760.
+
+Wieland Brendel and Matthias Bethge. Approximating CNNs with bag-of-local-features models works surprisingly well on imagenet. In International Conference on Learning Representations, 2019b. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } }$ SkfMWhAqYQ.
+
+Soravit Changpinyo, Wei-Lun Chao, Boqing Gong, and Fei Sha. Synthesized classifiers for zero-shot learning. 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), Jun 2016. doi: 10.1109/cvpr.2016.575. URL http://dx.doi.org/10.1109/CVPR.2016.575.
+
+Koby Crammer, Michael Kearns, and Jennifer Wortman. Learning from multiple sources. In B. Scholkopf, J. C. Platt, and T. Hoffman (eds.), ¨ Advances in Neural Information Processing Systems 19, pp. 321–328. MIT Press, 2007. URL http://papers.nips.cc/paper/ 2972-learning-from-multiple-sources.pdf.
+
+Yin Cui, Yang Song, Chen Sun, Andrew Howard, and Serge Belongie. Large scale fine-grained categorization and domain-specific transfer learning. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4109–4118, 2018.
+
+Carl Doersch and Andrew Zisserman. Multi-task self-supervised visual learning. CoRR, abs/1708.07860, 2017. URL http://arxiv.org/abs/1708.07860.
+
+Carl Doersch, Abhinav Gupta, and Alexei A. Efros. Unsupervised visual representation learning by context prediction. CoRR, abs/1505.05192, 2015. URL http://arxiv.org/abs/1505.05192.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 1126–1135. JMLR. org, 2017.
+
+Kunihiko Fukushima. Neocognitron: A self-organizing neural network model for a mechanism of pattern recognition unaffected by shift in position. Biological cybernetics, 36(4):193–202, 1980.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Xiangteng He and Yuxin Peng. Fine-grained image classification via combining vision and language. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5994–6002, 2017.
+
+Irina Higgins, Lo¨ıc Matthey, Arka Pal, Christopher Burgess, Xavier Glorot, Matthew Botvinick, Shakir Mohamed, and Alexander Lerchner. beta-vae: Learning basic visual concepts with a constrained variational framework. In ICLR, 2017a.
+
+Irina Higgins, Nicolas Sonnerat, Loic Matthey, Arka Pal, Christopher P Burgess, Matko Bosnjak, Murray Shanahan, Matthew Botvinick, Demis Hassabis, and Alexander Lerchner. Scan: Learning hierarchical compositional visual concepts. arXiv preprint arXiv:1707.03389, 2017b.
+
+R Devon Hjelm, Alex Fedorov, Samuel Lavoie-Marchildon, Karan Grewal, Phil Bachman, Adam Trischler, and Yoshua Bengio. Learning deep representations by mutual information estimation and maximization. 2018.
+
+Donald D Hoffman and Whitman A Richards. Parts of recognition. Cognition, 18(1-3):65–96, 1984.
+
+Gabriel Huang, Hugo Larochelle, and Simon Lacoste-Julien. Centroid networks for few-shot clustering and unsupervised few-shot classification. arXiv preprint arXiv:1902.08605, 2019.
+
+Minyoung Huh, Pulkit Agrawal, and Alexei A Efros. What makes imagenet good for transfer learning? arXiv preprint arXiv:1608.08614, 2016.
+
+Jin-Hwa Kim, Jaehyun Jun, and Byoung-Tak Zhang. Bilinear attention networks. In Advances in Neural Information Processing Systems, pp. 1564–1574, 2018.
+
+Diederik P Kingma and Max Welling. Auto-Encoding Variational Bayes. arXiv e-prints, art. arXiv:1312.6114, Dec 2013.
+
+Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. CoRR, abs/1609.02907, 2016. URL http://arxiv.org/abs/1609.02907.
+
+Elyor Kodirov, Tao Xiang, and Shaogang Gong. Semantic autoencoder for zero-shot learning. 2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), Jul 2017. doi: 10.1109/cvpr.2017.473. URL http://dx.doi.org/10.1109/CVPR.2017.473.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
+
+Hugo Larochelle, Dumitru Erhan, and Yoshua Bengio. Zero-data learning of new tasks. In Proceedings of the 23rd National Conference on Artificial Intelligence - Volume 2, AAAI’08, pp. 646–651. AAAI Press, 2008. ISBN 978-1-57735-368-3. URL http://dl.acm.org/citation.cfm?id=1620163.1620172.
+
+Fei-Fei Li, Rob Fergus, and Pietro Perona. One-shot learning of object categories. IEEE transactions on pattern analysis and machine intelligence, 28(4):594–611, 2006.
+
+Hengduo Li, Bharat Singh, Mahyar Najibi, Zuxuan Wu, and Larry S. Davis. An analysis of pre-training on object detection, 2019.
+
+Linghui Li, Sheng Tang, Lixi Deng, Yongdong Zhang, and Qi Tian. Image caption with global-local attention. In Thirty-First AAAI Conference on Artificial Intelligence, 2017.
+
+Alireza Makhzani, Jonathon Shlens, Navdeep Jaitly, and Ian J. Goodfellow. Adversarial autoencoders. CoRR, abs/1511.05644, 2015. URL http://arxiv.org/abs/1511.05644.
+
+Richard Montague. Universal grammar. In Richmond H. Thomason (ed.), Formal Philosophy: Selected Papers of Richard Montague, number 222–247. Yale University Press, New Haven, London, 1974.
+
+Behnam Neyshabur, Srinadh Bhojanapalli, David McAllester, and Nati Srebro. Exploring generalization in deep learning. In Advances in Neural Information Processing Systems, pp. 5947–5956, 2017.
+
+Mehdi Noroozi and Paolo Favaro. Unsupervised learning of visual representations by solving jigsaw puzzles. CoRR, abs/1603.09246, 2016. URL http://arxiv.org/abs/1603.09246.
+
+Genevieve Patterson and James Hays. Sun attribute database: Discovering, annotating, and recognizing scene attributes. In Proceeding of the 25th Conference on Computer Vision and Pattern Recognition (CVPR), 2012.
+
+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, Xinchen Yan, Lajanugen Logeswaran, Bernt Schiele, and Honglak Lee. Generative adversarial text to image synthesis. arXiv preprint arXiv:1605.05396, 2016.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. ImageNet Large Scale Visual Recognition Challenge. International Journal of Computer Vision (IJCV), 115 (3):211–252, 2015. doi: 10.1007/s11263-015-0816-y.
+
+Hidetoshi Shimodaira. Improving predictive inference under covariate shift by weighting the log-likelihood function. Journal of statistical planning and inference, 90(2):227–244, 2000.
+
+Jake Snell, Kevin Swersky, and Richard S Zemel. Prototypical networks for few-shot learning. arXiv preprint arXiv:1703.05175, 2017.
+
+Austin Stone, Huayan Wang, Michael Stark, Yi Liu, D Scott Phoenix, and Dileep George. Teaching compositionality to cnns. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5058–5067, 2017.
+
+Chen Sun, Abhinav Shrivastava, Saurabh Singh, and Abhinav Gupta. Revisiting unreasonable effectiveness of data in deep learning era. In Proceedings of the IEEE international conference on computer vision, pp. 843–852, 2017.
+
+Ming Sun, Yuchen Yuan, Feng Zhou, and Errui Ding. Multi-attention multi-class constraint for fine-grained image recognition. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 805–821, 2018.
+
+Flood Sung, Yongxin Yang, Li Zhang, Tao Xiang, Philip H.S. Torr, and Timothy M. Hospedales. Learning to compare: Relation network for few-shot learning. 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition, Jun 2018. doi: 10.1109/cvpr.2018.00131. URL http://dx.doi.org/10.1109/cvpr.2018.00131.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2818–2826, 2016.
+
+Ran Tian, Naoaki Okazaki, and Kentaro Inui. Learning semantically and additively compositional distributional representations. arXiv preprint arXiv:1606.02461, 2016.
+
+Pavel Tokmakov, Yu-Xiong Wang, and Martial Hebert. Learning compositional representations for few-shot recognition. arXiv preprint arXiv:1812.09213, 2018.
+
+Petar Velickovi ˇ c, William Fedus, William L Hamilton, Pietro Li ´ o, Yoshua Bengio, and R Devon Hjelm.\` Deep graph infomax. arXiv preprint arXiv:1809.10341, 2018.
+
+Catherine Wah, Steve Branson, Peter Welinder, Pietro Perona, and Serge Belongie. The caltech-ucsd birds-200-2011 dataset. 2011.
+
+Xinsheng Wang, Shanmin Pang, Jihua Zhu, Zhongyu Li, Zhiqiang Tian, and Yaochen Li. Visual space optimization for zero-shot learning. arXiv preprint arXiv:1907.00330, 2019.
+
+Yongqin Xian, Christoph H. Lampert, Bernt Schiele, and Zeynep Akata. Zero-shot learning - A comprehensive evaluation of the good, the bad and the ugly. CoRR, abs/1707.00600, 2017. URL http://arxiv.org/abs/1707.00600.   
+Yongqin Xian, Christoph H Lampert, Bernt Schiele, and Zeynep Akata. Zero-shot learning-a comprehensive evaluation of the good, the bad and the ugly. IEEE transactions on pattern analysis and machine intelligence, 2018.   
+Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In Advances in neural information processing systems, pp. 3320–3328, 2014.   
+Adams Wei Yu, David Dohan, Minh-Thang Luong, Rui Zhao, Kai Chen, Mohammad Norouzi, and Quoc V Le. Qanet: Combining local convolution with global self-attention for reading comprehension. arXiv preprint arXiv:1804.09541, 2018.   
+Amir R Zamir, Alexander Sax, William Shen, Leonidas J Guibas, Jitendra Malik, and Silvio Savarese. Taskonomy: Disentangling task transfer learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3712–3722, 2018.   
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. arXiv preprint arXiv:1611.03530, 2016.   
+Han Zhang, Ian Goodfellow, Dimitris Metaxas, and Augustus Odena. Self-attention generative adversarial networks. arXiv preprint arXiv:1805.08318, 2018a.   
+Li Zhang, Tao Xiang, and Shaogang Gong. Learning a deep embedding model for zero-shot learning. 2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), Jul 2017. doi: 10.1109/cvpr.2017.321. URL http://dx.doi.org/10.1109/CVPR.2017.321.   
+Yabin Zhang, Hui Tang, and Kui Jia. Fine-grained visual categorization using meta-learning optimization with sample selection of auxiliary data. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 233–248, 2018b.
+
+A.1 EXPLAINING LOCAL AND GLOBAL FEATURES
+
+![](images/d266141e01ea0daaa5d0553c424405a314d91897b461504a34774daed0fb23c7.jpg)  
+Figure 7: The convolutional encoder takes as input an image and outputs a global representation - used to compute the model loss $\mathcal { L } _ { m o d e l }$ . To encourage locality and compositionality, label or attribute based classification is performed on the activations from early layers $\bar { \mathcal { L } } _ { l o c a l } )$ .
+
+A.2 EXPLAINING THE ROLE OF LOCAL AND GLOBAL FEATURES FOR MI COMPUTATION
+
+![](images/72872e4991f3c15830c6dfc2409029e9e9f056e1553198427fbd094c9ed862c4.jpg)  
+Figure 8: Local and global features are extracted from different images (where local features are activations from an early layer in the CNN encoder), then scored against each other. A high score means the two are considered likely to be extracted from the same image by the model, giving us insight in what information is encoded by the global representation. A heatmap of the scores is used to make the result interpretable.
+
+# B IMPLEMENTATION DETAILS
+
+All models used in this paper have been implemented in PyTorch, and code will be made publically available. All images were resized to size $1 2 8 \times 1 2 8$ , random crops with aspect ratio 0.875 were used during training, and center crops with the same ratio were used during test. While most ZSL approaches do not use crops (due to the fact that they used pre-computed features), this experimental setup was shown to be efficient in the field of text to image synthesis (Reed et al., 2016). All models are optimized with Adam with a learning rate of 0.0001 with a batch size of 64. The final output of the encoder was chosen to be 1024 across all models. Local experiments were performed extracting features from the third layer of the network. These features have dimension ${ \bar { 2 } } 7 \times 2 7 \times 3 8 4$ for the AlexNet based encoder and $1 4 \times 1 4 \times 2 5 6$ for the DCGAN encoder.
+
+# C MI HEATMAPS COMPARING CMDIM WITH DIFFERENT LOCAL LOSSES
+
+In Fig. 9 we show how local losses affect the type of information CMDIM extracts. We can see how in some cases, e.g. the Nashville Warbler and Rusty Blackbird, the label-based local loss (LC) results in the encoder focusing more on the background and missing out on discriminative features. On the other hand, the label-based (LC) local loss helps the model focus on more localised distinctive patches, especially for the Rusty Blackbird and the Rufous Hummingbird.
+
+# D PARTS RATIO AND RELATIONSHIP TO DIFFERENT MEASURES OF IMAGE SIMILARITY.
+
+In Fig. 10, we plot the Parts ratio against the two different measure of image similarity considered in our experiments and we report the correlation between them across the considered families of models. The correlation was computed over 20.000 pairs of images for each family. While not being a strong correlation, our experiments show how it’s a statistically significant one, with associated p-value (expressing the probability of a not-correlated sample resulting in the reported correlation coefficients) of less than $1 0 ^ { - 6 }$ .
+
+![](images/6a0760bd4c2e17beda449c33df4fe1c07174fb8d4068693de8d4ea72944690f0.jpg)  
+Figure 9: Visualization of locality comparing encoders trained with CMDIM’s loss and the proposed local losses. The Figure highlights the impact of local losses on the content extracted by the encoders.
+
+![](images/5f1867007d5bd909650ff6978c98713c098894c2e3afb2475f8f4d55c0dcea38.jpg)  
+Figure 10: Relationship between the parts score and different measures of similarity. On the left, the parts scores is plotted against the two different measures of similarity. We can see there is a clear trend for all the models: the parts score increases for more semantically similar images, and decreases as the images become more similar pixel-wise. The figure on the right shows Pearson’s correlation coefficient between the metrics for different models
+
+![](images/091311fa1c9079f79e590046e4e1f40c6d91d4dfec914ea1edb28da38218bff9.jpg)  
+Figure 11: Comparing pre and post-pooling (respectively Small and $B i g$ ) features in terms of ZSL accuracy. The effect of a varying receptive field size strongly depends on the model type and on the dataset, highlighting how locality is expressed differently in the datasets.
+
+# E HOW LOCAL DO THE REPRESENTATIONS NEED TO BE?
+
+A somewhat alternative way to test if local information is relevant for generalization is to explicitly only consider local information. To achieve this, we consider performing classification directly on features whose receptive field doesn’t cover the entire image. In our experiments we consider the features extracted from the AlexNet based encoder right before the flattening and final linear layers. To see the effect of varying the receptive field, we perform the same experiment and pre and post last pooling layer, going from a receptive field of 65 pixels (referred to as small in the plots) to 85 pixels (big), out of 128 in the original input. The way these local prediction are combined is described in the following section. The results are summarized in Fig. 11. We can see how the dataset seems to make quite a difference for class-matching DIM that benefits from pooling for the datasets where usually the object is in a small part of input, while for SUN, where the whole image tends to be relevant as the images depict scenes, pooling either does not affect or has a negative effect on performance. For reconstruction based models on the other side we see a different trend, where not performing pooling consistently results in better performance across all datasets.
+
+# F BIRD PARTS LOCATION MAPS
+
+The parts annotations provided with the CUB dataset give us the ability to explicitly quantify whether the encoder is learning to extract meaningful local information. To evaluate this, we train a classifier for each part, that takes as input local features extracted from a specific layer of the CNN encoder and outputs the probability of that part being present within the receptive field of the local feature. To construct a ground truth for this evaluation, we pre-process the parts clicks annotations as follows: the datasets provides, for each input and part, a list of multiple parts location as perceived by multiple MTurk workers. Each annotation is provided as $( x , y )$ coordinates of the center of the part and a boolean feature visible indicating whether the part is hidden in the considered input. The ground truth for the classifiers is obtained by converting each part annotation into a boolean semantic map, where a truth value is assigned to a square of side 10 pixels centered in all the locations provided by different MTurk users for each part when visible. This process is repeated separately for all the 15 parts. The obtained boolean masks are then processed through a CNN to project them to the size compatible with the extracted features, so that the classifier’s loss can be computed. Importantly, this loss is never backpropagated through the encoder, as these classifiers are meant to only evaluate whether the considered local features are predictive of the parts.
+
+# G CLASS MATCHING DIM
+
+Deep InfoMax (Hjelm et al., 2018) is a self-supervised representation learning algorithm that is trained by maximizing Mutual Information (MI) between local and global features extracted from the network. More specifically, DIM’s objective is a lower bound to MI based on the Donsker-Varadhan representation of the KL divergence that computes two expectations: one over the joint distribution of local and global features, and one over the product of the marginals. In the original DIM setting, samples from the joint distribution (positive samples) are defined as local-global pairs extracted from the same input, while for the product of marginals (negative samples) local and global features are extracted from different inputs.
+
+Class Matching DIM performs a similar operation, but samples from the joint distribution are defined to be pairs of local-global features extracted from different inputs belonging to the same class, and negative samples are pairs where features are extracted from inputs of different classes. Moreover, we add a hyper-parameter $p$ that allows to control the interplay between DIM and CMDIM, so that positive samples are extracted from inputs of the same class with probability $p$ and from the same input otherwise. Intuitively, this would push the encoder to extract features relevant to a specific input while identifying what features are shared across a single class.
+
+# H DEFINITION OF TRE
+
+We introduce the following notations:
+
+• $\mathcal { X }$ is a dataset, split into train ${ \mathcal { X } } _ { \mathrm { t r } }$ and test $\mathcal { X } _ { \mathrm { t e } }$ sets.   
+• For $x \in \mathcal { X }$ belonging to a class with binary attributes $a _ { i }$ (for continuous attributes we threshold them beforehand), we define $D ( x )$ to be the set of 1-valued attributes (present attributes).   
+• Each attribute $a _ { i }$ is assigned a learnable vector representation $f _ { \eta } ( \mathbf { a } _ { i } ) = \eta _ { i }$ .   
+• $\delta ( \cdot , \cdot )$ is a distance function, chosen to be cosine similarity as in Andreas (2019).
+
+As in Andreas (2019) we combine individual attribute representations by summation:
+
+$$
+f _ { \eta } ( D ( x ) ) = \sum _ { \mathbf { a } _ { i } \in D ( x ) } f _ { \eta } ( \mathbf { a } _ { i } )
+$$
+
+We can now define:
+
+$$
+\begin{array} { c } { { \mathrm { T R E } ( x , { \bf a } ; \eta ) = \delta \Big ( f _ { \eta } ( x ) , f _ { \eta } ( D ( x ) ) \Big ) } } \\ { { \mathrm { T R E } ( \mathcal { X } , { \bf a } ; \eta ) = \displaystyle \frac { 1 } { | \mathcal { X } | } \sum _ { x \in \mathcal { X } } \mathrm { T R E } ( x , { \bf a } ; \eta ) } } \end{array}
+$$
+
+We compute $\begin{array} { r } { \eta { = } \mathrm { a r g m i n } _ { \eta ^ { \prime } } \mathrm { T R E } ( \mathcal { X } _ { \mathrm { t r } } , \mathbf { a } ; \eta ^ { \prime } ) } \end{array}$ and omit it in what follows by abuse of notations.
+
+# I ARCHITECTURES AND DATASETS DETAILS
+
+Table 1: Details of the datasets used   
+
+<table><tr><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=1>#Images</td><td rowspan=1 colspan=1>#Attributes</td><td rowspan=1 colspan=1>#Classes</td><td rowspan=1 colspan=1>#Train classes</td><td rowspan=1 colspan=1>#Testclasses</td></tr><tr><td rowspan=1 colspan=1>CUB</td><td rowspan=1 colspan=1>11,788</td><td rowspan=1 colspan=1>312</td><td rowspan=1 colspan=1>200</td><td rowspan=1 colspan=1>150</td><td rowspan=1 colspan=1>50</td></tr><tr><td rowspan=1 colspan=1>AWA</td><td rowspan=1 colspan=1>30,475</td><td rowspan=1 colspan=1>85</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>10</td></tr><tr><td rowspan=1 colspan=1>SUN</td><td rowspan=1 colspan=1>14,340</td><td rowspan=1 colspan=1>102</td><td rowspan=1 colspan=1>717</td><td rowspan=1 colspan=1>645</td><td rowspan=1 colspan=1>72</td></tr></table>
+
+Table 2: Basic $1 2 8 \mathrm { x } 1 2 8$ architecture details.   
+
+<table><tr><td>Layer</td><td>Layer type</td><td>Layer params</td><td>pooling</td><td>activation</td></tr><tr><td>0 1 2 3 4</td><td>conv conv conv conv</td><td>(64,4,2,1),batch norm (128,4,2,1),batch norm (256,4,2,1),batch norm (512,4,2,1), batch norm (1024,4,2,1),batch norm</td><td>1</td><td>ReLU ReLU ReLU ReLU</td></tr></table>
+
+Table 3: AlexNet 128x128 architecture details.   
+
+<table><tr><td>Layer</td><td>Layer type</td><td>Layer params</td><td>pooling</td><td>activation</td></tr><tr><td>0 1</td><td>conv</td><td>(96,3,1,1),batch norm</td><td>(MaxPool2d,3,2)</td><td>ReLU ReLU</td></tr><tr><td>2</td><td>conv conv</td><td>(192,3,1,1),batch norm (384,3,1,1), batch norm</td><td>(MaxPool2d,3,2)</td><td>ReLU</td></tr><tr><td>3</td><td></td><td>(384,3,1,1),batch norm</td><td>1</td><td>ReLU</td></tr><tr><td>4</td><td>conv</td><td>(192,3,1,1),batch norm</td><td>(MaxPool2d,3,2)</td><td>ReLU</td></tr><tr><td>5</td><td>conv conv</td><td>(192,3,1,1),batch norm</td><td>(MaxPool2d, 3,2)</td><td>ReLU</td></tr><tr><td>6</td><td>flatten</td><td></td><td></td><td>=</td></tr><tr><td>7</td><td>linear</td><td>(4096,), batch norm</td><td></td><td>ReLU</td></tr><tr><td>8</td><td>linear</td><td>(4096,), batch norm</td><td></td><td>ReLU</td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+# J TRE RATIO VALUES
+
+Table 4: TRE ratio values for the CUB dataset   
+
+<table><tr><td rowspan=1 colspan=3></td><td rowspan=1 colspan=1>Normal</td><td rowspan=1 colspan=3>AC</td><td rowspan=1 colspan=1>LC</td><td rowspan=1 colspan=1>Normal_a</td><td rowspan=1 colspan=1>AC_a</td><td rowspan=1 colspan=1>LC_a</td></tr><tr><td rowspan=1 colspan=3>Model</td><td rowspan=1 colspan=5>Basic</td><td rowspan=1 colspan=3>Alex</td></tr><tr><td rowspan=2 colspan=3>classifier_fullvae</td><td rowspan=1 colspan=1>0.761</td><td rowspan=1 colspan=3>0.737</td><td rowspan=1 colspan=1>0.807</td><td rowspan=1 colspan=1>0.758</td><td rowspan=1 colspan=1>0.787</td><td rowspan=1 colspan=1>0.758</td></tr><tr><td rowspan=6 colspan=3>vaevae_betaaaelocal_dimlocal_twopasslocal_twopass_class_matching</td><td rowspan=1 colspan=1>vae</td><td rowspan=1 colspan=3>1.062</td><td rowspan=1 colspan=1>1.042</td><td rowspan=1 colspan=1>1.066</td><td rowspan=3 colspan=1>1.1111.121.003</td><td rowspan=3 colspan=1>1.0791.0870.974</td></tr><tr><td rowspan=1 colspan=1>1.04</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=2>1.044</td><td rowspan=1 colspan=1>1.044</td><td></td></tr><tr><td rowspan=1 colspan=1>1.011</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=2>0.989</td><td rowspan=1 colspan=1>1.036</td><td></td></tr><tr><td rowspan=1 colspan=1>0.771</td><td rowspan=1 colspan=3>0.875</td><td rowspan=1 colspan=1>0.798</td><td rowspan=1 colspan=1>0.755</td><td rowspan=1 colspan=1>0.783</td><td rowspan=2 colspan=1>0.7250.739</td></tr><tr><td rowspan=1 colspan=1>0.881</td><td rowspan=1 colspan=3>0.913</td><td rowspan=1 colspan=1>0.85</td><td rowspan=1 colspan=1>0.762</td><td rowspan=1 colspan=1>0.804</td></tr><tr><td rowspan=1 colspan=1>0.639</td><td rowspan=1 colspan=3>0.633</td><td rowspan=1 colspan=1>0.752</td><td rowspan=1 colspan=1>0.676</td><td rowspan=1 colspan=1>0.649</td><td rowspan=1 colspan=1>0.624</td></tr></table>
+
+Table 5: TRE ratio values for the AWA2 dataset   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Normal</td><td rowspan=1 colspan=2>AC</td><td rowspan=1 colspan=1>LC</td><td rowspan=1 colspan=1>Normal_a</td><td rowspan=1 colspan=1>AC_a</td><td rowspan=1 colspan=1>LC_a</td></tr><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=4>Basic</td><td rowspan=1 colspan=3>Alex</td></tr><tr><td rowspan=7 colspan=1>classifier_fullvaevae_betaaaelocal_dimlocal_twopasslocal_twopass_class_matching</td><td rowspan=1 colspan=1>0.88</td><td rowspan=1 colspan=2>0.873</td><td rowspan=1 colspan=1>0.913</td><td rowspan=1 colspan=1>0.882</td><td rowspan=1 colspan=1>0.878</td><td rowspan=1 colspan=1>0.909</td></tr><tr><td rowspan=1 colspan=1>1.395</td><td rowspan=1 colspan=2>1.292</td><td rowspan=1 colspan=1>1.379</td><td rowspan=1 colspan=1>1.566</td><td rowspan=2 colspan=1>1.4991.485</td><td rowspan=2 colspan=1>1.6811.567</td></tr><tr><td rowspan=2 colspan=1>1.3250.886</td><td rowspan=2 colspan=2>1.330.941</td><td rowspan=1 colspan=1>1.33</td><td rowspan=1 colspan=1>1.372</td><td rowspan=1 colspan=1>1.631</td><td rowspan=1 colspan=1>1.485</td><td rowspan=2 colspan=1>1.5670.913</td></tr><tr><td rowspan=1 colspan=1>0.986</td><td rowspan=1 colspan=1>1.282</td><td rowspan=1 colspan=1>0.945</td></tr><tr><td rowspan=1 colspan=1>1.211</td><td rowspan=1 colspan=2>1.206</td><td rowspan=1 colspan=1>1.174</td><td rowspan=1 colspan=1>1.154</td><td rowspan=1 colspan=1>1.264</td><td rowspan=1 colspan=1>1.062</td></tr><tr><td rowspan=2 colspan=1>1.1030.996</td><td rowspan=1 colspan=2>1.072</td><td rowspan=1 colspan=1>1.093</td><td rowspan=1 colspan=1>1.151</td><td rowspan=1 colspan=1>0.998</td><td rowspan=1 colspan=1>1.105</td></tr><tr><td rowspan=1 colspan=2>1.155</td><td rowspan=1 colspan=1>0.887</td><td rowspan=1 colspan=1>1.054</td><td rowspan=1 colspan=1>1.118</td><td rowspan=1 colspan=1>1.07</td></tr></table>
+
+Table 6: TRE ratio values for the SUN dataset   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=2>Normal</td><td rowspan=1 colspan=1>AC</td><td rowspan=1 colspan=1>LC</td><td rowspan=1 colspan=2>Normal_a</td><td rowspan=1 colspan=2>AC_a</td><td rowspan=1 colspan=1>LC_a</td></tr><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=4>Basic</td><td rowspan=1 colspan=5>Alex</td></tr><tr><td rowspan=7 colspan=1>classifier_fullvaevae_betaaaelocal_dimlocal_twopasslocal_twopass_class_matching</td><td rowspan=1 colspan=2>0.85</td><td rowspan=1 colspan=1>0.803</td><td rowspan=1 colspan=1>0.82</td><td rowspan=1 colspan=2>0.839</td><td rowspan=1 colspan=2>0.794</td><td rowspan=1 colspan=1>0.848</td></tr><tr><td rowspan=3 colspan=2>1.0050.9890.963</td><td rowspan=1 colspan=1>1.005</td><td rowspan=1 colspan=1>1.002</td><td rowspan=1 colspan=2>1.04</td><td rowspan=1 colspan=2>1.036</td><td rowspan=1 colspan=1>1.035</td></tr><tr><td rowspan=1 colspan=1>0.989</td><td rowspan=2 colspan=1>0.9950.976</td><td rowspan=1 colspan=1>0.989</td><td rowspan=2 colspan=2>1.0380.954</td><td rowspan=2 colspan=2>1.0310.926</td><td rowspan=2 colspan=1>1.0310.958</td></tr><tr><td rowspan=1 colspan=1>0.975</td></tr><tr><td rowspan=1 colspan=2>1.132</td><td rowspan=1 colspan=1>0.977</td><td rowspan=1 colspan=1>1.043</td><td></td><td></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>0.995</td><td rowspan=1 colspan=1>1.036</td></tr><tr><td rowspan=1 colspan=2>1.047</td><td rowspan=1 colspan=1>0.912</td><td rowspan=1 colspan=1>0.969</td><td rowspan=2 colspan=2>1.1230.859</td><td rowspan=2 colspan=2>1.0420.82</td><td rowspan=2 colspan=1>1.0570.956</td></tr><tr><td rowspan=1 colspan=2>0.832</td><td rowspan=1 colspan=1>0.755</td><td rowspan=1 colspan=1>0.877</td></tr></table>
+
+# K F1 PART AVERAGE SCORES
+
+Table 7: Part average F1 score, CUB dataset, basic encoder.   
+
+<table><tr><td rowspan=1 colspan=1>Loss</td><td rowspan=1 colspan=1>Normal</td><td rowspan=2 colspan=2>Normal  AC    LC</td></tr><tr><td rowspan=1 colspan=1>Model</td><td></td></tr><tr><td rowspan=1 colspan=1>FC</td><td rowspan=1 colspan=1>0.198</td><td rowspan=1 colspan=1>0.368</td><td rowspan=1 colspan=1>0.284</td></tr><tr><td rowspan=1 colspan=1>VAE</td><td rowspan=1 colspan=1>0.07</td><td rowspan=1 colspan=1>0.334</td><td rowspan=1 colspan=1>0.265</td></tr><tr><td rowspan=1 colspan=1>beta-VAE</td><td rowspan=1 colspan=1>0.067</td><td rowspan=1 colspan=1>0.353</td><td rowspan=1 colspan=1>0.255</td></tr><tr><td rowspan=1 colspan=1>AAE</td><td rowspan=1 colspan=1>0.086</td><td rowspan=1 colspan=1>0.085</td><td rowspan=1 colspan=1>0.024</td></tr><tr><td rowspan=1 colspan=1>DIM</td><td rowspan=1 colspan=1>0.235</td><td rowspan=1 colspan=1>0.393</td><td rowspan=1 colspan=1>0.304</td></tr><tr><td rowspan=1 colspan=1>AMDIM</td><td rowspan=1 colspan=1>0.311</td><td rowspan=1 colspan=1>0.406</td><td rowspan=1 colspan=1>0.319</td></tr><tr><td rowspan=1 colspan=1>CMDIM (p=1)</td><td rowspan=1 colspan=1>0.313</td><td rowspan=1 colspan=1>0.406</td><td rowspan=1 colspan=1>0.314</td></tr><tr><td rowspan=1 colspan=1>CMDIM (p=0.5)</td><td rowspan=1 colspan=1>0.295</td><td rowspan=1 colspan=1>0.397</td><td rowspan=1 colspan=1>0.321</td></tr><tr><td rowspan=1 colspan=1>CMDIM (p=0.1)</td><td rowspan=1 colspan=1>0.315</td><td rowspan=1 colspan=1>0.382</td><td rowspan=1 colspan=1>0.312</td></tr><tr><td rowspan=1 colspan=1>PN</td><td rowspan=1 colspan=1>0.288</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr></table>
+
+Table 8: ZSL accuracy, comparing the different local losses.   
+
+<table><tr><td rowspan=1 colspan=2>Encoder</td><td rowspan=1 colspan=3>alex128x128</td><td rowspan=1 colspan=3>basic128x128</td></tr><tr><td rowspan=1 colspan=2>Loss</td><td rowspan=1 colspan=1>Normal</td><td rowspan=2 colspan=4>AC    LC     Normal  AC</td><td rowspan=1 colspan=1>LC</td></tr><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>FC</td><td rowspan=10 colspan=1>CUB</td><td rowspan=1 colspan=1>30.47</td><td rowspan=1 colspan=1>34.92</td><td rowspan=1 colspan=1>32.40</td><td rowspan=1 colspan=1>27.44</td><td rowspan=1 colspan=1>32.17</td><td rowspan=1 colspan=1>30.44</td></tr><tr><td rowspan=1 colspan=1>VAE</td><td rowspan=1 colspan=1>12.08</td><td rowspan=1 colspan=1>13.41</td><td rowspan=1 colspan=1>12.51</td><td rowspan=1 colspan=1>12.13</td><td rowspan=1 colspan=1>13.46</td><td rowspan=1 colspan=1>10.27</td></tr><tr><td rowspan=1 colspan=1>beta-VAE</td><td rowspan=1 colspan=1>11.75</td><td rowspan=1 colspan=1>11.77</td><td rowspan=1 colspan=1>12.33</td><td rowspan=1 colspan=1>12.03</td><td rowspan=1 colspan=1>12.85</td><td rowspan=1 colspan=1>12.52</td></tr><tr><td rowspan=1 colspan=1>AAE</td><td rowspan=1 colspan=1>15.16</td><td rowspan=1 colspan=1>15.00</td><td rowspan=1 colspan=1>15.49</td><td rowspan=1 colspan=1>9.12</td><td rowspan=1 colspan=1>12.36</td><td rowspan=1 colspan=1>9.80</td></tr><tr><td rowspan=1 colspan=1>DIM</td><td rowspan=1 colspan=1>23.93</td><td rowspan=1 colspan=1>33.35</td><td rowspan=1 colspan=1>31.84</td><td rowspan=1 colspan=1>24.42</td><td rowspan=1 colspan=1>32.54</td><td rowspan=1 colspan=1>29.17</td></tr><tr><td rowspan=1 colspan=1>AMDIM</td><td rowspan=1 colspan=1>24.34</td><td rowspan=1 colspan=1>29.05</td><td rowspan=1 colspan=1>31.12</td><td rowspan=1 colspan=1>24.42</td><td rowspan=1 colspan=1>30.29</td><td rowspan=1 colspan=1>28.83</td></tr><tr><td rowspan=1 colspan=1>CMDIM (p=1)</td><td rowspan=1 colspan=1>35.80</td><td rowspan=1 colspan=1>40.11</td><td rowspan=1 colspan=1>32.31</td><td rowspan=1 colspan=1>29.24</td><td rowspan=1 colspan=1>30.08</td><td rowspan=1 colspan=1>30.04</td></tr><tr><td rowspan=1 colspan=1>CMDIM(p=0.5)</td><td rowspan=1 colspan=1>35.12</td><td rowspan=1 colspan=1>37.02</td><td rowspan=1 colspan=1>35.27</td><td rowspan=1 colspan=1>29.67</td><td rowspan=1 colspan=1>35.15</td><td rowspan=1 colspan=1>31.06</td></tr><tr><td rowspan=1 colspan=1>CMDIM (p=0.1)</td><td rowspan=1 colspan=1>29.83</td><td rowspan=1 colspan=1>33.60</td><td rowspan=1 colspan=1>33.02</td><td rowspan=1 colspan=1>27.03</td><td rowspan=1 colspan=1>32.35</td><td rowspan=1 colspan=1>31.14</td></tr><tr><td rowspan=1 colspan=1>PN</td><td rowspan=1 colspan=1>37.59</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>26.29</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td></tr><tr><td rowspan=1 colspan=1>FC</td><td rowspan=10 colspan=1>AWA2</td><td rowspan=1 colspan=1>46.48</td><td rowspan=1 colspan=1>52.81</td><td rowspan=1 colspan=1>46.04</td><td rowspan=1 colspan=1>45.94</td><td rowspan=1 colspan=1>45.98</td><td rowspan=1 colspan=1>46.09</td></tr><tr><td rowspan=1 colspan=1>VAE</td><td rowspan=1 colspan=1>29.17</td><td rowspan=1 colspan=1>28.54</td><td rowspan=1 colspan=1>28.76</td><td rowspan=1 colspan=1>30.02</td><td rowspan=1 colspan=1>29.60</td><td rowspan=1 colspan=1>29.48</td></tr><tr><td rowspan=1 colspan=1>beta-VAE</td><td rowspan=1 colspan=1>29.98</td><td rowspan=1 colspan=1>30.11</td><td rowspan=1 colspan=1>29.22</td><td rowspan=1 colspan=1>29.00</td><td rowspan=1 colspan=1>29.47</td><td rowspan=1 colspan=1>29.94</td></tr><tr><td rowspan=1 colspan=1>AAE</td><td rowspan=1 colspan=1>32.07</td><td rowspan=1 colspan=1>29.46</td><td rowspan=1 colspan=1>30.93</td><td rowspan=1 colspan=1>31.94</td><td rowspan=1 colspan=1>29.31</td><td rowspan=1 colspan=1>31.85</td></tr><tr><td rowspan=1 colspan=1>DIM</td><td rowspan=1 colspan=1>38.73</td><td rowspan=1 colspan=1>45.54</td><td rowspan=1 colspan=1>43.89</td><td rowspan=1 colspan=1>39.63</td><td rowspan=1 colspan=1>44.23</td><td rowspan=1 colspan=1>44.32</td></tr><tr><td rowspan=1 colspan=1>AMDIM</td><td rowspan=1 colspan=1>42.84</td><td rowspan=1 colspan=1>45.41</td><td rowspan=1 colspan=1>46.95</td><td rowspan=1 colspan=1>42.04</td><td rowspan=1 colspan=1>49.01</td><td rowspan=1 colspan=1>43.77</td></tr><tr><td rowspan=1 colspan=1>CMDIM (p=1)</td><td rowspan=1 colspan=1>45.80</td><td rowspan=1 colspan=1>46.56</td><td rowspan=1 colspan=1>42.14</td><td rowspan=1 colspan=1>46.87</td><td rowspan=1 colspan=1>45.00</td><td rowspan=1 colspan=1>39.70</td></tr><tr><td rowspan=1 colspan=1>CMDIM(p=0.5)</td><td rowspan=1 colspan=1>46.87</td><td rowspan=1 colspan=1>48.06</td><td rowspan=1 colspan=1>48.45</td><td rowspan=1 colspan=1>46.87</td><td rowspan=1 colspan=1>47.92</td><td rowspan=1 colspan=1>45.63</td></tr><tr><td rowspan=1 colspan=1>CMDIM(p=0.1)</td><td rowspan=1 colspan=1>47.29</td><td rowspan=1 colspan=1>51.51</td><td rowspan=1 colspan=1>50.17</td><td rowspan=1 colspan=1>45.71</td><td rowspan=1 colspan=1>49.51</td><td rowspan=1 colspan=1>48.01</td></tr><tr><td rowspan=1 colspan=1>PN</td><td rowspan=1 colspan=1>46.53</td><td rowspan=1 colspan=1>二</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>45.23</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>-</td></tr><tr><td rowspan=1 colspan=1>FC</td><td rowspan=10 colspan=1>SUN</td><td rowspan=1 colspan=1>33.02</td><td rowspan=1 colspan=1>36.89</td><td rowspan=1 colspan=1>37.57</td><td rowspan=1 colspan=1>32.20</td><td rowspan=1 colspan=1>38.79</td><td rowspan=1 colspan=1>32.74</td></tr><tr><td rowspan=1 colspan=1>VAE</td><td rowspan=1 colspan=1>14.61</td><td rowspan=1 colspan=1>15.08</td><td rowspan=1 colspan=1>14.33</td><td rowspan=1 colspan=1>15.14</td><td rowspan=1 colspan=1>16.58</td><td rowspan=1 colspan=1>15.22</td></tr><tr><td rowspan=1 colspan=1>beta-VAE</td><td rowspan=1 colspan=1>13.80</td><td rowspan=1 colspan=1>14.20</td><td rowspan=1 colspan=1>13.79</td><td rowspan=1 colspan=1>15.08</td><td rowspan=1 colspan=1>15.29</td><td rowspan=1 colspan=1>16.58</td></tr><tr><td rowspan=1 colspan=1>AAE</td><td rowspan=1 colspan=1>17.93</td><td rowspan=1 colspan=1>16.78</td><td rowspan=1 colspan=1>17.86</td><td rowspan=1 colspan=1>18.55</td><td rowspan=1 colspan=1>18.41</td><td rowspan=1 colspan=1>18.13</td></tr><tr><td rowspan=1 colspan=1>DIM</td><td rowspan=1 colspan=1>31.73</td><td rowspan=1 colspan=1>39.06</td><td rowspan=1 colspan=1>37.64</td><td rowspan=1 colspan=1>33.69</td><td rowspan=1 colspan=1>41.44</td><td rowspan=1 colspan=1>38.52</td></tr><tr><td rowspan=1 colspan=1>AMDIM</td><td rowspan=1 colspan=1>38.04</td><td rowspan=1 colspan=1>41.44</td><td rowspan=1 colspan=1>39.67</td><td rowspan=1 colspan=1>37.64</td><td rowspan=1 colspan=1>42.26</td><td rowspan=1 colspan=1>38.19</td></tr><tr><td rowspan=1 colspan=1>CMDIM (p=1)</td><td rowspan=1 colspan=1>35.73</td><td rowspan=1 colspan=1>37.43</td><td rowspan=1 colspan=1>32.81</td><td rowspan=1 colspan=1>34.44</td><td rowspan=1 colspan=1>37.98</td><td rowspan=1 colspan=1>31.18</td></tr><tr><td rowspan=1 colspan=1>CMDIM (p=0.5)</td><td rowspan=1 colspan=1>37.43</td><td rowspan=1 colspan=1>40.15</td><td rowspan=1 colspan=1>36.62</td><td rowspan=1 colspan=1>35.39</td><td rowspan=1 colspan=1>39.74</td><td rowspan=1 colspan=1>34.10</td></tr><tr><td rowspan=1 colspan=1>CMDIM(p=0.1)</td><td rowspan=1 colspan=1>40.01</td><td rowspan=1 colspan=1>42.05</td><td rowspan=1 colspan=1>38.51</td><td rowspan=1 colspan=1>40.56</td><td rowspan=1 colspan=1>43.13</td><td rowspan=1 colspan=1>38.93</td></tr><tr><td rowspan=1 colspan=1>PN</td><td rowspan=1 colspan=1>32.00</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>29.82</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>1</td></tr></table>
+
+Table 9: ZSL accuracy, comparing the different local models.   
+
+<table><tr><td rowspan=1 colspan=2></td><td rowspan=1 colspan=2>Average before</td><td rowspan=1 colspan=2>Averageafter</td></tr><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=1>pool</td><td rowspan=1 colspan=1>no pool</td><td rowspan=1 colspan=1>pool</td><td rowspan=1 colspan=1>no pool</td></tr><tr><td rowspan=1 colspan=1>FC</td><td rowspan=9 colspan=1>CUB</td><td rowspan=1 colspan=1>28.55</td><td rowspan=1 colspan=1>21.45</td><td rowspan=1 colspan=1>13.02</td><td rowspan=1 colspan=1>11.75</td></tr><tr><td rowspan=1 colspan=1>VAE</td><td rowspan=1 colspan=1>8.37</td><td rowspan=1 colspan=1>8.06</td><td rowspan=1 colspan=1>8.33</td><td rowspan=1 colspan=1>8.15</td></tr><tr><td rowspan=1 colspan=1>beta-VAE</td><td rowspan=1 colspan=1>8.04</td><td rowspan=1 colspan=1>8.77</td><td rowspan=1 colspan=1>7.91</td><td rowspan=1 colspan=1>8.02</td></tr><tr><td rowspan=1 colspan=1>AAE</td><td rowspan=1 colspan=1>8.20</td><td rowspan=1 colspan=1>7.37</td><td rowspan=1 colspan=1>7.28</td><td rowspan=1 colspan=1>6.84</td></tr><tr><td rowspan=1 colspan=1>DIM</td><td rowspan=1 colspan=1>18.48</td><td rowspan=1 colspan=1>14.39</td><td rowspan=1 colspan=1>15.07</td><td rowspan=1 colspan=1>11.81</td></tr><tr><td rowspan=1 colspan=1>AMDIM</td><td rowspan=1 colspan=1>21.45</td><td rowspan=1 colspan=1>17.68</td><td rowspan=1 colspan=1>16.67</td><td rowspan=1 colspan=1>14.04</td></tr><tr><td rowspan=1 colspan=1>CMDIM (p=1)</td><td rowspan=1 colspan=1>34.11</td><td rowspan=1 colspan=1>22.16</td><td rowspan=1 colspan=1>13.51</td><td rowspan=1 colspan=1>15.17</td></tr><tr><td rowspan=1 colspan=1>CMDIM (p=0.5)</td><td rowspan=1 colspan=1>33.48</td><td rowspan=1 colspan=1>22.88</td><td rowspan=1 colspan=1>19.07</td><td rowspan=1 colspan=1>16.35</td></tr><tr><td rowspan=1 colspan=1>CMDIM (p=0.1)</td><td rowspan=1 colspan=1>26.17</td><td rowspan=1 colspan=1>19.23</td><td rowspan=1 colspan=1>18.38</td><td rowspan=1 colspan=1>15.89</td></tr><tr><td rowspan=1 colspan=1>FC</td><td rowspan=9 colspan=1>AWA2</td><td rowspan=1 colspan=1>48.57</td><td rowspan=1 colspan=1>46.95</td><td rowspan=1 colspan=1>38.90</td><td rowspan=1 colspan=1>41.98</td></tr><tr><td rowspan=1 colspan=1>VAE</td><td rowspan=1 colspan=1>26.36</td><td rowspan=1 colspan=1>30.04</td><td rowspan=1 colspan=1>25.47</td><td rowspan=1 colspan=1>26.37</td></tr><tr><td rowspan=1 colspan=1>beta-VAE</td><td rowspan=1 colspan=1>24.78</td><td rowspan=1 colspan=1>26.32</td><td rowspan=1 colspan=1>27.63</td><td rowspan=1 colspan=1>27.11</td></tr><tr><td rowspan=1 colspan=1>AAE</td><td rowspan=1 colspan=1>26.74</td><td rowspan=1 colspan=1>23.59</td><td rowspan=1 colspan=1>26.08</td><td rowspan=1 colspan=1>25.23</td></tr><tr><td rowspan=1 colspan=1>DIM</td><td rowspan=1 colspan=1>35.37</td><td rowspan=1 colspan=1>34.77</td><td rowspan=1 colspan=1>33.54</td><td rowspan=1 colspan=1>33.99</td></tr><tr><td rowspan=1 colspan=1>AMDIM</td><td rowspan=1 colspan=1>41.37</td><td rowspan=1 colspan=1>41.34</td><td rowspan=1 colspan=1>40.57</td><td rowspan=1 colspan=1>37.12</td></tr><tr><td rowspan=1 colspan=1>CMDIM (p=1)</td><td rowspan=1 colspan=1>49.66</td><td rowspan=1 colspan=1>46.26</td><td rowspan=1 colspan=1>48.16</td><td rowspan=1 colspan=1>42.57</td></tr><tr><td rowspan=1 colspan=1>CMDIM (p=0.5)</td><td rowspan=1 colspan=1>49.17</td><td rowspan=1 colspan=1>45.99</td><td rowspan=1 colspan=1>45.90</td><td rowspan=1 colspan=1>43.28</td></tr><tr><td rowspan=1 colspan=1>CMDIM (p=0.1)</td><td rowspan=1 colspan=1>50.95</td><td rowspan=1 colspan=1>44.26</td><td rowspan=1 colspan=1>44.90</td><td rowspan=1 colspan=1>37.79</td></tr><tr><td rowspan=1 colspan=1>FC</td><td rowspan=9 colspan=1>SUN</td><td rowspan=1 colspan=1>33.97</td><td rowspan=1 colspan=1>34.31</td><td rowspan=1 colspan=1>32.13</td><td rowspan=1 colspan=1>32.15</td></tr><tr><td rowspan=1 colspan=1>VAE</td><td rowspan=1 colspan=1>11.48</td><td rowspan=1 colspan=1>12.84</td><td rowspan=1 colspan=1>10.73</td><td rowspan=1 colspan=1>10.14</td></tr><tr><td rowspan=1 colspan=1>beta-VAE</td><td rowspan=1 colspan=1>11.96</td><td rowspan=1 colspan=1>14.06</td><td rowspan=1 colspan=1>11.89</td><td rowspan=1 colspan=1>13.06</td></tr><tr><td rowspan=1 colspan=1>AAE</td><td rowspan=1 colspan=1>9.38</td><td rowspan=1 colspan=1>11.07</td><td rowspan=1 colspan=1>9.31</td><td rowspan=1 colspan=1>11.32</td></tr><tr><td rowspan=1 colspan=1>DIM</td><td rowspan=1 colspan=1>25.82</td><td rowspan=1 colspan=1>26.83</td><td rowspan=1 colspan=1>24.80</td><td rowspan=1 colspan=1>25.56</td></tr><tr><td rowspan=1 colspan=1>AMDIM</td><td rowspan=1 colspan=1>34.04</td><td rowspan=1 colspan=1>35.19</td><td rowspan=1 colspan=1>34.51</td><td rowspan=1 colspan=1>34.58</td></tr><tr><td rowspan=1 colspan=1>CMDIM (p=1)</td><td rowspan=1 colspan=1>37.02</td><td rowspan=1 colspan=1>36.75</td><td rowspan=1 colspan=1>33.70</td><td rowspan=1 colspan=1>36.53</td></tr><tr><td rowspan=1 colspan=1>CMDIM (p=0.5)</td><td rowspan=1 colspan=1>37.98</td><td rowspan=1 colspan=1>38.93</td><td rowspan=1 colspan=1>35.53</td><td rowspan=1 colspan=1>37.29</td></tr><tr><td rowspan=1 colspan=1>CMDIM (p=0.1)</td><td rowspan=1 colspan=1>35.73</td><td rowspan=1 colspan=1>35.60</td><td rowspan=1 colspan=1>34.58</td><td rowspan=1 colspan=1>36.39</td></tr></table>
+
+![](images/7188eb322f9dfae7ee4b13bd8fc75dbe7dfda6a7e2619c8bb9ecd7735018cc5b.jpg)  
+Figure 12: Comparison between averaging representations VS averaging scores for all models.
+
+![](images/c954d4d79065cdee7ec3ea4fda6e047f8c16f4283642fa1a898b58a730c44ded.jpg)  
+Figure 13: Comparison between small and big receptive field for all models.

parse/train/Ozk9MrX1hvA/Ozk9MrX1hvA.md

@@ -0,0 +1,310 @@
+# CODA: CONTRAST-ENHANCED AND DIVERSITYPROMOTING DATA AUGMENTATION FOR NATURAL LANGUAGE UNDERSTANDING
+
+Yanru $\mathbf { Q } \mathbf { u } ^ { 1 }$ ∗, Dinghan Shen2, Yelong Shen2, Sandra Sajeev2, Jiawei $\mathbf { H a n } ^ { 1 }$ , Weizhu Chen2
+
+1University of Illinois, Urbana-Champaign, 2Microsoft Dynamics 3   
+1{yanruqu2,hanj}@illinois.edu,   
+2{dishen,yeshe,ssajeev,wzchen}@microsoft.com
+
+# ABSTRACT
+
+Data augmentation has been demonstrated as an effective strategy for improving model generalization and data efficiency. However, due to the discrete nature of natural language, designing label-preserving transformations for text data tends to be more challenging. In this paper, we propose a novel data augmentation framework dubbed CoDA, which synthesizes diverse and informative augmented examples by integrating multiple transformations organically. Moreover, a contrastive regularization objective is introduced to capture the global relationship among all the data samples. A momentum encoder along with a memory bank is further leveraged to better estimate the contrastive loss. To verify the effectiveness of the proposed framework, we apply CoDA to Transformer-based models on a wide range of natural language understanding tasks. On the GLUE benchmark, CoDA gives rise to an average improvement of $2 . 2 \%$ while applied to the RoBERTa-large model. More importantly, it consistently exhibits stronger results relative to several competitive data augmentation and adversarial training baselines (including the low-resource settings). Extensive experiments show that the proposed contrastive objective can be flexibly combined with various data augmentation approaches to further boost their performance, highlighting the wide applicability of the CoDA framework.
+
+# 1 INTRODUCTION
+
+Data augmentation approaches have successfully improved large-scale neural-network-based models, (Laine & Aila, 2017; Xie et al., 2019; Berthelot et al., 2019; Sohn et al., 2020; He et al., 2020; Khosla et al., 2020; Chen et al., 2020b), however, the majority of existing research is geared towards computer vision tasks. The discrete nature of natural language makes it challenging to design effective label-preserving transformations for text sequences that can help improve model generalization (Hu et al., 2019; Xie et al., 2019). On the other hand, fine-tuning powerful, over-parameterized language models1 proves to be difficult, especially when there is a limited amount of task-specific data available. It may result in representation collapse (Aghajanyan et al., 2020) or require special finetuning techniques (Sun et al., 2019; Hao et al., 2019). In this work, we aim to take a further step towards finding effective data augmentation strategies through systematic investigation.
+
+In essence, data augmentation can be regarded as constructing neighborhoods around a training instance that preserve the ground-truth label. With such a characterization, adversarial training (Zhu et al., 2020; Jiang et al., 2020; Liu et al., 2020; Cheng et al., 2020) also performs label-preserving transformation in embedding space, and thus is considered as an alternative to data augmentation methods in this work. From this perspective, the goal of developing effective data augmentation strategies can be summarized as answering three fundamental questions:
+
+i) What are some label-preserving transformations, that can be applied to text, to compose useful augmented samples?
+
+ii) Are these transformations complementary in nature, and can we find some strategies to consolidate them for producing more diverse augmented examples?
+
+iii) How can we incorporate the obtained augmented samples into the training process in an effective and principled manner?
+
+Previous efforts in augmenting text data were mainly focused on answering the first question (Yu et al., 2018; Xie et al., 2019; Kumar et al., 2019; Wei & Zou, 2019; Chen et al., 2020a; Shen et al., 2020). Regarding the second question, different label-preserving transformations have been proposed, but it remains unclear how to integrate them organically. In addition, it has been shown that the diversity of augmented samples plays a vital role in their effectiveness (Xie et al., 2019; Gontijo-Lopes et al., 2020). In the case of image data, several strategies that combine different augmentation methods have been proposed, such as applying multiple transformations sequentially (Cubuk et al., 2018; 2020; Hendrycks et al., 2020), learning data augmentation policies (Cubuk et al., 2018), randomly sampling operations for each data point (Cubuk et al., 2020). However, these methods cannot be naively applied to text data, since the semantic meanings of a sentence are much more sensitive to local perturbations (relative to an image).
+
+As for the third question, consistency training is typically employed to utilize the augmented samples (Laine & Aila, 2017; Hendrycks et al., 2020; Xie et al., 2019; Sohn et al., 2020; Miyato et al., 2018). This method encourages the model predictions to be invariant to certain label-preserving transformations. However, existing approaches only examine a pair of original and augmented samples in isolation, without considering other examples in the entire training set. As a result, the representation of an augmented sample may be closer to those of other training instances, rather than the one it is derived from. Based on this observation, we advocate that, in addition to consistency training, a training objective that can globally capture the intrinsic relationship within the entire set of original and augmented training instances can help leverage augmented examples more effectively.
+
+In this paper, we introduce a novel Contrast-enhanced and Diversity-promoting Data Augmentation (CoDA) framework for natural language understanding. To improve the diversity of augmented samples, we extensively explore different combinations of isolated label-preserving transformations in an unified approach. We find that stacking distinct label-preserving transformations produces particularly informative samples. Specifically, the most diverse and high-quality augmented samples are obtained by stacking an adversarial training module over the back-translation transformation. Besides the consistency-regularized loss for repelling the model to behave consistently within local neighborhoods, we propose a contrastive learning objective to capture the global relationship among the data points in the representation space. We evaluate CoDA on the GLUE benchmark (with RoBERTa (Liu et al., 2019) as the testbed), and CoDA consistently improves the generalization ability of resulting models and gives rise to significant gains relative to the standard fine-tuning procedure. Moreover, our method also outperforms various single data augmentation operations, combination schemes, and other strong baselines. Additional experiments in the low-resource settings and ablation studies further demonstrate the effectiveness of this framework.
+
+# 2 METHOD
+
+In this section, we focus our discussion on the natural language understanding (NLU) tasks, and particularly, under a text classification scenario. However, the proposed data augmentation framework can be readily extended to other NLP tasks as well.
+
+# 2.1 BACKGROUND: DATA AUGMENTATION AND ADVERSARIAL TRAINING
+
+Data Augmentation Let $\mathcal { D } = \{ \substack { { \pmb x } _ { i } , y _ { i } } \} _ { i = 1 \ldots N }$ denote the training dataset, where the input example $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { i } }$ is a sequence of tokens, and $y _ { i }$ is the corresponding label. To improve model’s robustness and generalization ability, several data augmentation techniques (e.g., back-translation (Sennrich et al., 2016; Edunov et al., 2018; Xie et al., 2019), mixup (Guo et al., 2019), c-BERT (Wu et al., 2019)) have been proposed. Concretely, label-preserving transformations are performed (on the original training sequences) to synthesize a collection of augmented samples, denoted by $\mathcal { D } ^ { \prime } = \{ { \pmb x } _ { i } ^ { \prime } , \bar { y } _ { i } ^ { \prime } \} _ { i = 1 \ldots N }$ . Thus, a model can learn from both the training set $\mathcal { D }$ and the augmented set $\mathcal { D } ^ { \prime }$ , with $p _ { \theta } ( \cdot )$ the predicted output distribution of the model parameterized by $\theta$ :
+
+$$
+\theta ^ { * } = \underset { \theta } { \arg \operatorname* { m i n } } \sum _ { ( \mathbf { x } _ { i } , y _ { i } ) \in \mathcal { D } } \mathcal { L } \big ( p _ { \theta } ( \mathbf { x } _ { i } ) , y _ { i } \big ) + \sum _ { ( \mathbf { x } _ { i } ^ { \prime } , y _ { i } ^ { \prime } ) \in \mathcal { D } ^ { \prime } } \mathcal { L } \big ( p _ { \theta } ( \mathbf { x } _ { i } ^ { \prime } ) , y _ { i } ^ { \prime } \big )
+$$
+
+![](images/f0bacbbacfc9f71f1fd81088fd1d953683a91465c641ddcc046cf39024761c21.jpg)  
+Figure 1: Illustration of data augmentation combined with adversarial training.
+
+Several recent research efforts were focused on encouraging model predictions to be invariant to stochastic or domain-specific data transformations (Xie et al., 2019; Laine $\&$ Aila, 2017; Tarvainen & Valpola, 2017; Sohn et al., 2020; Miyato et al., 2018; Jiang et al., 2020; Hendrycks et al., 2020). Take back-translation as example: $\pmb { x } _ { i } ^ { \prime } = \mathbf { B a c k T r a n s } ( \pmb { x } _ { i } )$ , then $\pmb { x } _ { i } ^ { \prime }$ is a paraphrase of $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { i } }$ . The model can be regularized to have consistent predictions for $( \pmb { x } _ { i } , \pmb { x } _ { i } ^ { \prime } )$ , by minimizing the distribution discrepancy $\mathcal { R } _ { \mathrm { C S } } ( p _ { \theta } ( \pmb { x } _ { i } ) , p _ { \theta } ( \pmb { x } _ { i } ^ { \prime } ) )$ , which typically adopts KL divergence (see Fig. 1a).
+
+Adversarial Training In another line, adversarial training methods are applied to text data (Zhu et al., 2020; Jiang et al., 2020; Cheng et al., 2020; Aghajanyan et al., 2020) for improving model’s robustness. Compared with data augmentation techniques, adversarial training requires no domain knowledge to generate additional training examples. Instead, it relies on the model itself to produce adversarial examples which the model are most likely to make incorrect predictions. Similar to data augmentation, adversarial training also typically utilizes the cross-entropy and consistencybased objectives for training. As the two most popular adversarial-training-based algorithms, the adversarial loss (Goodfellow et al., 2015) (Eqn. 2) and virtual adversarial loss (Miyato et al., 2018) (Eqn. 3) can be expressed as follows (see Fig. 1b):
+
+$$
+\begin{array} { r } { \mathcal { R } _ { \mathrm { A T } } ( \boldsymbol { x } _ { i } , \tilde { \boldsymbol { x } } _ { i } , y _ { i } ) = \mathcal { L } \big ( p _ { \theta } ( \tilde { x } _ { i } ) , y _ { i } \big ) , s . t . , \| \tilde { \boldsymbol { x } } _ { i } - \boldsymbol { x } _ { i } \| \leq \epsilon , } \\ { \mathcal { R } _ { \mathrm { V A T } } ( \boldsymbol { x } _ { i } , \tilde { \boldsymbol { x } } _ { i } ) = \mathcal { R } _ { \mathrm { C S } } \big ( p _ { \theta } ( \tilde { \boldsymbol { x } } _ { i } ) , p _ { \theta } ( \boldsymbol { x } _ { i } ) \big ) , s . t . , \| \tilde { \boldsymbol { x } } _ { i } - \boldsymbol { x } _ { i } \| \leq \epsilon . } \end{array}
+$$
+
+Generally, there is no closed-form to obtain the exact adversarial example $\hat { \mathbf { x } } _ { i }$ in either Eqn. 2 or 3. However, it usually can be approximated by a low-order approximation of the objective function with respect to $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { i } }$ . For example, the adversarial example in Eqn. 2 can be approximated by:
+
+$$
+\hat { \pmb { x } } _ { i } \approx \pmb { x } _ { i } + \epsilon \frac { \pmb { g } } { \lVert \pmb { g } \rVert _ { 2 } } , \mathrm { w h e r e } \ \pmb { g } = \nabla _ { \pmb { x } _ { i } } \mathcal { L } \big ( p _ { \theta } ( \pmb { x } _ { i } ) , y _ { i } \big ) \ .
+$$
+
+# 2.2 DIVERSITY-PROMOTING CONSISTENCY TRAINING
+
+As discussed in the previous section, data augmentation and adversarial training share the same intuition of producing neighbors around the original training instances. Moreover, both approaches share very similar training objectives. Therefore, it is natural to ask the following question: are different data augmentation methods and adversarial training equal in nature? Otherwise, are they complementary to each other, and thus can be consolidated together to further improve the model’s generalization ability? Notably, it has been shown, in the CV domain, that combining different data augmentation operations could lead to more diverse augmented examples (Cubuk et al., 2018; 2020; Hendrycks et al., 2020). However, this is especially challenging for natural language, given that the semantics of a sentence can be entirely altered by slight perturbations.
+
+To answer the above question, we propose several distinct strategies to combine different data transformations, with the hope to produce more diverse and informative augmented examples. Specifically, we consider 5 different types of label-preserving transformations: back-translation (Sennrich et al., 2016; Edunov et al., 2018; Xie et al., 2019), $c$ -BERT word replacement (Wu et al., 2019), mixup (Guo et al., 2019; Chen et al., 2020a), cutoff (Shen et al., 2020), and adversarial training (Zhu et al., 2020; Jiang et al., 2020). The 3 combination strategies are schematically illustrated in Figure 2. For random combination, a particular label-preserving transformation is randomly selected, among all the augmentation operations available, for each mini-batch. As to the mixup interpolation, given two samples $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { i } }$ and $\boldsymbol { \mathscr { x } } _ { j }$ drawn in a mini-batch, linear interpolation is performed between their input embedding matrices $e _ { i }$ and $e _ { j }$ (Zhang et al., 2017): $\pmb { e } _ { i } ^ { \prime } = \bar { a \pmb { e } } _ { i } + ( 1 - a ) \bar { \pmb { e } } _ { j }$ , where $a$ is the interpolation parameter, usually drawn from a Beta distribution.
+
+![](images/9b120597e49a72475b0c9efa34911ad271f1fa285d26f033d4cccf77a78aba65.jpg)  
+Figure 2: Illustration of different strategies to combine various label-preserving transformations.
+
+Moreover, we consider stacking different label-preserving transformations in a sequential manner (see Figure 2c). It is worth noting that due to the discrete nature of text data, some stacking orders are infeasible. For example, it is not reasonable to provide an adversarially-perturbed embedding sequence to the back-translation module. Without loss of generality, we choose the combination where adversarial training is stacked over back-translation to demonstrate the sequential stacking operation (see Fig. 1c). Formally, given a training example $( { \pmb x } _ { i } , y _ { i } )$ , the consistency training objective for such a stacking operation can be written as:
+
+$$
+\begin{array} { r } { x _ { i } ^ { \prime } = \mathrm { B a c k T r a n s } ( x _ { i } ) , \ \hat { x } _ { i } \approx \mathrm { a r g m a x } _ { \hat { x } _ { i } } \mathcal { R } _ { \mathrm { A T } } ( x _ { i } ^ { \prime } , \tilde { x } _ { i } , y _ { i } ) \ , \ } \\ { \mathcal { L } _ { \mathrm { c o n s i s t e n c y } } ( x _ { i } , \hat { x } _ { i } , y _ { i } ) = \mathcal { L } \big ( p _ { \theta } ( x _ { i } ) , y _ { i } \big ) + \alpha \mathcal { L } ( p _ { \theta } ( \hat { x } _ { i } ) , y _ { i } ) + \beta \mathcal { R } _ { \mathrm { C S } } ( p _ { \theta } ( x _ { i } ) , p _ { \theta } ( \hat { x } _ { i } ) ) \ , \ } \end{array}
+$$
+
+where the first term corresponds to the cross-entropy loss, the second term is the adversarial loss, $\mathcal { R } _ { \mathrm { C S } }$ denotes the consistency loss term between $( \pmb { x } _ { i } , \hat { \pmb { x } } _ { i } )$ . Note that $\hat { \mathbf { x } } _ { i }$ is obtained through two different label-preserving transformations applied to $_ { \textbf { \em x } }$ , and thus deviates farther from $_ { \textbf { \em x } }$ and should be more diverse than $\pmb { x } _ { i } ^ { \prime }$ . Inspired by (Bachman et al., 2014; Zheng et al., 2016; Kannan et al., 2018; Hendrycks et al., 2020), we employ the Jensen-Shannon divergence for $\mathcal { R } _ { \mathrm { C S } }$ , since it is upper bounded and tends to be more stable and consistent relative to the KL divergence:
+
+$$
+\mathcal { R } _ { \mathrm { C S } } ( p _ { \theta } ( \pmb { x } _ { i } ) , p _ { \theta } ( \pmb { \hat { x } } _ { i } ) ) = \frac { 1 } { 2 } \big ( \mathrm { K L } ( p _ { \theta } ( \pmb { x } _ { i } ) | | M ) + \mathrm { K L } ( p _ { \theta } ( \pmb { \hat { x } } _ { i } ) ) | | M ) \big ) ,
+$$
+
+where $M = ( p _ { \theta } ( \pmb { x } _ { i } ) + p _ { \theta } ( \pmb { \hat { x } } _ { i } ) ) / 2$ . Later we simply use $\pmb { x } _ { i } ^ { \prime }$ to represent the transformed example.
+
+# 2.3 CONTRASTIVE REGULARIZATION
+
+Consistency loss only provides local regularization, i.e., $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { i } }$ and $\pmb { x } _ { i } ^ { \prime }$ should have close predictions. However, the relative positions between $\pmb { x } _ { i } ^ { \prime }$ and other training instances $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { j } }$ $( j \ne i )$ have not been examined. In this regard, we propose to leverage a contrastive learning objective to better utilize the augmented examples. Specifically, we assume that the model should encourage an augmented sample $\pmb { x } _ { i } ^ { \prime }$ to be closer, in the representation space, to its original sample $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { i } }$ , relative to other data points $\boldsymbol { \mathscr { x } } _ { j }$ $( j \neq i )$ in the training set. This is a reasonable assumption since intuitively, the model should be robust enough to successfully determine from which original data an augmented sample is produced.
+
+![](images/3b1849a4b182dd47ff6c7a8384d5c9c21cd5935667573b78612c73e4aef11f9b.jpg)  
+Figure 3: Illustration of the contrastive learning module.
+
+The contrastive learning module is illustrated in Fig. 3. As demonstrated by prior efforts on contrastive learning, adopting a large batch size is especially vital for its effectiveness (Chen et al., 2020b; Khosla et al., 2020). Therefore, we introduce a memory bank that stores the history embeddings, thus enabling much larger number of negative samples. Moreover, to avoid the encoder from changing too rapidly (which may result in inconsistency embeddings), a momentum encoder module is incorporated into our algorithm. Concretely, let $f _ { \theta } { \overset { \cdot } { ( } . ) }$ and $f _ { \bar { \theta } } ( . )$ denote the transformation parameterized by the query encoder and key encoder, respectively. Note that $\theta$ and $\bar { \theta }$ represent their parameters. The momentum model parameters $\bar { \theta }$ are not learned by gradients. Instead, they are updated through the momentum rule: $\bar { \theta }  \gamma \bar { \theta } + ( 1 - \gamma ) \theta$ at each training step. We omit the details here and refer the interested readers to the work by (He et al., 2020) for further explanation. Given a sample $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { i } }$ and its augmented example $\pmb { x } _ { i } ^ { \prime }$ , the query and key can be obtained as follows:
+
+$$
+\begin{array} { r } { \pmb q _ { i } = f _ { \theta } ( \pmb x _ { i } ) , \quad \pmb q _ { i } ^ { \prime } = f _ { \theta } ( \pmb x _ { i } ^ { \prime } ) , \quad \pmb k _ { i } = f _ { \bar { \theta } } ( \pmb x _ { i } ) . } \end{array}
+$$
+
+Thus, the contrastive training objective can be written as:
+
+$$
+\begin{array} { r l } & { \mathcal { R } _ { \mathrm { c o n t r a s t } } ( \boldsymbol { x } _ { i } , \boldsymbol { x } _ { i } ^ { \prime } , \mathcal { M } ) = \mathcal { R } _ { \mathrm { C T } } ( \boldsymbol { q } _ { i } , \boldsymbol { k } _ { i } , \mathcal { M } ) + \mathcal { R } _ { \mathrm { C T } } ( \boldsymbol { q } _ { i } ^ { \prime } , \boldsymbol { k } _ { i } , \mathcal { M } ) , } \\ & { \quad \mathcal { R } _ { \mathrm { C T } } ( \boldsymbol { q } _ { i } , \boldsymbol { k } _ { i } , \mathcal { M } ) = - \log \frac { \exp ( \sin ( \boldsymbol { q } _ { i } , \boldsymbol { k } _ { i } ) / \tau ) } { \sum _ { \boldsymbol { k } _ { j } \in \mathcal { M } \bigcup \{ \boldsymbol { k } _ { i } \} } \exp ( \sin ( \boldsymbol { q } _ { i } , \boldsymbol { k } _ { j } ) / \tau ) } , } \end{array}
+$$
+
+where $\tau$ is the temperature, and $\mathcal { M }$ is the memory bank in which the history keys are stored. Cosine similarity is chosen for $\mathrm { s i m } ( \cdot )$ . Note that $\mathscr { R } _ { \mathrm { C T } } ( \dot { \pmb q } _ { i } ^ { \prime } , \pmb { k } _ { i } , \mathcal { M } )$ is similarly defined as $\mathscr { R } _ { \mathrm { C T } } ( \ b { q } _ { i } , \ b { k } _ { i } , \mathscr { M } )$ (with $\pmb q _ { i }$ replaced by $\pmb q _ { i } ^ { \prime }$ in Eqn. 10). In Eqn. 9, the first term corresponds to the contrastive loss calculated on the original examples (self-contrastive loss), while the second term is computed on the augmented sample (augment-contrastive loss). Under such a framework, the pair of original and augmented samples are encouraged to stay closer in the learned embedding space, relative to all other training instances. As a result, the model is regularized globally through considering the embeddings of all the training examples available.
+
+By integrating both the consistency training objective and the contrastive regularization, the overall training objective for the CoDA framework can be expressed as:
+
+$$
+\theta ^ { * } = \operatorname * { a r g m i n } _ { \theta } \sum _ { ( \pmb { x } _ { i } , y _ { i } ) \in \mathcal { D } } \mathcal { L } _ { \mathrm { c o n s i s t e n c y } } ( \pmb { x } _ { i } , \pmb { x } _ { i } ^ { \prime } , y _ { i } ) + \lambda \mathcal { R } _ { \mathrm { c o n t r a s t } } ( \pmb { x } _ { i } , \pmb { x } _ { i } ^ { \prime } , \mathcal { M } ) .
+$$
+
+where $\lambda$ is a hyperparameter to be chosen. It is worth noting that the final objective has taken both the local (consistency loss) and global (contrastive loss) information introduced by the augmented examples into consideration.
+
+# 3 EXPERIMENTS
+
+To verify the effectiveness of CoDA, We evaluate it on the widely-adopted GLUE benchmark (Wang et al., 2018), which consists of multiple natural language understanding (NLU) tasks. The details of these datasets can be found in Appendix B. RoBERTa (Liu et al., 2019) is employed as the testbed for our experiments. However, the proposed approach can be flexibly integrated with other models as well. We provide more implementation details in Appendix C. Our code will be released to encourage future research.
+
+In this section, we first present our exploration of several different strategies to consolidate various data transformations (Sec 3.1). Next, we conduct extensive experiments to carefully select the contrastive objective for NLU problems in Sec 3.2. Based upon these settings, we further evaluate CoDA on the GLUE benchmark and compare it with a set of competitive baselines in Sec 3.3. Additional experiments in the low-resource settings and qualitative analysis (Sec 3.4) are further conducted to gain a deep understanding of the proposed framework.
+
+# 3.1 COMBINING LABEL-PRESERVING TRANSFORMATIONS
+
+We start by implementing and comparing several data augmentation baselines. As described in the previous section, we explore 5 different approaches: back-translation, $c$ -BERT word replacement, Mixup, Cutoff and adversarial training. More details can be found in Appendix A. The standard cross-entropy loss, along with the consistency regularization term (Eq. 6) is utilized for all methods to ensure a fair comparison. We employ the MNLI dataset and RoBERTa-base model for the comparison experiments with the results shown in Table 1.
+
+All these methods have achieved improvements over the RoBERTa-base model, demonstrating the effectiveness of leveraging label-preserving transformations for NLU. Moreover, back-translation, cutoff and adversarial training exhibit stronger empirical results relative to mixup and c-BERT.
+
+To improve the diversity of augmented examples, we explore several strategies to combine multiple transformations: i) random combination, $\romannumeral 2$ ) mixup interpolation, and iii) sequential stacking, as shown in Fig. 2. In Table 1, the score of naive random combination lies between single transformations. This may be attributed to the fact that different label-preserving transformations regularize the model in distinct ways, and thus the model may not be able to leverage different regularization terms simultaneously.
+
+Besides, among all the other combination strategies, we observe that gains can be obtained by integrating back-translation and adversarial training together. Concretely, mixing back-translation and adversarial training samples (in the input embedding space) slightly improve the accuracy from 88.5 to 88.6. More importantly, the result is further improved to 88.8 with these two transformations stacking together2 (see Sec 2.2). With significance test, we find stack (back, adv) performs consistently better than other combinations (t-test of 10 runs, $p$ -values $< ~ 0 . 0 2 $ ). This observation indicates that the stacking operation, especially in the case of back-translation and adversarial training, can produce more diverse augment examples.
+
+Table 1: Comparison of different transformations on the MNLI-m development set. Abbr: original training instances (ori), back-translation (back), cutoff (cut), mixup (mix), adversarial (adv).   
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>MNLI-m(Acc)</td><td rowspan=1 colspan=1>MMD</td></tr><tr><td rowspan=1 colspan=1>RoBERTa-base</td><td rowspan=1 colspan=1>87.6</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>SingleTransformation</td><td rowspan=1 colspan=1>rmation</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>+back-translation+c-BERT+ cutoff+ mixup (ori,ori)+adversarial</td><td rowspan=1 colspan=1>88.588.088.488.288.5</td><td rowspan=1 colspan=1>0.630.010.020.060.65</td></tr><tr><td rowspan=1 colspan=1>MultipleTransformations</td><td rowspan=1 colspan=1>ormations</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=3 colspan=1>+random (back,cut,adv)+ mix (ori,back)+ mix (back,adv)+ stack (back, cut)+ stack (back,adv)+ stack(back,cut,adv)+ stack (back,adv, cut)</td><td rowspan=3 colspan=1>88.488.488.688.588.888.588.4</td><td rowspan=1 colspan=1>-0.110.810.621.14</td></tr><tr><td rowspan=1 colspan=1>1.14</td></tr><tr><td rowspan=1 colspan=1>1.14</td></tr></table>
+
+Intuitively, the augmented sample, with two sequential transformations, deviates more from the corresponding training data, and thus tends to be more effective at improving the model’s generalization ability. To verify this hypothesis,
+
+we further calculate the MMD (Gretton et al., 2012) between augmented samples and the original training instances. It can be observed that stack (back, adv), stack (back, cut, adv) and stack (back, adv, cut) have all produced examples the farthest from the original training instances (see Table 1). However, we conjecture that the latter two may have altered the semantic meanings too much, thus leading to inferior results. In this regard, stack (back, adv) is employed as the data transformation module for all the experiments below.
+
+# 3.2 CONTRASTIVE REGULARIZATION DESIGN
+
+In this section, we aim to incorporate the global information among the entire set of original and augmented samples via a contrastive regularization. First, we explore a few hyperparameters for the proposed contrastive objective. Since both the memory bank and the momentum encoder are vital components, we study the impacts of different hyperparameter values on both the temperature and the momentum. As shown in Fig. 4a, a temperature of 1.0 combined with the momentum of 0.99 can achieve the best empirical result. We then examine the size effect of the memory bank, and observe a larger memory bank size leads to a better capture of the global information and results in higher performance boost3 (see Fig. 4b).
+
+After carefully choosing the best setting based on the above experiments, we apply the contrastive learning objective to several GLUE datasets. We also implement several prior works on contrastive learning to compare, including the MoCo loss (He et al., 2020) and the supervised contrastive (SupCon) loss (Khosla et al., 2020), all implemented with memory banks. Note that we remove the consistency regularization for this experiment to better examine the effect of the contrastive regularization term (i.e., $\alpha = \beta = 0$ , $\lambda \neq 0$ ). As presented in Table 2, our contrastive objective consistently exhibits the largest performance improvement. This observation demonstrates for NLU, our data transformation module can be effectively equipped with the contrastive regularization.
+
+![](images/029eab1defd649960014e8e5c10e25a60a2e898591f8e548b3c848144984c049.jpg)  
+Figure 4: Hyperparameter exploration for the contrastive loss, evaluated on the MNLI-m development set. Note: All models use the RoBERTa-base model as the encoder.
+
+<table><tr><td>Method</td><td>MNLI-m (Acc)</td><td>QNLI (Acc)</td><td>SST-2 (Acc)</td><td>RTE (Acc)</td><td>MRPC (Acc)</td></tr><tr><td>RoBERTa-base</td><td>87.6</td><td>92.8</td><td>94.8</td><td>78.7</td><td>90.2</td></tr><tr><td>+ MoCo (He et al., 2020)</td><td>88.2</td><td>93.3</td><td>95.1</td><td>80.8</td><td>90.9</td></tr><tr><td>+ SupCon (Khosla et al., 2020) + Contrastive (ours)</td><td>88.1 88.1</td><td>93.2 93.6</td><td>95.2 95.3</td><td>80.5 82.0</td><td>90.2 91.7</td></tr></table>
+
+Table 2: Comparison among different contrastive objectives on the GLUE development set.
+
+# 3.3 GLUE BENCHMARK EVALUATION
+
+With both components within the CoDA algorithm being specifically tailored to the natural language understanding applications, we apply it to the RoBERTa-large model (Liu et al., 2019). Comparisons are made with several competitive data-augmentation-based and adversarial-training-based approaches on the GLUE benchmark. Specifically, we consider back-translation, cutoff (Shen et al., 2020), FreeLB (Zhu et al., 2020), SMART (Jiang et al., 2020), and R3F (Aghajanyan et al., 2020) as the baselines, where the last three all belong to adversarial training. The results are presented in Table 3. It is worth noting that back-translation is based on our implementation, where both the cross-entropy and consistency regularization terms are utilized.
+
+<table><tr><td>Method</td><td>MNLI-m/ mm (Acc)</td><td>QQP (Acc/F1)</td><td>QNLI (Acc)</td><td>SST-2 (Acc)</td><td>MRPC (Acc/F1)</td><td>CoLA (Mcc)</td><td>RTE (Acc)</td><td>STS-B (P/S)</td><td>Avg</td></tr><tr><td>RoBERTa-large</td><td>90.2/-</td><td>92.2/-</td><td>94.7</td><td>96.4</td><td>-/90.9</td><td>68</td><td>86.6</td><td>92.4/-</td><td>88.9</td></tr><tr><td>Back-Trans</td><td>91.1/90.4</td><td>92/-</td><td>95.3</td><td>97.1</td><td>90.9/93.5</td><td>69.4</td><td>91.7</td><td>92.8/92.6</td><td>90.4</td></tr><tr><td>Cutoff</td><td>91.1/-</td><td>92.4/-</td><td>95.3</td><td>96.9</td><td>91.4/93.8</td><td>71.5</td><td>91.0</td><td>92.8/-</td><td>90.6</td></tr><tr><td>FreeLB</td><td>90.6/-</td><td>92.6/-</td><td>95</td><td>96.7</td><td>91.4/-</td><td>71.1</td><td>88.1</td><td>92.71-</td><td>1</td></tr><tr><td>SMART</td><td>91.1/91.3</td><td>92.4/89.8</td><td>95.6</td><td>96.9</td><td>89.2/92.1</td><td>70.6</td><td>92</td><td>92.8/92.6</td><td>90.4</td></tr><tr><td>R3F</td><td>91.1/91.3</td><td>92.4/89.9</td><td>95.3</td><td>97.0</td><td>91.6/-</td><td>71.2</td><td>88.5</td><td>1</td><td>-</td></tr><tr><td>CoDA</td><td>91.3/90.8</td><td>92.5/89.9</td><td>95.3</td><td>97.4</td><td>91.9/94</td><td>72.6</td><td>92.4</td><td>93/92.7</td><td>91.1</td></tr></table>
+
+Table 3: Main results of single models on the GLUE development set. Note: The best result on each task is in bold and “-” denotes the missing results. The average score is calculated based on the same setting as RoBERTa.
+
+We find that $C o D A$ brings significant gains to the RoBERTa-large model, with the averaged score on the GLUE dev set improved from 88.9 to 91.1. More importantly, CoDA consistently outperforms these strong baselines (indicated by a higher averaged score), demonstrating that our algorithm can produce informative and high-quality augmented samples and leverage them effectively as well. Concretely, on datasets with relatively larger numbers of training instances $( > 1 0 0 \mathrm { K } )$ , i.e., MNLI, QQP and QNLI, different approaches show similar gains over the RoBERTa-large model. However, on smaller tasks (SST-2, MRPC, CoLA, RTE, and STS-B), CoDA beats other data augmentation or adversarial-based methods by a wide margin. We attribute this observation to the fact that the synthetically produced examples are more helpful when the tasks-specific data is limited. Thus, when smaller datasets are employed for fine-tuning large-scale language models, the superiority of the proposed approach is manifested to a larger extent.
+
+# 3.4 ADDITIONAL EXPERIMENTS AND ANALYSIS
+
+Low-resource Setting To verify the advantages of CoDA when a smaller number of taskspecific data is available, we further conduct a low-resource experiment with the MNLI and QNLI datasets. Concretely, different proportions of training data are sampled and utilized for training. We apply CoDA to RoBERTa-base and compare it with backtranslation and adversarial training across various training set sizes. The corresponding results are presented in Fig. 5. We observe that back-translation and adversarial training exhibit similar performance across different proportions. More importantly, CoDA demonstrates stronger results consistently, further highlighting its effectiveness with limited training data.
+
+![](images/28115cc53ada6d47b656ea2b0a8d4b1fa65a9cf68abc9459a1a5f49dac4ed108.jpg)  
+Figure 5: Low-resource setting experiments on the MNLI (left) and QNLI (right) dev sets.
+
+The Effectiveness of Contrastive Objective To investigate the general applicability of the proposed contrastive regularization objective, we further apply it to different data augmentation methods. The RoBERTa-base model and QNLI dataset are leveraged for this set of experiments, and the results are shown in Fig. 6. We observe that the contrastive learning objective boosts the empirical performance of the resulting algorithm regardless of the data augmentation approaches it is applied to. This further validates our assumption that considering the global information among the embeddings of all examples is beneficial for leveraging augmented samples more effectively.
+
+![](images/ed9d2bde5a7f1e01a5feeedf34d4e708470883227a4d953ce1d6f4d19190d9ca.jpg)  
+Figure 6: Evaluation of the proposed contrastive objective while applied to different data augmentation approaches.
+
+# 4 RELATED WORK
+
+Data Augmentation in NLP Different data augmentation approaches have been proposed for text data, such as back-translation (Sennrich et al., 2016; Edunov et al., 2018; Xie et al., 2019), c-BERT word replacement (Wu et al., 2019), mixup (Guo et al., 2019; Chen et al., 2020a), Cutoff (Shen et al., 2020). Broadly speaking, adversarial training (Zhu et al., 2020; Jiang et al., 2020) also synthesizes additional examples via perturbations at the word embedding layer. Although effective, how these data augmentation transformations may be combined together to obtain further improvement has been rarely explored. This could be attributed to the fact that a sentence’s semantic meanings are quite sensitive to small perturbations. Consistency-regularized loss (Bachman et al., 2014; Rasmus et al., 2015; Laine & Aila, 2017; Tarvainen & Valpola, 2017) is typically employed as the training objective, which ignores the global information within the entire dataset.
+
+Contrastive Learning Contrastive methods learn representations by contrasting positive and negative examples, which has demonstrated impressive empirical success in computer vision tasks (Henaff et al., 2019; He et al., 2020). Under an unsupervised setting, Contrastive learning ap- ´ proaches learn representation by maximizing mutual information between local-global hidden representations (Hjelm et al., 2019; Oord et al., 2018; Henaff et al., 2019). It can be also leveraged ´ to learn invariant representations by encouraging consensus between augmented samples from the same input (Bachman et al., 2019; Tian et al., 2019). He et al. (2020); Wu et al. (2018) proposes to utilize a memory bank to enable a much larger number of negative samples, which is shown to benefit the transferability of learned representations as well (Khosla et al., 2020). Recently, contrastive learning was also employed to improve language model pre-training (Iter et al., 2020).
+
+# 5 CONCLUSION
+
+In this paper, we proposed CoDA, a Contrast-enhanced and Diversity promoting data Augmentation framework. Through extensive experiments, we found that stacking adversarial training over a back-translation module can give rise to more diverse and informative augmented samples. Besides, we introduced a specially-designed contrastive loss to incorporate these examples for training in a principled manner. Experiments on the GLUE benchmark showed that CoDA consistently improves over several competitive data augmentation and adversarial training baselines. Moreover, it is observed that the proposed contrastive objective can be leveraged to improve other data augmentation approaches as well, highlighting the wide applicability of the CoDA framework.
+
+# REFERENCES
+
+Armen Aghajanyan, Akshat Shrivastava, Anchit Gupta, Naman Goyal, Luke Zettlemoyer, and Sonal Gupta. Better fine-tuning by reducing representational collapse. arXiv preprint arXiv:2008.03156, 2020.
+
+Philip Bachman, Ouais Alsharif, and Doina Precup. Learning with pseudo-ensembles. In Advances in neural information processing systems, pp. 3365–3373, 2014.
+
+Philip Bachman, R Devon Hjelm, and William Buchwalter. Learning representations by maximizing mutual information across views. In Advances in Neural Information Processing Systems, pp. 15535–15545, 2019.
+
+David Berthelot, Nicholas Carlini, Ian Goodfellow, Nicolas Papernot, Avital Oliver, and Colin A Raffel. Mixmatch: A holistic approach to semi-supervised learning. In Advances in Neural Information Processing Systems, pp. 5049–5059, 2019.
+
+Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020.
+
+Jiaao Chen, Zichao Yang, and Diyi Yang. MixText: Linguistically-informed interpolation of hidden space for semi-supervised text classification. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pp. 2147–2157, Online, July 2020a. Association for Computational Linguistics. doi: 10.18653/v1/2020.acl-main.194. URL https: //www.aclweb.org/anthology/2020.acl-main.194.
+
+Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. arXiv preprint arXiv:2002.05709, 2020b.
+
+Yong Cheng, Lu Jiang, Wolfgang Macherey, and Jacob Eisenstein. Advaug: Robust adversarial augmentation for neural machine translation. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, ACL 2020, Online, July 5-10, 2020, 2020.
+
+E. Cubuk, Barret Zoph, Dandelion Mane, V. Vasudevan, and Quoc V. Le. Autoaugment: Learning ´ augmentation policies from data. ArXiv, abs/1805.09501, 2018.
+
+Ekin D Cubuk, Barret Zoph, Jonathon Shlens, and Quoc V Le. Randaugment: Practical automated data augmentation with a reduced search space. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pp. 702–703, 2020.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, NAACL-HLT 2019, 2019.
+
+Terrance DeVries and Graham W Taylor. Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552, 2017.
+
+Sergey Edunov, Myle Ott, Michael Auli, and David Grangier. Understanding back-translation at scale. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, 2018.
+
+Raphael Gontijo-Lopes, Sylvia J Smullin, Ekin D Cubuk, and Ethan Dyer. Affinity and diversity: Quantifying mechanisms of data augmentation. arXiv preprint arXiv:2002.08973, 2020.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. 2015.
+
+Arthur Gretton, Karsten M Borgwardt, Malte J Rasch, Bernhard Scholkopf, and Alexander Smola. ¨ A kernel two-sample test. The Journal of Machine Learning Research, 13(1):723–773, 2012.
+
+Hongyu Guo, Yongyi Mao, and Richong Zhang. Augmenting data with mixup for sentence classification: An empirical study. arXiv preprint arXiv:1905.08941, 2019.
+
+Yaru Hao, Li Dong, Furu Wei, and Ke Xu. Visualizing and understanding the effectiveness of bert. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing, EMNLP-IJCNLP, 2019.
+
+Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 9729–9738, 2020.
+
+Olivier J Henaff, Aravind Srinivas, Jeffrey De Fauw, Ali Razavi, Carl Doersch, SM Eslami, and ´ Aaron van den Oord. Data-efficient image recognition with contrastive predictive coding. arXiv preprint arXiv:1905.09272, 2019.
+
+Dan Hendrycks, Norman Mu, Ekin D Cubuk, Barret Zoph, Justin Gilmer, and Balaji Lakshminarayanan. Augmix: A simple data processing method to improve robustness and uncertainty. In 8th International Conference on Learning Representations, ICLR, 2020.
+
+R Devon Hjelm, Alex Fedorov, Samuel Lavoie-Marchildon, Karan Grewal, Phil Bachman, Adam Trischler, and Yoshua Bengio. Learning deep representations by mutual information estimation and maximization. In 7th International Conference on Learning Representations, ICLR, 2019.
+
+Vu Cong Duy Hoang, Philipp Koehn, Gholamreza Haffari, and Trevor Cohn. Iterative backtranslation for neural machine translation. In Proceedings of the 2nd Workshop on Neural Machine Translation and Generation, pp. 18–24, 2018.
+
+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. 15764–15775, 2019.
+
+Dan Iter, Kelvin Guu, Larry Lansing, and Dan Jurafsky. Pretraining with contrastive sentence objectives improves discourse performance of language models. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, ACL, 2020.
+
+Haoming Jiang, Pengcheng He, Weizhu Chen, Xiaodong Liu, Jianfeng Gao, and Tuo Zhao. Smart: Robust and efficient fine-tuning for pre-trained natural language models through principled regularized optimization. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, ACL, 2020.
+
+Harini Kannan, Alexey Kurakin, and Ian Goodfellow. Adversarial logit pairing. arXiv preprint arXiv:1803.06373, 2018.
+
+Prannay Khosla, Piotr Teterwak, Chen Wang, Aaron Sarna, Yonglong Tian, Phillip Isola, Aaron Maschinot, Ce Liu, and Dilip Krishnan. Supervised contrastive learning. arXiv preprint arXiv:2004.11362, 2020.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In 3rd International Conference on Learning Representations, ICLR 2015, 2014.
+
+Ashutosh Kumar, Satwik Bhattamishra, Manik Bhandari, and Partha Talukdar. Submodular optimization-based diverse paraphrasing and its effectiveness in data augmentation. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, 2019.
+
+Samuli Laine and Timo Aila. Temporal ensembling for semi-supervised learning. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings. OpenReview.net, 2017.
+
+Xiaodong Liu, Hao Cheng, Pengcheng He, Weizhu Chen, Yu Wang, Hoifung Poon, and Jianfeng Gao. Adversarial training for large neural language models. arXiv preprint arXiv:2004.08994, 2020.
+
+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. arXiv preprint arXiv:1907.11692, 2019.
+
+Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, and Shin Ishii. Virtual adversarial training: a regularization method for supervised and semi-supervised learning. IEEE transactions on pattern analysis and machine intelligence, 41(8):1979–1993, 2018.
+
+Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018.
+
+Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. arXiv preprint arXiv:1910.10683, 2019.
+
+Antti Rasmus, Mathias Berglund, Mikko Honkala, Harri Valpola, and Tapani Raiko. Semisupervised learning with ladder networks. In Advances in neural information processing systems, pp. 3546–3554, 2015.
+
+Rico Sennrich, Barry Haddow, and Alexandra Birch. Improving neural machine translation models with monolingual data. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics, ACL, 2016.
+
+Dinghan Shen, Mingzhi Zheng, Yelong Shen, Yanru Qu, and Weizhu Chen. A simple but tough-tobeat data augmentation approach for natural language understanding and generation, 2020.
+
+Jian Shen, Yanru Qu, Weinan Zhang, and Yong Yu. Wasserstein distance guided representation learning for domain adaptation. In Proceedings of the Thirty-Second AAAI Conference on Artificial Intelligence, (AAAI-18), 2018.
+
+Kihyuk Sohn, David Berthelot, Chun-Liang Li, Zizhao Zhang, Nicholas Carlini, Ekin D Cubuk, Alex Kurakin, Han Zhang, and Colin Raffel. Fixmatch: Simplifying semi-supervised learning with consistency and confidence. arXiv preprint arXiv:2001.07685, 2020.
+
+Chi Sun, Xipeng Qiu, Yige Xu, and Xuanjing Huang. How to fine-tune bert for text classification? In China National Conference on Chinese Computational Linguistics, pp. 194–206. Springer, 2019.
+
+Antti Tarvainen and Harri Valpola. Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results. In Advances in neural information processing systems, pp. 1195–1204, 2017.
+
+Yonglong Tian, Dilip Krishnan, and Phillip Isola. Contrastive multiview coding. arXiv preprint arXiv:1906.05849, 2019.
+
+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. EMNLP 2018, pp. 353, 2018.
+
+Jason Wei and Kai Zou. Eda: Easy data augmentation techniques for boosting performance on text classification tasks. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing, EMNLP-IJCNLP, 2019.
+
+Xing Wu, Shangwen Lv, Liangjun Zang, Jizhong Han, and Songlin Hu. Conditional bert contextual augmentation. In International Conference on Computational Science, pp. 84–95. Springer, 2019.
+
+Zhirong Wu, Yuanjun Xiong, Stella X Yu, and Dahua Lin. Unsupervised feature learning via nonparametric instance discrimination. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3733–3742, 2018.
+
+Qizhe Xie, Zihang Dai, Eduard Hovy, Minh-Thang Luong, and Quoc V Le. Unsupervised data augmentation for consistency training. arXiv preprint arXiv:1904.12848, 2019.
+
+Adams Wei Yu, David Dohan, Minh-Thang Luong, Rui Zhao, Kai Chen, Mohammad Norouzi, and Quoc V Le. Qanet: Combining local convolution with global self-attention for reading comprehension. In 6th International Conference on Learning Representations, ICLR 2018, 2018.
+
+Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. arXiv preprint arXiv:1710.09412, 2017.
+
+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.
+
+Chen Zhu, Yu Cheng, Zhe Gan, Siqi Sun, Thomas Goldstein, and Jingjing Liu. Freelb: Enhanced adversarial training for language understanding. In 8th International Conference on Learning Representations, ICLR, 2020.
+
+# A DATA AUGMENTATION DETAILS
+
+We select the following representative data augmentation operations as basic building blocks of our data augmentation module. We denote $\pmb { x } _ { i } = [ x _ { i , 1 } , . . . , x _ { i , l } ]$ as the input text sequence, and $\boldsymbol { e } _ { i } = [ e _ { i , 1 } , \bar { \ldots } , e _ { i , l } ]$ as corresponding embedding vectors.
+
+• Back translation is widely applied in machine translation (MT) (Sennrich et al., 2016; Hoang et al., 2018; Edunov et al., 2018), and is introduced to text classification recently (Xie et al., 2019). Back-Trans uses 2 MT models to translate the input example to another pivot language, and then translate it back, ${ \bf { x } } _ { i } $ Pivot Language $ \pmb { x } _ { i } ^ { \prime }$ . C-BERT Word Replacement $\mathrm { W u }$ et al., 2019) is a representative of the word replacement augmentation family. C-BERT pretrains a conditional BERT model to learn contextualized representation $P ( \mathbf { x } _ { j } | [ x _ { i , 1 } \dots x _ { i , j - 1 } [ \mathbf { M A S K } ] x _ { i , j + 1 } \dots x _ { i , l } ] , y _ { i } )$ conditioning on classes. This method then randomly substitutes wor $\mathrm { d } \mathrm { s \ o f \ } x \mathrm { \ t o \ }$ obtain $\pmb { x } ^ { \prime } ( [ x _ { i , 1 } \dots x _ { i , j } ^ { \prime } \dots x _ { i , l } ] ) ^ { 4 }$ .   
+Cutoff (DeVries & Taylor, 2017) randomly drops units in a continuous span on the input, while Shen et al. (2020) adapts this method to text embeddings. For input embeddings $e _ { i }$ , this method randomly set a continuous span of elements to 0s, $\pmb { e } _ { i } ^ { \prime } = [ \pmb { e } _ { i , 1 } . . . \pmb { e } _ { i , j - 1 } , 0 . . . 0 , \pmb { e } _ { i , j + w } . . . \pmb { e } _ { i , l } ]$ , where the window size $w \propto l$ , and the start position $j \in [ 1 , l - w ]$ is randomly selected. For transformer encoders that involve position embeddings, we also set input mask as 0s at corresponding positions.   
+• Mixup (Zhang et al., 2017) interpolates two image as well as their labels. Guo et al. (2019) borrows this method to text. For 2 input embeddings $( e _ { i } , e _ { j } )$ , mixup interpolates the embedding vectors $\pmb { e } _ { i } ^ { \prime } = a \pmb { e } _ { i } + ( 1 - a ) \pmb { e } _ { j }$ where $a$ is sampled from a Beta distribution. Also, the labels are interpolated for the augmented sample $y _ { i } ^ { \prime } = a { \bar { y _ { i } } } + ( 1 - a ) y _ { j }$ .   
+• Adversarial training generates adversarial examples for input embeddings, simply, $\begin{array} { r l } { e _ { i } ^ { \prime } } & { { } = } \end{array}$ arg $\begin{array} { r } { \operatorname* { m a x } _ { \| e _ { i } - e _ { i } ^ { \prime } \| \leq 1 } \bar { \mathcal { L } } ( \bar { f } ( e _ { i } ^ { \prime } ) , y _ { i } ) } \end{array}$ . We mainly follow the implementation of Zhu et al. (2020). Besides, when computing the adversarial example $\boldsymbol { e } _ { i } ^ { \prime }$ , the dropout variables are recorded and reused later when encoding $\bar { e _ { i } ^ { \prime } }$ .
+
+Maximum mean discrepancy (MMD) (Gretton et al., 2012) is a widely used discrepancy measure for 2 distributions. We adopt the multi-kernel MMD implementation based on Shen et al. $( 2 0 1 8 ) ^ { 5 }$ to quantify the distance of data distributions before and after DA transformations.
+
+# B DATASET DETAILS
+
+The datasets and statistics are summarized in Table 4.
+
+Table 4: GLUE benchmark summary.   
+
+<table><tr><td rowspan=1 colspan=1>Corpus</td><td rowspan=1 colspan=1>Task</td><td rowspan=1 colspan=1>SentencePair</td><td rowspan=1 colspan=1>#Train</td><td rowspan=1 colspan=1>#Dev</td><td rowspan=1 colspan=1>#Test</td><td rowspan=1 colspan=1>#Class</td><td rowspan=1 colspan=1>Metrics</td></tr><tr><td rowspan=1 colspan=1>MNLI</td><td rowspan=1 colspan=1>NLI</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>393k</td><td rowspan=1 colspan=1>20k</td><td rowspan=1 colspan=1>20k</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>Accuracy</td></tr><tr><td rowspan=1 colspan=1>QQP</td><td rowspan=1 colspan=1>Paraphrase</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>364k</td><td rowspan=1 colspan=1>40k</td><td rowspan=1 colspan=1>391k</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>Accuracy/F1</td></tr><tr><td rowspan=1 colspan=1>QNLI</td><td rowspan=1 colspan=1>QA/NLI</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>108k</td><td rowspan=1 colspan=1>5.7k</td><td rowspan=1 colspan=1>5.7k</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>Accuracy</td></tr><tr><td rowspan=1 colspan=1>SST</td><td rowspan=1 colspan=1>Sentiment</td><td rowspan=1 colspan=1>×</td><td rowspan=1 colspan=1>67k</td><td rowspan=1 colspan=1>872</td><td rowspan=1 colspan=1>1.8k</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>Accuracy</td></tr><tr><td rowspan=1 colspan=1>MRPC</td><td rowspan=1 colspan=1>Paraphrase</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>3.7k</td><td rowspan=1 colspan=1>408</td><td rowspan=1 colspan=1>1.7k</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>Accuracy/F1</td></tr><tr><td rowspan=1 colspan=1>CoLA</td><td rowspan=1 colspan=1>Acceptability</td><td rowspan=1 colspan=1>×</td><td rowspan=1 colspan=1>8.5k</td><td rowspan=1 colspan=1>1k</td><td rowspan=1 colspan=1>1k</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>Matthews corr</td></tr><tr><td rowspan=1 colspan=1>RTE</td><td rowspan=1 colspan=1>NLI</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>2.5k</td><td rowspan=1 colspan=1>276</td><td rowspan=1 colspan=1>3k</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>Accuracy</td></tr><tr><td rowspan=1 colspan=1>STS-B</td><td rowspan=1 colspan=1>Similarity</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>7k</td><td rowspan=1 colspan=1>1.5k</td><td rowspan=1 colspan=1>1.4k</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>Pearson/Spe-arman corr</td></tr></table>
+
+# C IMPLEMENTATION DETAILS
+
+Our implementation is based on RoBERTa (Liu et al., 2019). We use ADAM (Kingma & Ba, 2014) as our optimizer. We follow the hyper-parameter study of RoBERTa and set as default the following parameters: batch size (32), learning rate (1e-5), epochs (5), warmup ratio (0.06), weight decay (0.1) and we keep other parameters unchanged with RoBERTa. For Back-Trans, we use the en-de single models trained on WMT19 and released in FairSeq. More specifically, we use beam search (beam size $= 5$ ) and keep only the top-1 hypothesis. We slightly tune Adversarial parameters on MNLI based on FreeLB and fix them on other datasets, since adversarial training is not our focus. For contrastive regularization, we implement based on MoCo. In GLUE evaluation, we mainly tune the weights of 3 regularization terms, $\alpha \in [ 0 , 1 ] , \beta \in [ 0 , 3 ] , \lambda \in [ 0 , 0 . 0 3 ]$ (Eq. 6, 11). Besides, for smaller tasks (MRPC, CoLA, RTE, STS-B), we use the best performed MNLI model to initialize their parameters6.

parse/train/Ozk9MrX1hvA/Ozk9MrX1hvA_content_list.json

@@ -0,0 +1,1662 @@
+[
+    {
+        "type": "text",
+        "text": "CODA: CONTRAST-ENHANCED AND DIVERSITYPROMOTING DATA AUGMENTATION FOR NATURAL LANGUAGE UNDERSTANDING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            823,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yanru $\\mathbf { Q } \\mathbf { u } ^ { 1 }$ ∗, Dinghan Shen2, Yelong Shen2, Sandra Sajeev2, Jiawei $\\mathbf { H a n } ^ { 1 }$ , Weizhu Chen2 ",
+        "bbox": [
+            186,
+            194,
+            790,
+            209
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1University of Illinois, Urbana-Champaign, 2Microsoft Dynamics 3   \n1{yanruqu2,hanj}@illinois.edu,   \n2{dishen,yeshe,ssajeev,wzchen}@microsoft.com ",
+        "bbox": [
+            186,
+            212,
+            625,
+            252
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            290,
+            544,
+            304
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Data augmentation has been demonstrated as an effective strategy for improving model generalization and data efficiency. However, due to the discrete nature of natural language, designing label-preserving transformations for text data tends to be more challenging. In this paper, we propose a novel data augmentation framework dubbed CoDA, which synthesizes diverse and informative augmented examples by integrating multiple transformations organically. Moreover, a contrastive regularization objective is introduced to capture the global relationship among all the data samples. A momentum encoder along with a memory bank is further leveraged to better estimate the contrastive loss. To verify the effectiveness of the proposed framework, we apply CoDA to Transformer-based models on a wide range of natural language understanding tasks. On the GLUE benchmark, CoDA gives rise to an average improvement of $2 . 2 \\%$ while applied to the RoBERTa-large model. More importantly, it consistently exhibits stronger results relative to several competitive data augmentation and adversarial training baselines (including the low-resource settings). Extensive experiments show that the proposed contrastive objective can be flexibly combined with various data augmentation approaches to further boost their performance, highlighting the wide applicability of the CoDA framework. ",
+        "bbox": [
+            233,
+            319,
+            764,
+            568
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            593,
+            336,
+            608
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Data augmentation approaches have successfully improved large-scale neural-network-based models, (Laine & Aila, 2017; Xie et al., 2019; Berthelot et al., 2019; Sohn et al., 2020; He et al., 2020; Khosla et al., 2020; Chen et al., 2020b), however, the majority of existing research is geared towards computer vision tasks. The discrete nature of natural language makes it challenging to design effective label-preserving transformations for text sequences that can help improve model generalization (Hu et al., 2019; Xie et al., 2019). On the other hand, fine-tuning powerful, over-parameterized language models1 proves to be difficult, especially when there is a limited amount of task-specific data available. It may result in representation collapse (Aghajanyan et al., 2020) or require special finetuning techniques (Sun et al., 2019; Hao et al., 2019). In this work, we aim to take a further step towards finding effective data augmentation strategies through systematic investigation. ",
+        "bbox": [
+            174,
+            612,
+            825,
+            751
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In essence, data augmentation can be regarded as constructing neighborhoods around a training instance that preserve the ground-truth label. With such a characterization, adversarial training (Zhu et al., 2020; Jiang et al., 2020; Liu et al., 2020; Cheng et al., 2020) also performs label-preserving transformation in embedding space, and thus is considered as an alternative to data augmentation methods in this work. From this perspective, the goal of developing effective data augmentation strategies can be summarized as answering three fundamental questions: ",
+        "bbox": [
+            174,
+            758,
+            823,
+            842
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "i) What are some label-preserving transformations, that can be applied to text, to compose useful augmented samples? ",
+        "bbox": [
+            176,
+            848,
+            823,
+            877
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ii) Are these transformations complementary in nature, and can we find some strategies to consolidate them for producing more diverse augmented examples? ",
+        "bbox": [
+            173,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "iii) How can we incorporate the obtained augmented samples into the training process in an effective and principled manner? ",
+        "bbox": [
+            173,
+            138,
+            823,
+            166
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Previous efforts in augmenting text data were mainly focused on answering the first question (Yu et al., 2018; Xie et al., 2019; Kumar et al., 2019; Wei & Zou, 2019; Chen et al., 2020a; Shen et al., 2020). Regarding the second question, different label-preserving transformations have been proposed, but it remains unclear how to integrate them organically. In addition, it has been shown that the diversity of augmented samples plays a vital role in their effectiveness (Xie et al., 2019; Gontijo-Lopes et al., 2020). In the case of image data, several strategies that combine different augmentation methods have been proposed, such as applying multiple transformations sequentially (Cubuk et al., 2018; 2020; Hendrycks et al., 2020), learning data augmentation policies (Cubuk et al., 2018), randomly sampling operations for each data point (Cubuk et al., 2020). However, these methods cannot be naively applied to text data, since the semantic meanings of a sentence are much more sensitive to local perturbations (relative to an image). ",
+        "bbox": [
+            174,
+            174,
+            825,
+            327
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As for the third question, consistency training is typically employed to utilize the augmented samples (Laine & Aila, 2017; Hendrycks et al., 2020; Xie et al., 2019; Sohn et al., 2020; Miyato et al., 2018). This method encourages the model predictions to be invariant to certain label-preserving transformations. However, existing approaches only examine a pair of original and augmented samples in isolation, without considering other examples in the entire training set. As a result, the representation of an augmented sample may be closer to those of other training instances, rather than the one it is derived from. Based on this observation, we advocate that, in addition to consistency training, a training objective that can globally capture the intrinsic relationship within the entire set of original and augmented training instances can help leverage augmented examples more effectively. ",
+        "bbox": [
+            174,
+            334,
+            825,
+            459
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we introduce a novel Contrast-enhanced and Diversity-promoting Data Augmentation (CoDA) framework for natural language understanding. To improve the diversity of augmented samples, we extensively explore different combinations of isolated label-preserving transformations in an unified approach. We find that stacking distinct label-preserving transformations produces particularly informative samples. Specifically, the most diverse and high-quality augmented samples are obtained by stacking an adversarial training module over the back-translation transformation. Besides the consistency-regularized loss for repelling the model to behave consistently within local neighborhoods, we propose a contrastive learning objective to capture the global relationship among the data points in the representation space. We evaluate CoDA on the GLUE benchmark (with RoBERTa (Liu et al., 2019) as the testbed), and CoDA consistently improves the generalization ability of resulting models and gives rise to significant gains relative to the standard fine-tuning procedure. Moreover, our method also outperforms various single data augmentation operations, combination schemes, and other strong baselines. Additional experiments in the low-resource settings and ablation studies further demonstrate the effectiveness of this framework. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            660
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            672,
+            282,
+            689
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we focus our discussion on the natural language understanding (NLU) tasks, and particularly, under a text classification scenario. However, the proposed data augmentation framework can be readily extended to other NLP tasks as well. ",
+        "bbox": [
+            176,
+            696,
+            823,
+            739
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 BACKGROUND: DATA AUGMENTATION AND ADVERSARIAL TRAINING",
+        "text_level": 1,
+        "bbox": [
+            174,
+            750,
+            700,
+            763
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Data Augmentation Let $\\mathcal { D } = \\{ \\substack { { \\pmb x } _ { i } , y _ { i } } \\} _ { i = 1 \\ldots N }$ denote the training dataset, where the input example $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { i } }$ is a sequence of tokens, and $y _ { i }$ is the corresponding label. To improve model’s robustness and generalization ability, several data augmentation techniques (e.g., back-translation (Sennrich et al., 2016; Edunov et al., 2018; Xie et al., 2019), mixup (Guo et al., 2019), c-BERT (Wu et al., 2019)) have been proposed. Concretely, label-preserving transformations are performed (on the original training sequences) to synthesize a collection of augmented samples, denoted by $\\mathcal { D } ^ { \\prime } = \\{ { \\pmb x } _ { i } ^ { \\prime } , \\bar { y } _ { i } ^ { \\prime } \\} _ { i = 1 \\ldots N }$ . Thus, a model can learn from both the training set $\\mathcal { D }$ and the augmented set $\\mathcal { D } ^ { \\prime }$ , with $p _ { \\theta } ( \\cdot )$ the predicted output distribution of the model parameterized by $\\theta$ : ",
+        "bbox": [
+            173,
+            767,
+            825,
+            880
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/70977c24a454b2549aa8a2fa8921b51c8de3a3626636321a2702c534779dedbf.jpg",
+        "text": "$$\n\\theta ^ { * } = \\underset { \\theta } { \\arg \\operatorname* { m i n } } \\sum _ { ( \\mathbf { x } _ { i } , y _ { i } ) \\in \\mathcal { D } } \\mathcal { L } \\big ( p _ { \\theta } ( \\mathbf { x } _ { i } ) , y _ { i } \\big ) + \\sum _ { ( \\mathbf { x } _ { i } ^ { \\prime } , y _ { i } ^ { \\prime } ) \\in \\mathcal { D } ^ { \\prime } } \\mathcal { L } \\big ( p _ { \\theta } ( \\mathbf { x } _ { i } ^ { \\prime } ) , y _ { i } ^ { \\prime } \\big )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            883,
+            709,
+            921
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/f0bacbbacfc9f71f1fd81088fd1d953683a91465c641ddcc046cf39024761c21.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of data augmentation combined with adversarial training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            97,
+            813,
+            270
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Several recent research efforts were focused on encouraging model predictions to be invariant to stochastic or domain-specific data transformations (Xie et al., 2019; Laine $\\&$ Aila, 2017; Tarvainen & Valpola, 2017; Sohn et al., 2020; Miyato et al., 2018; Jiang et al., 2020; Hendrycks et al., 2020). Take back-translation as example: $\\pmb { x } _ { i } ^ { \\prime } = \\mathbf { B a c k T r a n s } ( \\pmb { x } _ { i } )$ , then $\\pmb { x } _ { i } ^ { \\prime }$ is a paraphrase of $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { i } }$ . The model can be regularized to have consistent predictions for $( \\pmb { x } _ { i } , \\pmb { x } _ { i } ^ { \\prime } )$ , by minimizing the distribution discrepancy $\\mathcal { R } _ { \\mathrm { C S } } ( p _ { \\theta } ( \\pmb { x } _ { i } ) , p _ { \\theta } ( \\pmb { x } _ { i } ^ { \\prime } ) )$ , which typically adopts KL divergence (see Fig. 1a). ",
+        "bbox": [
+            173,
+            315,
+            825,
+            400
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Adversarial Training In another line, adversarial training methods are applied to text data (Zhu et al., 2020; Jiang et al., 2020; Cheng et al., 2020; Aghajanyan et al., 2020) for improving model’s robustness. Compared with data augmentation techniques, adversarial training requires no domain knowledge to generate additional training examples. Instead, it relies on the model itself to produce adversarial examples which the model are most likely to make incorrect predictions. Similar to data augmentation, adversarial training also typically utilizes the cross-entropy and consistencybased objectives for training. As the two most popular adversarial-training-based algorithms, the adversarial loss (Goodfellow et al., 2015) (Eqn. 2) and virtual adversarial loss (Miyato et al., 2018) (Eqn. 3) can be expressed as follows (see Fig. 1b): ",
+        "bbox": [
+            173,
+            415,
+            825,
+            540
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7cba9cfe1750c59313ab0dc6e893c2c069a8ff70982d076c9f90c5ae9478da89.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { R } _ { \\mathrm { A T } } ( \\boldsymbol { x } _ { i } , \\tilde { \\boldsymbol { x } } _ { i } , y _ { i } ) = \\mathcal { L } \\big ( p _ { \\theta } ( \\tilde { x } _ { i } ) , y _ { i } \\big ) , s . t . , \\| \\tilde { \\boldsymbol { x } } _ { i } - \\boldsymbol { x } _ { i } \\| \\leq \\epsilon , } \\\\ { \\mathcal { R } _ { \\mathrm { V A T } } ( \\boldsymbol { x } _ { i } , \\tilde { \\boldsymbol { x } } _ { i } ) = \\mathcal { R } _ { \\mathrm { C S } } \\big ( p _ { \\theta } ( \\tilde { \\boldsymbol { x } } _ { i } ) , p _ { \\theta } ( \\boldsymbol { x } _ { i } ) \\big ) , s . t . , \\| \\tilde { \\boldsymbol { x } } _ { i } - \\boldsymbol { x } _ { i } \\| \\leq \\epsilon . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            545,
+            697,
+            588
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Generally, there is no closed-form to obtain the exact adversarial example $\\hat { \\mathbf { x } } _ { i }$ in either Eqn. 2 or 3. However, it usually can be approximated by a low-order approximation of the objective function with respect to $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { i } }$ . For example, the adversarial example in Eqn. 2 can be approximated by: ",
+        "bbox": [
+            173,
+            592,
+            825,
+            635
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eea9f9b6a866a3f42b39f7736e86cfd3fec52e2907644d4d9fb26a5feb10eb99.jpg",
+        "text": "$$\n\\hat { \\pmb { x } } _ { i } \\approx \\pmb { x } _ { i } + \\epsilon \\frac { \\pmb { g } } { \\lVert \\pmb { g } \\rVert _ { 2 } } , \\mathrm { w h e r e } \\ \\pmb { g } = \\nabla _ { \\pmb { x } _ { i } } \\mathcal { L } \\big ( p _ { \\theta } ( \\pmb { x } _ { i } ) , y _ { i } \\big ) \\ .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            641,
+            665,
+            672
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 DIVERSITY-PROMOTING CONSISTENCY TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            689,
+            562,
+            704
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As discussed in the previous section, data augmentation and adversarial training share the same intuition of producing neighbors around the original training instances. Moreover, both approaches share very similar training objectives. Therefore, it is natural to ask the following question: are different data augmentation methods and adversarial training equal in nature? Otherwise, are they complementary to each other, and thus can be consolidated together to further improve the model’s generalization ability? Notably, it has been shown, in the CV domain, that combining different data augmentation operations could lead to more diverse augmented examples (Cubuk et al., 2018; 2020; Hendrycks et al., 2020). However, this is especially challenging for natural language, given that the semantics of a sentence can be entirely altered by slight perturbations. ",
+        "bbox": [
+            173,
+            707,
+            825,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To answer the above question, we propose several distinct strategies to combine different data transformations, with the hope to produce more diverse and informative augmented examples. Specifically, we consider 5 different types of label-preserving transformations: back-translation (Sennrich et al., 2016; Edunov et al., 2018; Xie et al., 2019), $c$ -BERT word replacement (Wu et al., 2019), mixup (Guo et al., 2019; Chen et al., 2020a), cutoff (Shen et al., 2020), and adversarial training (Zhu et al., 2020; Jiang et al., 2020). The 3 combination strategies are schematically illustrated in Figure 2. For random combination, a particular label-preserving transformation is randomly selected, among all the augmentation operations available, for each mini-batch. As to the mixup interpolation, given two samples $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { i } }$ and $\\boldsymbol { \\mathscr { x } } _ { j }$ drawn in a mini-batch, linear interpolation is performed between their input embedding matrices $e _ { i }$ and $e _ { j }$ (Zhang et al., 2017): $\\pmb { e } _ { i } ^ { \\prime } = \\bar { a \\pmb { e } } _ { i } + ( 1 - a ) \\bar { \\pmb { e } } _ { j }$ , where $a$ is the interpolation parameter, usually drawn from a Beta distribution. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/9b120597e49a72475b0c9efa34911ad271f1fa285d26f033d4cccf77a78aba65.jpg",
+        "image_caption": [
+            "Figure 2: Illustration of different strategies to combine various label-preserving transformations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            98,
+            826,
+            190
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            231,
+            825,
+            301
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Moreover, we consider stacking different label-preserving transformations in a sequential manner (see Figure 2c). It is worth noting that due to the discrete nature of text data, some stacking orders are infeasible. For example, it is not reasonable to provide an adversarially-perturbed embedding sequence to the back-translation module. Without loss of generality, we choose the combination where adversarial training is stacked over back-translation to demonstrate the sequential stacking operation (see Fig. 1c). Formally, given a training example $( { \\pmb x } _ { i } , y _ { i } )$ , the consistency training objective for such a stacking operation can be written as: ",
+        "bbox": [
+            173,
+            308,
+            825,
+            405
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ab7e17fbc4eeed6e728e12ef9e54667f96aaa4d16a3fdcb638ef73be777bcdf8.jpg",
+        "text": "$$\n\\begin{array} { r } { x _ { i } ^ { \\prime } = \\mathrm { B a c k T r a n s } ( x _ { i } ) , \\ \\hat { x } _ { i } \\approx \\mathrm { a r g m a x } _ { \\hat { x } _ { i } } \\mathcal { R } _ { \\mathrm { A T } } ( x _ { i } ^ { \\prime } , \\tilde { x } _ { i } , y _ { i } ) \\ , \\ } \\\\ { \\mathcal { L } _ { \\mathrm { c o n s i s t e n c y } } ( x _ { i } , \\hat { x } _ { i } , y _ { i } ) = \\mathcal { L } \\big ( p _ { \\theta } ( x _ { i } ) , y _ { i } \\big ) + \\alpha \\mathcal { L } ( p _ { \\theta } ( \\hat { x } _ { i } ) , y _ { i } ) + \\beta \\mathcal { R } _ { \\mathrm { C S } } ( p _ { \\theta } ( x _ { i } ) , p _ { \\theta } ( \\hat { x } _ { i } ) ) \\ , \\ } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            227,
+            410,
+            769,
+            452
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where the first term corresponds to the cross-entropy loss, the second term is the adversarial loss, $\\mathcal { R } _ { \\mathrm { C S } }$ denotes the consistency loss term between $( \\pmb { x } _ { i } , \\hat { \\pmb { x } } _ { i } )$ . Note that $\\hat { \\mathbf { x } } _ { i }$ is obtained through two different label-preserving transformations applied to $_ { \\textbf { \\em x } }$ , and thus deviates farther from $_ { \\textbf { \\em x } }$ and should be more diverse than $\\pmb { x } _ { i } ^ { \\prime }$ . Inspired by (Bachman et al., 2014; Zheng et al., 2016; Kannan et al., 2018; Hendrycks et al., 2020), we employ the Jensen-Shannon divergence for $\\mathcal { R } _ { \\mathrm { C S } }$ , since it is upper bounded and tends to be more stable and consistent relative to the KL divergence: ",
+        "bbox": [
+            173,
+            455,
+            825,
+            539
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/33fbdb57333c7c78cddaaffa91cf72ebb264d511dc6e3ec4b2c4bdadfc3c0037.jpg",
+        "text": "$$\n\\mathcal { R } _ { \\mathrm { C S } } ( p _ { \\theta } ( \\pmb { x } _ { i } ) , p _ { \\theta } ( \\pmb { \\hat { x } } _ { i } ) ) = \\frac { 1 } { 2 } \\big ( \\mathrm { K L } ( p _ { \\theta } ( \\pmb { x } _ { i } ) | | M ) + \\mathrm { K L } ( p _ { \\theta } ( \\pmb { \\hat { x } } _ { i } ) ) | | M ) \\big ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            545,
+            715,
+            575
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $M = ( p _ { \\theta } ( \\pmb { x } _ { i } ) + p _ { \\theta } ( \\pmb { \\hat { x } } _ { i } ) ) / 2$ . Later we simply use $\\pmb { x } _ { i } ^ { \\prime }$ to represent the transformed example. ",
+        "bbox": [
+            169,
+            580,
+            805,
+            597
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 CONTRASTIVE REGULARIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            613,
+            446,
+            627
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Consistency loss only provides local regularization, i.e., $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { i } }$ and $\\pmb { x } _ { i } ^ { \\prime }$ should have close predictions. However, the relative positions between $\\pmb { x } _ { i } ^ { \\prime }$ and other training instances $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { j } }$ $( j \\ne i )$ have not been examined. In this regard, we propose to leverage a contrastive learning objective to better utilize the augmented examples. Specifically, we assume that the model should encourage an augmented sample $\\pmb { x } _ { i } ^ { \\prime }$ to be closer, in the representation space, to its original sample $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { i } }$ , relative to other data points $\\boldsymbol { \\mathscr { x } } _ { j }$ $( j \\neq i )$ in the training set. This is a reasonable assumption since intuitively, the model should be robust enough to successfully determine from which original data an augmented sample is produced. ",
+        "bbox": [
+            174,
+            638,
+            516,
+            833
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/3b1849a4b182dd47ff6c7a8384d5c9c21cd5935667573b78612c73e4aef11f9b.jpg",
+        "image_caption": [
+            "Figure 3: Illustration of the contrastive learning module. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            540,
+            609,
+            818,
+            772
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The contrastive learning module is illustrated in Fig. 3. As demonstrated by prior efforts on contrastive learning, adopting a large batch size is especially vital for its effectiveness (Chen et al., 2020b; Khosla et al., 2020). Therefore, we introduce a memory bank that stores the history embeddings, thus enabling much larger number of negative samples. Moreover, to avoid the encoder from changing too rapidly (which may result in inconsistency embeddings), a momentum encoder module is incorporated into our algorithm. Concretely, let $f _ { \\theta } { \\overset { \\cdot } { ( } . ) }$ and $f _ { \\bar { \\theta } } ( . )$ denote the transformation parameterized by the query encoder and key encoder, respectively. Note that $\\theta$ and $\\bar { \\theta }$ represent their parameters. The momentum model parameters $\\bar { \\theta }$ are not learned by gradients. Instead, they are updated through the momentum rule: $\\bar { \\theta }  \\gamma \\bar { \\theta } + ( 1 - \\gamma ) \\theta$ at each training step. We omit the details here and refer the interested readers to the work by (He et al., 2020) for further explanation. Given a sample $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { i } }$ and its augmented example $\\pmb { x } _ { i } ^ { \\prime }$ , the query and key can be obtained as follows: ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c047416ffd9122039defcf8e533b5816fb46e245b5192103e67b80b37b556205.jpg",
+        "text": "$$\n\\begin{array} { r } { \\pmb q _ { i } = f _ { \\theta } ( \\pmb x _ { i } ) , \\quad \\pmb q _ { i } ^ { \\prime } = f _ { \\theta } ( \\pmb x _ { i } ^ { \\prime } ) , \\quad \\pmb k _ { i } = f _ { \\bar { \\theta } } ( \\pmb x _ { i } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            178,
+            650,
+            196
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Thus, the contrastive training objective can be written as: ",
+        "bbox": [
+            174,
+            200,
+            549,
+            215
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/002a4bcacc80e25328011a737dcd9a06bd2e33917b941e09db7a2acf58ef5447.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { R } _ { \\mathrm { c o n t r a s t } } ( \\boldsymbol { x } _ { i } , \\boldsymbol { x } _ { i } ^ { \\prime } , \\mathcal { M } ) = \\mathcal { R } _ { \\mathrm { C T } } ( \\boldsymbol { q } _ { i } , \\boldsymbol { k } _ { i } , \\mathcal { M } ) + \\mathcal { R } _ { \\mathrm { C T } } ( \\boldsymbol { q } _ { i } ^ { \\prime } , \\boldsymbol { k } _ { i } , \\mathcal { M } ) , } \\\\ & { \\quad \\mathcal { R } _ { \\mathrm { C T } } ( \\boldsymbol { q } _ { i } , \\boldsymbol { k } _ { i } , \\mathcal { M } ) = - \\log \\frac { \\exp ( \\sin ( \\boldsymbol { q } _ { i } , \\boldsymbol { k } _ { i } ) / \\tau ) } { \\sum _ { \\boldsymbol { k } _ { j } \\in \\mathcal { M } \\bigcup \\{ \\boldsymbol { k } _ { i } \\} } \\exp ( \\sin ( \\boldsymbol { q } _ { i } , \\boldsymbol { k } _ { j } ) / \\tau ) } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            285,
+            219,
+            710,
+            279
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\tau$ is the temperature, and $\\mathcal { M }$ is the memory bank in which the history keys are stored. Cosine similarity is chosen for $\\mathrm { s i m } ( \\cdot )$ . Note that $\\mathscr { R } _ { \\mathrm { C T } } ( \\dot { \\pmb q } _ { i } ^ { \\prime } , \\pmb { k } _ { i } , \\mathcal { M } )$ is similarly defined as $\\mathscr { R } _ { \\mathrm { C T } } ( \\ b { q } _ { i } , \\ b { k } _ { i } , \\mathscr { M } )$ (with $\\pmb q _ { i }$ replaced by $\\pmb q _ { i } ^ { \\prime }$ in Eqn. 10). In Eqn. 9, the first term corresponds to the contrastive loss calculated on the original examples (self-contrastive loss), while the second term is computed on the augmented sample (augment-contrastive loss). Under such a framework, the pair of original and augmented samples are encouraged to stay closer in the learned embedding space, relative to all other training instances. As a result, the model is regularized globally through considering the embeddings of all the training examples available. ",
+        "bbox": [
+            173,
+            281,
+            825,
+            393
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "By integrating both the consistency training objective and the contrastive regularization, the overall training objective for the CoDA framework can be expressed as: ",
+        "bbox": [
+            174,
+            398,
+            821,
+            428
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fc59c344e41eeb32717b886e58d36b6a9d435080d9c9c15adf7d687a564a988a.jpg",
+        "text": "$$\n\\theta ^ { * } = \\operatorname * { a r g m i n } _ { \\theta } \\sum _ { ( \\pmb { x } _ { i } , y _ { i } ) \\in \\mathcal { D } } \\mathcal { L } _ { \\mathrm { c o n s i s t e n c y } } ( \\pmb { x } _ { i } , \\pmb { x } _ { i } ^ { \\prime } , y _ { i } ) + \\lambda \\mathcal { R } _ { \\mathrm { c o n t r a s t } } ( \\pmb { x } _ { i } , \\pmb { x } _ { i } ^ { \\prime } , \\mathcal { M } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            433,
+            732,
+            469
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda$ is a hyperparameter to be chosen. It is worth noting that the final objective has taken both the local (consistency loss) and global (contrastive loss) information introduced by the augmented examples into consideration. ",
+        "bbox": [
+            174,
+            473,
+            825,
+            516
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            529,
+            328,
+            545
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To verify the effectiveness of CoDA, We evaluate it on the widely-adopted GLUE benchmark (Wang et al., 2018), which consists of multiple natural language understanding (NLU) tasks. The details of these datasets can be found in Appendix B. RoBERTa (Liu et al., 2019) is employed as the testbed for our experiments. However, the proposed approach can be flexibly integrated with other models as well. We provide more implementation details in Appendix C. Our code will be released to encourage future research. ",
+        "bbox": [
+            173,
+            553,
+            825,
+            637
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first present our exploration of several different strategies to consolidate various data transformations (Sec 3.1). Next, we conduct extensive experiments to carefully select the contrastive objective for NLU problems in Sec 3.2. Based upon these settings, we further evaluate CoDA on the GLUE benchmark and compare it with a set of competitive baselines in Sec 3.3. Additional experiments in the low-resource settings and qualitative analysis (Sec 3.4) are further conducted to gain a deep understanding of the proposed framework. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            727
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 COMBINING LABEL-PRESERVING TRANSFORMATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            737,
+            589,
+            751
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We start by implementing and comparing several data augmentation baselines. As described in the previous section, we explore 5 different approaches: back-translation, $c$ -BERT word replacement, Mixup, Cutoff and adversarial training. More details can be found in Appendix A. The standard cross-entropy loss, along with the consistency regularization term (Eq. 6) is utilized for all methods to ensure a fair comparison. We employ the MNLI dataset and RoBERTa-base model for the comparison experiments with the results shown in Table 1. ",
+        "bbox": [
+            174,
+            756,
+            825,
+            839
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "All these methods have achieved improvements over the RoBERTa-base model, demonstrating the effectiveness of leveraging label-preserving transformations for NLU. Moreover, back-translation, cutoff and adversarial training exhibit stronger empirical results relative to mixup and c-BERT. ",
+        "bbox": [
+            174,
+            847,
+            825,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To improve the diversity of augmented examples, we explore several strategies to combine multiple transformations: i) random combination, $\\romannumeral 2$ ) mixup interpolation, and iii) sequential stacking, as shown in Fig. 2. In Table 1, the score of naive random combination lies between single transformations. This may be attributed to the fact that different label-preserving transformations regularize the model in distinct ways, and thus the model may not be able to leverage different regularization terms simultaneously. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Besides, among all the other combination strategies, we observe that gains can be obtained by integrating back-translation and adversarial training together. Concretely, mixing back-translation and adversarial training samples (in the input embedding space) slightly improve the accuracy from 88.5 to 88.6. More importantly, the result is further improved to 88.8 with these two transformations stacking together2 (see Sec 2.2). With significance test, we find stack (back, adv) performs consistently better than other combinations (t-test of 10 runs, $p$ -values $< ~ 0 . 0 2 $ ). This observation indicates that the stacking operation, especially in the case of back-translation and adversarial training, can produce more diverse augment examples. ",
+        "bbox": [
+            174,
+            166,
+            483,
+            401
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/de5096cd2494ef886b619b966d3ae398ef6c4308096bb7cf0b0eb10d0cb920dd.jpg",
+        "table_caption": [
+            "Table 1: Comparison of different transformations on the MNLI-m development set. Abbr: original training instances (ori), back-translation (back), cutoff (cut), mixup (mix), adversarial (adv). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>MNLI-m(Acc)</td><td rowspan=1 colspan=1>MMD</td></tr><tr><td rowspan=1 colspan=1>RoBERTa-base</td><td rowspan=1 colspan=1>87.6</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>SingleTransformation</td><td rowspan=1 colspan=1>rmation</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>+back-translation+c-BERT+ cutoff+ mixup (ori,ori)+adversarial</td><td rowspan=1 colspan=1>88.588.088.488.288.5</td><td rowspan=1 colspan=1>0.630.010.020.060.65</td></tr><tr><td rowspan=1 colspan=1>MultipleTransformations</td><td rowspan=1 colspan=1>ormations</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=3 colspan=1>+random (back,cut,adv)+ mix (ori,back)+ mix (back,adv)+ stack (back, cut)+ stack (back,adv)+ stack(back,cut,adv)+ stack (back,adv, cut)</td><td rowspan=3 colspan=1>88.488.488.688.588.888.588.4</td><td rowspan=1 colspan=1>-0.110.810.621.14</td></tr><tr><td rowspan=1 colspan=1>1.14</td></tr><tr><td rowspan=1 colspan=1>1.14</td></tr></table>",
+        "bbox": [
+            508,
+            176,
+            813,
+            405
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, the augmented sample, with two sequential transformations, deviates more from the corresponding training data, and thus tends to be more effective at improving the model’s generalization ability. To verify this hypothesis, ",
+        "bbox": [
+            173,
+            410,
+            483,
+            478
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "we further calculate the MMD (Gretton et al., 2012) between augmented samples and the original training instances. It can be observed that stack (back, adv), stack (back, cut, adv) and stack (back, adv, cut) have all produced examples the farthest from the original training instances (see Table 1). However, we conjecture that the latter two may have altered the semantic meanings too much, thus leading to inferior results. In this regard, stack (back, adv) is employed as the data transformation module for all the experiments below. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            561
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 CONTRASTIVE REGULARIZATION DESIGN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            578,
+            504,
+            592
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we aim to incorporate the global information among the entire set of original and augmented samples via a contrastive regularization. First, we explore a few hyperparameters for the proposed contrastive objective. Since both the memory bank and the momentum encoder are vital components, we study the impacts of different hyperparameter values on both the temperature and the momentum. As shown in Fig. 4a, a temperature of 1.0 combined with the momentum of 0.99 can achieve the best empirical result. We then examine the size effect of the memory bank, and observe a larger memory bank size leads to a better capture of the global information and results in higher performance boost3 (see Fig. 4b). ",
+        "bbox": [
+            173,
+            597,
+            825,
+            708
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "After carefully choosing the best setting based on the above experiments, we apply the contrastive learning objective to several GLUE datasets. We also implement several prior works on contrastive learning to compare, including the MoCo loss (He et al., 2020) and the supervised contrastive (SupCon) loss (Khosla et al., 2020), all implemented with memory banks. Note that we remove the consistency regularization for this experiment to better examine the effect of the contrastive regularization term (i.e., $\\alpha = \\beta = 0$ , $\\lambda \\neq 0$ ). As presented in Table 2, our contrastive objective consistently exhibits the largest performance improvement. This observation demonstrates for NLU, our data transformation module can be effectively equipped with the contrastive regularization. ",
+        "bbox": [
+            173,
+            715,
+            825,
+            827
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/029eab1defd649960014e8e5c10e25a60a2e898591f8e548b3c848144984c049.jpg",
+        "image_caption": [
+            "Figure 4: Hyperparameter exploration for the contrastive loss, evaluated on the MNLI-m development set. Note: All models use the RoBERTa-base model as the encoder. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            218,
+            85,
+            769,
+            250
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/bc5b90758df91ae6eb99afad0b51f7713800af017ed0caffb19f9764ba6f9260.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 2: Comparison among different contrastive objectives on the GLUE development set. "
+        ],
+        "table_body": "<table><tr><td>Method</td><td>MNLI-m (Acc)</td><td>QNLI (Acc)</td><td>SST-2 (Acc)</td><td>RTE (Acc)</td><td>MRPC (Acc)</td></tr><tr><td>RoBERTa-base</td><td>87.6</td><td>92.8</td><td>94.8</td><td>78.7</td><td>90.2</td></tr><tr><td>+ MoCo (He et al., 2020)</td><td>88.2</td><td>93.3</td><td>95.1</td><td>80.8</td><td>90.9</td></tr><tr><td>+ SupCon (Khosla et al., 2020) + Contrastive (ours)</td><td>88.1 88.1</td><td>93.2 93.6</td><td>95.2 95.3</td><td>80.5 82.0</td><td>90.2 91.7</td></tr></table>",
+        "bbox": [
+            256,
+            290,
+            736,
+            373
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3 GLUE BENCHMARK EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            404,
+            452,
+            419
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "With both components within the CoDA algorithm being specifically tailored to the natural language understanding applications, we apply it to the RoBERTa-large model (Liu et al., 2019). Comparisons are made with several competitive data-augmentation-based and adversarial-training-based approaches on the GLUE benchmark. Specifically, we consider back-translation, cutoff (Shen et al., 2020), FreeLB (Zhu et al., 2020), SMART (Jiang et al., 2020), and R3F (Aghajanyan et al., 2020) as the baselines, where the last three all belong to adversarial training. The results are presented in Table 3. It is worth noting that back-translation is based on our implementation, where both the cross-entropy and consistency regularization terms are utilized. ",
+        "bbox": [
+            173,
+            422,
+            825,
+            535
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/8b08b89715da4287f491cc2f4c888f307eaadbaadfa8b455e4a9b229f4953b5a.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>MNLI-m/ mm (Acc)</td><td>QQP (Acc/F1)</td><td>QNLI (Acc)</td><td>SST-2 (Acc)</td><td>MRPC (Acc/F1)</td><td>CoLA (Mcc)</td><td>RTE (Acc)</td><td>STS-B (P/S)</td><td>Avg</td></tr><tr><td>RoBERTa-large</td><td>90.2/-</td><td>92.2/-</td><td>94.7</td><td>96.4</td><td>-/90.9</td><td>68</td><td>86.6</td><td>92.4/-</td><td>88.9</td></tr><tr><td>Back-Trans</td><td>91.1/90.4</td><td>92/-</td><td>95.3</td><td>97.1</td><td>90.9/93.5</td><td>69.4</td><td>91.7</td><td>92.8/92.6</td><td>90.4</td></tr><tr><td>Cutoff</td><td>91.1/-</td><td>92.4/-</td><td>95.3</td><td>96.9</td><td>91.4/93.8</td><td>71.5</td><td>91.0</td><td>92.8/-</td><td>90.6</td></tr><tr><td>FreeLB</td><td>90.6/-</td><td>92.6/-</td><td>95</td><td>96.7</td><td>91.4/-</td><td>71.1</td><td>88.1</td><td>92.71-</td><td>1</td></tr><tr><td>SMART</td><td>91.1/91.3</td><td>92.4/89.8</td><td>95.6</td><td>96.9</td><td>89.2/92.1</td><td>70.6</td><td>92</td><td>92.8/92.6</td><td>90.4</td></tr><tr><td>R3F</td><td>91.1/91.3</td><td>92.4/89.9</td><td>95.3</td><td>97.0</td><td>91.6/-</td><td>71.2</td><td>88.5</td><td>1</td><td>-</td></tr><tr><td>CoDA</td><td>91.3/90.8</td><td>92.5/89.9</td><td>95.3</td><td>97.4</td><td>91.9/94</td><td>72.6</td><td>92.4</td><td>93/92.7</td><td>91.1</td></tr></table>",
+        "bbox": [
+            174,
+            544,
+            818,
+            666
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Main results of single models on the GLUE development set. Note: The best result on each task is in bold and “-” denotes the missing results. The average score is calculated based on the same setting as RoBERTa. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            714
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We find that $C o D A$ brings significant gains to the RoBERTa-large model, with the averaged score on the GLUE dev set improved from 88.9 to 91.1. More importantly, CoDA consistently outperforms these strong baselines (indicated by a higher averaged score), demonstrating that our algorithm can produce informative and high-quality augmented samples and leverage them effectively as well. Concretely, on datasets with relatively larger numbers of training instances $( > 1 0 0 \\mathrm { K } )$ , i.e., MNLI, QQP and QNLI, different approaches show similar gains over the RoBERTa-large model. However, on smaller tasks (SST-2, MRPC, CoLA, RTE, and STS-B), CoDA beats other data augmentation or adversarial-based methods by a wide margin. We attribute this observation to the fact that the synthetically produced examples are more helpful when the tasks-specific data is limited. Thus, when smaller datasets are employed for fine-tuning large-scale language models, the superiority of the proposed approach is manifested to a larger extent. ",
+        "bbox": [
+            173,
+            719,
+            825,
+            873
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4 ADDITIONAL EXPERIMENTS AND ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            881,
+            519,
+            893
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Low-resource Setting To verify the advantages of CoDA when a smaller number of taskspecific data is available, we further conduct a low-resource experiment with the MNLI and QNLI datasets. Concretely, different proportions of training data are sampled and utilized for training. We apply CoDA to RoBERTa-base and compare it with backtranslation and adversarial training across various training set sizes. The corresponding results are presented in Fig. 5. We observe that back-translation and adversarial training exhibit similar performance across different proportions. More importantly, CoDA demonstrates stronger results consistently, further highlighting its effectiveness with limited training data. ",
+        "bbox": [
+            174,
+            896,
+            821,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/28115cc53ada6d47b656ea2b0a8d4b1fa65a9cf68abc9459a1a5f49dac4ed108.jpg",
+        "image_caption": [
+            "Figure 5: Low-resource setting experiments on the MNLI (left) and QNLI (right) dev sets. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            90,
+            785,
+            234
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            267,
+            825,
+            351
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The Effectiveness of Contrastive Objective To investigate the general applicability of the proposed contrastive regularization objective, we further apply it to different data augmentation methods. The RoBERTa-base model and QNLI dataset are leveraged for this set of experiments, and the results are shown in Fig. 6. We observe that the contrastive learning objective boosts the empirical performance of the resulting algorithm regardless of the data augmentation approaches it is applied to. This further validates our assumption that considering the global information among the embeddings of all examples is beneficial for leveraging augmented samples more effectively. ",
+        "bbox": [
+            174,
+            359,
+            516,
+            553
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/ed9d2bde5a7f1e01a5feeedf34d4e708470883227a4d953ce1d6f4d19190d9ca.jpg",
+        "image_caption": [
+            "Figure 6: Evaluation of the proposed contrastive objective while applied to different data augmentation approaches. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            558,
+            371,
+            790,
+            502
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            556,
+            344,
+            571
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Data Augmentation in NLP Different data augmentation approaches have been proposed for text data, such as back-translation (Sennrich et al., 2016; Edunov et al., 2018; Xie et al., 2019), c-BERT word replacement (Wu et al., 2019), mixup (Guo et al., 2019; Chen et al., 2020a), Cutoff (Shen et al., 2020). Broadly speaking, adversarial training (Zhu et al., 2020; Jiang et al., 2020) also synthesizes additional examples via perturbations at the word embedding layer. Although effective, how these data augmentation transformations may be combined together to obtain further improvement has been rarely explored. This could be attributed to the fact that a sentence’s semantic meanings are quite sensitive to small perturbations. Consistency-regularized loss (Bachman et al., 2014; Rasmus et al., 2015; Laine & Aila, 2017; Tarvainen & Valpola, 2017) is typically employed as the training objective, which ignores the global information within the entire dataset. ",
+        "bbox": [
+            173,
+            577,
+            825,
+            717
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Contrastive Learning Contrastive methods learn representations by contrasting positive and negative examples, which has demonstrated impressive empirical success in computer vision tasks (Henaff et al., 2019; He et al., 2020). Under an unsupervised setting, Contrastive learning ap- ´ proaches learn representation by maximizing mutual information between local-global hidden representations (Hjelm et al., 2019; Oord et al., 2018; Henaff et al., 2019). It can be also leveraged ´ to learn invariant representations by encouraging consensus between augmented samples from the same input (Bachman et al., 2019; Tian et al., 2019). He et al. (2020); Wu et al. (2018) proposes to utilize a memory bank to enable a much larger number of negative samples, which is shown to benefit the transferability of learned representations as well (Khosla et al., 2020). Recently, contrastive learning was also employed to improve language model pre-training (Iter et al., 2020). ",
+        "bbox": [
+            173,
+            718,
+            825,
+            857
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            864,
+            320,
+            880
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we proposed CoDA, a Contrast-enhanced and Diversity promoting data Augmentation framework. Through extensive experiments, we found that stacking adversarial training over a back-translation module can give rise to more diverse and informative augmented samples. Besides, we introduced a specially-designed contrastive loss to incorporate these examples for training in a principled manner. Experiments on the GLUE benchmark showed that CoDA consistently improves over several competitive data augmentation and adversarial training baselines. Moreover, it is observed that the proposed contrastive objective can be leveraged to improve other data augmentation approaches as well, highlighting the wide applicability of the CoDA framework. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            195,
+            285,
+            210
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Armen Aghajanyan, Akshat Shrivastava, Anchit Gupta, Naman Goyal, Luke Zettlemoyer, and Sonal Gupta. Better fine-tuning by reducing representational collapse. arXiv preprint arXiv:2008.03156, 2020. ",
+        "bbox": [
+            176,
+            219,
+            825,
+            261
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Philip Bachman, Ouais Alsharif, and Doina Precup. Learning with pseudo-ensembles. In Advances in neural information processing systems, pp. 3365–3373, 2014. ",
+        "bbox": [
+            173,
+            272,
+            821,
+            301
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Philip Bachman, R Devon Hjelm, and William Buchwalter. Learning representations by maximizing mutual information across views. In Advances in Neural Information Processing Systems, pp. 15535–15545, 2019. ",
+        "bbox": [
+            173,
+            310,
+            825,
+            353
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David Berthelot, Nicholas Carlini, Ian Goodfellow, Nicolas Papernot, Avital Oliver, and Colin A Raffel. Mixmatch: A holistic approach to semi-supervised learning. In Advances in Neural Information Processing Systems, pp. 5049–5059, 2019. ",
+        "bbox": [
+            176,
+            363,
+            823,
+            407
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020. ",
+        "bbox": [
+            174,
+            416,
+            823,
+            460
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jiaao Chen, Zichao Yang, and Diyi Yang. MixText: Linguistically-informed interpolation of hidden space for semi-supervised text classification. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pp. 2147–2157, Online, July 2020a. Association for Computational Linguistics. doi: 10.18653/v1/2020.acl-main.194. URL https: //www.aclweb.org/anthology/2020.acl-main.194. ",
+        "bbox": [
+            173,
+            469,
+            825,
+            541
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. arXiv preprint arXiv:2002.05709, 2020b. ",
+        "bbox": [
+            174,
+            550,
+            825,
+            580
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yong Cheng, Lu Jiang, Wolfgang Macherey, and Jacob Eisenstein. Advaug: Robust adversarial augmentation for neural machine translation. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, ACL 2020, Online, July 5-10, 2020, 2020. ",
+        "bbox": [
+            176,
+            590,
+            825,
+            633
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "E. Cubuk, Barret Zoph, Dandelion Mane, V. Vasudevan, and Quoc V. Le. Autoaugment: Learning ´ augmentation policies from data. ArXiv, abs/1805.09501, 2018. ",
+        "bbox": [
+            171,
+            642,
+            825,
+            672
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ekin D Cubuk, Barret Zoph, Jonathon Shlens, and Quoc V Le. Randaugment: Practical automated data augmentation with a reduced search space. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pp. 702–703, 2020. ",
+        "bbox": [
+            176,
+            683,
+            823,
+            726
+        ],
+        "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. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, NAACL-HLT 2019, 2019. ",
+        "bbox": [
+            173,
+            736,
+            826,
+            791
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Terrance DeVries and Graham W Taylor. Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552, 2017. ",
+        "bbox": [
+            169,
+            803,
+            825,
+            832
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sergey Edunov, Myle Ott, Michael Auli, and David Grangier. Understanding back-translation at scale. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, 2018. ",
+        "bbox": [
+            173,
+            842,
+            823,
+            885
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Raphael Gontijo-Lopes, Sylvia J Smullin, Ekin D Cubuk, and Ethan Dyer. Affinity and diversity: Quantifying mechanisms of data augmentation. arXiv preprint arXiv:2002.08973, 2020. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. 2015. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Arthur Gretton, Karsten M Borgwardt, Malte J Rasch, Bernhard Scholkopf, and Alexander Smola. ¨ A kernel two-sample test. The Journal of Machine Learning Research, 13(1):723–773, 2012. ",
+        "bbox": [
+            173,
+            142,
+            821,
+            172
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hongyu Guo, Yongyi Mao, and Richong Zhang. Augmenting data with mixup for sentence classification: An empirical study. arXiv preprint arXiv:1905.08941, 2019. ",
+        "bbox": [
+            174,
+            183,
+            820,
+            212
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yaru Hao, Li Dong, Furu Wei, and Ke Xu. Visualizing and understanding the effectiveness of bert. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing, EMNLP-IJCNLP, 2019. ",
+        "bbox": [
+            173,
+            222,
+            825,
+            280
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 9729–9738, 2020. ",
+        "bbox": [
+            174,
+            290,
+            825,
+            334
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Olivier J Henaff, Aravind Srinivas, Jeffrey De Fauw, Ali Razavi, Carl Doersch, SM Eslami, and ´ Aaron van den Oord. Data-efficient image recognition with contrastive predictive coding. arXiv preprint arXiv:1905.09272, 2019. ",
+        "bbox": [
+            174,
+            343,
+            826,
+            387
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks, Norman Mu, Ekin D Cubuk, Barret Zoph, Justin Gilmer, and Balaji Lakshminarayanan. Augmix: A simple data processing method to improve robustness and uncertainty. In 8th International Conference on Learning Representations, ICLR, 2020. ",
+        "bbox": [
+            173,
+            397,
+            826,
+            440
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "R Devon Hjelm, Alex Fedorov, Samuel Lavoie-Marchildon, Karan Grewal, Phil Bachman, Adam Trischler, and Yoshua Bengio. Learning deep representations by mutual information estimation and maximization. In 7th International Conference on Learning Representations, ICLR, 2019. ",
+        "bbox": [
+            176,
+            450,
+            825,
+            494
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Vu Cong Duy Hoang, Philipp Koehn, Gholamreza Haffari, and Trevor Cohn. Iterative backtranslation for neural machine translation. In Proceedings of the 2nd Workshop on Neural Machine Translation and Generation, pp. 18–24, 2018. ",
+        "bbox": [
+            174,
+            505,
+            823,
+            549
+        ],
+        "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. 15764–15775, 2019. ",
+        "bbox": [
+            173,
+            559,
+            825,
+            602
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Iter, Kelvin Guu, Larry Lansing, and Dan Jurafsky. Pretraining with contrastive sentence objectives improves discourse performance of language models. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, ACL, 2020. ",
+        "bbox": [
+            174,
+            613,
+            825,
+            656
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Haoming Jiang, Pengcheng He, Weizhu Chen, Xiaodong Liu, Jianfeng Gao, and Tuo Zhao. Smart: Robust and efficient fine-tuning for pre-trained natural language models through principled regularized optimization. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, ACL, 2020. ",
+        "bbox": [
+            173,
+            666,
+            825,
+            723
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Harini Kannan, Alexey Kurakin, and Ian Goodfellow. Adversarial logit pairing. arXiv preprint arXiv:1803.06373, 2018. ",
+        "bbox": [
+            173,
+            733,
+            823,
+            763
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Prannay Khosla, Piotr Teterwak, Chen Wang, Aaron Sarna, Yonglong Tian, Phillip Isola, Aaron Maschinot, Ce Liu, and Dilip Krishnan. Supervised contrastive learning. arXiv preprint arXiv:2004.11362, 2020. ",
+        "bbox": [
+            173,
+            773,
+            825,
+            816
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In 3rd International Conference on Learning Representations, ICLR 2015, 2014. ",
+        "bbox": [
+            165,
+            827,
+            823,
+            857
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ashutosh Kumar, Satwik Bhattamishra, Manik Bhandari, and Partha Talukdar. Submodular optimization-based diverse paraphrasing and its effectiveness in data augmentation. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, 2019. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Samuli Laine and Timo Aila. Temporal ensembling for semi-supervised learning. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings. OpenReview.net, 2017. ",
+        "bbox": [
+            176,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiaodong Liu, Hao Cheng, Pengcheng He, Weizhu Chen, Yu Wang, Hoifung Poon, and Jianfeng Gao. Adversarial training for large neural language models. arXiv preprint arXiv:2004.08994, 2020. ",
+        "bbox": [
+            174,
+            155,
+            823,
+            198
+        ],
+        "page_idx": 10
+    },
+    {
+        "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. arXiv preprint arXiv:1907.11692, 2019. ",
+        "bbox": [
+            174,
+            207,
+            826,
+            250
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, and Shin Ishii. Virtual adversarial training: a regularization method for supervised and semi-supervised learning. IEEE transactions on pattern analysis and machine intelligence, 41(8):1979–1993, 2018. ",
+        "bbox": [
+            174,
+            260,
+            825,
+            303
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018. ",
+        "bbox": [
+            173,
+            311,
+            823,
+            340
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. arXiv preprint arXiv:1910.10683, 2019. ",
+        "bbox": [
+            173,
+            349,
+            826,
+            392
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Antti Rasmus, Mathias Berglund, Mikko Honkala, Harri Valpola, and Tapani Raiko. Semisupervised learning with ladder networks. In Advances in neural information processing systems, pp. 3546–3554, 2015. ",
+        "bbox": [
+            173,
+            401,
+            823,
+            444
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rico Sennrich, Barry Haddow, and Alexandra Birch. Improving neural machine translation models with monolingual data. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics, ACL, 2016. ",
+        "bbox": [
+            176,
+            454,
+            823,
+            497
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dinghan Shen, Mingzhi Zheng, Yelong Shen, Yanru Qu, and Weizhu Chen. A simple but tough-tobeat data augmentation approach for natural language understanding and generation, 2020. ",
+        "bbox": [
+            173,
+            506,
+            821,
+            536
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jian Shen, Yanru Qu, Weinan Zhang, and Yong Yu. Wasserstein distance guided representation learning for domain adaptation. In Proceedings of the Thirty-Second AAAI Conference on Artificial Intelligence, (AAAI-18), 2018. ",
+        "bbox": [
+            174,
+            544,
+            825,
+            587
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kihyuk Sohn, David Berthelot, Chun-Liang Li, Zizhao Zhang, Nicholas Carlini, Ekin D Cubuk, Alex Kurakin, Han Zhang, and Colin Raffel. Fixmatch: Simplifying semi-supervised learning with consistency and confidence. arXiv preprint arXiv:2001.07685, 2020. ",
+        "bbox": [
+            174,
+            595,
+            825,
+            640
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chi Sun, Xipeng Qiu, Yige Xu, and Xuanjing Huang. How to fine-tune bert for text classification? In China National Conference on Chinese Computational Linguistics, pp. 194–206. Springer, 2019. ",
+        "bbox": [
+            173,
+            648,
+            825,
+            678
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Antti Tarvainen and Harri Valpola. Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results. In Advances in neural information processing systems, pp. 1195–1204, 2017. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            729
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yonglong Tian, Dilip Krishnan, and Phillip Isola. Contrastive multiview coding. arXiv preprint arXiv:1906.05849, 2019. ",
+        "bbox": [
+            171,
+            738,
+            823,
+            767
+        ],
+        "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. EMNLP 2018, pp. 353, 2018. ",
+        "bbox": [
+            176,
+            776,
+            823,
+            819
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jason Wei and Kai Zou. Eda: Easy data augmentation techniques for boosting performance on text classification tasks. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing, EMNLP-IJCNLP, 2019. ",
+        "bbox": [
+            173,
+            829,
+            825,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xing Wu, Shangwen Lv, Liangjun Zang, Jizhong Han, and Songlin Hu. Conditional bert contextual augmentation. In International Conference on Computational Science, pp. 84–95. Springer, 2019. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhirong Wu, Yuanjun Xiong, Stella X Yu, and Dahua Lin. Unsupervised feature learning via nonparametric instance discrimination. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3733–3742, 2018. ",
+        "bbox": [
+            174,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Qizhe Xie, Zihang Dai, Eduard Hovy, Minh-Thang Luong, and Quoc V Le. Unsupervised data augmentation for consistency training. arXiv preprint arXiv:1904.12848, 2019. ",
+        "bbox": [
+            171,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Adams Wei Yu, David Dohan, Minh-Thang Luong, Rui Zhao, Kai Chen, Mohammad Norouzi, and Quoc V Le. Qanet: Combining local convolution with global self-attention for reading comprehension. In 6th International Conference on Learning Representations, ICLR 2018, 2018. ",
+        "bbox": [
+            176,
+            193,
+            823,
+            236
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. arXiv preprint arXiv:1710.09412, 2017. ",
+        "bbox": [
+            168,
+            243,
+            823,
+            272
+        ],
+        "page_idx": 11
+    },
+    {
+        "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": [
+            173,
+            281,
+            823,
+            324
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chen Zhu, Yu Cheng, Zhe Gan, Siqi Sun, Thomas Goldstein, and Jingjing Liu. Freelb: Enhanced adversarial training for language understanding. In 8th International Conference on Learning Representations, ICLR, 2020. ",
+        "bbox": [
+            174,
+            333,
+            825,
+            376
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A DATA AUGMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            475,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We select the following representative data augmentation operations as basic building blocks of our data augmentation module. We denote $\\pmb { x } _ { i } = [ x _ { i , 1 } , . . . , x _ { i , l } ]$ as the input text sequence, and $\\boldsymbol { e } _ { i } = [ e _ { i , 1 } , \\bar { \\ldots } , e _ { i , l } ]$ as corresponding embedding vectors. ",
+        "bbox": [
+            174,
+            135,
+            825,
+            178
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "• Back translation is widely applied in machine translation (MT) (Sennrich et al., 2016; Hoang et al., 2018; Edunov et al., 2018), and is introduced to text classification recently (Xie et al., 2019). Back-Trans uses 2 MT models to translate the input example to another pivot language, and then translate it back, ${ \\bf { x } } _ { i } $ Pivot Language $ \\pmb { x } _ { i } ^ { \\prime }$ . C-BERT Word Replacement $\\mathrm { W u }$ et al., 2019) is a representative of the word replacement augmentation family. C-BERT pretrains a conditional BERT model to learn contextualized representation $P ( \\mathbf { x } _ { j } | [ x _ { i , 1 } \\dots x _ { i , j - 1 } [ \\mathbf { M A S K } ] x _ { i , j + 1 } \\dots x _ { i , l } ] , y _ { i } )$ conditioning on classes. This method then randomly substitutes wor $\\mathrm { d } \\mathrm { s \\ o f \\ } x \\mathrm { \\ t o \\ }$ obtain $\\pmb { x } ^ { \\prime } ( [ x _ { i , 1 } \\dots x _ { i , j } ^ { \\prime } \\dots x _ { i , l } ] ) ^ { 4 }$ .   \nCutoff (DeVries & Taylor, 2017) randomly drops units in a continuous span on the input, while Shen et al. (2020) adapts this method to text embeddings. For input embeddings $e _ { i }$ , this method randomly set a continuous span of elements to 0s, $\\pmb { e } _ { i } ^ { \\prime } = [ \\pmb { e } _ { i , 1 } . . . \\pmb { e } _ { i , j - 1 } , 0 . . . 0 , \\pmb { e } _ { i , j + w } . . . \\pmb { e } _ { i , l } ]$ , where the window size $w \\propto l$ , and the start position $j \\in [ 1 , l - w ]$ is randomly selected. For transformer encoders that involve position embeddings, we also set input mask as 0s at corresponding positions.   \n• Mixup (Zhang et al., 2017) interpolates two image as well as their labels. Guo et al. (2019) borrows this method to text. For 2 input embeddings $( e _ { i } , e _ { j } )$ , mixup interpolates the embedding vectors $\\pmb { e } _ { i } ^ { \\prime } = a \\pmb { e } _ { i } + ( 1 - a ) \\pmb { e } _ { j }$ where $a$ is sampled from a Beta distribution. Also, the labels are interpolated for the augmented sample $y _ { i } ^ { \\prime } = a { \\bar { y _ { i } } } + ( 1 - a ) y _ { j }$ .   \n• Adversarial training generates adversarial examples for input embeddings, simply, $\\begin{array} { r l } { e _ { i } ^ { \\prime } } & { { } = } \\end{array}$ arg $\\begin{array} { r } { \\operatorname* { m a x } _ { \\| e _ { i } - e _ { i } ^ { \\prime } \\| \\leq 1 } \\bar { \\mathcal { L } } ( \\bar { f } ( e _ { i } ^ { \\prime } ) , y _ { i } ) } \\end{array}$ . We mainly follow the implementation of Zhu et al. (2020). Besides, when computing the adversarial example $\\boldsymbol { e } _ { i } ^ { \\prime }$ , the dropout variables are recorded and reused later when encoding $\\bar { e _ { i } ^ { \\prime } }$ . ",
+        "bbox": [
+            173,
+            190,
+            825,
+            529
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Maximum mean discrepancy (MMD) (Gretton et al., 2012) is a widely used discrepancy measure for 2 distributions. We adopt the multi-kernel MMD implementation based on Shen et al. $( 2 0 1 8 ) ^ { 5 }$ to quantify the distance of data distributions before and after DA transformations. ",
+        "bbox": [
+            174,
+            540,
+            821,
+            582
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B DATASET DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            603,
+            364,
+            621
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The datasets and statistics are summarized in Table 4. ",
+        "bbox": [
+            174,
+            637,
+            526,
+            651
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/1579d73a9f660740f30cf6ef484ee4baf831b33bfc56871f64acc15135d539cc.jpg",
+        "table_caption": [
+            "Table 4: GLUE benchmark summary. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Corpus</td><td rowspan=1 colspan=1>Task</td><td rowspan=1 colspan=1>SentencePair</td><td rowspan=1 colspan=1>#Train</td><td rowspan=1 colspan=1>#Dev</td><td rowspan=1 colspan=1>#Test</td><td rowspan=1 colspan=1>#Class</td><td rowspan=1 colspan=1>Metrics</td></tr><tr><td rowspan=1 colspan=1>MNLI</td><td rowspan=1 colspan=1>NLI</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>393k</td><td rowspan=1 colspan=1>20k</td><td rowspan=1 colspan=1>20k</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>Accuracy</td></tr><tr><td rowspan=1 colspan=1>QQP</td><td rowspan=1 colspan=1>Paraphrase</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>364k</td><td rowspan=1 colspan=1>40k</td><td rowspan=1 colspan=1>391k</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>Accuracy/F1</td></tr><tr><td rowspan=1 colspan=1>QNLI</td><td rowspan=1 colspan=1>QA/NLI</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>108k</td><td rowspan=1 colspan=1>5.7k</td><td rowspan=1 colspan=1>5.7k</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>Accuracy</td></tr><tr><td rowspan=1 colspan=1>SST</td><td rowspan=1 colspan=1>Sentiment</td><td rowspan=1 colspan=1>×</td><td rowspan=1 colspan=1>67k</td><td rowspan=1 colspan=1>872</td><td rowspan=1 colspan=1>1.8k</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>Accuracy</td></tr><tr><td rowspan=1 colspan=1>MRPC</td><td rowspan=1 colspan=1>Paraphrase</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>3.7k</td><td rowspan=1 colspan=1>408</td><td rowspan=1 colspan=1>1.7k</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>Accuracy/F1</td></tr><tr><td rowspan=1 colspan=1>CoLA</td><td rowspan=1 colspan=1>Acceptability</td><td rowspan=1 colspan=1>×</td><td rowspan=1 colspan=1>8.5k</td><td rowspan=1 colspan=1>1k</td><td rowspan=1 colspan=1>1k</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>Matthews corr</td></tr><tr><td rowspan=1 colspan=1>RTE</td><td rowspan=1 colspan=1>NLI</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>2.5k</td><td rowspan=1 colspan=1>276</td><td rowspan=1 colspan=1>3k</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>Accuracy</td></tr><tr><td rowspan=1 colspan=1>STS-B</td><td rowspan=1 colspan=1>Similarity</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>7k</td><td rowspan=1 colspan=1>1.5k</td><td rowspan=1 colspan=1>1.4k</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>Pearson/Spe-arman corr</td></tr></table>",
+        "bbox": [
+            191,
+            664,
+            805,
+            827
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            439,
+            117
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Our implementation is based on RoBERTa (Liu et al., 2019). We use ADAM (Kingma & Ba, 2014) as our optimizer. We follow the hyper-parameter study of RoBERTa and set as default the following parameters: batch size (32), learning rate (1e-5), epochs (5), warmup ratio (0.06), weight decay (0.1) and we keep other parameters unchanged with RoBERTa. For Back-Trans, we use the en-de single models trained on WMT19 and released in FairSeq. More specifically, we use beam search (beam size $= 5$ ) and keep only the top-1 hypothesis. We slightly tune Adversarial parameters on MNLI based on FreeLB and fix them on other datasets, since adversarial training is not our focus. For contrastive regularization, we implement based on MoCo. In GLUE evaluation, we mainly tune the weights of 3 regularization terms, $\\alpha \\in [ 0 , 1 ] , \\beta \\in [ 0 , 3 ] , \\lambda \\in [ 0 , 0 . 0 3 ]$ (Eq. 6, 11). Besides, for smaller tasks (MRPC, CoLA, RTE, STS-B), we use the best performed MNLI model to initialize their parameters6. ",
+        "bbox": [
+            173,
+            133,
+            825,
+            286
+        ],
+        "page_idx": 13
+    }
+]

parse/train/SyJ7ClWCb/SyJ7ClWCb.md

@@ -0,0 +1,252 @@
+# COUNTERING ADVERSARIAL IMAGES USING INPUT TRANSFORMATIONS
+
+Chuan Guo∗ Cornell University
+
+Mayank Rana & Moustapha Cisse & Laurens van der Maaten ´ Facebook AI Research
+
+# ABSTRACT
+
+This paper investigates strategies that defend against adversarial-example attacks on image-classification systems by transforming the inputs before feeding them to the system. Specifically, we study applying image transformations such as bit-depth reduction, JPEG compression, total variance minimization, and image quilting before feeding the image to a convolutional network classifier. Our experiments on ImageNet show that total variance minimization and image quilting are very effective defenses in practice, in particular, when the network is trained on transformed images. The strength of those defenses lies in their non-differentiable nature and their inherent randomness, which makes it difficult for an adversary to circumvent the defenses. Our best defense eliminates $6 0 \%$ of strong gray-box and $9 0 \%$ of strong black-box attacks by a variety of major attack methods.
+
+# 1 INTRODUCTION
+
+As the use of machine intelligence increases in security-sensitive applications (Bojarski et al., 2016; Amodei et al., 2015), robustness has become a critical feature to guarantee the reliability of deployed machine-learning systems. Unfortunately, recent research has demonstrated that existing models are not robust to small, adversarially designed perturbations of the input (Biggio et al., 2013; Szegedy et al., 2014; Goodfellow et al., 2015; Kurakin et al., 2016a; Cisse et al., 2017a). Adversarially perturbed examples have been deployed to attack image classification services (Liu et al., 2016), speech recognition systems (Cisse et al., 2017a), and robot vision (Melis et al., 2017). The existence of these adversarial examples has motivated proposals for approaches that increase the robustness of learning systems to such examples (Papernot et al., 2016; Kurakin et al., 2016a; Cisse et al., 2017b).
+
+The robustness of machine learning models to adversarial examples depends both on the properties of the model (i.e., Lipschitzness) and on the nature of the problem considered, e.g., on the input dimensionality and the Bayes error of the problem (Fawzi et al., 2015; 2016). Consequently, defenses that aim to increase robustness against adversarial examples fall in one of two main categories. The first category comprises model-specific strategies that enforce model properties such as invariance and smoothness via the learning algorithm or regularization scheme (Shaham et al., 2015; Kurakin et al., 2016a; Cisse et al., 2017b), potentially exploiting knowledge about the adversary’s attack strategy (Goodfellow et al., 2015). The second category of defenses are model-agnostic: they try to remove adversarial perturbations from the input. For example, in the context of image classification, adversarial perturbations can be partly removed via JPEG compression (Dziugaite et al., 2016) or image re-scaling (Lu et al., 2017). Hitherto, none of these defenses has been shown to be very effective. Specifically, model-agnostic defenses appear too simple to sufficiently remove adversarial perturbations from input images. By contrast, model-specific defenses make strong assumptions about the nature of the adversary (e.g., on the norm that the adversary minimizes or on the number of iterations it uses to generate the perturbation). Consequently, they do not satisfy Kerckhoffs (1883) principle: the adversary can alter its attack to circumvent such model-specific defenses.
+
+In this paper, we focus on increasing the effectiveness of model-agnostic defense strategies by developing approaches that (1) remove the adversarial perturbations from input images, (2) maintain sufficient information in input images to correctly classify them, and (3) are still effective in settings in which the adversary has information on the defense strategy being used. We explore transformations based on image cropping and rescaling (Graese et al., 2016), bit-depth reduction (Xu et al.,
+
+2017), JPEG compression (Dziugaite et al., 2016), total variance minimization (Rudin et al., 1992), and image quilting (Efros & Freeman, 2001). We show that these defenses can be surprisingly effective against existing attacks, in particular, when the convolutional network is trained on images that are transformed in a similar way. The image transformations are good at countering the (iterative) fast gradient sign method (Kurakin et al., 2016a), Deepfool (Moosavi-Dezfooli et al., 2016), and the Carlini & Wagner (2017) attack, even in gray-box settings in which the model architecture and parameters are public. Our strongest defenses are based on total variation minimization and image quilting: these defenses are non-differentiable and inherently random, which makes it difficult for an adversary to get around them. Our best defenses eliminate $6 0 \%$ of gray-box attacks and $9 0 \%$ of black-box attacks by four major attack methods that perturb pixel values by $8 \%$ on average.
+
+# 2 PROBLEM DEFINITION
+
+We study defenses against non-targeted adversarial examples for image-recognition systems. Let $\chi = [ 0 , \mathbf { \bar { 1 } } ] ^ { H \times W \times C }$ be the image space. Given an image classifier $h ( \cdot )$ and a source image $\mathbf { x } \in \mathcal { X }$ , a non-targeted1 adversarial example of $\mathbf { x }$ is a perturbed image $\mathbf { x } ^ { \prime } \in { \mathcal { X } }$ such that $h ( \mathbf { x } ) \neq h ( \mathbf { x } ^ { \prime } )$ and $d ( \mathbf { x } , \mathbf { \bar { x } } ^ { \prime } ) \leq \rho$ for some dissimilarity function $d ( \cdot , \cdot )$ and $\rho \geq 0$ . Ideally, $d ( \cdot , \cdot )$ measures the perceptual difference between $\mathbf { x }$ and $\mathbf { x } ^ { \prime }$ but, in practice, the Euclidean distance $d ( \mathbf { x } , \mathbf { x } ^ { \prime } ) = \lVert \mathbf { x } - \mathbf { x } ^ { \prime } \rVert _ { 2 }$ or the Chebyshev distance $d ( \mathbf { x } , \mathbf { x } ^ { \prime } ) = \| \mathbf { x } - \mathbf { x } ^ { \prime } \| _ { \infty }$ is most commonly used.
+
+Given a set of $N$ images $\{ \mathbf { x } _ { 1 } , \dotsc , \mathbf { x } _ { N } \}$ and a target classifier $h ( \cdot )$ , an adversarial attack aims to generate $\{ \mathbf { x } _ { 1 } ^ { \prime } , \ldots , \mathbf { x } _ { N } ^ { \prime } \}$ such that each $\mathbf { x } _ { n } ^ { \prime }$ is an adversarial example for $\mathbf { x } _ { n }$ . The success rate of an attack is measured by the proportion of predictions that was altered by an attack: $\begin{array} { r } { \frac { 1 } { N } \sum _ { n = 1 } ^ { N } \mathbb { 1 } \left[ h ( \mathbf { x } _ { n } ) \right. \neq \left. h ( \mathbf { x } _ { n } ^ { \prime } ) \right] } \end{array}$ . The success rate is generally measured as a function of the magnitude of the perturbations performed by the attack, using the normalized $L _ { 2 }$ -dissimilarity:
+
+$$
+\frac { 1 } { N } \sum _ { n = 1 } ^ { N } \frac { \| \mathbf { x } _ { n } - \mathbf { x } _ { n } ^ { \prime } \| _ { 2 } } { \| \mathbf { x } _ { n } \| _ { 2 } } .
+$$
+
+A strong adversarial attack has a high success rate whilst its normalized $L _ { 2 }$ -dissimilarity is low.
+
+In most practical settings, an adversary does not have direct access to the model $h ( \cdot )$ and has to do a black-box attack. However, prior work has shown successful attacks by transferring adversarial examples generated for a separately-trained model to an unknown target model (Liu et al., 2016). Therefore, we investigate both the black-box and a more difficult gray-box attack setting: in our gray-box setting, the adversary has access to the model architecture and the model parameters, but is unaware of the defense strategy that is being used.
+
+A defense is an approach that aims make the prediction on an adversarial example $h ( \mathbf { x } ^ { \prime } )$ equal to the prediction on the corresponding clean example $h ( \mathbf { x } )$ . In this study, we focus on imagetransformation defenses $g ( \mathbf { x } )$ that perform prediction via $h ( g ( \mathbf { x } ^ { \prime } ) )$ . Ideally, $g ( \cdot )$ is a complex, nondifferentiable, and potentially stochastic function: this makes it difficult for an adversary to attack the prediction model $h ( g ( \mathbf { x } ) { \dot { ) } }$ even when the adversary knows both $h ( \cdot )$ and $g ( \cdot )$ .
+
+# 3 ADVERSARIAL ATTACKS
+
+One of the first successful attack methods is the fast gradient sign method (FGSM; Goodfellow et al. (2015)). Let $\ell ( \cdot , \cdot )$ be the differentiable loss function that was used to train the classifier $h ( \cdot )$ , e.g., the cross-entropy loss. The FGSM adversarial example corresponding to a source input $\mathbf { x }$ and true label $y$ is:
+
+$$
+\mathbf { x } ^ { \prime } = \mathbf { x } + \epsilon \cdot \mathrm { s i g n } \left( \nabla _ { \mathbf { x } } \ell ( \mathbf { x } , y ) \right) ,
+$$
+
+for some $\epsilon > 0$ that governs the perturbation magnitude. A stronger variant of this attack, called iterative FGSM (I-FGSM; Kurakin et al. (2016b)), iteratively applies the FGSM update:
+
+$$
+\begin{array} { r } { \mathbf { x } ^ { ( m ) } = \mathbf { x } ^ { ( m - 1 ) } + \epsilon \cdot \mathrm { s i g n } \left( \nabla _ { \mathbf { x } ^ { ( m - 1 ) } } \ell ( \mathbf { x } ^ { ( m - 1 ) } , y ) \right) , } \end{array}
+$$
+
+![](images/4796b80e01b3f89ce7e440f6f79ded8b7dbe2921d10ffd0c7f4a353c86cfb011.jpg)  
+Figure 1: Adversarial images and corresponding perturbations at five levels of normalized $L _ { 2 }$ - dissimilarity for all four attacks.
+
+where $m = 1 , \ldots , M$ ; $\mathbf { x } ^ { ( 0 ) } = \mathbf { x }$ ; and $\mathbf { x } ^ { \prime } = \mathbf { x } ^ { ( M ) }$ . The number of iterations $M$ is set such that $h ( \mathbf { x } ^ { \prime } ) \neq h ( \mathbf { x } )$ . Both FGSM and I-FGSM approximately minimize the Chebyshev distance between the inputs and the adversarial examples they generate.
+
+Alternative attacks aim to minimize the Euclidean distance between the input and the adversarial example instead. For instance, assuming $h ( \cdot )$ is a binary classifier, DeepFool (Moosavi-Dezfooli et al., 2016) projects $\mathbf { x }$ onto a linearization of the decision boundary defined by $h ( \cdot )$ for $M$ iterations:
+
+$$
+\mathbf { x } ^ { ( m ) } = \mathbf { x } ^ { ( m - 1 ) } - \epsilon \cdot \frac { h ( \mathbf { x } ^ { ( m - 1 ) } ) } { \| \nabla _ { \mathbf { x } ^ { ( m - 1 ) } } h ( \mathbf { x } ^ { ( m - 1 ) } ) \| _ { 2 } ^ { 2 } } \nabla _ { \mathbf { x } ^ { ( m - 1 ) } } h \left( \mathbf { x } ^ { ( m - 1 ) } \right) ,
+$$
+
+where $\mathbf { x } ^ { ( 0 ) }$ and $\mathbf { x } ^ { \prime }$ are defined as in I-FGSM. The multi-class variant of DeepFool performs the projection onto the nearest class boundaries. The linearization performed in DeepFool is particularly well suited for ReLU-networks, as these represent piecewise linear class boundaries.
+
+Carlini-Wagner’s $L _ { 2 }$ attack (CW-L2; Carlini & Wagner (2017)) is an optimization-based attack that combines a differentiable surrogate for the model’s classification accuracy with an $L _ { 2 }$ -penalty term. Let $Z ( \mathbf { x } )$ be the operation that computes the logit vector (i.e., the output before the softmax layer) for an input $\mathbf { x }$ , and $Z ( \mathbf { x } ) _ { k }$ be the logit value corresponding to class $k$ . The untargeted variant of CW-L2 finds a solution to the unconstrained optimization problem
+
+$$
+\operatorname* { m i n } _ { \mathbf { x } ^ { \prime } } \left[ \| \mathbf { x } - \mathbf { x } ^ { \prime } \| _ { 2 } ^ { 2 } + \lambda _ { f } \operatorname* { m a x } \left( - \kappa , Z ( \mathbf { x } ^ { \prime } ) _ { h ( \mathbf { x } ) } - \operatorname* { m a x } \{ Z ( \mathbf { x } ^ { \prime } ) _ { k } : k \neq h ( \mathbf { x } ) \} \right) \right] ,
+$$
+
+where $\kappa$ denotes a margin parameter, and where the parameter $\lambda _ { f }$ trades off the perturbation norm and the hinge loss of predicting a different class. We perform the minimization over $\mathbf { x } ^ { \prime }$ using the Adam optimizer (Kingma & Ba, 2014) for 100 iterations with an initial learning rate of 0.001.
+
+All of the aforementioned attacks enforce that $\mathbf { x } ^ { \prime } \in { \mathcal { X } }$ by clipping values between 0 and 1. Figure 1 shows adversarial images produced by all four attacks at five normalized $L _ { 2 }$ -dissimilarity levels.
+
+# 4 DEFENSES
+
+Adversarial attacks alter particular statistics of the input image in order to change the model prediction. Indeed, adversarial perturbations $\mathbf { x } - \mathbf { x } ^ { \prime }$ have a particular structure, as illustrated by Figure 1. We design and experiment with image transformations that alter the structure of these perturbations, and investigate whether the alterations undo the effects of the adversarial attack. We investigate five image transformations: (1) image cropping and rescaling, (2) bit-depth reduction, (3) JPEG compression, (4) total variance minimization, and (5) image quilting.
+
+We first introduce three simple image transformations: image cropping-rescaling (Graese et al., 2016), bit-depth reduction (Xu et al., 2017), and JPEG compression and decompression (Dziugaite et al., 2016). Image croppingrescaling has the effect of altering the spatial positioning of the adversarial perturbation, which is important in making attacks successful. Following He et al. (2016), we crop and rescale images at training time as part of the data augmentation. At test time, we average predictions over random image crops. Bitdepth reduction (Xu et al., 2017) perform a simple type of quantization that can removes small (adversarial) variations in pixel values from an image; we reduce images to 3 bits in our experiments. JPEG compression (Dziugaite et al., 2016) removes small perturbations in a similar way; we perform compression at quality level 75 (out of 100).
+
+# 4.2 TOTAL VARIANCE MINIMIZATION
+
+An alternative way of removing adversarial perturbations is via a compressed sensing approach that combines pixel dropout with total variation minimization (Rudin et al., 1992). This approach randomly selects a small set of pixels, and reconstructs the “simplest” image that is consistent with the selected pixels. The reconstructed image does not contain the adversarial perturbations because these perturbations tend to be small and localized.
+
+![](images/5f134c8eea06771359ec9cbe61af525c03cb806d9ac48319199ba6e27f005054.jpg)  
+Figure 2: Illustration of total variance minimization and image quilting applied to an original and an adversarial image (produced using I-FGSM with $\epsilon = 0 . 0 3$ , corresponding to a normalized $L _ { 2 }$ - dissimilarity of 0.075). From left to right, the columns correspond to: (1) no transformation, (2) total variance minimization, and (3) image quilting. From top to bottom, rows correspond to: (1) the original image, (2) the corresponding adversarial image produced by I-FGSM, and (3) the absolute difference between the two images above. Difference images were multiplied by a constant scaling factor to increase visibility.
+
+Specifically, we first select a random set of pixels by sampling a Bernoulli random variable $X ( i , j , k )$ for each pixel location $( i , j , k )$ ; we maintain a pixel when $X ( \bar { i } , j , k ) = 1$ . Next, we use total variation minimization to constructs an image $\mathbf { z }$ that is similar to the (perturbed) input image $\mathbf { x }$ for the selected set of pixels, whilst also being “simple” in terms of total variation by solving:
+
+$$
+\operatorname* { m i n } _ { \mathbf { z } } \| ( 1 - X ) \odot ( \mathbf { z } - \mathbf { x } ) \| _ { 2 } + \lambda _ { \mathrm { T V } } \cdot \mathrm { T V } _ { p } ( \mathbf { z } ) .
+$$
+
+Herein, $\odot$ denotes element-wise multiplication, and $\mathrm { T V } _ { p } ( { \mathbf z } )$ represents the $L _ { p }$ -total variation of $\mathbf { z }$ :
+
+$$
+\mathrm { T V } _ { p } ( \mathbf { z } ) = \sum _ { k = 1 } ^ { K } \left[ \sum _ { i = 2 } ^ { N } \| \mathbf { z } ( i , : , k ) - \mathbf { z } ( i - 1 , : , k ) \| _ { p } + \sum _ { j = 2 } ^ { N } \| \mathbf { z } ( : , j , k ) - \mathbf { z } ( : , j - 1 , k ) \| _ { p } \right] .
+$$
+
+The total variation (TV) measures the amount of fine-scale variation in the image $\mathbf { z }$ , as a result of which TV minimization encourages removal of small (adversarial) perturbations in the image. The objective function (6) is convex in $\mathbf { z }$ , which makes solving for $\mathbf { z }$ straightforward. In our implementation, we set $p = 2$ and employ a special-purpose solver based on the split Bregman method (Goldstein & Osher, 2009) to perform total variance minimization efficiently.
+
+The effectiveness of TV minimization is illustrated by the images in the middle column of Figure 2: in particular, note that the adversarial perturbations that were present in the background for the nontransformed image (see bottom-left image) have nearly completely disappeared in the TV-minimized adversarial image (bottom-center image). As expected, TV minimization also changes image structure in non-homogeneous regions of the image, but as these perturbations were not adversarially designed we expect the negative effect of these changes to be limited.
+
+![](images/a70380ebaa590d9eaf6bd859744d4c3de7cc9206fff309be23ac9144d5f6a71d.jpg)  
+Figure 3: Block diagram detailing the differences between the experimental setups in Section 5.2, 5.3, and 5.4. We train networks (a) on regular images or (b) on transformed images; we test the networks on transformed adversarial images. For each of the three setups, dashed arrows indicate which model is used by the adversary and which model is used by the classification model.
+
+# 4.3 IMAGE QUILTING
+
+Image quilting (Efros & Freeman, 2001) is a non-parametric technique that synthesizes images by piecing together small patches that are taken from a database of image patches. The algorithm places appropriate patches in the database for a predefined set of grid points, and computes minimum graph cuts (Boykov et al., 2001) in all overlapping boundary regions to remove edge artifacts.
+
+Image quilting can be used to remove adversarial perturbations by constructing a patch database that only contains patches from “clean” images (without adversarial perturbations); the patches used to create the synthesized image are selected by finding the $K$ nearest neighbors (in pixel space) of the corresponding patch from the adversarial image in the patch database, and picking one of these neighbors uniformly at random. The motivation for this defense is that the resulting image only consists of pixels that were not modified by the adversary — the database of real patches is unlikely to contain the structures that appear in adversarial images.
+
+The right-most column of Figure 2 illustrates the effect of image quilting on adversarial images. Whilst interpretation of these images is more complicated due to the quantization errors that image quilting introduces, it is interesting to note that the absolute differences between quilted original and the quilted adversarial image appear to be smaller in non-homogeneous regions of the image. This suggests that TV minimization and image quilting lead to inherently different defenses.
+
+# 5 EXPERIMENTS
+
+We performed five experiments to test the efficacy of our defenses. The experiment in Section 5.2 considers gray-box attacks: it applies the defenses on adversarial images before using them as input into a convolutional network trained to classify “clean” images. In this setting, the adversary has access to the model architecture and parameters but is unaware of the defense strategy. The experiment in Section 5.3 focuses on a black-box setting: it replaces the convolutional network by networks that were trained on images with a particular input-transformation. The experiment in Section 5.4 combines our defenses with ensembling and model transfer. The experiment in Section 5.5 investigates to what extent networks trained on image-transformations can be attacked in a gray-box setting. The experiment in Section 5.6 compares our defenses with prior work. The setup of our gray-box and black-box experiments is illustrated in Figure 3. Code to reproduce our results is available at https://github.com/facebookresearch/adversarial_image_defenses.
+
+# 5.1 EXPERIMENTAL SETUP
+
+We performed experiments on the ImageNet image classification dataset. The dataset comprises 1.2 million training images and 50, 000 test images that correspond to one of $1 , 0 0 0$ classes. Our adversarial images are produced by attacking a ResNet-50 model (He et al., 2016). We evaluate our defense strategies against the four adversarial attacks presented in Section 3. We measure the strength of an adversary in terms of its normalized $L _ { 2 }$ -dissimilarity and report classification accuracies as a function of the normalized $L _ { 2 }$ -dissimilarity. To produce adversarial images like those in Figure 1, we set the normalized $L _ { 2 }$ -dissimilarity for each of the attacks as follows:
+
+![](images/cb27099cf36179accd666897d315503aa0039bf2e01d559ec88280cd10dad8bb.jpg)  
+Figure 4: Top-1 classification accuracy of ResNet-50 tested on transformed adversarial images produced by four attacks using five image transformations in a gray-box setting: (1) cropping-rescaling, (2) bit-depth reduction, (3) JPEG compression, (4) total variance minimization, and (5) image quilting. The dotted line shows the top-1 accuracy of the ResNet-50 model on non-adversarial images, providing an upper bound on the effectiveness of a defense. An $L _ { 2 }$ -dissimilarity of 0.00 corresponds to the classification accuracy on non-adversarial images. Higher is better.
+
+• FGSM. Increasing the step size $\epsilon$ increases the normalized $L _ { 2 }$ -dissimilarity.   
+• I-FGSM. We fix $M = 1 0$ , and increase $\epsilon$ to increase the normalized $L _ { 2 }$ -dissimilarity.   
+• DeepFool. We fix $M = 5$ , and increase $\epsilon$ to increase the normalized $L _ { 2 }$ -dissimilarity.   
+• CW-L2. We fix $\kappa = 0$ and $\lambda _ { f } = 1 0$ , and multiply the resulting perturbation by an appropriately chosen $\epsilon \geq 1$ to alter the normalized $L _ { 2 }$ -dissimilarity.
+
+We fixed the hyperparameters of our defenses in all experiments: specifically, we set pixel dropout probability $p { = } 0 . 5$ and the regularization parameter of the total variation minimizer $\lambda _ { \mathrm { T V } } { = } 0 . 0 3$ . We use a quilting patch size of $5 \times 5$ and a database of $1 , 0 0 0 , 0 0 0$ patches that were randomly selected from the ImageNet training set. We use the nearest neighbor patch (i.e., $K = 1$ ) for experiments in Sections 5.2 and 5.3, and randomly select a patch from one of $K = 1 0$ nearest neighbors in all other experiments. In the cropping defense, we sample 30 crops of size $9 0 \times 9 0$ from the $2 2 4 \times 2 2 4$ input image, rescale the crops to $2 2 4 \times 2 2 4$ , and average the model predictions over all crops.
+
+# 5.2 GRAY BOX: IMAGE TRANSFORMATIONS AT TEST TIME
+
+Figure 4 shows the top-1 accuracy of a ResNet-50 tested on transformed adversarial images as a function of the adversary strength for each of the four attacks. Each plot shows results for five different transformations we apply to the images at test time (viz., image cropping-rescaling, bitdepth reduction, JPEG compression, total variation minimization, and image quilting). The dotted line shows the classification error of the ResNet-50 model on images that are not adversarially perturbed, i.e., it gives an upper bound on the accuracy that defenses can achieve.
+
+In line with the results reported in the literature, the four adversaries successfully attack the ResNet50 model in nearly all cases (FGSM has a slightly lower favorable attack rate of $8 0 - 9 0 \%$ ) when the input images are not transformed. The results also show that the proposed image transformations are capable of partly eliminating the effect of the attacks. In particular, ensembling 30 predictions over different, random image crops is very efficient: these predictions are correct for $4 0 - 6 0 \%$ of the images (note that $76 \%$ is the highest accuracy that one can expect to achieve). This result suggests that adversarial examples are susceptible to changes in the location and scale of the adversarial perturbations. While not as effective, image transformations based on total variation minimization and image quilting also successfully defend against adversarial examples from all four attacks: applying these transformations allows us to classify $3 0 { - } 4 0 \%$ of the images correctly. This result suggests that total variation minimization and image quilting can successfully remove part of the perturbations from adversarial images. In particular, the accuracy of the image-quilting defense hardly deteriorates as the strength of the adversary increases. However, the quilting transformation does severely impact the model’s accuracy on non-adversarial images.
+
+![](images/e58dbb9814413968996a5583754ff345817e903a1717edd3f9c62704c1811217.jpg)  
+Figure 5: Top-1 classification accuracy of ResNet-50 trained and tested on transformed adversarial images produced by four attacks using five image transformations in a black-box setting: (1) cropping-rescaling, (2) bit-depth reduction, (3) JPEG compression, (4) total variance minimization, and (5) image quilting. The dotted line represents the top-1 accuracy of the ResNet-50 model on nonadversarial images, providing an upper bound on the effectiveness of a defense. An $L _ { 2 }$ -dissimilarity of 0.00 corresponds to the classification accuracy on non-adversarial images. Higher is better.
+
+# 5.3 BLACK BOX: IMAGE TRANSFORMATIONS AT TRAINING AND TEST TIME
+
+The high relative performance of image cropping-rescaling in 5.2 may be partly explained by the fact that the convolutional network was trained on randomly cropped-rescaled images2, but not on any of the other transformations. This implies that independent of whether an image is adversarial or not, the network is more robust to image cropping-rescaling than it is to those transformations. The results in Figure 4 suggest that this negatively affects the effectiveness of these defenses, even if the defenses are successful in removing the adversarial perturbation. To investigate this, we trained ResNet-50 models on transformed ImageNet training images. We adopt the standard data augmentation from He et al. (2016), but apply bit-depth reduction, JPEG compression, TV minimization, or image quilting on the resized image crop before feeding it to the network. We measure the classification accuracy of the resulting networks on the same adversarial images as before. Note that this implies that we assume a black-box setting in this experiment.
+
+<table><tr><td></td><td colspan="4">Quilting</td><td colspan="4">TVM +Quilting</td><td colspan="4">Cropping+TVM+Quilting</td></tr><tr><td></td><td>RN50</td><td>RN101</td><td>DN169</td><td>Iv4</td><td>RN50</td><td>RN101</td><td>DN169</td><td>Iv4</td><td>RN50</td><td>RN101</td><td>DN169</td><td>Iv4</td></tr><tr><td>No Attack</td><td>70.07</td><td>72.56</td><td>70.18</td><td>73.01</td><td>72.38</td><td>74.74</td><td>73.10</td><td>75.55</td><td>72.14</td><td>74.53</td><td>72.92</td><td>75.10</td></tr><tr><td>FGSM</td><td>65.45</td><td>68.50</td><td>65.96</td><td>67.53</td><td>65.70</td><td>68.77</td><td>67.09</td><td>69.19</td><td>66.65</td><td>69.75</td><td>67.86</td><td>70.37</td></tr><tr><td>I-FGSM</td><td>65.59</td><td>68.72</td><td>66.16</td><td>69.29</td><td>65.84</td><td>69.10</td><td>67.32</td><td>71.05</td><td>67.03</td><td>70.14</td><td>68.20</td><td>71.52</td></tr><tr><td>DeepFool</td><td>65.20</td><td>68.73</td><td>65.86</td><td>68.70</td><td>65.80</td><td>69.34</td><td>67.40</td><td>71.03</td><td>67.11</td><td>70.49</td><td>68.62</td><td>71.47</td></tr><tr><td>CW-L2</td><td>64.11</td><td>67.72</td><td>65.00</td><td>68.14</td><td>63.99</td><td>68.20</td><td>66.08</td><td>70.13</td><td>65.31</td><td>69.14</td><td>66.96</td><td>70.50</td></tr></table>
+
+Table 1: Top-1 classification accuracy of ensemble and model transfer defenses (columns) against four black-box attacks (rows). The four networks we use to classify images are ResNet-50 (RN50), ResNet-101 (RN101), DenseNet-169 (DN169), and Inception-v4 (Iv4). Adversarial images are generated by running attacks against the ResNet-50 model, aiming for an average normalized $L _ { 2 }$ - dissimilarity of 0.06. Higher is better. The best defense against each attack is typeset in boldface.
+
+We present the results of these experiments in Figure 5. Training convolutional networks on images that are transformed in the same way as at test time, indeed, dramatically improves the effectiveness of all transformation defenses. In our experiments, the image-quilting defense is particularly effective against strong attacks: it successfully defends against $8 0 - 9 0 \%$ of all four attacks, even when the normalized $L _ { 2 }$ -dissimilarity of the attack approaches 0.08.
+
+# 5.4 BLACK BOX: ENSEMBLING AND MODEL TRANSFER
+
+We evaluate the efficacy of (1) ensembling different defenses and (2) “transferring” attacks to different network architectures (in a black-box setting). Specifically, we measured the accuracy of four networks using ensembles of defenses on adversarial images generated to attack a ResNet-50; the four networks we consider are ResNet-50, ResNet-101, DenseNet-169 (Huang et al., 2017), and Inception-v4 (Szegedy et al., 2017). To ensemble the image quilting and TVM defenses, we average the image-quilting prediction (using a weight of 0.5) with model predictions for 10 different TVM reconstructions (with a weight of 0.05 each), re-sampling the pixels used to measure the reconstruction error each time. To combine cropping with other transformations, we first apply those transformations and average predictions over 10 random crops from the transformed images.
+
+The results of our ensembling experiments are presented in Table 1. The results show that gains of $1 - 2 \%$ in classification accuracy can be achieved by ensembling different defenses, whereas transferring attacks to different convolutional network architectures can lead to an improvement of $2 - 3 \%$ . Inception-v4 performs best in our experiments, but this may be partly due to that network having a higher accuracy even in non-adversarial settings. Our best black-box defense achieves an accuracy of about $7 1 \%$ against all four defenses: the attacks deteriorate the accuracy of our best classifier (which combines cropping, TVM, image quilting, and model transfer) by at most $6 \%$ .
+
+# 5.5 GRAY BOX: IMAGE TRANSFORMATIONS AT TRAINING AND TEST TIME
+
+The previous experiments demonstrated the effectiveness of image transformations against adversarial images, in particular, when convolutional networks are re-trained to be robust to those image transformations. In this experiment, we investigate to what extent the resulting networks can be attacked in a gray-box setting in which the adversary has access to those networks (but does not have access to the input transformations applied at test time). We use the four attack methods to generate novel adversarial images against the transformation-robust networks trained in 5.3, and measure the accuracy of the networks on these novel adversarial images in Figure 6.
+
+The results show that bit-depth reduction and JPEG compression are weak defenses in such a graybox setting. Whilst their relative ordering varies between attack methods, image cropping and rescaling, total variation minimization, and image quilting are fairly robust defenses in the white-box setting. Specifically, networks using these defenses classify up to $5 0 \%$ of adversarial images correctly.
+
+# 5.6 COMPARISON WITH PRIOR WORK
+
+In our final set of experiments, we compare our defenses with the state-of-the-art ensemble adversarial training approach proposed by Tramer et al. (2017). Ensemble adversarial training fits the \` parameters of a convolutional network on adversarial examples that were generated to attack an ensemble of pre-trained models. These adversarial examples are very diverse, which makes the convolutional network being trained robust to a variety of adversarial perturbation. In our experiments, we used the model released by Tramer et al. (2017): an Inception-Resnet-v2 (Szegedy et al., 2016)\` trained on adversarial examples generated by FGSM against Inception-Resnet-v2 and Inception-v3 models. We compare the model to our ResNet-50 models with image cropping, total variance minimization, and image quilting defenses. We note that there are two small differences in terms of the assumptions that ensemble adversarial training makes and the assumptions our defenses make: (1) in contrast to ensemble adversarial training, our defenses assume that part of the defense strategy (viz., the input transformation) is unknown to the adversary, and (2) in contrast to ensemble adversarial training, our defenses assume no prior knowledge of the attacks being used. The former difference is advantageous to our defenses, whereas the latter difference gives our defenses a disadvantage compared to ensemble adversarial training.
+
+![](images/e25357bdeaa7019fe1216779f702901eab0df83e0824c6b9fef069aac97c257b.jpg)  
+Figure 6: Top-1 classification accuracy of ResNet-50 trained and tested on transformed adversarial images produced by four attacks using five image transformations in a gray-box setting: (1) cropping-rescaling, (2) bit-depth reduction, (3) JPEG compression, (4) total variance minimization, and (5) image quilting. The dotted line represents the top-1 accuracy of the ResNet-50 model on non-adversarial images, providing an upper bound on the effectiveness of a defense. $L _ { 2 }$ -dissimilarity of 0 corresponds to clean image accuracy. Higher is better.
+
+Table 2 compares the classification accuracies of the defense strategief on adversarial examples with a normalized $L _ { 2 }$ -dissimilarity of 0.06. The results show that ensemble adversarial training works better on FGSM attacks (which it uses at training time), but is outperformed by each of the transformation-based defenses all other attacks. Input transformations particularly outperform ensemble adversarial training against the iterative attacks: our defense are are $1 8 - 2 4 \times$ more robust than ensemble adversarial training against DeepFool attacks. Combining cropping, TVM, and quilting increases the accuracy of our defenses against DeepFool gray-box attacks to $5 1 . 5 1 \%$ (compared to $1 . 8 4 \%$ for ensemble adversarial training).
+
+# 6 DISCUSSION
+
+The results from this study suggest there exists a range of image transformations that have the potential to remove adversarial perturbations while preserving the visual content of the image: one merely has to train the convolutional network on images that were transformed in the same way. A critical property that governs which image transformations are most effective in practice is whether
+
+<table><tr><td></td><td>Cropping</td><td>TVM</td><td>Quilting</td><td>Ensemble Training (Tramer et al., 2017)</td></tr><tr><td>No Attack</td><td>65.41</td><td>66.29</td><td>69.66</td><td>80.3</td></tr><tr><td>FGSM</td><td>49.52</td><td>31.37</td><td>39.55</td><td>69.15</td></tr><tr><td>I-FGSM</td><td>43.89</td><td>40.99</td><td>33.22</td><td>5.07</td></tr><tr><td>DeepFool</td><td>44.92</td><td>44.69</td><td>34.54</td><td>1.84</td></tr><tr><td>CW-L2</td><td>41.06</td><td>48.41</td><td>30.51</td><td>22.23</td></tr></table>
+
+Table 2: Top-1 classification accuracy on images perturbed using attacks against ResNet-50 models trained on input-transformed images, and an Inception-v4 model trained using ensemble adversarial. Adversarial images are generated by running attacks against the models, aiming for an average normalized $L _ { 2 }$ -dissimilarity of 0.06. The best defense against each attack is typeset in boldface.
+
+an adversary can incorporate the transformation in its attack. For instance, median filtering likely is a weak remedy because one can backpropagate through the median filter, which is sufficient to perform any of the attacks described in Section 3. A strong input-transformation defense should, therefore, be non-differentiable and randomized, a strategy has been previously shown to be effective (Wang et al., 2016a;b). Two of our top defenses possess both properties:
+
+1. Both total variation minimization and image quilting are difficult to differentiate through. Specifically, total variation minimization involves solving a complex minimization of a function that is inherently random. Image quilting involves a discrete variable that selects the patch from the database, which is a non-differentiable operation, and the graph-cut optimization complicates the use of differentiable approximations (Maddison et al., 2017). 2. Both total variation minimization and image quilting give rise to randomized defenses. Total variation minimization randomly selects the pixels it uses to measure reconstruction error on when creating the denoised image. Image quilting randomly selects one of the $K$ nearest neighbors uniformly at random. The inherent randomness of our defenses makes it difficult to attack the model: it implies the adversary has to find a perturbation that alters the prediction for the entire distribution of images that could be used as input, which is harder than perturbing a single image (Moosavi-Dezfooli et al., 2017).
+
+Our results with gray-box attacks suggest that randomness is particularly important in developing strong defenses. Therefore, we surmise that total variation minimization, image quilting, and related methods (Dong et al., 2011) are stronger defenses than deterministic denoising procedures such as bit-depth reduction, JPEG compression, or non-local means (Buades, 2005). Defenses based on total variation minimization and image quilting also have an advantage over adversarial-training approaches (Kurakin et al., 2016a): an adversarially trained network is differentiable, which implies that it can be attacked using the methods in Section 3. An additional disadvantage of adversarial training is that it focuses on a particular attack; by contrast, transformation-based defenses generalize well across attack methods because they are model-agnostic.
+
+While our study focuses exclusively on image classification, we expect similar defenses to be useful in other domains for which successful attacks have been developed, such as semantic segmentation and speech recognition (Cisse et al., 2017a; Zhang et al., 2017). In speech recognition, for example, total variance minimization can be used to remove perturbations from waveforms, and one could develop “spectrogram quilting” techniques that reconstruct a spectrogram by concatenating “spectrogram patches” along the temporal dimension. We leave such extensions to future work. In future work, we also intend to study combinations of our input-transformation defenses with ensemble adversarial training (Tramer et al., 2017), and we intend to investigate new attack methods that are \` specifically designed to circumvent our input-transformation defenses.
+
+# ACKNOWLEDGEMENTS
+
+We thank Kilian Weinberger, Iasonas Kokkinos, Changhan Wang, and the entire Facebook AI Research team for helpful discussions and code support. Chuan Guo is supported in part by NSF grant IIS-1618134.
+
+# REFERENCES
+
+Dario Amodei, Rishita Anubhai, Eric Battenberg, Carl Case, Jared Casper, Bryan Catanzaro, Jingdong Chen, Mike Chrzanowski, Adam Coates, Greg Diamos, et al. Deep Speech 2: End-to-end speech recognition in English and Mandarin. CoRR, abs/1512.02595, 2015.
+
+Battista Biggio, Igino Corona, Davide Maiorca, Blaine Nelson, Nedim Srndi ˇ c, Pavel Laskov, Gior- ´ gio Giacinto, and Fabio Roli. Evasion attacks against machine learning at test time. In Proc. ECML, pp. 387–402, 2013.
+
+Mariusz Bojarski, Davide Del Testa, Daniel Dworakowski, Bernhard Firner, Beat Flepp, Prasoon Goyal, Lawrence D Jackel, Mathew Monfort, Urs Muller, Jiakai Zhang, et al. End-to-end learning for self-driving cars. CoRR, abs/1604.07316, 2016.
+
+Yuri Boykov, Olga Veksler, and Ramin Zabih. Fast approximate energy minimization via graph cuts. IEEE Transactions on Pattern Analysis and Machine Intelligence, 23(11):1222–1239, 2001.
+
+Antoni Buades. A non-local algorithm for image denoising. In Proc. CVPR, pp. 60–65, 2005.
+
+Nicholas Carlini and David A. Wagner. Towards evaluating the robustness of neural networks. In IEEE Symposium on Security and Privacy, pp. 39–57, 2017.
+
+Moustapha Cisse, Yossi Adi, Natalia Neverova, and Joseph Keshet. Houdini: Fooling deep structured prediction models. CoRR, abs/1707.05373, 2017a.
+
+Moustapha Cisse, Piotr Bojanowski, Edouard Grave, Yann Dauphin, and Nicolas Usunier. Parseval networks: Improving robustness to adversarial examples. CoRR, abs/1704.08847, 2017b.
+
+Weisheng Dong, Lei Zhang, and Guangming Shi. Centralized sparse representation for image restoration. In Proc. ICCV, pp. 1259–1266, 2011.
+
+Gintare Karolina Dziugaite, Zoubin Ghahramani, and Daniel Roy. A study of the effect of JPG compression on adversarial images. CoRR, abs/1608.00853, 2016.
+
+Alexei Efros and William Freeman. Image quilting for texture synthesis and transfer. In Proc. SIGGRAPH, pp. 341–346, 2001.
+
+Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Analysis of classifiers’ robustness to adversarial perturbations. CoRR, abs/1502.02590, 2015.
+
+Alhussein Fawzi, Seyed-Mohsen Moosavi-Dezfooli, and Pascal Frossard. Robustness of classifiers: From adversarial to random noise. In Proc. NIPS, pp. 1632–1640, 2016.
+
+Tom Goldstein and Stanley Osher. The split Bregman method for L1-regularized problems. SIAM Journal of Imaging Science, 2(2):323–343, April 2009.
+
+Ian Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In Proc. ICLR, 2015.
+
+Abigail Graese, Andras Rozsa, and Terrance E. Boult. Assessing threat of adversarial examples on deep neural networks. CoRR, abs/1610.04256, 2016.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proc. CVPR, pp. 770–778, 2016.
+
+Gao Huang, Zhuang Liu, Kilian Weinberger, and Laurens van der Maaten. Densely connected convolutional networks. In Proc. CVPR, pp. 2261–2269, 2017.
+
+Auguste Kerckhoffs. La cryptographie militaire. Journal des sciences militaires, IX:5–83, 161–191, 1883.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. CoRR, abs/1611.01236, 2016a.   
+Alexey Kurakin, Ian J. Goodfellow, and Samy Bengio. Adversarial examples in the physical world. CoRR, abs/1607.02533, 2016b.   
+Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. CoRR, abs/1611.02770, 2016.   
+Jiajun Lu, Hussein Sibai, Evan Fabry, and David Forsyth. No need to worry about adversarial examples in object detection in autonomous vehicles. CoRR, abs/1707.03501, 2017.   
+Chris Maddison, Andriy Mnih, and Yee-Whye Teh. The concrete distribution: A continuous relaxation of discrete random variables. In Proc. ICLR, 2017.   
+Marco Melis, Ambra Demontis, Battista Biggio, Gavin Brown, Giorgio Fumera, and Fabio Roli. Is deep learning safe for robot vision? adversarial examples against the icub humanoid. CoRR, abs/1708.06939, 2017.   
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: A simple and accurate method to fool deep neural networks. In Proc. CVPR, pp. 2574–2582, 2016.   
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Universal adversarial perturbations. In Proc. CVPR, pp. 86–94, 2017.   
+Nicolas Papernot, Patrick McDaniel, Xi Wu, Somesh Jha, and Ananthram Swami. Distillation as a defense to adversarial perturbations against deep neural networks. In IEEE Symposium on Security and Privacy, pp. 582–597, 2016.   
+Leonid Rudin, Stanley Osher, and Emad Fatemi. Nonlinear total variation based noise removal algorithms. Physica D, 60:259–268, 1992.   
+Uri Shaham, Yutaro Yamada, and Sahand Negahban. Understanding adversarial training: Increasing local stability of neural nets through robust optimization. CoRR, abs/1511.05432, 2015.   
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In In Proc. ICLR, 2014.   
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proc. CVPR, pp. 2818–2826, 2016.   
+Christian Szegedy, Sergey Ioffe, Vincent Vanhoucke, and Alexander Alemi. Inception-v4, InceptionResNet and the impact of residual connections on learning. In Proc. AAAI, pp. 4278–4284, 2017.   
+Florian Tramer, Alexey Kurakin, Nicolas Papernot, Dan Boneh, and Patrick D. McDaniel. Ensemble \` adversarial training: Attacks and defenses. CoRR, abs/1705.07204, 2017.   
+Qinglong Wang, Wenbo Guo, Kaixuan Zhang, Alexander G. Ororbia II, Xinyu Xing, C. Lee Giles, and Xue Liu. Adversary resistant deep neural networks with an application to malware detection. CoRR, abs/1610.01239, 2016a.   
+Qinglong Wang, Wenbo Guo, Kaixuan Zhang, Alexander G. Ororbia II, Xinyu Xing, C. Lee Giles, and Xue Liu. Learning adversary-resistant deep neural networks. CoRR, abs/1612.01401, 2016b.   
+Weilin Xu, David Evans, and Yanjun Qi. Feature squeezing: Detecting adversarial examples in deep neural networks. CoRR, abs/1704.01155, 2017.   
+Guoming Zhang, Chen Yan, Xiaoyu Ji, Taimin Zhang, Tianchen Zhang, and Wenyuan Xu. Dolphinatack: Inaudible voice commands. CoRR, abs/1708.09537, 2017.

parse/train/SyJ7ClWCb/SyJ7ClWCb_content_list.json

@@ -0,0 +1,1263 @@
+[
+    {
+        "type": "text",
+        "text": "COUNTERING ADVERSARIAL IMAGES USING INPUT TRANSFORMATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            625,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Chuan Guo∗ Cornell University ",
+        "bbox": [
+            184,
+            170,
+            305,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mayank Rana & Moustapha Cisse & Laurens van der Maaten ´ Facebook AI Research ",
+        "bbox": [
+            351,
+            170,
+            787,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper investigates strategies that defend against adversarial-example attacks on image-classification systems by transforming the inputs before feeding them to the system. Specifically, we study applying image transformations such as bit-depth reduction, JPEG compression, total variance minimization, and image quilting before feeding the image to a convolutional network classifier. Our experiments on ImageNet show that total variance minimization and image quilting are very effective defenses in practice, in particular, when the network is trained on transformed images. The strength of those defenses lies in their non-differentiable nature and their inherent randomness, which makes it difficult for an adversary to circumvent the defenses. Our best defense eliminates $6 0 \\%$ of strong gray-box and $9 0 \\%$ of strong black-box attacks by a variety of major attack methods. ",
+        "bbox": [
+            233,
+            265,
+            764,
+            417
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            440,
+            336,
+            457
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As the use of machine intelligence increases in security-sensitive applications (Bojarski et al., 2016; Amodei et al., 2015), robustness has become a critical feature to guarantee the reliability of deployed machine-learning systems. Unfortunately, recent research has demonstrated that existing models are not robust to small, adversarially designed perturbations of the input (Biggio et al., 2013; Szegedy et al., 2014; Goodfellow et al., 2015; Kurakin et al., 2016a; Cisse et al., 2017a). Adversarially perturbed examples have been deployed to attack image classification services (Liu et al., 2016), speech recognition systems (Cisse et al., 2017a), and robot vision (Melis et al., 2017). The existence of these adversarial examples has motivated proposals for approaches that increase the robustness of learning systems to such examples (Papernot et al., 2016; Kurakin et al., 2016a; Cisse et al., 2017b). ",
+        "bbox": [
+            174,
+            472,
+            825,
+            597
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The robustness of machine learning models to adversarial examples depends both on the properties of the model (i.e., Lipschitzness) and on the nature of the problem considered, e.g., on the input dimensionality and the Bayes error of the problem (Fawzi et al., 2015; 2016). Consequently, defenses that aim to increase robustness against adversarial examples fall in one of two main categories. The first category comprises model-specific strategies that enforce model properties such as invariance and smoothness via the learning algorithm or regularization scheme (Shaham et al., 2015; Kurakin et al., 2016a; Cisse et al., 2017b), potentially exploiting knowledge about the adversary’s attack strategy (Goodfellow et al., 2015). The second category of defenses are model-agnostic: they try to remove adversarial perturbations from the input. For example, in the context of image classification, adversarial perturbations can be partly removed via JPEG compression (Dziugaite et al., 2016) or image re-scaling (Lu et al., 2017). Hitherto, none of these defenses has been shown to be very effective. Specifically, model-agnostic defenses appear too simple to sufficiently remove adversarial perturbations from input images. By contrast, model-specific defenses make strong assumptions about the nature of the adversary (e.g., on the norm that the adversary minimizes or on the number of iterations it uses to generate the perturbation). Consequently, they do not satisfy Kerckhoffs (1883) principle: the adversary can alter its attack to circumvent such model-specific defenses. ",
+        "bbox": [
+            174,
+            604,
+            825,
+            825
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we focus on increasing the effectiveness of model-agnostic defense strategies by developing approaches that (1) remove the adversarial perturbations from input images, (2) maintain sufficient information in input images to correctly classify them, and (3) are still effective in settings in which the adversary has information on the defense strategy being used. We explore transformations based on image cropping and rescaling (Graese et al., 2016), bit-depth reduction (Xu et al., ",
+        "bbox": [
+            174,
+            833,
+            823,
+            904
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2017), JPEG compression (Dziugaite et al., 2016), total variance minimization (Rudin et al., 1992), and image quilting (Efros & Freeman, 2001). We show that these defenses can be surprisingly effective against existing attacks, in particular, when the convolutional network is trained on images that are transformed in a similar way. The image transformations are good at countering the (iterative) fast gradient sign method (Kurakin et al., 2016a), Deepfool (Moosavi-Dezfooli et al., 2016), and the Carlini & Wagner (2017) attack, even in gray-box settings in which the model architecture and parameters are public. Our strongest defenses are based on total variation minimization and image quilting: these defenses are non-differentiable and inherently random, which makes it difficult for an adversary to get around them. Our best defenses eliminate $6 0 \\%$ of gray-box attacks and $9 0 \\%$ of black-box attacks by four major attack methods that perturb pixel values by $8 \\%$ on average. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            243
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PROBLEM DEFINITION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            263,
+            393,
+            279
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We study defenses against non-targeted adversarial examples for image-recognition systems. Let $\\chi = [ 0 , \\mathbf { \\bar { 1 } } ] ^ { H \\times W \\times C }$ be the image space. Given an image classifier $h ( \\cdot )$ and a source image $\\mathbf { x } \\in \\mathcal { X }$ , a non-targeted1 adversarial example of $\\mathbf { x }$ is a perturbed image $\\mathbf { x } ^ { \\prime } \\in { \\mathcal { X } }$ such that $h ( \\mathbf { x } ) \\neq h ( \\mathbf { x } ^ { \\prime } )$ and $d ( \\mathbf { x } , \\mathbf { \\bar { x } } ^ { \\prime } ) \\leq \\rho$ for some dissimilarity function $d ( \\cdot , \\cdot )$ and $\\rho \\geq 0$ . Ideally, $d ( \\cdot , \\cdot )$ measures the perceptual difference between $\\mathbf { x }$ and $\\mathbf { x } ^ { \\prime }$ but, in practice, the Euclidean distance $d ( \\mathbf { x } , \\mathbf { x } ^ { \\prime } ) = \\lVert \\mathbf { x } - \\mathbf { x } ^ { \\prime } \\rVert _ { 2 }$ or the Chebyshev distance $d ( \\mathbf { x } , \\mathbf { x } ^ { \\prime } ) = \\| \\mathbf { x } - \\mathbf { x } ^ { \\prime } \\| _ { \\infty }$ is most commonly used. ",
+        "bbox": [
+            173,
+            295,
+            825,
+            380
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Given a set of $N$ images $\\{ \\mathbf { x } _ { 1 } , \\dotsc , \\mathbf { x } _ { N } \\}$ and a target classifier $h ( \\cdot )$ , an adversarial attack aims to generate $\\{ \\mathbf { x } _ { 1 } ^ { \\prime } , \\ldots , \\mathbf { x } _ { N } ^ { \\prime } \\}$ such that each $\\mathbf { x } _ { n } ^ { \\prime }$ is an adversarial example for $\\mathbf { x } _ { n }$ . The success rate of an attack is measured by the proportion of predictions that was altered by an attack: $\\begin{array} { r } { \\frac { 1 } { N } \\sum _ { n = 1 } ^ { N } \\mathbb { 1 } \\left[ h ( \\mathbf { x } _ { n } ) \\right. \\neq \\left. h ( \\mathbf { x } _ { n } ^ { \\prime } ) \\right] } \\end{array}$ . The success rate is generally measured as a function of the magnitude of the perturbations performed by the attack, using the normalized $L _ { 2 }$ -dissimilarity: ",
+        "bbox": [
+            174,
+            385,
+            825,
+            458
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/861041de7a98fa36b8877234d34d0dc4861f3a2927f3ed7ff5e1a3c91ff554e0.jpg",
+        "text": "$$\n\\frac { 1 } { N } \\sum _ { n = 1 } ^ { N } \\frac { \\| \\mathbf { x } _ { n } - \\mathbf { x } _ { n } ^ { \\prime } \\| _ { 2 } } { \\| \\mathbf { x } _ { n } \\| _ { 2 } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            465,
+            570,
+            508
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A strong adversarial attack has a high success rate whilst its normalized $L _ { 2 }$ -dissimilarity is low. ",
+        "bbox": [
+            174,
+            515,
+            797,
+            530
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In most practical settings, an adversary does not have direct access to the model $h ( \\cdot )$ and has to do a black-box attack. However, prior work has shown successful attacks by transferring adversarial examples generated for a separately-trained model to an unknown target model (Liu et al., 2016). Therefore, we investigate both the black-box and a more difficult gray-box attack setting: in our gray-box setting, the adversary has access to the model architecture and the model parameters, but is unaware of the defense strategy that is being used. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            621
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A defense is an approach that aims make the prediction on an adversarial example $h ( \\mathbf { x } ^ { \\prime } )$ equal to the prediction on the corresponding clean example $h ( \\mathbf { x } )$ . In this study, we focus on imagetransformation defenses $g ( \\mathbf { x } )$ that perform prediction via $h ( g ( \\mathbf { x } ^ { \\prime } ) )$ . Ideally, $g ( \\cdot )$ is a complex, nondifferentiable, and potentially stochastic function: this makes it difficult for an adversary to attack the prediction model $h ( g ( \\mathbf { x } ) { \\dot { ) } }$ even when the adversary knows both $h ( \\cdot )$ and $g ( \\cdot )$ . ",
+        "bbox": [
+            174,
+            626,
+            825,
+            696
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 ADVERSARIAL ATTACKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            717,
+            411,
+            733
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "One of the first successful attack methods is the fast gradient sign method (FGSM; Goodfellow et al. (2015)). Let $\\ell ( \\cdot , \\cdot )$ be the differentiable loss function that was used to train the classifier $h ( \\cdot )$ , e.g., the cross-entropy loss. The FGSM adversarial example corresponding to a source input $\\mathbf { x }$ and true label $y$ is: ",
+        "bbox": [
+            173,
+            750,
+            825,
+            805
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/75ad531385f430e007932e5dd7d87426595c08441519628462d1f45049b61e2a.jpg",
+        "text": "$$\n\\mathbf { x } ^ { \\prime } = \\mathbf { x } + \\epsilon \\cdot \\mathrm { s i g n } \\left( \\nabla _ { \\mathbf { x } } \\ell ( \\mathbf { x } , y ) \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            803,
+            601,
+            821
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "for some $\\epsilon > 0$ that governs the perturbation magnitude. A stronger variant of this attack, called iterative FGSM (I-FGSM; Kurakin et al. (2016b)), iteratively applies the FGSM update: ",
+        "bbox": [
+            174,
+            825,
+            830,
+            853
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/389e15708eebe6e24068bfd53bf91065d3f4ca3f350e270006398e1a3ed7e31a.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { x } ^ { ( m ) } = \\mathbf { x } ^ { ( m - 1 ) } + \\epsilon \\cdot \\mathrm { s i g n } \\left( \\nabla _ { \\mathbf { x } ^ { ( m - 1 ) } } \\ell ( \\mathbf { x } ^ { ( m - 1 ) } , y ) \\right) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            859,
+            669,
+            887
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/4796b80e01b3f89ce7e440f6f79ded8b7dbe2921d10ffd0c7f4a353c86cfb011.jpg",
+        "image_caption": [
+            "Figure 1: Adversarial images and corresponding perturbations at five levels of normalized $L _ { 2 }$ - dissimilarity for all four attacks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            102,
+            808,
+            366
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $m = 1 , \\ldots , M$ ; $\\mathbf { x } ^ { ( 0 ) } = \\mathbf { x }$ ; and $\\mathbf { x } ^ { \\prime } = \\mathbf { x } ^ { ( M ) }$ . The number of iterations $M$ is set such that $h ( \\mathbf { x } ^ { \\prime } ) \\neq h ( \\mathbf { x } )$ . Both FGSM and I-FGSM approximately minimize the Chebyshev distance between the inputs and the adversarial examples they generate. ",
+        "bbox": [
+            173,
+            426,
+            825,
+            472
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Alternative attacks aim to minimize the Euclidean distance between the input and the adversarial example instead. For instance, assuming $h ( \\cdot )$ is a binary classifier, DeepFool (Moosavi-Dezfooli et al., 2016) projects $\\mathbf { x }$ onto a linearization of the decision boundary defined by $h ( \\cdot )$ for $M$ iterations: ",
+        "bbox": [
+            174,
+            478,
+            825,
+            521
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d943607e736f41a23cc935555cdb729191534cd92ef7135c216477cb85a62054.jpg",
+        "text": "$$\n\\mathbf { x } ^ { ( m ) } = \\mathbf { x } ^ { ( m - 1 ) } - \\epsilon \\cdot \\frac { h ( \\mathbf { x } ^ { ( m - 1 ) } ) } { \\| \\nabla _ { \\mathbf { x } ^ { ( m - 1 ) } } h ( \\mathbf { x } ^ { ( m - 1 ) } ) \\| _ { 2 } ^ { 2 } } \\nabla _ { \\mathbf { x } ^ { ( m - 1 ) } } h \\left( \\mathbf { x } ^ { ( m - 1 ) } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            529,
+            720,
+            565
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { x } ^ { ( 0 ) }$ and $\\mathbf { x } ^ { \\prime }$ are defined as in I-FGSM. The multi-class variant of DeepFool performs the projection onto the nearest class boundaries. The linearization performed in DeepFool is particularly well suited for ReLU-networks, as these represent piecewise linear class boundaries. ",
+        "bbox": [
+            174,
+            568,
+            825,
+            609
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Carlini-Wagner’s $L _ { 2 }$ attack (CW-L2; Carlini & Wagner (2017)) is an optimization-based attack that combines a differentiable surrogate for the model’s classification accuracy with an $L _ { 2 }$ -penalty term. Let $Z ( \\mathbf { x } )$ be the operation that computes the logit vector (i.e., the output before the softmax layer) for an input $\\mathbf { x }$ , and $Z ( \\mathbf { x } ) _ { k }$ be the logit value corresponding to class $k$ . The untargeted variant of CW-L2 finds a solution to the unconstrained optimization problem ",
+        "bbox": [
+            173,
+            616,
+            825,
+            685
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/258190af9f742f4d768388df7a2f56710a80745041a73de6c189aa7d27d67e87.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\mathbf { x } ^ { \\prime } } \\left[ \\| \\mathbf { x } - \\mathbf { x } ^ { \\prime } \\| _ { 2 } ^ { 2 } + \\lambda _ { f } \\operatorname* { m a x } \\left( - \\kappa , Z ( \\mathbf { x } ^ { \\prime } ) _ { h ( \\mathbf { x } ) } - \\operatorname* { m a x } \\{ Z ( \\mathbf { x } ^ { \\prime } ) _ { k } : k \\neq h ( \\mathbf { x } ) \\} \\right) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            248,
+            686,
+            745,
+            710
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\kappa$ denotes a margin parameter, and where the parameter $\\lambda _ { f }$ trades off the perturbation norm and the hinge loss of predicting a different class. We perform the minimization over $\\mathbf { x } ^ { \\prime }$ using the Adam optimizer (Kingma & Ba, 2014) for 100 iterations with an initial learning rate of 0.001. ",
+        "bbox": [
+            176,
+            713,
+            825,
+            755
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "All of the aforementioned attacks enforce that $\\mathbf { x } ^ { \\prime } \\in { \\mathcal { X } }$ by clipping values between 0 and 1. Figure 1 shows adversarial images produced by all four attacks at five normalized $L _ { 2 }$ -dissimilarity levels. ",
+        "bbox": [
+            174,
+            761,
+            823,
+            790
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 DEFENSES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            809,
+            294,
+            825
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Adversarial attacks alter particular statistics of the input image in order to change the model prediction. Indeed, adversarial perturbations $\\mathbf { x } - \\mathbf { x } ^ { \\prime }$ have a particular structure, as illustrated by Figure 1. We design and experiment with image transformations that alter the structure of these perturbations, and investigate whether the alterations undo the effects of the adversarial attack. We investigate five image transformations: (1) image cropping and rescaling, (2) bit-depth reduction, (3) JPEG compression, (4) total variance minimization, and (5) image quilting. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We first introduce three simple image transformations: image cropping-rescaling (Graese et al., 2016), bit-depth reduction (Xu et al., 2017), and JPEG compression and decompression (Dziugaite et al., 2016). Image croppingrescaling has the effect of altering the spatial positioning of the adversarial perturbation, which is important in making attacks successful. Following He et al. (2016), we crop and rescale images at training time as part of the data augmentation. At test time, we average predictions over random image crops. Bitdepth reduction (Xu et al., 2017) perform a simple type of quantization that can removes small (adversarial) variations in pixel values from an image; we reduce images to 3 bits in our experiments. JPEG compression (Dziugaite et al., 2016) removes small perturbations in a similar way; we perform compression at quality level 75 (out of 100). ",
+        "bbox": [
+            174,
+            130,
+            483,
+            406
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.2 TOTAL VARIANCE MINIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            424,
+            442,
+            438
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "An alternative way of removing adversarial perturbations is via a compressed sensing approach that combines pixel dropout with total variation minimization (Rudin et al., 1992). This approach randomly selects a small set of pixels, and reconstructs the “simplest” image that is consistent with the selected pixels. The reconstructed image does not contain the adversarial perturbations because these perturbations tend to be small and localized. ",
+        "bbox": [
+            174,
+            450,
+            482,
+            588
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/5f134c8eea06771359ec9cbe61af525c03cb806d9ac48319199ba6e27f005054.jpg",
+        "image_caption": [
+            "Figure 2: Illustration of total variance minimization and image quilting applied to an original and an adversarial image (produced using I-FGSM with $\\epsilon = 0 . 0 3$ , corresponding to a normalized $L _ { 2 }$ - dissimilarity of 0.075). From left to right, the columns correspond to: (1) no transformation, (2) total variance minimization, and (3) image quilting. From top to bottom, rows correspond to: (1) the original image, (2) the corresponding adversarial image produced by I-FGSM, and (3) the absolute difference between the two images above. Difference images were multiplied by a constant scaling factor to increase visibility. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            501,
+            125,
+            823,
+            372
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Specifically, we first select a random set of pixels by sampling a Bernoulli random variable $X ( i , j , k )$ for each pixel location $( i , j , k )$ ; we maintain a pixel when $X ( \\bar { i } , j , k ) = 1$ . Next, we use total variation minimization to constructs an image $\\mathbf { z }$ that is similar to the (perturbed) input image $\\mathbf { x }$ for the selected set of pixels, whilst also being “simple” in terms of total variation by solving: ",
+        "bbox": [
+            174,
+            595,
+            825,
+            652
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/34de66b597b5dc51c2d06e694126eb16f89aa5a3edaf22d450bffb3caaf568a8.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\mathbf { z } } \\| ( 1 - X ) \\odot ( \\mathbf { z } - \\mathbf { x } ) \\| _ { 2 } + \\lambda _ { \\mathrm { T V } } \\cdot \\mathrm { T V } _ { p } ( \\mathbf { z } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            657,
+            650,
+            680
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Herein, $\\odot$ denotes element-wise multiplication, and $\\mathrm { T V } _ { p } ( { \\mathbf z } )$ represents the $L _ { p }$ -total variation of $\\mathbf { z }$ : ",
+        "bbox": [
+            171,
+            686,
+            818,
+            702
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/97f2b7c896d490a1015ff383d7af3223d6655b4cbe7581930b0329ef9aa4d8f5.jpg",
+        "text": "$$\n\\mathrm { T V } _ { p } ( \\mathbf { z } ) = \\sum _ { k = 1 } ^ { K } \\left[ \\sum _ { i = 2 } ^ { N } \\| \\mathbf { z } ( i , : , k ) - \\mathbf { z } ( i - 1 , : , k ) \\| _ { p } + \\sum _ { j = 2 } ^ { N } \\| \\mathbf { z } ( : , j , k ) - \\mathbf { z } ( : , j - 1 , k ) \\| _ { p } \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            212,
+            708,
+            784,
+            758
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The total variation (TV) measures the amount of fine-scale variation in the image $\\mathbf { z }$ , as a result of which TV minimization encourages removal of small (adversarial) perturbations in the image. The objective function (6) is convex in $\\mathbf { z }$ , which makes solving for $\\mathbf { z }$ straightforward. In our implementation, we set $p = 2$ and employ a special-purpose solver based on the split Bregman method (Goldstein & Osher, 2009) to perform total variance minimization efficiently. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            833
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The effectiveness of TV minimization is illustrated by the images in the middle column of Figure 2: in particular, note that the adversarial perturbations that were present in the background for the nontransformed image (see bottom-left image) have nearly completely disappeared in the TV-minimized adversarial image (bottom-center image). As expected, TV minimization also changes image structure in non-homogeneous regions of the image, but as these perturbations were not adversarially designed we expect the negative effect of these changes to be limited. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/a70380ebaa590d9eaf6bd859744d4c3de7cc9206fff309be23ac9144d5f6a71d.jpg",
+        "image_caption": [
+            "Figure 3: Block diagram detailing the differences between the experimental setups in Section 5.2, 5.3, and 5.4. We train networks (a) on regular images or (b) on transformed images; we test the networks on transformed adversarial images. For each of the three setups, dashed arrows indicate which model is used by the adversary and which model is used by the classification model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            98,
+            821,
+            247
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.3 IMAGE QUILTING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            343,
+            333,
+            358
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Image quilting (Efros & Freeman, 2001) is a non-parametric technique that synthesizes images by piecing together small patches that are taken from a database of image patches. The algorithm places appropriate patches in the database for a predefined set of grid points, and computes minimum graph cuts (Boykov et al., 2001) in all overlapping boundary regions to remove edge artifacts. ",
+        "bbox": [
+            174,
+            369,
+            825,
+            425
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Image quilting can be used to remove adversarial perturbations by constructing a patch database that only contains patches from “clean” images (without adversarial perturbations); the patches used to create the synthesized image are selected by finding the $K$ nearest neighbors (in pixel space) of the corresponding patch from the adversarial image in the patch database, and picking one of these neighbors uniformly at random. The motivation for this defense is that the resulting image only consists of pixels that were not modified by the adversary — the database of real patches is unlikely to contain the structures that appear in adversarial images. ",
+        "bbox": [
+            174,
+            433,
+            825,
+            530
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The right-most column of Figure 2 illustrates the effect of image quilting on adversarial images. Whilst interpretation of these images is more complicated due to the quantization errors that image quilting introduces, it is interesting to note that the absolute differences between quilted original and the quilted adversarial image appear to be smaller in non-homogeneous regions of the image. This suggests that TV minimization and image quilting lead to inherently different defenses. ",
+        "bbox": [
+            176,
+            536,
+            825,
+            606
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            627,
+            326,
+            642
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We performed five experiments to test the efficacy of our defenses. The experiment in Section 5.2 considers gray-box attacks: it applies the defenses on adversarial images before using them as input into a convolutional network trained to classify “clean” images. In this setting, the adversary has access to the model architecture and parameters but is unaware of the defense strategy. The experiment in Section 5.3 focuses on a black-box setting: it replaces the convolutional network by networks that were trained on images with a particular input-transformation. The experiment in Section 5.4 combines our defenses with ensembling and model transfer. The experiment in Section 5.5 investigates to what extent networks trained on image-transformations can be attacked in a gray-box setting. The experiment in Section 5.6 compares our defenses with prior work. The setup of our gray-box and black-box experiments is illustrated in Figure 3. Code to reproduce our results is available at https://github.com/facebookresearch/adversarial_image_defenses. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            810
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.1 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            828,
+            375,
+            842
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We performed experiments on the ImageNet image classification dataset. The dataset comprises 1.2 million training images and 50, 000 test images that correspond to one of $1 , 0 0 0$ classes. Our adversarial images are produced by attacking a ResNet-50 model (He et al., 2016). We evaluate our defense strategies against the four adversarial attacks presented in Section 3. We measure the strength of an adversary in terms of its normalized $L _ { 2 }$ -dissimilarity and report classification accuracies as a function of the normalized $L _ { 2 }$ -dissimilarity. To produce adversarial images like those in Figure 1, we set the normalized $L _ { 2 }$ -dissimilarity for each of the attacks as follows: ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/cb27099cf36179accd666897d315503aa0039bf2e01d559ec88280cd10dad8bb.jpg",
+        "image_caption": [
+            "Figure 4: Top-1 classification accuracy of ResNet-50 tested on transformed adversarial images produced by four attacks using five image transformations in a gray-box setting: (1) cropping-rescaling, (2) bit-depth reduction, (3) JPEG compression, (4) total variance minimization, and (5) image quilting. The dotted line shows the top-1 accuracy of the ResNet-50 model on non-adversarial images, providing an upper bound on the effectiveness of a defense. An $L _ { 2 }$ -dissimilarity of 0.00 corresponds to the classification accuracy on non-adversarial images. Higher is better. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            256,
+            102,
+            743,
+            401
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            526,
+            825,
+            554
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• FGSM. Increasing the step size $\\epsilon$ increases the normalized $L _ { 2 }$ -dissimilarity.   \n• I-FGSM. We fix $M = 1 0$ , and increase $\\epsilon$ to increase the normalized $L _ { 2 }$ -dissimilarity.   \n• DeepFool. We fix $M = 5$ , and increase $\\epsilon$ to increase the normalized $L _ { 2 }$ -dissimilarity.   \n• CW-L2. We fix $\\kappa = 0$ and $\\lambda _ { f } = 1 0$ , and multiply the resulting perturbation by an appropriately chosen $\\epsilon \\geq 1$ to alter the normalized $L _ { 2 }$ -dissimilarity. ",
+        "bbox": [
+            215,
+            566,
+            823,
+            650
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We fixed the hyperparameters of our defenses in all experiments: specifically, we set pixel dropout probability $p { = } 0 . 5$ and the regularization parameter of the total variation minimizer $\\lambda _ { \\mathrm { T V } } { = } 0 . 0 3$ . We use a quilting patch size of $5 \\times 5$ and a database of $1 , 0 0 0 , 0 0 0$ patches that were randomly selected from the ImageNet training set. We use the nearest neighbor patch (i.e., $K = 1$ ) for experiments in Sections 5.2 and 5.3, and randomly select a patch from one of $K = 1 0$ nearest neighbors in all other experiments. In the cropping defense, we sample 30 crops of size $9 0 \\times 9 0$ from the $2 2 4 \\times 2 2 4$ input image, rescale the crops to $2 2 4 \\times 2 2 4$ , and average the model predictions over all crops. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            761
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2 GRAY BOX: IMAGE TRANSFORMATIONS AT TEST TIME ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            777,
+            598,
+            792
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 4 shows the top-1 accuracy of a ResNet-50 tested on transformed adversarial images as a function of the adversary strength for each of the four attacks. Each plot shows results for five different transformations we apply to the images at test time (viz., image cropping-rescaling, bitdepth reduction, JPEG compression, total variation minimization, and image quilting). The dotted line shows the classification error of the ResNet-50 model on images that are not adversarially perturbed, i.e., it gives an upper bound on the accuracy that defenses can achieve. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In line with the results reported in the literature, the four adversaries successfully attack the ResNet50 model in nearly all cases (FGSM has a slightly lower favorable attack rate of $8 0 - 9 0 \\%$ ) when the input images are not transformed. The results also show that the proposed image transformations are capable of partly eliminating the effect of the attacks. In particular, ensembling 30 predictions over different, random image crops is very efficient: these predictions are correct for $4 0 - 6 0 \\%$ of the images (note that $76 \\%$ is the highest accuracy that one can expect to achieve). This result suggests that adversarial examples are susceptible to changes in the location and scale of the adversarial perturbations. While not as effective, image transformations based on total variation minimization and image quilting also successfully defend against adversarial examples from all four attacks: applying these transformations allows us to classify $3 0 { - } 4 0 \\%$ of the images correctly. This result suggests that total variation minimization and image quilting can successfully remove part of the perturbations from adversarial images. In particular, the accuracy of the image-quilting defense hardly deteriorates as the strength of the adversary increases. However, the quilting transformation does severely impact the model’s accuracy on non-adversarial images. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/e58dbb9814413968996a5583754ff345817e903a1717edd3f9c62704c1811217.jpg",
+        "image_caption": [
+            "Figure 5: Top-1 classification accuracy of ResNet-50 trained and tested on transformed adversarial images produced by four attacks using five image transformations in a black-box setting: (1) cropping-rescaling, (2) bit-depth reduction, (3) JPEG compression, (4) total variance minimization, and (5) image quilting. The dotted line represents the top-1 accuracy of the ResNet-50 model on nonadversarial images, providing an upper bound on the effectiveness of a defense. An $L _ { 2 }$ -dissimilarity of 0.00 corresponds to the classification accuracy on non-adversarial images. Higher is better. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            258,
+            101,
+            743,
+            401
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            527,
+            825,
+            694
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3 BLACK BOX: IMAGE TRANSFORMATIONS AT TRAINING AND TEST TIME ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            714,
+            714,
+            728
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The high relative performance of image cropping-rescaling in 5.2 may be partly explained by the fact that the convolutional network was trained on randomly cropped-rescaled images2, but not on any of the other transformations. This implies that independent of whether an image is adversarial or not, the network is more robust to image cropping-rescaling than it is to those transformations. The results in Figure 4 suggest that this negatively affects the effectiveness of these defenses, even if the defenses are successful in removing the adversarial perturbation. To investigate this, we trained ResNet-50 models on transformed ImageNet training images. We adopt the standard data augmentation from He et al. (2016), but apply bit-depth reduction, JPEG compression, TV minimization, or image quilting on the resized image crop before feeding it to the network. We measure the classification accuracy of the resulting networks on the same adversarial images as before. Note that this implies that we assume a black-box setting in this experiment. ",
+        "bbox": [
+            174,
+            742,
+            825,
+            893
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/6d95e93ae27d2f868e5a3450b3198c6d24b5098c337bb6d20efe82843f75e0c4.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"4\">Quilting</td><td colspan=\"4\">TVM +Quilting</td><td colspan=\"4\">Cropping+TVM+Quilting</td></tr><tr><td></td><td>RN50</td><td>RN101</td><td>DN169</td><td>Iv4</td><td>RN50</td><td>RN101</td><td>DN169</td><td>Iv4</td><td>RN50</td><td>RN101</td><td>DN169</td><td>Iv4</td></tr><tr><td>No Attack</td><td>70.07</td><td>72.56</td><td>70.18</td><td>73.01</td><td>72.38</td><td>74.74</td><td>73.10</td><td>75.55</td><td>72.14</td><td>74.53</td><td>72.92</td><td>75.10</td></tr><tr><td>FGSM</td><td>65.45</td><td>68.50</td><td>65.96</td><td>67.53</td><td>65.70</td><td>68.77</td><td>67.09</td><td>69.19</td><td>66.65</td><td>69.75</td><td>67.86</td><td>70.37</td></tr><tr><td>I-FGSM</td><td>65.59</td><td>68.72</td><td>66.16</td><td>69.29</td><td>65.84</td><td>69.10</td><td>67.32</td><td>71.05</td><td>67.03</td><td>70.14</td><td>68.20</td><td>71.52</td></tr><tr><td>DeepFool</td><td>65.20</td><td>68.73</td><td>65.86</td><td>68.70</td><td>65.80</td><td>69.34</td><td>67.40</td><td>71.03</td><td>67.11</td><td>70.49</td><td>68.62</td><td>71.47</td></tr><tr><td>CW-L2</td><td>64.11</td><td>67.72</td><td>65.00</td><td>68.14</td><td>63.99</td><td>68.20</td><td>66.08</td><td>70.13</td><td>65.31</td><td>69.14</td><td>66.96</td><td>70.50</td></tr></table>",
+        "bbox": [
+            176,
+            101,
+            821,
+            185
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Top-1 classification accuracy of ensemble and model transfer defenses (columns) against four black-box attacks (rows). The four networks we use to classify images are ResNet-50 (RN50), ResNet-101 (RN101), DenseNet-169 (DN169), and Inception-v4 (Iv4). Adversarial images are generated by running attacks against the ResNet-50 model, aiming for an average normalized $L _ { 2 }$ - dissimilarity of 0.06. Higher is better. The best defense against each attack is typeset in boldface. ",
+        "bbox": [
+            173,
+            195,
+            825,
+            265
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We present the results of these experiments in Figure 5. Training convolutional networks on images that are transformed in the same way as at test time, indeed, dramatically improves the effectiveness of all transformation defenses. In our experiments, the image-quilting defense is particularly effective against strong attacks: it successfully defends against $8 0 - 9 0 \\%$ of all four attacks, even when the normalized $L _ { 2 }$ -dissimilarity of the attack approaches 0.08. ",
+        "bbox": [
+            174,
+            291,
+            825,
+            362
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.4 BLACK BOX: ENSEMBLING AND MODEL TRANSFER ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            378,
+            576,
+            393
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the efficacy of (1) ensembling different defenses and (2) “transferring” attacks to different network architectures (in a black-box setting). Specifically, we measured the accuracy of four networks using ensembles of defenses on adversarial images generated to attack a ResNet-50; the four networks we consider are ResNet-50, ResNet-101, DenseNet-169 (Huang et al., 2017), and Inception-v4 (Szegedy et al., 2017). To ensemble the image quilting and TVM defenses, we average the image-quilting prediction (using a weight of 0.5) with model predictions for 10 different TVM reconstructions (with a weight of 0.05 each), re-sampling the pixels used to measure the reconstruction error each time. To combine cropping with other transformations, we first apply those transformations and average predictions over 10 random crops from the transformed images. ",
+        "bbox": [
+            174,
+            405,
+            825,
+            530
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The results of our ensembling experiments are presented in Table 1. The results show that gains of $1 - 2 \\%$ in classification accuracy can be achieved by ensembling different defenses, whereas transferring attacks to different convolutional network architectures can lead to an improvement of $2 - 3 \\%$ . Inception-v4 performs best in our experiments, but this may be partly due to that network having a higher accuracy even in non-adversarial settings. Our best black-box defense achieves an accuracy of about $7 1 \\%$ against all four defenses: the attacks deteriorate the accuracy of our best classifier (which combines cropping, TVM, image quilting, and model transfer) by at most $6 \\%$ . ",
+        "bbox": [
+            174,
+            537,
+            825,
+            635
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.5 GRAY BOX: IMAGE TRANSFORMATIONS AT TRAINING AND TEST TIME ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            651,
+            705,
+            666
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The previous experiments demonstrated the effectiveness of image transformations against adversarial images, in particular, when convolutional networks are re-trained to be robust to those image transformations. In this experiment, we investigate to what extent the resulting networks can be attacked in a gray-box setting in which the adversary has access to those networks (but does not have access to the input transformations applied at test time). We use the four attack methods to generate novel adversarial images against the transformation-robust networks trained in 5.3, and measure the accuracy of the networks on these novel adversarial images in Figure 6. ",
+        "bbox": [
+            174,
+            678,
+            825,
+            775
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The results show that bit-depth reduction and JPEG compression are weak defenses in such a graybox setting. Whilst their relative ordering varies between attack methods, image cropping and rescaling, total variation minimization, and image quilting are fairly robust defenses in the white-box setting. Specifically, networks using these defenses classify up to $5 0 \\%$ of adversarial images correctly. ",
+        "bbox": [
+            174,
+            782,
+            823,
+            838
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.6 COMPARISON WITH PRIOR WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            854,
+            447,
+            869
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In our final set of experiments, we compare our defenses with the state-of-the-art ensemble adversarial training approach proposed by Tramer et al. (2017). Ensemble adversarial training fits the \\` parameters of a convolutional network on adversarial examples that were generated to attack an ensemble of pre-trained models. These adversarial examples are very diverse, which makes the convolutional network being trained robust to a variety of adversarial perturbation. In our experiments, we used the model released by Tramer et al. (2017): an Inception-Resnet-v2 (Szegedy et al., 2016)\\` trained on adversarial examples generated by FGSM against Inception-Resnet-v2 and Inception-v3 models. We compare the model to our ResNet-50 models with image cropping, total variance minimization, and image quilting defenses. We note that there are two small differences in terms of the assumptions that ensemble adversarial training makes and the assumptions our defenses make: (1) in contrast to ensemble adversarial training, our defenses assume that part of the defense strategy (viz., the input transformation) is unknown to the adversary, and (2) in contrast to ensemble adversarial training, our defenses assume no prior knowledge of the attacks being used. The former difference is advantageous to our defenses, whereas the latter difference gives our defenses a disadvantage compared to ensemble adversarial training. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/e25357bdeaa7019fe1216779f702901eab0df83e0824c6b9fef069aac97c257b.jpg",
+        "image_caption": [
+            "Figure 6: Top-1 classification accuracy of ResNet-50 trained and tested on transformed adversarial images produced by four attacks using five image transformations in a gray-box setting: (1) cropping-rescaling, (2) bit-depth reduction, (3) JPEG compression, (4) total variance minimization, and (5) image quilting. The dotted line represents the top-1 accuracy of the ResNet-50 model on non-adversarial images, providing an upper bound on the effectiveness of a defense. $L _ { 2 }$ -dissimilarity of 0 corresponds to clean image accuracy. Higher is better. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            256,
+            102,
+            743,
+            401
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            526,
+            825,
+            694
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 2 compares the classification accuracies of the defense strategief on adversarial examples with a normalized $L _ { 2 }$ -dissimilarity of 0.06. The results show that ensemble adversarial training works better on FGSM attacks (which it uses at training time), but is outperformed by each of the transformation-based defenses all other attacks. Input transformations particularly outperform ensemble adversarial training against the iterative attacks: our defense are are $1 8 - 2 4 \\times$ more robust than ensemble adversarial training against DeepFool attacks. Combining cropping, TVM, and quilting increases the accuracy of our defenses against DeepFool gray-box attacks to $5 1 . 5 1 \\%$ (compared to $1 . 8 4 \\%$ for ensemble adversarial training). ",
+        "bbox": [
+            174,
+            700,
+            825,
+            813
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            834,
+            310,
+            851
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The results from this study suggest there exists a range of image transformations that have the potential to remove adversarial perturbations while preserving the visual content of the image: one merely has to train the convolutional network on images that were transformed in the same way. A critical property that governs which image transformations are most effective in practice is whether ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/10ea05a538fa756dac7a9d765efd9f36a889133a30d4e8176209031edf7f4182.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Cropping</td><td>TVM</td><td>Quilting</td><td>Ensemble Training (Tramer et al., 2017)</td></tr><tr><td>No Attack</td><td>65.41</td><td>66.29</td><td>69.66</td><td>80.3</td></tr><tr><td>FGSM</td><td>49.52</td><td>31.37</td><td>39.55</td><td>69.15</td></tr><tr><td>I-FGSM</td><td>43.89</td><td>40.99</td><td>33.22</td><td>5.07</td></tr><tr><td>DeepFool</td><td>44.92</td><td>44.69</td><td>34.54</td><td>1.84</td></tr><tr><td>CW-L2</td><td>41.06</td><td>48.41</td><td>30.51</td><td>22.23</td></tr></table>",
+        "bbox": [
+            302,
+            101,
+            691,
+            196
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Top-1 classification accuracy on images perturbed using attacks against ResNet-50 models trained on input-transformed images, and an Inception-v4 model trained using ensemble adversarial. Adversarial images are generated by running attacks against the models, aiming for an average normalized $L _ { 2 }$ -dissimilarity of 0.06. The best defense against each attack is typeset in boldface. ",
+        "bbox": [
+            176,
+            207,
+            823,
+            263
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "an adversary can incorporate the transformation in its attack. For instance, median filtering likely is a weak remedy because one can backpropagate through the median filter, which is sufficient to perform any of the attacks described in Section 3. A strong input-transformation defense should, therefore, be non-differentiable and randomized, a strategy has been previously shown to be effective (Wang et al., 2016a;b). Two of our top defenses possess both properties: ",
+        "bbox": [
+            174,
+            294,
+            825,
+            364
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "1. Both total variation minimization and image quilting are difficult to differentiate through. Specifically, total variation minimization involves solving a complex minimization of a function that is inherently random. Image quilting involves a discrete variable that selects the patch from the database, which is a non-differentiable operation, and the graph-cut optimization complicates the use of differentiable approximations (Maddison et al., 2017). 2. Both total variation minimization and image quilting give rise to randomized defenses. Total variation minimization randomly selects the pixels it uses to measure reconstruction error on when creating the denoised image. Image quilting randomly selects one of the $K$ nearest neighbors uniformly at random. The inherent randomness of our defenses makes it difficult to attack the model: it implies the adversary has to find a perturbation that alters the prediction for the entire distribution of images that could be used as input, which is harder than perturbing a single image (Moosavi-Dezfooli et al., 2017). ",
+        "bbox": [
+            212,
+            376,
+            825,
+            553
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our results with gray-box attacks suggest that randomness is particularly important in developing strong defenses. Therefore, we surmise that total variation minimization, image quilting, and related methods (Dong et al., 2011) are stronger defenses than deterministic denoising procedures such as bit-depth reduction, JPEG compression, or non-local means (Buades, 2005). Defenses based on total variation minimization and image quilting also have an advantage over adversarial-training approaches (Kurakin et al., 2016a): an adversarially trained network is differentiable, which implies that it can be attacked using the methods in Section 3. An additional disadvantage of adversarial training is that it focuses on a particular attack; by contrast, transformation-based defenses generalize well across attack methods because they are model-agnostic. ",
+        "bbox": [
+            174,
+            566,
+            825,
+            690
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "While our study focuses exclusively on image classification, we expect similar defenses to be useful in other domains for which successful attacks have been developed, such as semantic segmentation and speech recognition (Cisse et al., 2017a; Zhang et al., 2017). In speech recognition, for example, total variance minimization can be used to remove perturbations from waveforms, and one could develop “spectrogram quilting” techniques that reconstruct a spectrogram by concatenating “spectrogram patches” along the temporal dimension. We leave such extensions to future work. In future work, we also intend to study combinations of our input-transformation defenses with ensemble adversarial training (Tramer et al., 2017), and we intend to investigate new attack methods that are \\` specifically designed to circumvent our input-transformation defenses. ",
+        "bbox": [
+            174,
+            698,
+            825,
+            824
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            849,
+            366,
+            863
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We thank Kilian Weinberger, Iasonas Kokkinos, Changhan Wang, and the entire Facebook AI Research team for helpful discussions and code support. Chuan Guo is supported in part by NSF grant IIS-1618134. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dario Amodei, Rishita Anubhai, Eric Battenberg, Carl Case, Jared Casper, Bryan Catanzaro, Jingdong Chen, Mike Chrzanowski, Adam Coates, Greg Diamos, et al. Deep Speech 2: End-to-end speech recognition in English and Mandarin. CoRR, abs/1512.02595, 2015. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            169
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Battista Biggio, Igino Corona, Davide Maiorca, Blaine Nelson, Nedim Srndi ˇ c, Pavel Laskov, Gior- ´ gio Giacinto, and Fabio Roli. Evasion attacks against machine learning at test time. In Proc. ECML, pp. 387–402, 2013. ",
+        "bbox": [
+            174,
+            179,
+            821,
+            223
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mariusz Bojarski, Davide Del Testa, Daniel Dworakowski, Bernhard Firner, Beat Flepp, Prasoon Goyal, Lawrence D Jackel, Mathew Monfort, Urs Muller, Jiakai Zhang, et al. End-to-end learning for self-driving cars. CoRR, abs/1604.07316, 2016. ",
+        "bbox": [
+            174,
+            233,
+            823,
+            276
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuri Boykov, Olga Veksler, and Ramin Zabih. Fast approximate energy minimization via graph cuts. IEEE Transactions on Pattern Analysis and Machine Intelligence, 23(11):1222–1239, 2001. ",
+        "bbox": [
+            173,
+            286,
+            820,
+            315
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Antoni Buades. A non-local algorithm for image denoising. In Proc. CVPR, pp. 60–65, 2005. ",
+        "bbox": [
+            171,
+            324,
+            789,
+            340
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David A. Wagner. Towards evaluating the robustness of neural networks. In IEEE Symposium on Security and Privacy, pp. 39–57, 2017. ",
+        "bbox": [
+            173,
+            349,
+            825,
+            380
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Moustapha Cisse, Yossi Adi, Natalia Neverova, and Joseph Keshet. Houdini: Fooling deep structured prediction models. CoRR, abs/1707.05373, 2017a. ",
+        "bbox": [
+            171,
+            388,
+            823,
+            417
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Moustapha Cisse, Piotr Bojanowski, Edouard Grave, Yann Dauphin, and Nicolas Usunier. Parseval networks: Improving robustness to adversarial examples. CoRR, abs/1704.08847, 2017b. ",
+        "bbox": [
+            171,
+            428,
+            823,
+            457
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Weisheng Dong, Lei Zhang, and Guangming Shi. Centralized sparse representation for image restoration. In Proc. ICCV, pp. 1259–1266, 2011. ",
+        "bbox": [
+            171,
+            467,
+            823,
+            496
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gintare Karolina Dziugaite, Zoubin Ghahramani, and Daniel Roy. A study of the effect of JPG compression on adversarial images. CoRR, abs/1608.00853, 2016. ",
+        "bbox": [
+            171,
+            505,
+            823,
+            535
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alexei Efros and William Freeman. Image quilting for texture synthesis and transfer. In Proc. SIGGRAPH, pp. 341–346, 2001. ",
+        "bbox": [
+            173,
+            544,
+            821,
+            574
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Analysis of classifiers’ robustness to adversarial perturbations. CoRR, abs/1502.02590, 2015. ",
+        "bbox": [
+            173,
+            583,
+            821,
+            613
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alhussein Fawzi, Seyed-Mohsen Moosavi-Dezfooli, and Pascal Frossard. Robustness of classifiers: From adversarial to random noise. In Proc. NIPS, pp. 1632–1640, 2016. ",
+        "bbox": [
+            173,
+            622,
+            823,
+            651
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tom Goldstein and Stanley Osher. The split Bregman method for L1-regularized problems. SIAM Journal of Imaging Science, 2(2):323–343, April 2009. ",
+        "bbox": [
+            173,
+            661,
+            823,
+            690
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In Proc. ICLR, 2015. ",
+        "bbox": [
+            173,
+            700,
+            825,
+            729
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Abigail Graese, Andras Rozsa, and Terrance E. Boult. Assessing threat of adversarial examples on deep neural networks. CoRR, abs/1610.04256, 2016. ",
+        "bbox": [
+            169,
+            738,
+            825,
+            768
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proc. CVPR, pp. 770–778, 2016. ",
+        "bbox": [
+            173,
+            779,
+            823,
+            808
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Zhuang Liu, Kilian Weinberger, and Laurens van der Maaten. Densely connected convolutional networks. In Proc. CVPR, pp. 2261–2269, 2017. ",
+        "bbox": [
+            171,
+            818,
+            823,
+            847
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Auguste Kerckhoffs. La cryptographie militaire. Journal des sciences militaires, IX:5–83, 161–191, 1883. ",
+        "bbox": [
+            173,
+            856,
+            821,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. CoRR, abs/1611.01236, 2016a.   \nAlexey Kurakin, Ian J. Goodfellow, and Samy Bengio. Adversarial examples in the physical world. CoRR, abs/1607.02533, 2016b.   \nYanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. CoRR, abs/1611.02770, 2016.   \nJiajun Lu, Hussein Sibai, Evan Fabry, and David Forsyth. No need to worry about adversarial examples in object detection in autonomous vehicles. CoRR, abs/1707.03501, 2017.   \nChris Maddison, Andriy Mnih, and Yee-Whye Teh. The concrete distribution: A continuous relaxation of discrete random variables. In Proc. ICLR, 2017.   \nMarco Melis, Ambra Demontis, Battista Biggio, Gavin Brown, Giorgio Fumera, and Fabio Roli. Is deep learning safe for robot vision? adversarial examples against the icub humanoid. CoRR, abs/1708.06939, 2017.   \nSeyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: A simple and accurate method to fool deep neural networks. In Proc. CVPR, pp. 2574–2582, 2016.   \nSeyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Universal adversarial perturbations. In Proc. CVPR, pp. 86–94, 2017.   \nNicolas Papernot, Patrick McDaniel, Xi Wu, Somesh Jha, and Ananthram Swami. Distillation as a defense to adversarial perturbations against deep neural networks. In IEEE Symposium on Security and Privacy, pp. 582–597, 2016.   \nLeonid Rudin, Stanley Osher, and Emad Fatemi. Nonlinear total variation based noise removal algorithms. Physica D, 60:259–268, 1992.   \nUri Shaham, Yutaro Yamada, and Sahand Negahban. Understanding adversarial training: Increasing local stability of neural nets through robust optimization. CoRR, abs/1511.05432, 2015.   \nChristian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In In Proc. ICLR, 2014.   \nChristian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proc. CVPR, pp. 2818–2826, 2016.   \nChristian Szegedy, Sergey Ioffe, Vincent Vanhoucke, and Alexander Alemi. Inception-v4, InceptionResNet and the impact of residual connections on learning. In Proc. AAAI, pp. 4278–4284, 2017.   \nFlorian Tramer, Alexey Kurakin, Nicolas Papernot, Dan Boneh, and Patrick D. McDaniel. Ensemble \\` adversarial training: Attacks and defenses. CoRR, abs/1705.07204, 2017.   \nQinglong Wang, Wenbo Guo, Kaixuan Zhang, Alexander G. Ororbia II, Xinyu Xing, C. Lee Giles, and Xue Liu. Adversary resistant deep neural networks with an application to malware detection. CoRR, abs/1610.01239, 2016a.   \nQinglong Wang, Wenbo Guo, Kaixuan Zhang, Alexander G. Ororbia II, Xinyu Xing, C. Lee Giles, and Xue Liu. Learning adversary-resistant deep neural networks. CoRR, abs/1612.01401, 2016b.   \nWeilin Xu, David Evans, and Yanjun Qi. Feature squeezing: Detecting adversarial examples in deep neural networks. CoRR, abs/1704.01155, 2017.   \nGuoming Zhang, Chen Yan, Xiaoyu Ji, Taimin Zhang, Tianchen Zhang, and Wenyuan Xu. Dolphinatack: Inaudible voice commands. CoRR, abs/1708.09537, 2017. ",
+        "bbox": [
+            171,
+            42,
+            828,
+            859
+        ],
+        "page_idx": 11
+    }
+]

parse/train/eqBwg3AcIAK/eqBwg3AcIAK.md

@@ -0,0 +1,560 @@
+# OFF-DYNAMICS REINFORCEMENT LEARNING: TRAINING FOR TRANSFER WITH DOMAIN CLASSIFIERS
+
+Benjamin Eysenbach∗ CMU, Google Brain beysenba@cs.cmu.edu
+
+Shreyas Chaudhari∗   
+CMU   
+shreyaschaudhari@cmu.edu
+
+Swapnil Asawa∗ University of Pittsburgh swa12@pitt.edu
+
+Sergey Levine UC Berkeley, Google Brain
+
+# Ruslan Salakhutinov CMU
+
+# ABSTRACT
+
+We propose a simple, practical, and intuitive approach for domain adaptation in reinforcement learning. Our approach stems from the idea that the agent’s experience in the source domain should look similar to its experience in the target domain. Building off of a probabilistic view of RL, we achieve this goal by compensating for the difference in dynamics by modifying the reward function. This modified reward function is simple to estimate by learning auxiliary classifiers that distinguish source-domain transitions from target-domain transitions. Intuitively, the agent is penalized for transitions that would indicate that the agent is interacting with the source domain, rather than the target domain. Formally, we prove that applying our method in the source domain is guaranteed to obtain a near-optimal policy for the target domain, provided that the source and target domains satisfy a lightweight assumption. Our approach is applicable to domains with continuous states and actions and does not require learning an explicit model of the dynamics. On discrete and continuous control tasks, we illustrate the mechanics of our approach and demonstrate its scalability to high-dimensional tasks.
+
+# 1 INTRODUCTION
+
+Reinforcement learning (RL) can automate the acquisition of complex behavioral policies through real-world trial-and-error experimentation. However, many domains where we would like to learn policies are not amenable to such trial-and-error learning, because the errors are too costly: from autonomous driving to flying airplanes to devising medical treatment plans, safety-critical RL problems necessitate some type of transfer learning, where a safer source domain, such as a simulator, is used to train a policy that can then function effectively in a target domain. In this paper, we examine a specific transfer learning scenario that we call domain adaptation, by analogy to domain adaptation problems in computer vision (Csurka, 2017), where the training process in a source domain can be modified so that the resulting policy is effective in a given target domain.
+
+RL algorithms today require a large amount of experience in the target domain. However, for many tasks we may have access to a different but structurally similar source domain. While the source domain has different dynamics than the target domain, experience in the source domain is much cheaper to collect. However, transferring policies from one domain to another is challenging because strategies which are effective in the source domain may not be effective in the target domain. For example, aggressive driving may work well on a dry racetrack but fail catastrophically on an icy road.
+
+![](images/dd1cdbe2233b38d10ab85e11dbd145518a0e8f18f8614e93f8e59ff737dc72ee.jpg)  
+Figure 1: Our method acquires a policy for the target domain by practicing in the source domain using a (learned) modified reward function.
+
+While prior work has studied the domain adaptation of observations in RL (Bousmalis et al., 2018;   
+Ganin et al., 2016; Higgins et al., 2017), it ignores the domain adaptation of the dynamics.
+
+This paper presents a simple approach for domain adaptation in RL, illustrated in Fig. 1. Our main idea is that the agent’s experience in the source domain should look similar to its experience in the target domain. Building off of a probabilistic view of RL, we formally show that we can achieve this goal by compensating for the difference in dynamics by modifying the reward function. This modified reward function is simple to estimate by learning auxiliary classifiers that distinguish sourcedomain transitions from target-domain transitions. Because our method learns a classifier, rather than a dynamics model, we expect it to handle high-dimensional tasks better than model-based methods, a conjecture supported by experiments on the 111-dimensional Ant task. Unlike prior work based on similar intuition (Koos et al., 2012; Wulfmeier et al., 2017b), a key contribution of our work is a formal guarantee that our method yields a near-optimal policy for the target domain.
+
+The main contribution of this work is an algorithm for domain adaptation to dynamics changes in RL, based on the idea of compensating for differences in dynamics by modifying the reward function. We call this algorithm Domain Adaptation with Rewards from Classifiers, or DARC for short. DARC does not estimate transition probabilities, but rather modifies the reward function using a pair of classifiers. We formally analyze the conditions under which our method produces nearoptimal policies for the target domain. On a range of discrete and continuous control tasks, we both illustrate the mechanics of our approach and demonstrate its scalability to higher-dimensional tasks.
+
+# 2 RELATED WORK
+
+While our work will focus on domain adaptation applied to RL, we start by reviewing more general ideas in domain adaptation, and defer to Kouw & Loog (2019) for a recent review of the field. Two common approaches to domain adaptation are importance weighting and domain-agnostic features. Importance-weighting methods (e.g., (Zadrozny, 2004; Cortes & Mohri, 2014; Lipton et al., 2018)) estimate the likelihood ratio of examples under the target domain versus the source domain, and use this ratio to re-weight examples sampled from the source domain. Similar to prior work on importance weighting (Bickel et al., 2007; Sønderby et al., 2016; Mohamed & Lakshminarayanan, 2016; Uehara et al., 2016), our method will use a classifier to estimate a probability ratio. Since we will need to estimate the density ratio of conditional distributions (transition probabilities), we will learn two classifiers. Importantly, we will use the logarithm of the density ratio to modify the reward function instead of weighting samples by the density ratio, which is often numerically unstable (see, e.g., Schulman et al. (2017, §3)) and led to poor performance in our experiments.
+
+Prior methods for applying domain adaptation to RL include approaches based on system identification, domain randomization, and observation adaptation. Perhaps the most established approach, system identification (Ljung, 1999), uses observed data to tune the parameters of a simulator (Feldbaum, 1960; Werbos, 1989; Wittenmark, 1995; Ross & Bagnell, 2012; Tan et al., 2016; Zhu et al., 2017b; Farchy et al., 2013) More recent work has successfully used this strategy to bridge the sim2real gap (Chebotar et al., 2019; Rajeswaran et al., 2016). Closely related is work on online system identification and meta-learning, which directly uses the inferred system parameters to update the policy (Yu et al., 2017; Clavera et al., 2018; Tanaskovic et al., 2013; Sastry & Isidori, 1989). However, these approaches typically require either a model of the environment or a manually-specified distribution over potential test-time dynamics, requirements that our method will lift. Another approach, domain randomization, randomly samples the parameters of the source domain and then finds the best policy for this randomized environment (Sadeghi & Levine, 2016; Tobin et al., 2017; Peng et al., 2018; Cutler et al., 2014). While often effective, this method is sensitive to the choice of which parameters are randomized, and the distributions from which these simulator parameters are sampled. A third approach, observation adaptation, modifies the observations of the source domain to appear similar to those in the target domain (Fernando et al., 2013; Hoffman et al., 2016; Wulfmeier et al., 2017a). While this approach has been successfully applied to video games (Gamrian & Goldberg, 2018) and robot manipulation (Bousmalis et al., 2018), it ignores the fact that the source and target domains may have differing dynamics.
+
+Finally, our work is similar to prior work on transfer learning (Taylor & Stone, 2009) and metalearning in RL, but makes less strict assumptions than most prior work. For example, most work on meta-RL (Killian et al., 2017; Duan et al., 2016; Mishra et al., 2017; Rakelly et al., 2019) and some work on transfer learning (Perkins et al., 1999; Tanaka & Yamamura, 2003; Sunmola & Wyatt, 2006) assume that the agent has access to many source tasks, all drawn from the same distribution as the target task. Selfridge et al. (1985); Madden & Howley (2004) assume a manually-specified curriculum of tasks, Ravindran & Barto (2004) assume that the source and target domains have the same dynamics locally, and Sherstov & Stone (2005) assume that the set of actions that are useful in the source domain is the same as the set of actions that will be useful in the target domain. Our method does not require these assumptions, allowing it to successfully learn in settings where these prior works would fail. For example, the assumption of Sherstov & Stone (2005) is violated in our experiments with broken robots: actions which move a joint are useful in the source domain (where the robot is fully-function) but not useful in the target domain (where that joint is disabled). Our method will significantly outperform an importance weighting baseline (Lazaric, 2008). Unlike Vemula et al. (2020), our method does not require learning a dynamics model and is applicable to stochastic environments and those with continuous states and actions. Our algorithm bears a resemblance to that in Wulfmeier et al. (2017b), but a crucial algorithmic difference allows us to prove that our method acquires a near-optimal policy in the target domain, and also leads to improved performance empirically.
+
+The theoretical derivation of our method is inspired by prior work which formulates control as a problem of probabilistic inference (e.g., (Toussaint, 2009; Rawlik et al., 2013; Levine et al., 2018)). Algorithms for model-based RL (e.g., (Deisenroth & Rasmussen, 2011; Hafner et al., 2018; Janner et al., 2019)) and off-policy RL (e.g., (Munos et al., 2016; Fujimoto et al., 2018; Dann et al., 2014; Dud´ık et al., 2011) similarly aim to improve the sample efficiency of RL, but do use the source domain to accelerate learning. Our method is applicable to any maximum entropy RL algorithm, including on-policy (Song et al., 2019), off-policy (Abdolmaleki et al., 2018; Haarnoja et al., 2018), and model-based (Janner et al., 2019; Williams et al., 2015) algorithms. We will use the SAC (Haarnoja et al., 2018) in our experiments and compare against model-based baselines.
+
+# 3 PRELIMINARIES
+
+In this section, we introduce notation and formally define domain adaptation for RL. Our problem setting will consider two MDPs: ${ \mathcal { M } } _ { \mathrm { s o u r c e } }$ represents the source domain (e.g., a practice facility, simulator, or learned approximate model of the target domain) while ${ \mathcal { M } } _ { \mathrm { t a r g e t } }$ represents a the target domain. We assume that the two domains have the same state space $s$ , action space $\mathcal { A }$ , reward function $r$ , and initially state distribution $p _ { 1 } ( s _ { 1 } )$ ; the only difference between the domains is the dynamics, $p _ { \mathrm { s o u r c e } } ( s _ { t + 1 } \mid s _ { t } , a _ { t } )$ and $p _ { \mathrm { t a r g e t } } ( s _ { t + 1 } \mid s _ { t } , a _ { t } )$ . We will learn a Markovian policy $\pi _ { \boldsymbol { \theta } } ( \boldsymbol { a } \mid \boldsymbol { s } )$ , parametrized by $\theta$ . Our objective is to learn a policy $\pi$ that maximizes the expected discounted sum of rewards on $\mathcal { M } _ { \mathrm { t a r g e t } }$ $\mathrm { _ { t } } , \mathbb { E } _ { \pi , \mathcal { M } _ { \mathrm { t a r g e t } } } [ \sum _ { t } \gamma ^ { t } r ( s _ { t } , a _ { t } ) ]$ . We now formally define our problem setting:
+
+Definition 1. Domain Adaptation for $\pmb { R L }$ is the problem of using interactions in the source MDP $\mathcal { M } _ { s o u r c e }$ together with a small number of interactions in the target MDP $\mathcal { M } _ { t a r g e t }$ to acquire a policy that achieves high reward in the target MDP, $\mathcal { M } _ { t a r g e t }$ .
+
+We will assume every transition with non-zero probability in the target domain will have non-zero probability in the source domain:
+
+$$
+p _ { \mathrm { t a r g e t } } ( s _ { t + 1 } \mid s _ { t } , a _ { t } ) > 0 \implies p _ { \mathrm { s o u r c e } } ( s _ { t + 1 } \mid s _ { t } , a _ { t } ) > 0 \qquad \mathrm { f o r ~ a l l ~ } s _ { t } , s _ { t + 1 } \in \mathcal { S } , a _ { t } \in \mathcal { A } .
+$$
+
+This assumption is common in work on importance sampling (Koller & Friedman, 2009, $\ S 1 2 . 2 . 2 )$ , and the converse need not hold: transitions that are possible in the source domain need not be possible in the target domain. If this assumption did not hold, then the optimal policy for the target domain might involve behaviors that are not possible in the source domain, so it is unclear how one could learn a near-optimal policy by practicing in the source domain.
+
+# 4 A VARIATIONAL PERSPECTIVE ON DOMAIN ADAPTATION IN RL
+
+The probabilistic inference interpretation of RL (Kappen, 2005; Todorov, 2007; Toussaint, 2009; Ziebart, 2010; Rawlik et al., 2013; Levine, 2018) treats the reward function as defining a desired distribution over trajectories. The agent’s task is to sample from this distribution by picking trajectories with probability proportional to their exponentiated reward. This section will reinterpret this model in the context of domain transfer, showing that domain adaptation of dynamics can be done by modifying the rewards. To apply this model to domain adaptation, define $p ( \tau )$ as the desired distribution over trajectories in the target domain,
+
+$$
+p ( \tau ) \propto p _ { 1 } ( s _ { 1 } ) \bigg ( \prod _ { t } p _ { \mathrm { t a r g e t } } ( s _ { t + 1 } \mid s _ { t } , a _ { t } ) \bigg ) \exp \bigg ( \sum _ { t } r ( s _ { t } , a _ { t } ) \bigg ) ,
+$$
+
+and $q ( \tau )$ as our agent’s distribution over trajectories in the source domain,
+
+$$
+q ( \tau ) = p _ { 1 } ( s _ { 1 } ) \prod _ { t } p _ { \mathrm { s o u r c e } } ( s _ { t + 1 } \mid s _ { t } , a _ { t } ) \pi _ { \theta } ( a _ { t } \mid s _ { t } ) .
+$$
+
+As noted in Section 3, we assume both trajectory distributions have the same initial state distribution. Our aim is to learn a policy whose behavior in the source domain both receives high reward and has high likelihood under the target domain dynamics. We codify this objective by minimizing the reverse KL divergence between these two distributions:
+
+$$
+\operatorname* { m i n } _ { \pi ( a \mid s ) } D _ { \mathrm { K L } } ( q \parallel p ) = - \mathbb { E } _ { p _ { \mathrm { s o u r c } } } \bigg [ \sum _ { t } r ( s _ { t } , a _ { t } ) + \mathcal { H } _ { \pi } [ a _ { t } \mid s _ { t } ] + \Delta r ( s _ { t + 1 } , s _ { t } , a _ { t } ) \bigg ] + c ,
+$$
+
+where
+
+$$
+\Delta r ( s _ { t + 1 } , s _ { t } , a _ { t } ) \triangleq \log p ( s _ { t + 1 } \mid s _ { t } , a _ { t } ) - \log q ( s _ { t + 1 } \mid s _ { t } , a _ { t } ) .
+$$
+
+The constant $c$ is the partition function of $p ( \tau )$ , which is independent of the policy and dynamics. While $\Delta r$ is defined in terms of transition probabilities, in Sec. 5 we show how to estimate $\Delta r$ by learning a classifier. We therefore call our method domain adaptation with rewards from classifiers (DARC), and will use $\pi _ { \mathrm { D A R C } } ^ { * }$ to refer to the policy that maximizes the objective in Eq. 2.
+
+Where the source and target dynamics are equal, the correction term $\Delta r$ is zero and we recover maximum entropy RL (Ziebart, 2010; Todorov, 2007). The reward correction is different from prior work that adds $\log \beta ( a \mid s )$ to the reward to regularize the policy to be close to the behavior policy $\beta$ (e.g., Jaques et al. (2017); Abdolmaleki et al. (2018)). In the case where the source dynamics are not equal to the true dynamics, this objective is not the same as maximum entropy RL on trajectories sampled from the source domain. Instead, this objective suggests a corrective term $\Delta r$ that should be added to the reward function to account for the discrepancy between the source and target dynamics. The correction term, $\Delta r$ , is quite intuitive. If a transition $\left( { { s _ { t } } , { a _ { t } } , { s _ { t + 1 } } } \right)$ has equal probability in the source and target domains, then $\Delta r ( s _ { t } , a _ { t } ) = 0$ so no correction is applied. For transitions that are likely in the source but are unlikely in the target domain, $\Delta r < 0$ , the agent is penalized for “exploiting” inaccuracies or discrepancies in the source domain by taking these transitions. For the example environment in Figure 1, transitions through the center of the environment are blocked in the target domain but not in the source domain. For these transitions, $\Delta r$ would serve as a large penalty, discouraging the agent from taking these transitions and instead learning to navigate around the wall. Appendix A presents additional interpretations of $\Delta r$ in terms of coding theory, mutual information, and a constraint on the discrepancy between the source and target dynamics. Appendix C discusses how prior work on domain agnostic feature learning can be viewed as a special case of our framework.
+
+# 4.1 THEORETICAL GUARANTEES
+
+We now analyze when maximizing the modified reward $r + \Delta r$ in the source domain yields a nearoptimal policy for the target domain. Our proof relies on the following lightweight assumption:
+
+Assumption 1. Let $\begin{array} { r } { \pi ^ { * } = \arg \operatorname* { m a x } _ { \pi } \mathbb { E } _ { p } \left[ \sum r ( s _ { t } , a _ { t } ) \right] } \end{array}$ be the reward-maximizing policy in the target domain. Then the expected reward in the source and target domains differs by at most $2 R _ { m a x } \sqrt { \epsilon / 2 }$ :
+
+$$
+\left| \mathbb { E } _ { p _ { \pi ^ { * } , s o u r c } } \left[ \sum r ( s _ { t } , a _ { t } ) \right] - \mathbb { E } _ { \pi ^ { * } , p _ { t a r g e t } } \left[ \sum r ( s _ { t } , a _ { t } ) \right] \right| \leq 2 R _ { m a x } \sqrt { \epsilon / 2 } .
+$$
+
+The variable $R _ { \mathrm { m a x } }$ refers to the maximum entropy-regularized return of any trajectory. This assumption says that the optimal policy in the target domain is still a good policy for the source domain, and its expected reward is similar in both domains. We do not require that the opposite be true: the optimal policy in the source domain does not need to receive high reward in the target domain. If there are multiple optimal policies, we only require that this assumption hold for one of them. We now state our main result:
+
+1: Input: source MDP ${ \mathcal { M } } _ { \mathrm { s o u r c e } }$ and target $\mathcal { M } _ { \mathrm { t a r g e t } }$ ; ratio $r$ of experience from source vs. target.   
+2: Initialize: replay buffers for source and target transitions, $\mathcal { D } _ { \mathrm { s o u r c e } }$ , $\mathcal { D } _ { \mathrm { t a r g e t } }$ ; policy $\pi$ ; parameters   
+$\theta = ( \theta _ { \mathrm { S A S } } , \theta _ { \mathrm { S A } } )$ for classifiers $q _ { \theta _ { \mathrm { S A S } } }$ (target $\mid s _ { t } , a _ { t } , s _ { t + 1 } \rangle$ and $q _ { \theta _ { \mathrm { S A S } } }$ (target $\mid s _ { t } , a _ { t } )$ .   
+3: for $t = 1 , \cdots$ , num iterations do   
+4: ${ \mathcal { D } } _ { \mathrm { s o u r c e } } \gets { \mathcal { D } } _ { \mathrm { s o u r c e } } \cup \operatorname { R O L L O U T } ( \pi , { \mathcal { M } } _ { \mathrm { s o u r c e } } )$ $\triangleright$ Collect source data.   
+5: if $t$ mod $r = 0$ then $\triangleright$ Periodically, collect target data.   
+6: ${ \mathcal { D } } _ { \mathrm { t a r g e t } }  { \mathcal { D } } _ { \mathrm { t a r g e t } } \cup \mathrm { R o L L O U T } ( \pi , { \mathcal { M } } _ { \mathrm { t a r g e t } } )$   
+7: $\theta  \theta - \eta \nabla _ { \theta } \ell ( \theta )$ $\triangleright$ Update both classifiers.   
+8: $\tilde { r } ( s _ { t } , a _ { t } , s _ { t + 1 } ) \gets r ( s _ { t } , a _ { t } ) + \Delta r ( s _ { t } , a _ { t } , s _ { t + 1 } )$ . $\Delta r$ is computed with Eq. 3.   
+9: π ← MAXENT RL(π, Dsource, r˜)
+
+10: return $\pi$
+
+Theorem 4.1. Let $\pi _ { D A R C } ^ { * }$ be the policy that maximizes the modified (entropy-regularized) reward in the source domain, let $\pi ^ { * }$ be the policy that maximizes the (unmodified, entropy-regularized) reward in the target domain, and assume that $\pi ^ { * }$ satisfies Assumption $^ { l }$ . Then the following holds:
+
+$$
+\mathbb { E } _ { p _ { u n c t } , \pi _ { \mathrm { A R C } } ^ { \star } } \left[ \sum r ( s _ { t } , a _ { t } ) + \mathcal { H } [ a _ { t } \mid s _ { t } ] \right] \geq \mathbb { E } _ { p _ { u n c t } , \pi ^ { \star } } \left[ \sum r ( s _ { t } , a _ { t } ) + \mathcal { H } [ a _ { t } \mid s _ { t } ] \right] - 4 R _ { m a x } \sqrt { \epsilon / 2 } .
+$$
+
+See Appendix B for the proof and definition of $\epsilon$ . This result says that $\pi _ { \mathrm { D A R C } } ^ { * }$ attains near-optimal (entropy-regularized) reward on the target domain. Thus, we can expect that modifying the reward function should allow us to adapt to different dynamics. The next section will present a practical algorithm for acquiring $\pi _ { \mathrm { D A R C } } ^ { * }$ by estimating and effectively maximizing the modified reward in the source domain.
+
+# 5 DOMAIN ADAPTATION IN RL WITH A LEARNED REWARD
+
+The variational perspective on model-based RL in the previous section suggests that we should modify the reward in the source domain by adding $\Delta r$ . In this section we develop a practical algorithm for off-dynamics RL by showing how $\Delta r$ can be estimated without learning an explicit dynamics model.
+
+To estimate $\Delta r$ , we will use a pair of (learned) binary classifiers, which will infer whether transitions came from the source or target domain. The key idea is that the transition probabilities are related to the classifier probabilities via Bayes’ rule:
+
+![](images/e0a247913ddee8afe9493eb27bacf92bbc818e82cc3e9be07c828750bc179ff4.jpg)  
+Figure 2: Block diagram of DARC (Alg. 1)
+
+$$
+p ( \mathrm { t a r g e t } \mid s _ { t } , a _ { t } , s _ { t + 1 } ) = \underbrace { p ( s _ { t + 1 } \mid s _ { t } , a _ { t } , \mathrm { t a r g e t } ) } _ { = p _ { \mathrm { t a r g e t } } ( s _ { t + 1 } \mid s _ { t } , a _ { t } ) } p ( s _ { t } , a _ { t } \mid \mathrm { t a r g e t } ) p ( \mathrm { t a r g e t } ) / p ( s _ { t } , a _ { t } , s _ { t + 1 } ) .
+$$
+
+We estimate the term $p ( s _ { t } , a _ { t } \ )$ target) on the RHS via another classifier, $p ( \mathrm { t a r g e t } \mid s _ { t } , a _ { t } )$
+
+$$
+p ( s _ { t } , a _ { t } \mid \mathrm { t a r g e t } ) = \frac { p ( \mathrm { t a r g e t } \mid s _ { t } , a _ { t } ) p ( s _ { t } , a _ { t } ) } { p ( \mathrm { t a r g e t } ) } .
+$$
+
+Substituting these expression into our definition for $\Delta r$ and simplifying, we obtain an estimate for $\Delta r$ that depends solely on the predictions of these two classifiers:
+
+$$
+\begin{array} { r } { \Delta r ( s _ { t } , a _ { t } , s _ { t + 1 } ) = \underbrace { \log p ( \mathrm { t a r g e t } \mid s _ { t } , a _ { t } , s _ { t + 1 } ) } _ { \substack { \dots \dots \dots \dots \dots \dots \dots \dots \dots } } - \underbrace { \log p ( \mathrm { t a r g e t } \mid s _ { t } , a _ { t } ) } _ { \substack { - - \dots - \dots - \dots - - \dots - - \dots - } } } \\ { \infty \underbrace { \log p ( \mathrm { s o u r c e } \mid s _ { t } , a _ { t } , s _ { t + 1 } ) } _ { \substack { \dots \dots \dots \dots \dots \dots \dots } } + \underbrace { \log p ( \mathrm { s o u r c e } \mid s _ { t } , a _ { t } ) } _ { \substack { - \dots \dots \dots \dots - \dots \dots } } } \end{array}
+$$
+
+The . . . . . . . .orange terms are the difference in logits from the classifier conditioned on $s _ { t } , a _ { t } , s _ { t + 1 }$ , while the blue terms are the difference in logits from the classifier conditioned on just $s _ { t } , a _ { t }$ . Intuitively, $\Delta r$ answers the following question: for the task of predicting whether a transition came from the source or target domain, how much better can you perform after observing $s _ { t + 1 } ?$ We make this connection precise in Appendix A.2 by relating $\Delta r$ to mutual information. Ablation experiments (Fig. 7) confirm that both classifiers are important to the success of our method. The use of transition classifiers makes our method look somewhat similar to adversarial imitation learning (Ho & Ermon, 2016; Fu et al., 2017). While our method is not solving an imitation learning problem (we do not assume access to any expert experience), our method can be interpreted as learning a policy such that the dynamics observed by that policy in the source domain imitate the dynamics of the target domain.
+
+Algorithm Summary Our algorithm modifies an existing MaxEnt RL algorithm to additionally learn two classifiers, $q _ { \theta _ { \mathrm { S A S } } }$ (target $\mid s _ { t } , a _ { t } , s _ { t + 1 } \big )$ and $q _ { \theta _ { \mathrm { S A } } } ( \mathrm { t a r g e t } \ | \ s _ { t } , a _ { t } )$ , parametrized by $\theta _ { \mathrm { S A S } }$ and $\theta _ { \mathrm { S A } }$ respectively, to minimize the standard cross-entropy loss.
+
+$$
+\begin{array} { r l } & { \ell _ { \mathrm { S A S } } ( \theta _ { \mathrm { S A S } } ) \triangleq - \mathbb { E } _ { \mathcal { D } _ { \mathrm { t a g e l } } } \left[ \log q _ { \theta _ { \mathrm { S A S } } } ( \mathrm { t a r g e t } \mid s _ { t } , a _ { t } , s _ { t + 1 } ) \right] - \mathbb { E } _ { \mathcal { D } _ { \mathrm { s o u r c } } } \left[ \log q _ { \theta _ { \mathrm { S A } } } ( \mathrm { s o u r c e } \mid s _ { t } , a _ { t } , s _ { t + 1 } ) \right] } \\ & { \quad \ell _ { \mathrm { S A } } ( \theta _ { \mathrm { S A } } ) \triangleq - \mathbb { E } _ { \mathcal { D } _ { \mathrm { t a g e l } } } \left[ \log q _ { \theta _ { \mathrm { S A } } } ( \mathrm { t a r g e t } \mid s _ { t } , a _ { t } ) \right] - \mathbb { E } _ { \mathcal { D } _ { \mathrm { s a r c } } } \left[ \log q _ { \theta _ { \mathrm { S A } } } ( \mathrm { s o u r c e } \mid s _ { t } , a _ { t } ) \right] . } \end{array}
+$$
+
+Our algorithm, Domain Adaptation with Rewards from Classifiers (DARC), is presented in Alg. 1 and illustrated in Fig. 2. To simplify notation, we define $\theta \triangleq ( \theta _ { \mathrm { S A S } } , \theta _ { \mathrm { S A } } )$ and $\ell ( \theta ) \triangleq \ell _ { \mathrm { S A S } } ( \theta _ { \mathrm { S A S } } ) +$ $\ell _ { \mathrm { S A } } ( \theta _ { \mathrm { S A } } )$ . At each iteration, we collect transitions from the source and (less frequently) target domain, storing the transitions in separate replay buffers. We then sample a batch of experience from both buffers to update the classifiers. We use the classifiers to modify the rewards from the source domain, and apply MaxEnt RL to this experience. We use SAC (Haarnoja et al., 2018) as our MaxEnt RL algorithm, but emphasize that DARC is applicable to any MaxEnt RL algorithm (e.g., on-policy, off-policy, and model-based). When training the classifiers, we add Gaussian input noise to prevent overfitting to the small number of target-domain transitions (see Fig. 7 for an ablation).
+
+# 6 EXPERIMENTS
+
+We start with a didactic experiment to build intuition for the mechanics of our method, and then evaluate on more complex tasks. Our experiments will show that DARC outperforms alternative approaches, such as directly applying RL to the target domain or learning importance weights. We will also show that our method can account for domain shift in the termination condition, and confirm the importance of learning two classifiers.
+
+Illustrative example. We start with a simple gridworld example, shown on the right, where we can apply our method without function approximation. The goal is to navigate from the top left to the bottom left. The real environment contains an obstacle (shown in red), which is not present in the source domain. If we simply apply RL on the source domain, we obtain
+
+![](images/dec0bdb6427ae0ddde0970b69d291280ec55f9e291c127110044144a8fb9ba4a.jpg)  
+Figure 3: Tabular example of off-dynamics RL
+
+a policy that navigates directly to the goal (blue arrows), and will fail when used in the target domain. We then apply our method: we collect trajectories from the source domain and real world to fit the two tabular classifiers. These classifiers give us a modified reward, which we use to learn a policy in the source domain. The modified reward causes our learned policy to navigate around the obstacle, which succeeds in the target environment.
+
+Visualizing the reward modification in stochastic domains. In our next experiment, we use an “archery” task to visualize how the modified reward accounts for differences in dynamics. The task, shown in Fig. 4, requires choosing an angle at which to shoot an arrow. The practice range (i.e., the source domain) is outdoors, with wind that usually blows from left to right. The competition range (i.e., the target domain) is indoors with no wind. The reward is the negative distance to the target. We
+
+![](images/d290777cdc5e0933a700ee49e2e59ffc5cca741db3e3c13529e8e5c66932e29f.jpg)  
+Figure 4: Visualizing the modified reward
+
+![](images/5f7812a2c99e354e76fb227ea186865a01eb106c0d04dfffe165170a8aa671c4.jpg)  
+Figure 6: DARC compensates for crippled robots and obstacles: We apply DARC to four continuous control tasks: three tasks (broken reacher, half cheetah, and ant) which are crippled in the target domain but not the source domain, and one task (half cheetah obstacle) where the source domain omits the obstacle from the target domain. Note that na¨ıvely ignoring the shift in dynamics (green dashed line) performs quite poorly, while directly learning on the crippled robot requires an order of magnitude more experience than our method.
+
+plot the reward as a function of the angle in both domains in Fig. 4. The optimal strategy for the outdoor range is to compensate for the wind by shooting slightly to the left $\mathopen { } \mathclose \bgroup \left( \theta = - 0 . 8 \aftergroup \egroup \right)$ , while the optimal strategy for the indoor range is to shoot straight ahead $\boldsymbol \theta = 0$ ). We estimate the modified reward function with DARC, and plot the modified reward in the windy outdoor range and indoor range. We aggregate across episodes using $J ( \theta ) = \log \mathbb { E } _ { p ( s ^ { \prime } \mid \theta ) } [ \exp ( r ( s ^ { \prime } ) ) ]$ ; see Appendix E.4 for details. We observe that maximizing the modified reward in the windy range does not yield high reward in the windy range, but does yield a policy that performs well in the indoor range.
+
+Scaling to more complex tasks. We now apply DARC to the more complex tasks shown in Fig. 5. We define three tasks by crippling one of the joints of each robot in the target domain, but using the fully-functional robot in the source domain. We use three simulated robots taken from OpenAI Gym (Brockman et al., 2016): 7
+
+![](images/4f2f4a34cfd5a708327ff20783988e426d6f24c0d8cbbd8f41f54c7ef4c057be.jpg)  
+Figure 5: Environments: broken reacher, broken half cheetah, broken ant, and half cheetah obstacle.
+
+DOF reacher, half cheetah, and ant. The broken reacher is based on the task described by Vemula et al. (2020). We also include a task where the shift in dynamics is external to the robot, by modifying the cheetah task to reward the agent for running both forward and backwards. It is easier to learn to run backwards, an obstacle in the target domain prevents the agent from running backwards. This “half cheetah obstacle” task does not entirely satisfy the assumption in Eq. 1 because transitions such as bouncing off the obstacle are only possible in the target domain, not the source domain. Nonetheless, the success of our method on this task illustrates that DARC can excel even in settings that do not satisfy the assumption in Eq. 1.
+
+We compare our method to eight baselines. RL on Source and RL on Target directly perform RL on the source and target domains, respectively. The Finetuning baseline takes the result of running RL on the source domain, and further finetunes the agent on the target domain. The Importance Weighting baseline performs RL on importance-weighted samples from the source domain; the importance weights are $\exp ( \Delta r )$ . Recall that DARC collects many $( r \ = \ 1 0 )$ ) transitions in the source domain and performs many gradient updates for each single transition collected in the target domain (Alg. 1 Line 5). We therefore compared against a RL on Target $\mathbf { ( 1 0 x ) }$ baseline that likewise performs many $\mathit { r } = 1 0 $ ) gradient updates per transition in the target domain. Next, we compared against two recent model-based RL methods: MBPO (Janner et al., 2019) and PETS (Chua et al., 2018). Finally, we also compared against MATL (Wulfmeier et al., 2017b), which is similar in spirit to our method but uses a different modified reward.
+
+We show the results of this experiment in Fig. 6, plotting the reward on the target domain as a function of the number of transitions in the target domain. In this figure, the transparent lines correspond to different random seeds, and the darker lines are the average of these random seeds. On all tasks, the RL on source baseline (shown as a dashed line because it observes no target transitions) performs considerably worse than the optimal policy from RL on the target domain, suggesting that good policies for the source domain are suboptimal for the target domain. Nonetheless, on three of the four tasks our method matches (or even surpasses) the asymptotic performance of doing RL on the target domain, despite never doing RL on experience from the target domain, and despite observing $5 - 1 0 \times$ less experience from the target domain. On the broken reacher and broken half cheetah tasks, finetuning on the target domain performs on par with our method. On the simpler broken reacher task, just doing RL on the target domain with a large number of gradient steps works quite well (we did not tune this parameter for our method). While the model-based baselines (PETS and MBPO) also performed well on for low-dimensional tasks (broken reacher, broken half cheetah), they perform quite poorly on more challenging tasks like broken ant, supporting our intuition that classification is easier than learning a dynamics model in high dimensional tasks. Finally, DARC outperforms MATL on all tasks.
+
+![](images/dd381c863b8c286577448d24ed8d582cef0adeb599247482126133fd2863cc06.jpg)  
+Figure 7: Ablation experiments (Left) DARC performs worse when only one classifier is used. (Right) Using input noise to regularize the classifiers boosts performance. Both plots show results for broken reacher; see Appendix D for results on all environments.
+
+Ablation Experiments. Our next experiment examines the importance of using two classifiers to estimate $\Delta r$ . We compared our method to an ablation that does not learn the SA classifier, effectively ignoring the blue terms in Eq. 3. As shown in Fig. 7 (left), this ablation performs considerably worse than our method. Intuitively, this makes sense: we might predict that a transition came from the source domain not because the next state had higher likelihood under the source dynamics, but rather because the state or action was visited more frequently in the source domain. The second classifier used in our method corrects for this distribution shift.
+
+Next, we examine the importance of input noise regularization in classifiers. As we observe only a handful of transitions from the target domain, we hypothesized that regularization would be important to prevent overfitting. We test this hypothesis in Fig. 7 (right) by training our method on the broken reacher environment with varying amounts of input noise. With no noise or little noise our method performs poorly (likely due to overfitting); too much noise also performs poorly (likely due to underfitting). We used a value of 1 in all our experiments, and did not tune this value. See Appendix D for more plots of both ablation experiments.
+
+To gain more intuition for our method, we recorded the reward correction $\Delta r$ throughout training on the broken reacher environment. In this experiment, we ran RL on the source domain for $1 0 0 \mathrm { k }$ steps before switching to our method. Said another way, we ignored $\Delta r$ for the first $1 0 0 \mathrm { k }$ steps of training. As shown in Fig. 8, $\Delta r$ steadily decreases during these first 100k steps, suggesting that the agent is learning a strategy that takes transitions where the source domain and target domain have different dynamics: the agent is making use of its broken joint. After $1 0 0 \mathrm { k }$ steps, when we maximize the combination of task reward and $\Delta r$ , we observe that $\Delta r$ increases, so the agent’s transitions in the source domain are increasingly consistent with target domain dynamics. After around 1e6
+
+![](images/d882a1da51e2aa480c9b44f596328ca7b9ca092c20fc090d4fa782a8b9b2bf12.jpg)  
+Figure 8: Without the reward correction, the agent takes transitions where the source domain and target domains are dissimilar; after adding the reward correction, the agent’s transitions in the source domain are increasingly likely under the target domain.
+
+training steps $\Delta r$ is zero: the agent has learned a strategy that uses transitions that are indistinguishable between the source and target domains.
+
+Safety emerges from domain adaptation to the termination condition. In many safety-critical applications, the real-world and simulator have different safeguards, which kick in to stop the agent and terminate the episode. For an agent to effectively transfer from the simulator to the real world, it cannot rely on safeguards which are present in one domain but not the other. Since this termination condition is part of the dynamics (White, 2017), we can readily apply DARC to this setting.
+
+We use the humanoid shown in Fig. 9 for this experiment and set the task reward to 0. In the source domain episodes have a fixed length of 300 steps; in the target domain the episode terminates when the robot falls. The scenario mimics the real-world setting where robots have freedom to practice in a safe, cushioned, practice facility, but are preemptively stopped when they try to take unsafe actions in the real world. Our aim is for the agent to learn to avoid unsafe transitions in the source domain
+
+![](images/68f4bd8e15352b34a0e33cfaac6134ff4bcd751d46da6900f5fcf1450d04efdc.jpg)  
+Figure 9: Our method accounts for domain shift in the termination condition, causing the agent to avoid transitions that cause termination in the target domain.
+
+that would result in episode termination in the target domain. As shown in Fig. 9, our method learns to remain standing for nearly the entire episode. As expected, baselines that maximize the zero reward on the source and target domains fall immediately. While DARC was not designed as a method for safe RL (Tamar et al., 2013; Achiam et al., 2017; Eysenbach et al., 2017; Berkenkamp et al., 2017), this experiment suggests that safety may emerge automatically from DARC, without any manual reward function design.
+
+Comparison with Prior Transfer Learning Methods. We are not the first work that modifies the reward function to perform transfer in RL (Koos et al., 2012), nor the first work to learn how to modify the reward function (Wulfmeier et al., 2017a). However, these prior works lack theoretical justification. In contrast, our approach maximizes a welldefined variational objective and our analysis guarantees that agents learned with our method will achieve similar rewards in the source and target domains. Our formal guarantees (Sec. 4)
+
+![](images/f97ce598a339f645e35280b9c172dfb4acfc3a344f05eaa9b61a1b982971cc67.jpg)  
+Figure 10: Comparison with MATL
+
+do not apply to MATL (Wulfmeier et al., 2017b) because their classifier is not conditioned on the action. Indeed, our results on the four tasks in Fig. 6 indicate that DARC ourperforms MATL on all tasks. To highlight this difference, we compared DARC and MATL on a gridworld (right), where the source and target domains differed by assigning opposite effects to the “up” and “down” in the purple state in the source and target domains. We collected data from a uniform random policy, so the marginal distribution $p ( s _ { t + 1 } \mid s _ { t } )$ was the same in the source and target domains, even though the dynamics $p ( s _ { t + 1 } \mid s _ { t } , { \dot { a } } _ { t } )$ where different. In this domain, MATL fails to recognize that the source and target domains are different. DARC succeeds in this task for $80 \%$ of trials while MATL succeeds for $0 \%$ of trials. We conclude that the conditioning on the action, as suggested by our analysis, is especially important when using experience collected from stochastic policies.
+
+# 7 DISCUSSION
+
+In this paper, we proposed a simple, practical, and intuitive approach for domain adaptation to changing dynamics in RL. We motivate this method from a novel variational perspective on domain adaptation in RL, which suggests that we can compensate for differences in dynamics via the reward function. Moreover, we formally prove that, subject to a lightweight assumption, our method is guaranteed to yield a near-optimal policy for the target domain. Experiments on a range of control tasks show that our method can leverage the source domain to learn policies that will work well in the target domain, despite observing only a handful of transitions from the target domain.
+
+Limitations The main limitation of our method is that the source dynamics must be sufficiently stochastic, an assumption that can usually be satisfied by adding noise to the dynamics, or ensembling a collection of sources. Empirically, we found that our method worked best on tasks that could be completed in many ways in the source domain, but some of these strategies were not compatible with the target dynamics. The main takeaway of this work is that inaccuracies in dynamics can be compensated for via the reward function. In future work we aim to use the variation perspective on domain adaptation (Sec. 4) to learn the dynamics for the source domain.
+
+Acknowledgements. We thank Anirudh Vemula for early discussions; we thank Karol Hausman, Vincent Vanhoucke and anonymous reviews for feedback on drafts of this work. We thank Barry Moore for providing containers with MuJoCo and Dr. Paul Munro granting access to compute at CRC. This work is supported by the Fannie and John Hertz Foundation, University of Pittsburgh Center for Research Computing (CRC), NSF (DGE1745016, IIS1763562), ONR (N000141812861), and US Army. Any opinions, findings and conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the National Science Foundation.
+
+Contributions. BE proposed the idea of using rewards to correct for dynamics, designed and ran many of the experiments in the paper, and wrote much of the paper. SA did the initial literature review, wrote and designed some of the DARC experiments and environments, developed visualizations of the modified reward function, and ran the MBPO experiments. SC designed some of the initial environments, helped with the implementation of DARC, and ran the PETS experiments. RS and SL provided guidance throughout the project, and contributed to the structure and writing of the paper.
+
+# REFERENCES
+
+Abbas Abdolmaleki, Jost Tobias Springenberg, Yuval Tassa, Remi Munos, Nicolas Heess, and Martin Riedmiller. Maximum a posteriori policy optimisation. arXiv preprint arXiv:1806.06920, 2018.
+
+Joshua Achiam, David Held, Aviv Tamar, and Pieter Abbeel. Constrained policy optimization. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 22–31. JMLR. org, 2017.
+
+Felix Berkenkamp, Matteo Turchetta, Angela Schoellig, and Andreas Krause. Safe model-based reinforcement learning with stability guarantees. In Advances in neural information processing systems, pp. 908–918, 2017.
+
+Steffen Bickel, Michael Bruckner, and Tobias Scheffer. Discriminative learning for differing training and test ¨ distributions. In Proceedings of the 24th international conference on Machine learning, pp. 81–88, 2007.
+
+Konstantinos Bousmalis, Alex Irpan, Paul Wohlhart, Yunfei Bai, Matthew Kelcey, Mrinal Kalakrishnan, Laura Downs, Julian Ibarz, Peter Pastor, Kurt Konolige, et al. Using simulation and domain adaptation to improve efficiency of deep robotic grasping. In 2018 IEEE International Conference on Robotics and Automation (ICRA), pp. 4243–4250. IEEE, 2018.
+
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym. arXiv preprint arXiv:1606.01540, 2016.
+
+Yevgen Chebotar, Ankur Handa, Viktor Makoviychuk, Miles Macklin, Jan Issac, Nathan Ratliff, and Dieter Fox. Closing the sim-to-real loop: Adapting simulation randomization with real world experience. In 2019 International Conference on Robotics and Automation (ICRA), pp. 8973–8979. IEEE, 2019.
+
+Kurtland Chua, Roberto Calandra, Rowan McAllister, and Sergey Levine. Deep reinforcement learning in a handful of trials using probabilistic dynamics models. In Advances in Neural Information Processing Systems, pp. 4754–4765, 2018.
+
+Ignasi Clavera, Anusha Nagabandi, Ronald S Fearing, Pieter Abbeel, Sergey Levine, and Chelsea Finn. Learning to adapt: Meta-learning for model-based control. arXiv preprint arXiv:1803.11347, 3, 2018.
+
+Corinna Cortes and Mehryar Mohri. Domain adaptation and sample bias correction theory and algorithm for regression. Theoretical Computer Science, 519:103–126, 2014.
+
+Gabriela Csurka. Domain adaptation for visual applications: A comprehensive survey. arXiv preprint arXiv:1702.05374, 2017.
+
+Mark Cutler, Thomas J Walsh, and Jonathan P How. Reinforcement learning with multi-fidelity simulators. In 2014 IEEE International Conference on Robotics and Automation (ICRA), pp. 3888–3895. IEEE, 2014.
+
+Christoph Dann, Gerhard Neumann, Jan Peters, et al. Policy evaluation with temporal differences: A survey and comparison. Journal of Machine Learning Research, 15:809–883, 2014.
+
+Marc Deisenroth and Carl E Rasmussen. Pilco: A model-based and data-efficient approach to policy search. In Proceedings of the 28th International Conference on machine learning (ICML-11), pp. 465–472, 2011.
+
+Yan Duan, John Schulman, Xi Chen, Peter L Bartlett, Ilya Sutskever, and Pieter Abbeel. Rlˆ2: Fast reinforcement learning via slow reinforcement learning. arXiv preprint arXiv:1611.02779, 2016.
+
+Miroslav Dud´ık, John Langford, and Lihong Li. Doubly robust policy evaluation and learning. arXiv preprint arXiv:1103.4601, 2011.
+
+Benjamin Eysenbach, Shixiang Gu, Julian Ibarz, and Sergey Levine. Leave no trace: Learning to reset for safe and autonomous reinforcement learning. arXiv preprint arXiv:1711.06782, 2017.
+
+Alon Farchy, Samuel Barrett, Patrick MacAlpine, and Peter Stone. Humanoid robots learning to walk faster: From the real world to simulation and back. In Proceedings of the 2013 international conference on Autonomous agents and multi-agent systems, pp. 39–46, 2013.
+
+AA Feldbaum. Dual control theory. i. Avtomatika i Telemekhanika, 21(9):1240–1249, 1960.
+
+Basura Fernando, Amaury Habrard, Marc Sebban, and Tinne Tuytelaars. Unsupervised visual domain adaptation using subspace alignment. In Proceedings of the IEEE international conference on computer vision, pp. 2960–2967, 2013.
+
+Justin Fu, Katie Luo, and Sergey Levine. Learning robust rewards with adversarial inverse reinforcement learning. arXiv preprint arXiv:1710.11248, 2017.
+
+Scott Fujimoto, David Meger, and Doina Precup. Off-policy deep reinforcement learning without exploration. arXiv preprint arXiv:1812.02900, 2018.
+
+Shani Gamrian and Yoav Goldberg. Transfer learning for related reinforcement learning tasks via image-toimage translation. arXiv preprint arXiv:1806.07377, 2018.
+
+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.
+
+Sergio Guadarrama, Anoop Korattikara, Oscar Ramirez, Pablo Castro, Ethan Holly, Sam Fishman, Ke Wang, Ekaterina Gonina, Chris Harris, Vincent Vanhoucke, et al. Tf-agents: A library for reinforcement learning in tensorflow, 2018.
+
+Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. arXiv preprint arXiv:1801.01290, 2018.
+
+Danijar Hafner, Timothy Lillicrap, Ian Fischer, Ruben Villegas, David Ha, Honglak Lee, and James Davidson. Learning latent dynamics for planning from pixels. arXiv preprint arXiv:1811.04551, 2018.
+
+Irina Higgins, Arka Pal, Andrei Rusu, Loic Matthey, Christopher Burgess, Alexander Pritzel, Matthew Botvinick, Charles Blundell, and Alexander Lerchner. Darla: Improving zero-shot transfer in reinforcement learning. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 1480–1490. JMLR. org, 2017.
+
+Jonathan Ho and Stefano Ermon. Generative adversarial imitation learning. In Advances in neural information processing systems, pp. 4565–4573, 2016.
+
+Judy Hoffman, Dequan Wang, Fisher Yu, and Trevor Darrell. Fcns in the wild: Pixel-level adversarial and constraint-based adaptation. arXiv preprint arXiv:1612.02649, 2016.
+
+Michael Janner, Justin Fu, Marvin Zhang, and Sergey Levine. When to trust your model: Model-based policy optimization. In Advances in Neural Information Processing Systems, pp. 12498–12509, 2019.
+
+Natasha Jaques, Shixiang Gu, Dzmitry Bahdanau, Jose Miguel Hern ´ andez-Lobato, Richard E Turner, and ´ Douglas Eck. Sequence tutor: Conservative fine-tuning of sequence generation models with kl-control. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 1645–1654. JMLR. org, 2017.
+
+Hilbert J Kappen. Path integrals and symmetry breaking for optimal control theory. Journal of statistical mechanics: theory and experiment, 2005(11):P11011, 2005.
+
+Taylor W Killian, Samuel Daulton, George Konidaris, and Finale Doshi-Velez. Robust and efficient transfer learning with hidden parameter markov decision processes. In Advances in neural information processing systems, pp. 6250–6261, 2017.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Daphne Koller and Nir Friedman. Probabilistic graphical models: principles and techniques. MIT press, 2009.
+
+Sylvain Koos, Jean-Baptiste Mouret, and Stephane Doncieux. The transferability approach: Crossing the reality ´ gap in evolutionary robotics. IEEE Transactions on Evolutionary Computation, 17(1):122–145, 2012.
+
+Wouter Marco Kouw and Marco Loog. A review of domain adaptation without target labels. IEEE transactions on pattern analysis and machine intelligence, 2019.
+
+Alessandro Lazaric. Knowledge transfer in reinforcement learning. PhD thesis, PhD thesis, Politecnico di Milano, 2008.
+
+Sergey Levine. Reinforcement learning and control as probabilistic inference: Tutorial and review. arXiv preprint arXiv:1805.00909, 2018.
+
+Sergey Levine, Peter Pastor, Alex Krizhevsky, Julian Ibarz, and Deirdre Quillen. Learning hand-eye coordination for robotic grasping with deep learning and large-scale data collection. The International Journal of Robotics Research, 37(4-5):421–436, 2018.
+
+Zachary C Lipton, Yu-Xiang Wang, and Alex Smola. Detecting and correcting for label shift with black box predictors. arXiv preprint arXiv:1802.03916, 2018.
+
+Lennart Ljung. System identification. Wiley encyclopedia of electrical and electronics engineering, pp. 1–19, 1999.
+
+Michael G Madden and Tom Howley. Transfer of experience between reinforcement learning environments with progressive difficulty. Artificial Intelligence Review, 21(3-4):375–398, 2004.
+
+Oliver Mihatsch and Ralph Neuneier. Risk-sensitive reinforcement learning. Machine learning, 49(2-3):267– 290, 2002.
+
+Nikhil Mishra, Mostafa Rohaninejad, Xi Chen, and Pieter Abbeel. A simple neural attentive meta-learner. arXiv preprint arXiv:1707.03141, 2017.
+
+Shakir Mohamed and Balaji Lakshminarayanan. Learning in implicit generative models. arXiv preprint arXiv:1610.03483, 2016.
+
+Remi Munos, Tom Stepleton, Anna Harutyunyan, and Marc Bellemare. Safe and efficient off-policy reinforce-´ ment learning. In Advances in Neural Information Processing Systems, pp. 1054–1062, 2016.
+
+Xue Bin Peng, Marcin Andrychowicz, Wojciech Zaremba, and Pieter Abbeel. Sim-to-real transfer of robotic control with dynamics randomization. In 2018 IEEE international conference on robotics and automation (ICRA), pp. 1–8. IEEE, 2018.
+
+Theodore J Perkins, Doina Precup, et al. Using options for knowledge transfer in reinforcement learning. University of Massachusetts, Amherst, MA, USA, Tech. Rep, 1999.
+
+Aravind Rajeswaran, Sarvjeet Ghotra, Balaraman Ravindran, and Sergey Levine. Epopt: Learning robust neural network policies using model ensembles. arXiv preprint arXiv:1610.01283, 2016.
+
+Kate Rakelly, Aurick Zhou, Chelsea Finn, Sergey Levine, and Deirdre Quillen. Efficient off-policy metareinforcement learning via probabilistic context variables. In International conference on machine learning, pp. 5331–5340, 2019.
+
+Balaraman Ravindran and Andrew G Barto. An algebraic approach to abstraction in reinforcement learning. PhD thesis, University of Massachusetts at Amherst, 2004.
+
+Konrad Rawlik, Marc Toussaint, and Sethu Vijayakumar. On stochastic optimal control and reinforcement learning by approximate inference. In Twenty-Third International Joint Conference on Artificial Intelligence, 2013.
+
+Stephane Ross and J Andrew Bagnell. Agnostic system identification for model-based reinforcement learning. arXiv preprint arXiv:1203.1007, 2012.
+
+Fereshteh Sadeghi and Sergey Levine. Cad2rl: Real single-image flight without a single real image. arXiv preprint arXiv:1611.04201, 2016.
+
+Sosale Shankara Sastry and Alberto Isidori. Adaptive control of linearizable systems. IEEE Transactions on Automatic Control, 34(11):1123–1131, 1989.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+Oliver G Selfridge, Richard S Sutton, and Andrew G Barto. Training and tracking in robotics. In IJCAI, pp. 670–672, 1985.   
+Alexander A Sherstov and Peter Stone. Improving action selection in mdp’s via knowledge transfer. In AAAI, volume 5, pp. 1024–1029, 2005.   
+Casper Kaae Sønderby, Jose Caballero, Lucas Theis, Wenzhe Shi, and Ferenc Huszar. Amortised map inference ´ for image super-resolution. arXiv preprint arXiv:1610.04490, 2016.   
+H Francis Song, Abbas Abdolmaleki, Jost Tobias Springenberg, Aidan Clark, Hubert Soyer, Jack W Rae, Seb Noury, Arun Ahuja, Siqi Liu, Dhruva Tirumala, et al. V-mpo: On-policy maximum a posteriori policy optimization for discrete and continuous control. arXiv preprint arXiv:1909.12238, 2019.   
+Funlade T Sunmola and Jeremy L Wyatt. Model transfer for markov decision tasks via parameter matching. In Proceedings of the 25th Workshop of the UK Planning and Scheduling Special Interest Group (PlanSIG 2006), pp. 246–252, 2006.   
+Aviv Tamar, Huan Xu, and Shie Mannor. Scaling up robust mdps by reinforcement learning. arXiv preprint arXiv:1306.6189, 2013.   
+Jie Tan, Zhaoming Xie, Byron Boots, and C Karen Liu. Simulation-based design of dynamic controllers for humanoid balancing. In 2016 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 2729–2736. IEEE, 2016.   
+Fumihide Tanaka and Masayuki Yamamura. Multitask reinforcement learning on the distribution of mdps. In Proceedings 2003 IEEE International Symposium on Computational Intelligence in Robotics and Automation. Computational Intelligence in Robotics and Automation for the New Millennium (Cat. No. 03EX694), volume 3, pp. 1108–1113. IEEE, 2003.   
+Marko Tanaskovic, Lorenzo Fagiano, Roy Smith, Paul Goulart, and Manfred Morari. Adaptive model predictive control for constrained linear systems. In 2013 European Control Conference (ECC), pp. 382–387. IEEE, 2013.   
+Matthew E Taylor and Peter Stone. Transfer learning for reinforcement learning domains: A survey. Journal of Machine Learning Research, 10(7), 2009.   
+Louis C Tiao, Edwin V Bonilla, and Fabio Ramos. Cycle-consistent adversarial learning as approximate bayesian inference. arXiv preprint arXiv:1806.01771, 2018.   
+Josh Tobin, Rachel Fong, Alex Ray, Jonas Schneider, Wojciech Zaremba, and Pieter Abbeel. Domain randomization for transferring deep neural networks from simulation to the real world. In 2017 IEEE/RSJ international conference on intelligent robots and systems (IROS), pp. 23–30. IEEE, 2017.   
+Emanuel Todorov. Linearly-solvable markov decision problems. In Advances in neural information processing systems, pp. 1369–1376, 2007.   
+Marc Toussaint. Robot trajectory optimization using approximate inference. In Proceedings of the 26th annual international conference on machine learning, pp. 1049–1056, 2009.   
+Masatoshi Uehara, Issei Sato, Masahiro Suzuki, Kotaro Nakayama, and Yutaka Matsuo. Generative adversarial nets from a density ratio estimation perspective. arXiv preprint arXiv:1610.02920, 2016.   
+Anirudh Vemula, Yash Oza, J Andrew Bagnell, and Maxim Likhachev. Planning and execution using inaccurate models with provable guarantees. arXiv preprint arXiv:2003.04394, 2020.   
+Paul J Werbos. Neural networks for control and system identification. In Proceedings of the 28th IEEE Conference on Decision and Control,, pp. 260–265. IEEE, 1989.   
+Martha White. Unifying task specification in reinforcement learning. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 3742–3750. JMLR. org, 2017.   
+Grady Williams, Andrew Aldrich, and Evangelos Theodorou. Model predictive path integral control using covariance variable importance sampling. arXiv preprint arXiv:1509.01149, 2015.   
+Bjorn Wittenmark. Adaptive dual control methods: An overview. In ¨ Adaptive Systems in Control and Signal Processing 1995, pp. 67–72. Elsevier, 1995.   
+Markus Wulfmeier, Alex Bewley, and Ingmar Posner. Addressing appearance change in outdoor robotics with adversarial domain adaptation. In 2017 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 1551–1558. IEEE, 2017a.   
+Markus Wulfmeier, Ingmar Posner, and Pieter Abbeel. Mutual alignment transfer learning. arXiv preprint arXiv:1707.07907, 2017b.   
+Wenhao Yu, Jie Tan, C Karen Liu, and Greg Turk. Preparing for the unknown: Learning a universal policy with online system identification. arXiv preprint arXiv:1702.02453, 2017.   
+Bianca Zadrozny. Learning and evaluating classifiers under sample selection bias. In Proceedings of the twenty-first international conference on Machine learning, pp. 114, 2004.   
+Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. In Proceedings of the IEEE international conference on computer vision, pp. 2223–2232, 2017a.   
+Shaojun Zhu, Andrew Kimmel, Kostas E Bekris, and Abdeslam Boularias. Fast model identification via physics engines for data-efficient policy search. arXiv preprint arXiv:1710.08893, 2017b.   
+Brian D. Ziebart. Modeling Purposeful Adaptive Behavior with the Principle of Maximum Causal Entropy. PhD thesis, Carnegie Mellon University, 2010.
+
+# A ADDITIONAL INTERPRETATIONS OF THE REWARD CORRECTION
+
+This section presents four additional interpretations of the reward correction, $\Delta r$ .
+
+# A.1 CODING THEORY
+
+The reward correction $\Delta r$ can also be understood from the perspective of coding theory. Suppose that we use a data-efficient replay buffer that exploits that fact that the next state $s _ { t + 1 }$ is highly redundant with the current state and action, $s _ { t } , a _ { t }$ . If we assume that the replay buffer compression has been optimized to store transitions from the target environment, (negative) $\Delta r$ is the number of additional bits (per transition) needed for our source replay buffer, as compared with our target replay buffer. Thus, an agent which maximizes $\Delta r$ will seek those transitions that can be encoded most efficiently, minimizing the size of the source replay buffer.
+
+# A.2 MUTUAL INFORMATION
+
+We can gain more intuition in the modified reward by writing the expected value of $\Delta r$ from Eq. 3 in terms of mutual information:
+
+$$
+\mathbb { E } [ \Delta r ( s _ { t } , a _ { t } , s _ { t + 1 } ) ] = I ( s _ { t + 1 } ; \mathrm { t a r g e t } \mid s _ { t } , a _ { t } ) - I ( s _ { t + 1 } ; \mathrm { s o u r c e } \mid s _ { t } , a _ { t } ) .
+$$
+
+The mutual information $I ( s _ { t + 1 } ; \mathrm { t a r g e t } \mid s _ { t } , a _ { t } )$ reflects how much better you can predict the next state if you know that you are interacting with the target domain, instead of the source domain. Our approach does exactly this, rewarding the agent for taking transitions that provide information about the target domain while penalizing transitions that hint to the agent that it is interacting with a source domain rather than the target domain: we don’t want our are agent to find bugs in the Matrix.
+
+# A.3 LOWER BOUND ON THE RISK-SENSITIVE REWARD OBJECTIVE.
+
+While we derived DARC by minimizing a reverse KL divergence (Eq. 2), we can also show that DARC maximizes a lower bound on a risk-sensitive reward objective (Mihatsch & Neuneier, 2002):
+
+$$
+\begin{array} { r l } & { \log \mathbb { E } _ { s ^ { \prime } \sim p _ { \operatorname* { m a x } } ( s ^ { \prime } | s , a ) , } [ \exp ( \sum _ { t } r ( s _ { t } , a _ { t } ) ) ] } \\ & { \qquad = \log \mathbb { E } _ { s ^ { \prime } \sim p _ { \operatorname* { m a x } } ( s ^ { \prime } | s , a ) , } [ ( \prod _ { t } \frac { p _ { \operatorname* { m a x } } ( s _ { t + 1 } \mid s _ { t } , a _ { t } ) } { p _ { \operatorname* { s o u r c } } ( s _ { t + 1 } \mid s _ { t } , a _ { t } ) } ) \exp ( \sum _ { t } r ( s _ { t } , a _ { t } ) ) ] } \\ & { \qquad = \log \mathbb { E } _ { s ^ { \prime } \sim p _ { \operatorname* { m a x } } ( s ^ { \prime } | s , a ) , } [ \exp ( \sum _ { t } r ( s _ { t } , a _ { t } ) + \underbrace { \log p _ { \operatorname* { m a x } } ( s _ { t + 1 } \mid s _ { t } , a _ { t } ) } _ { \Delta r ( s _ { t } , a _ { t } , s _ { t + 1 } ) } ) \log p _ { \operatorname* { m a x } } ( s _ { t + 1 } \mid s _ { t } , a _ { t } ) ) ] } \\ & { \qquad = \log \mathbb { E } _ { s ^ { \prime } \sim p _ { \operatorname* { m a x } } ( a | s ) } , [ \exp ( \sum _ { t } r ( s _ { t } , a _ { t } ) + \underbrace { \log p _ { \operatorname* { m a x } } ( s _ { t + 1 } \mid s _ { t } , a _ { t } ) - \log p _ { \operatorname* { s o u r c } } ( s _ { t + 1 } \mid s _ { t } , a _ { t } ) } _ { \Delta r ( s _ { t } , a _ { t } , s _ { t + 1 } ) } ) ] } \end{array}
+$$
+
+The inequality on the last line is an application of Jensen’s inequality. One interesting question is when it would be preferable to maximize Eq. 4 rather than Eq. 5. While Eq. 5 provides a loser bound on the risk sensitive objective, empirically it may avoid the risk-seeking behavior that can be induced by risk-sensitive objectives. We leave the investigation of this trade-off as future work.
+
+# A.4 A CONSTRAINT ON DYNAMICS DISCREPANCY
+
+Our method regularizes the policy to visit states where the transition dynamics are similar between the source domain and target domain:
+
+$$
+\operatorname* { n a x } _ { \pi } \mathbb { E } _ { \left. a \sim \pi \left( a \mid s \right) \right. } \left[ \sum _ { t } r ( s _ { t } , a _ { t } ) + \underbrace { \log p _ { \mathrm { t a r g e t } } ( s _ { t + 1 } \mid s _ { t } , a _ { t } ) - \log p _ { \mathrm { s o u r c e } } ( s _ { t + 1 } \mid s _ { t } , a _ { t } ) } _ { - D _ { \mathrm { K L } } ( p _ { \mathrm { s o u r c e } } \mid \mathcal { P } _ { \mathrm { a r g e t } } ) } + \mathcal { H } _ { \pi } [ a _ { t } \mid s _ { t } ] \right] .
+$$
+
+This objective can equivalently be expressed as applying MaxEnt RL to only those policies which avoid exploiting the dynamics discrepancy. More precisely, the KKT conditions guarantee that there exists a positive constant $\epsilon > 0$ such that our objective is equivalent to the following constrained objective:
+
+$$
+\operatorname* { m a x } _ { \pi \in \Pi _ { \mathrm { D A R C } } } \mathbb { E } _ { \mathbf { \Phi } _ { s ^ { \prime } \sim p ( { s ^ { \prime } } | s , a ) } } \left[ \sum _ { t } r ( s _ { t } , a _ { t } ) + \mathcal { H } _ { \pi } [ a _ { t } \mid s _ { t } ] \right] ,
+$$
+
+where $\Pi _ { \mathrm { D A R C } }$ denotes the set of policies that do not exploit the dynamics discrepancy:
+
+$$
+\Pi _ { \mathrm { D A R C } } \triangleq \left\{ \pi \Big | \mathbb { E } _ { \begin{array} { l } { a \sim \pi ( a \mid s ) } \\ { s ^ { \prime } \sim p ( s ^ { \prime } \mid s , a ) } \end{array} } \left[ \sum _ { t } D _ { \mathrm { K L } } \big ( p _ { \mathrm { s o u r c e } } \big ( s _ { t + 1 } \mid s _ { t } , a _ { t } \big ) \parallel p _ { \mathrm { t a r g e t } } \big ( s _ { t + 1 } \mid s _ { t } , a _ { t } \big ) \big ) \right] \le \epsilon \right\} .
+$$
+
+One potential benefit of considering our method as the unconstrained objective is that it provides a principled method for increasing or decreasing the weight on the $\Delta r$ term, depending on how much the policy is currently exploiting the dynamics discrepancy. We leave this investigation as future work.
+
+# B PROOFS OF THEORETICAL GUARANTEES
+
+In this section we present our analysis showing that maximizing the modified reward $r + \Delta r$ in the source domain yields a near-optimal policy for the target domain, subject to Assumption 1. To start, we show that maximizing the modified reward in the source domain is equivalent to maximizing the unmodified reward, subject to the constraint that the policy not exploit the dynamics:
+
+Lemma B.1. Let a reward function $r ( s , a )$ , source dynamics $p _ { s o u r c e } ( s ^ { \prime } \mid s , a )$ , and target dynamics $p _ { t a r g e t } ( s ^ { \prime } \mid s , a )$ be given. Then there exists $\epsilon > 0$ such the optimization problem in Eq. 2 is equivalent to
+
+$$
+\operatorname* { m a x } _ { \pi \in \Pi _ { n o e x p l o i t } } \mathbb { E } _ { p _ { s o u r c e } , \pi } \left[ \sum r ( s _ { t } , a _ { t } ) + \mathcal { H } _ { \pi } [ a _ { t } \mid s _ { t } ] \right] ,
+$$
+
+where $\Pi _ { n o e x p l o i t }$ denotes the set of policies that do not exploit the dynamics:
+
+$$
+\Pi _ { n o e x p l o i t } \triangleq \left\{ \mathbb { E } _ { \begin{array} { c } { a \sim \pi ( a | s ) } \\ { s ^ { \prime } \sim p ( s ^ { \prime } | s , a ) } \end{array} } \left[ \sum _ { t } D _ { \mathrm { K L } } ( p _ { s o u r e } ( s _ { t + 1 } \mid s _ { t } , a _ { t } ) \parallel p _ { t a r g e t } ( s _ { t + 1 } \mid s _ { t } , a _ { t } ) ) \right] \leq \epsilon \right\} .
+$$
+
+The proof is a straightforward application of the KKT conditions. This lemma says that maximizing the modified reward can be equivalently viewed as restricting the set of policies to those that do not exploit the dynamics. Next, we will show that policies that do not exploit the dynamics have an expected (entropy-regularized) reward that is similar in the source and target domains:
+
+Lemma B.2. Let policy $\pi \in \Pi _ { n o e x p l o i t }$ be given, and let $R _ { m a x }$ be the maximum (entropy-regularized) return of any trajectory. Then the following inequality holds:
+
+$$
+\Big | \mathbb { E } _ { p _ { a v a r e } } \left[ \sum r ( s _ { t } , a _ { t } ) + \mathcal { H } _ { \pi } [ a _ { t } \mid s _ { t } ] \right] - \mathbb { E } _ { p _ { a v a r e } } \left[ \sum r ( s _ { t } , a _ { t } ) + \mathcal { H } _ { \pi } [ a _ { t } \mid s _ { t } ] \right] \Big | \leq 2 R _ { m a x } \sqrt { \epsilon / 2 } .
+$$
+
+This Lemma proves that all policies in $\scriptstyle \prod _ { \mathrm { n o } \mathrm { e x p l o i t } }$ satisfy the same condition as the optimal policy (Assumption 1).
+
+Proof. To simplify notation, define ${ \tilde { r } } ( s , a ) = r ( s , a ) - \log \pi ( a \mid s )$ . We then apply Holder’s inequality and Pinsker’s inequality to obtain the desired result:
+
+$$
+\begin{array} { r l } & { \natural _ { p _ { \operatorname* { s u r c } } } \left[ \sum \tilde { r } ( s _ { t } , a _ { t } ) \right] - \mathbb { E } _ { p _ { \operatorname* { m a x } } } \left[ \sum \tilde { r } ( s _ { t } , a _ { t } ) \right] = \displaystyle \sum _ { \tau } ( p _ { \operatorname* { s o u r c } } ( \tau ) - p _ { \operatorname* { t a r g e t } } ( \tau ) ) \left( \sum \tilde { r } ( s _ { t } , a _ { t } ) \right) } \\ & { \qquad \leq \| \sum \tilde { r } ( s _ { t } , a _ { t } ) \| _ { \infty } \cdot \| p _ { \operatorname* { s u r c } } ( \tau ) - p _ { \operatorname* { t a r g e t } } ( \tau ) \| _ { 1 } } \\ & { \qquad \leq \left( \operatorname* { m a x } \sum r ( s _ { t } , a _ { t } ) \right) \cdot 2 \sqrt { \frac { 1 } { 2 } } D _ { \mathrm { K L } } ( p _ { \operatorname* { s u r c } } ( \tau ) \parallel p _ { \operatorname* { t a r g e t } } ( \tau ) } \\ & { \qquad \leq 2 R _ { \operatorname* { m a x } } \sqrt { \epsilon / 2 } . } \end{array}
+$$
+
+We restate our main result:
+
+Theorem 4.1 (Repeated from main text). Let $\pi _ { D A R C } ^ { * }$ be the policy that maximizes the modified (entropy-regularized) reward in the source domain, let $\pi ^ { * }$ be the policy that maximizes the (unmodified, entropy-regularized) reward in the target domain, and assume that $\pi ^ { * }$ satisfies Assumption $^ { l }$ . Then $\pi _ { D A R C } ^ { * }$ receives near-optimal (entropy-regularized) reward on the target domain:
+
+$$
+\mathbb { E } _ { p _ { t o r e t } , \pi _ { n + R } ^ { * } } \left[ \sum r ( s _ { t } , a _ { t } ) + \mathcal { H } [ a _ { t } \mid s _ { t } ] \right] \geq \mathbb { E } _ { p _ { t o r e t } , \pi ^ { * } } \left[ \sum r ( s _ { t } , a _ { t } ) + \mathcal { H } [ a _ { t } \mid s _ { t } ] \right] - 4 R _ { m a x } \sqrt { \epsilon / 2 } .
+$$
+
+Proof. Assumption 1 guarantees that the optimal policy for the target domain, $\pi ^ { * }$ , lies within $\scriptstyle \prod _ { \mathrm { n o } \mathrm { e x p l o i t } }$ . Among all policies in $\Pi _ { \mathrm { n o } }$ exploit, $\pi _ { \mathrm { D A R C } } ^ { * }$ is (by definition) the one that receives highest reward on the source dynamics, so
+
+$$
+\mathbb { E } _ { p _ { \mathrm { s o u r e } } , \pi _ { \mathrm { D A R C } } ^ { * } } \left[ \sum r ( s _ { t } , a _ { t } ) + \mathcal { H } [ a _ { t } \ | \ s _ { t } ] \right] \geq \mathbb { E } _ { p _ { \mathrm { s o u r e } } , \pi ^ { * } } \left[ \sum r ( s _ { t } , a _ { t } ) + \mathcal { H } [ a _ { t } \ | \ s _ { t } ] \right] .
+$$
+
+Since the both $\pi _ { \mathrm { D A R C } } ^ { * }$ and $\pi ^ { * }$ lie inside the constraint set, Lemma B.2 dictates that their rewards on the target domain differ by at most $2 R _ { \mathrm { m a x } } \sqrt { \epsilon / 2 }$ from their source domain rewards. In the worst case, the reward for $\pi _ { \mathrm { D A R C } } ^ { * }$ decreases by this amount and the reward for $\pi ^ { * }$ increases by this amount:
+
+$$
+\begin{array} { r l } & { \mathbb { E } _ { p _ { \mathrm { s o u r e } } , \pi _ { \mathrm { b a r c } } ^ { * } } \left[ \displaystyle \sum r ( s _ { t } , a _ { t } ) + \mathcal { H } [ a _ { t } \mid s _ { t } ] \right] \le \mathbb { E } _ { p _ { \mathrm { u p s t } } , \pi _ { \mathrm { b a r c } } ^ { * } } \left[ \displaystyle \sum r ( s _ { t } , a _ { t } ) + \mathcal { H } [ a _ { t } \mid s _ { t } ] \right] + 2 R _ { \operatorname* { m a x } } \sqrt { \epsilon / 2 } } \\ & { \mathbb { E } _ { p _ { \mathrm { s o u r e } } , \pi ^ { * } } \left[ \displaystyle \sum r ( s _ { t } , a _ { t } ) + \mathcal { H } [ a _ { t } \mid s _ { t } ] \right] \ge \mathbb { E } _ { p _ { \mathrm { u p s t } } , \pi ^ { * } } \left[ \displaystyle \sum r ( s _ { t } , a _ { t } ) + \mathcal { H } [ a _ { t } \mid s _ { t } ] \right] - 2 R _ { \operatorname* { m a x } } \sqrt { \epsilon / 2 } } \end{array}
+$$
+
+Substituting these inequalities on the LHS and RHS of Eq. B and rearranging terms, we obtain the desired result. □
+
+# C THE SPECIAL CASE OF AN OBSERVATION MODEL
+
+To highlight the relationship between domain adaptation of dynamics versus observations, we now consider a special case. In this subsection, we will assume that the state $s _ { t } \triangleq \left( z _ { t } , o _ { t } \right)$ is a combination of the system latent state $z _ { t }$ (e.g., the poses of all objects in a scene) and an observation $o _ { t }$ (e.g., a camera observation). We will define $q ( o _ { t } \mid z _ { t } )$ and $p ( o _ { t } \mid z _ { t } )$ as the observation models for the source and target domains. In this special case, we can decompose the KL objective (Eq. 2) into three terms:
+
+$$
+\begin{array} { r l } & { D _ { \mathrm { K L } } ( q \parallel p ) = - \mathbb { E } _ { q } \Bigg [ \underset { t } { \sum } \underset { \mathrm { ~ \operatorname* { m a x } } \mathrm { E n t } \mathrm { ~ \mathbb { R } } \mathrm { ~ \Omega } \mathrm { o b j e c t i v e } } { \underbrace { r \big ( s _ { t } , a _ { t } \big ) + \mathcal { H } _ { \pi } [ a _ { t } \mid s _ { t } ] } } + \underset { \mathrm { ~ \operatorname* { l o g } ~ \mathbb { p } _ \mathrm { t a r g e t } } \big ( \omega _ { t } \big \backslash \mathrm { ~ \Omega } \mathrm { / ~ } z _ { t } \big ) } { \underbrace { \log p _ { \mathrm { t a r g e t } } \big ( o _ { t } \mid z _ { t } \big ) - \log p _ { \mathrm { s o u r c e } } \big ( o _ { t } \mid z _ { t } \big ) } } } \\ & { \quad \quad \quad \quad + \underset { \mathrm { ~ \operatorname* { l o g } ~ \mathbb { p } _ \mathrm { t a r g e t } } \big ( z _ { t + 1 } \mid z _ { t } , a _ { t } \big ) - \mathrm { ~ \log p _ \mathrm { s o u r c e } } \big ( z _ { t + 1 } \mid z _ { t } , a _ { t } \big ) } { \mathrm { ~ \operatorname* { D y n a m i c s } ~ \mathrm { A d a p u a t i o n } ~ } } \Bigg ] . } \end{array}
+$$
+
+Prior methods that perform observation adaptation (Bousmalis et al., 2018; Gamrian & Goldberg, 2018) effectively minimize the observation adaptation term,1 but ignore the effect of dynamics. In contrast, the $\Delta r$ reward correction in our method provides one method to address both dynamics and observations. These approaches could be combined; we leave this as future work.
+
+![](images/8fc7913cfb11621ae0cd2b70714653a459eb8ce8f605ce7d545bfe3fb41d3a32.jpg)  
+Figure 11: Importance of using two classifiers: Results of the ablation experiment from Fig. 7 (left) on all environments.
+
+![](images/9117c26c9a10df051045dc1797fa8b2679a0bed6440fdc87e19bc10ed7ddb076.jpg)  
+Figure 12: Importance of regularizing the classifiers: Results of the ablation experiment from Fig. 7 (right) on all environments.
+
+# D ADDITIONAL EXPERIMENTS
+
+Figures 11 and 12 show the results of the ablation experiment from Fig. 7 run on all environments. The results support our conclusion in the main text regarding the importance of using two classifiers and using input noise. Figure 13 is a copy of Fig. 8 from the main text, modified to also show the agent’s reward on the target domain. We observe that the reward does not start increasing until we start using DARC.
+
+![](images/f549125b3478c7e6d5423467e471b0aee9073ffb882b351b5f5a1aa68e25551f.jpg)  
+Figure 13: Copy of Fig. 8 overlaid with the target domain reward.
+
+# E EXPERIMENT DETAILS AND HYPERPARAMETERS
+
+Our implementation of DARC is built on top of the implementation of SAC from Guadarrama et al. (2018). Unless otherwise specified, all hyperparameters are taken from Guadarrama et al. (2018). All neural networks (actor, critics, and classifiers) have two hidden layers with 256-units each and ReLU activations. Since we ultimately will use the difference in the predictions of the two classifiers, we use a residual parametrization for the SAS classifier $q ( \mathrm { t a r g e t } \mid s _ { t } , a _ { t } , s _ { t + 1 } )$ . Using $f _ { \mathrm { S A S } } ( s _ { t } , a _ { t } , s _ { t + 1 } )$ , $f _ { \mathrm { S A } } ( s _ { t } , a _ { t } ) ^ { \ast } \in \mathbb { R } ^ { 2 }$ to denote the outputs of the two classifier networks, we compute the classifier predictions as follows:
+
+$$
+\begin{array} { r } { q _ { \theta _ { \mathrm { S A } } } ( \cdot  { | } s _ { t } , a _ { t } ) = \mathrm { S O F T M A X } \big ( f _ { \mathrm { S A } } ( s _ { t } , a _ { t } ) \big ) \qquad } \\ { q _ { \theta _ { \mathrm { S A S } } } ( \cdot  { | } s _ { t } , a _ { t } , s _ { t + 1 } ) = \mathrm { S O F T M A X } \big ( f _ { \mathrm { S A S } } ( s _ { t } , a _ { t } , s _ { t + 1 } ) + f _ { \mathrm { S A } } ( s _ { t } , a _ { t } ) \big ) } \end{array}
+$$
+
+For the SAS classifier we propagate gradients back through both networks parameters, $\theta _ { \mathrm { S A S } }$ and $\theta _ { \mathrm { S A } }$ . Both classifiers use Gaussian input noise with $\sigma = 1$ . Optimization of all networks is done with Adam (Kingma & Ba, 2014) with a learning rate of 3e-4 and batch size of 128. Most experiments with DARC collected 1 step in the target domain every 10 steps in the source domain (i.e., $r = 1 0$ ). The one exception is the half cheetah obstacle domain, where we tried increasing $r$ beyond 10 to 30, 100, 300, and 1000. We found a large benefit from increasing $r$ to 30 and 100, but did not run the other experiments long enough to draw any conclusions. Fig. 6 uses $r = 3 0$ for half cheetah obstacle. We did not tune this parameter, and expect that tuning it would result in significant improvements in sample efficiency.
+
+We found that DARC was slightly more stable if we warm-started the method by applying RL on the source task without $\Delta r$ for the first $t _ { \mathrm { w a r m u p } }$ iterations. We used $t _ { \mathrm { w a r m u p } } = 1 e 5$ for all tasks except the broken reacher, where we used $t _ { \mathrm { w a r m u p } } \doteq 2 e 5$ . This discrepancy was caused by a typo in an experiment, and subsequent experiments found that DARC is relatively robust to different values of $t _ { \mathrm { w a r m u p } }$ ; we did not tune this parameter.
+
+# E.1 BASELINES
+
+The RL on Source and RL on Target baselines are implemented identically to our method, with the exception that $\Delta r$ is not added to the reward function. The RL on Target $\mathbf { ( 1 0 x ) }$ is identical to $\mathtt { R L }$ on Target, with the exception that we take 10 gradient steps per environment interaction (instead of 1). The Importance Weighting baseline estimates the importance weights as $p _ { \mathrm { t a r g e t } } ( s _ { t + 1 } \mid s _ { t } , a _ { t } ) / p _ { \mathrm { s o u r c e } } ( s _ { t + 1 } \mid s _ { t } , a _ { t } ) \approx \exp ( \Delta r )$ . The importance weight is used to weight transitions in the SAC actor and critic losses.
+
+PETS (Chua et al., 2018) The PETS baseline is implemented using the default configurations used by (Chua et al., 2018) for the environments evaluated. The broken-half-cheetah environment uses the hyperparameters as used by the half-cheetah environment in (Chua et al., 2018). The broken-ant environment uses the same set of hyperparameters, namely: task hori$\mathrm { z o n } = 1 0 0 0$ , number of training iterations $= 3 0 0$ , number of planning (real) steps per iteration $= 3 0$ , number of particles to be used in particle propagation methods $= 2 0$ . The PETS codebase can be found at https://github.com/kchua/handful-of-trials.
+
+MBPO (Janner et al., 2019) We used the authors implementation with the default hyperparameters: https://github.com/JannerM/mbpo. We kept the environment configurations the same as their default unmodified MuJoCo environments, except for the domain and task name. We added our custom environment xmls in mbpo/env/assets/ folder, and their corresponding environment python files in the mbpo/env/ folder. Their static files were added under mbpo/static/. These environments can be registered as gym environments in the init file under mbpo odrl/mbpo/env/ or can be initialized directly in softlearning/environments/adapters/gym adapter.py. We set the time limit to max episode step $s { = } 1 0 0 0$ for the Broken Half Cheetah, Broken Ant and Half Cheetah Obstacle environments and to 100 for the Broken Reacher environment.
+
+# E.2 ENVIRONMENTS
+
+Broken Reacher This environment uses the 7DOF robot arm from the Pusher environment in OpenAI Gym. The observation space is the position and velocities of all joints and the goal. The reward function is
+
+$$
+r ( s , a ) = - \frac { 1 } { 2 } \| s _ { \mathrm { e n d e f f e c t o r } } - s _ { \mathrm { g o a l } } \| _ { 2 } - \frac { 1 } { 1 0 } \| a \| _ { 2 } ^ { 2 } ,
+$$
+
+and episodes are 100 steps long. In the target domain the 2nd joint (0-indexed) is broken: zero torque is applied to this joint, regardless of the commanded torque.
+
+Broken Half Cheetah This environment is based on the HalfCheetah environment in OpenAI Gym. We modified the observation to include the agent’s global $\mathrm { X }$ coordinate so the agent can infer its relative position to the obstacle. Episodes are 1000 steps long. In the target domain the 0th joint (0-indexed) is broken: zero torque is applied to this joint, regardless of the commanded torque.
+
+Broken Ant This environment is based on the Ant environment in OpenAI Gym. We use the standard termination condition and cap the maximum episode length at 1000 steps. In the target domain the 3rd joint (0-indexed) is broken: zero torque is applied to this joint, regardless of the commanded torque.
+
+In all the broken joint environments, we choose which joint to break to computing which joint caused the “RL on Source” baseline to perform worst on the target domain, as compared with the “RL on Target” baseline.
+
+Half Cheetah Obstacle This environment is based on the HalfCheetah environment in OpenAI Gym. Episodes are 1000 steps long. We modified the standard reward function to use the absolute value in place of the velocity, resulting the following reward function:
+
+$$
+r ( s , a ) = s _ { \mathrm { x v e l } } \cdot \Delta t - \| a \| _ { 2 } ^ { 2 } ,
+$$
+
+where $s _ { \mathrm { X \ v e l } }$ is the velocity of the agent along the forward-aft axis and $\Delta t = 0 . 0 1$ is the time step of the simulator. In the target domain, we added a wall at $x = - 3 m$ , roughly 3 meters behind the agent.
+
+Humanoid Used for the experiment in Fig. 9, we used a modified version of Humanoid from OpenAI Gym. The source domain modified this environment to ignore the default termination condition and instead terminate after exactly 300 time steps. The target domain uses the unmodified environment, which terminates when the agent falls.
+
+# E.3 FIGURES
+
+Unless otherwise noted, all experiments were run with three random seeds. Figures showing learning curves (Figures 6, 7, 8, 11, and 12) plot the mean over the three random seeds, and also plot the results for each individual random seed with semi-transparent lines.
+
+# E.4 ARCHERY EXPERIMENT
+
+We used a simple physics model for the archery experiment. The target was located $7 0 \mathrm { m }$ North of the agent, and wind was applied along the East-West axis. The system dynamics:
+
+$$
+\begin{array} { r l r } { s _ { t + 1 } = 7 0 \sin ( \theta ) + f / \cos ( \theta ) ^ { 2 } } & { { } } & { \left\{ \begin{array} { l l } { f \sim \mathcal { N } ( \mu = 1 , \sigma = 1 ) } & { { \mathrm { i n ~ t h e ~ s o u r c e ~ d o m a i n } } } \\ { f \sim \mathcal { N } ( \mu = 0 , \sigma = 0 . 3 ) } & { { \mathrm { i n ~ t h e ~ t a r g e t ~ d o m a i n } } } \end{array} \right. } \end{array}
+$$
+
+We trained the classifier by sampling $\theta \sim \mathcal { U } [ - 2 , 2 ]$ (measured in degrees) for $1 0 \mathrm { k }$ episodes in the source domain and $1 0 \mathrm { k }$ episodes in the target domain. The classifier was a neural network with 1 hidden layer with 32 hidden units and ReLU activation. We optimized the classifier using the Adam optimizer with a learning rate of 3e-3 and a batch size of 1024. We trained until the validation loss increased for 3 consecutive epochs, which took 16 epochs in our experiment. We generated Fig. 4 by sampling 10k episodes for each value of $\theta$ and aggregating the rewards using $\begin{array} { r } { \dot { \boldsymbol J } ( \theta ) = \log \bar { \mathbb { E } } _ { p ( s ^ { \prime } | \theta ) } \big [ \exp \big ( r ( s ^ { \prime } ) \big ) \big ] } \end{array}$ . We found that aggregating rewards by taking the mean did not yield meaningful results, perhaps because the mean corresponds to a (possibly loose) lower bound on $J$ (see Appendix A.3).

parse/train/rklwwo05Ym/rklwwo05Ym.md

@@ -0,0 +1,347 @@
+# PUSHING THE BOUNDS OF DROPOUT
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We show that dropout training is best understood as performing MAP estimation concurrently for a family of conditional models whose objectives are themselves lower bounded by the original dropout objective. This discovery allows us to pick any model from this family after training, which leads to a substantial improvement on regularisation-heavy language modelling. The family includes models that compute a power mean over the sampled dropout masks, and their less stochastic subvariants with tighter and higher lower bounds than the fully stochastic dropout objective. We argue that since the deterministic subvariant’s bound is equal to its objective, and the highest amongst these models, the predominant view of it as a good approximation to MC averaging is misleading. Rather, deterministic dropout is the best available approximation to the true objective.
+
+# 1 INTRODUCTION
+
+The regularisation technique known as dropout underpins numerous state-of-the-art results in deep learning (Hinton et al. 2012; Srivastava et al. 2014), and its application has received much attention in the form of optimisation (Wang & Manning 2013) and attempts at explaining or improving its approximation properties (Baldi & Sadowski 2013; Zolna et al. 2017; Ma et al. 2016). The dominant perspective today views dropout as either an implicit ensemble method (Warde-Farley et al. 2013) or averaging over an approximate Bayesian posterior (Gal & Ghahramani 2016a). Regardless of which view we take, dropout training is carried out the same way, by minimising the expectation of the loss over randomly sampled dropout masks. However, at test time these views naturally lead to different algorithms: the Bayesian approach computes an arithmetic average as it marginalises out the weight uncertainty, while the ensemble approach typically uses the geometric average due to its close relationship to the loss. Collectively they are called MC dropout and neither is clearly better than the other (Warde-Farley et al. 2013). A third way to make predictions is to “turn dropout off”, that is, propagate expected values through the network in a single, deterministic pass. This deterministic (also known as standard) dropout in considered to be an excellent approximation to MC dropout.
+
+This situation is unsatisfactory as it does not provide theoretical grounding for dropout, without which the choice of dropout variant remains arbitrary. In this paper, we provide such theoretical foundations. First, we prove the dropout objective to be a common lower bound on the objectives of a family of infinitely many models. This family includes models corresponding to the three aforementioned methods of evaluation: the arithmetic averaging, the geometric averaging, and the deterministic. Thus by maximising the dropout objective we get a single set of parameters and many models that all have the same parameters but differ in how they make predictions. This allows us to train once and perform model selection at validation time by evaluating the different methods of making predictions corresponding to individual models in the family. Second, we turn the conventional perspective on its head by showing that while dropout training performs stochastic regularisation, the trained model is best viewed as deterministic, not as a stochastic model with a deterministic approximation.
+
+This paper is structured as follows. In $\ S 2$ , we revisit variational dropout (Gal & Ghahramani 2016a) and demonstrate that, despite common perception, sharing of masks is not necessary, neither in theory nor in practice. Then, by recasting dropout in a simple conditional form, we highlight the counterintuitive role played by the variational posterior. $\ S 3$ contains our main contributions. Here we construct a family of conditional models whose MAP objectives are all lower bounded by the usual dropout objective, and identify a member of this family as best in terms of model fit. In $\ S 4$ , we select the best of this family in terms of generalisation to improve language modelling. Finally, creating a cheap approximation to the bias of this model allows us to get better results from model tuning.
+
+# 2 VARIATIONAL DROPOUT
+
+Since its original publication (Hinton et al. 2012), dropout had been considered a stochastic regularisation method, implemented as a tweak to the loss function. That was until Gal & Ghahramani (2016a) grounded dropout in much-needed theory. Their subsequent work (Gal & Ghahramani 2016b) focused on RNNs, showing that if dropout masks are shared between time steps, the objective for their proposed variational model is the same as the commonly used dropout objective with an $\ell _ { 2 }$ penalty. Their method became known as variational dropout, not to be confused with Kingma et al. (2015), and is used in state-of-the-art sequential models (Merity et al. 2017; Melis et al. 2017). Before we move on to a more general formulation we revisit it to better understand its critical features.
+
+First, we recall the derivation of variational dropout. Consider an RNN that takes input $x$ and maps it to output $y$ and is trained on a set of $N$ data points in paired sets $X , Y$ . A variational lower bound on the log likelihood is obtained as follows:
+
+$$
+\begin{array} { l } { \displaystyle \ln p ( \boldsymbol { Y } | \boldsymbol { X } ) = \ln \underset { \omega \sim q ( \omega ) } { \mathbb { E } } \frac { p ( \boldsymbol { Y } | \boldsymbol { X } , \omega ) p ( \omega ) } { q ( \omega ) } } \\ { \displaystyle \geqslant \underset { \omega \sim q ( \omega ) } { \mathbb { E } } \ln p ( \boldsymbol { Y } | \boldsymbol { X } , \omega ) - \mathrm { K L } ( q ( \omega ) | | p ( \omega ) ) } \\ { \displaystyle = \int q ( \omega ) \ln p ( \boldsymbol { Y } | \boldsymbol { X } , \omega ) d \omega - \mathrm { K L } ( q ( \omega ) | | p ( \omega ) ) } \\ { \displaystyle = \sum _ { i = 1 } ^ { N } \int q ( \omega ) \ln p ( y _ { i } | x _ { i } , \omega ) d \omega - \mathrm { K L } ( q ( \omega ) | | p ( \omega ) ) , } \end{array}
+$$
+
+where $p ( \boldsymbol { y } | \boldsymbol { x } , \boldsymbol { \omega } )$ is defined by the RNN with weights $\omega$ . Variational Bayesian methods then maximise this lower bound with respect to the variational distribution $q ( \omega )$ . For variational dropout, $q ( \omega )$ takes the form of a mixture of two gaussians with small variances: one with zero mean that represents the dropped out rows of weights, and another with mean $\Theta$ :
+
+$$
+q ( \omega _ { r } ) = p \mathcal { N } ( \omega _ { r } | 0 , \sigma ^ { 2 } \mathrm { I } ) + ( 1 - p ) \mathcal { N } ( \omega _ { r } | \Theta _ { r } , \sigma ^ { 2 } \mathrm { I } )
+$$
+
+In the above, $r$ is the index of a row of a weight matrix. Dropping whole rows of weights is equivalent to the more familiar view of dropout over units. The prior over the weights is a zero mean gaussian:
+
+$$
+p ( \omega ) = \mathcal { N } ( \omega | 0 , \sigma _ { p } ^ { 2 } \mathrm { I } )
+$$
+
+The loss is defined based on Eq. 1. The integrals are approximated using a single sample $\hat { \omega } \sim q ( \omega )$ and the KL term is approximated with weight decay on $\Theta$ :
+
+$$
+\mathcal { L } = - \sum _ { i = 1 } ^ { N } \ln p ( y _ { i } | x _ { i } , \hat { \omega } _ { i } ) + \mathrm { K L } ( q ( \omega ) | | p ( \omega ) )
+$$
+
+The same dropout mask (and consequently the same $\omega$ ) is employed at every time step. This sharing of masks is considered the defining characteristic of variational dropout, but we note in passing that the theory for the non-shared masks case is very similar and there is little between them in practice with LSTMs (see Appendix A). With this we conclude the recap of variational dropout, and describe our contributions in the rest of the paper.
+
+# 2.1 DROPOUT AS A CONDITIONAL MODEL
+
+In variational inference the idea is to approximate the intractable and complicated posterior with a simple, parameterised distribution $q$ . Crucially, this approximation affects our inferences and predictions. If we are serious about it being an approximation to the posterior and want to reduce its distortion of the model $p$ , then $q$ can be made more flexible. But making $q$ more flexible in variational dropout can potentially ruin the regularisation effect. So the particular choice of $q$ plays an important, active role: it effectively performs posterior regularisation and acts as an integral part of the model.
+
+Coming from another angle, Osband (2016) makes the point that in variational dropout the posterior over weights does not concentrate with more data, unlike for example in Graves (2011), which is unexpected behaviour from a Bayesian model. This conundrum is caused by encoding dropout with a fixed rate mixture of fixed variance components in $q$ , which also necessitates expensive tuning of the dropout rate. Gal et al. (2017) proposes a way to address these shortcomings.
+
+To avoid getting bogged down in the issues surrounding the suitability of variational inference and ease interpretation, we construct a straightforward conditional model and lower bound its MAP objective in the same form as the variational objective. Suppose we want to do MAP estimation for the model parameters (the means of the distribution of weights, $\Theta$ ): arg maxΘ $p ( \Theta | X , Y )$ Consider a conditional model $p ( \boldsymbol { Y } | \boldsymbol { X } , \Theta )$ as a crippled generative model with $p ( x _ { i } )$ constant, $x _ { i }$ and $\Theta$ independent. Place a normal prior on the means $\Theta$ and otherwise make the weights $\omega$ conditional on $\Theta$ the same way as they were in the variational posterior $q ( \omega )$ :
+
+$$
+\begin{array} { r l } & { ~ p ( \Theta ) = N ( \Theta | 0 , \sigma _ { p } ^ { 2 } \mathrm { I } ) } \\ & { ~ p ( \omega _ { r } | \Theta ) = p \mathcal N ( \omega _ { r } | 0 , \sigma ^ { 2 } \mathrm { I } ) + ( 1 - p ) \mathcal N ( \omega _ { r } | \Theta _ { r } , \sigma ^ { 2 } \mathrm { I } ) } \\ & { p ( y , \omega | x , \Theta ) = p ( y | x , \omega ) p ( \omega | \Theta ) } \end{array}
+$$
+
+The log posterior of this model has a similar lower bound to the variational objective (Eq. 1):
+
+$$
+\ln p ( \Theta | X , Y ) \geqslant \sum _ { i = 1 } ^ { N } \int p ( \omega | \Theta ) \ln p ( y _ { i } | x _ { i } , \omega ) d \omega + \ln p ( \Theta ) - C _ { M A P }
+$$
+
+See Appendix $\textrm { C }$ for detailed derivation. Dropping the normalisation constant $C _ { M A P }$ that doesn’t depend on $\Theta$ , and approximating the above integrals with a single sample, the loss corresponding to the MAP objective becomes:
+
+$$
+\mathcal { L } _ { M A P } = - \sum _ { i = 1 } ^ { N } \ln p ( y _ { i } | x _ { i } , \hat { \omega } _ { i } ) - \ln p ( \Theta )
+$$
+
+The first term of this loss is identical to that of the loss for variational dropout (Eq 2). If the prior on $\Theta$ is a zero mean gaussian, then the second term is equivalent to a weight decay penalty just like the KL term in the variational setup. With the two losses being effectively the same, in the following we focus on MAP estimation for the conditional model to sidestep any questions about whether variational inference makes sense in this case.
+
+# 3 THE DROPOUT FAMILY OF MODELS
+
+Having developed a conditional model for dropout that leads to the same objective as variational dropout, we now derive a family of models whose objectives are all lower bounded by the usual dropout objective. We draw inspiration from the different evaluation methods employed for dropout:
+
+• Deterministic dropout propagates the expectation of each unit through the network in single pass. This is very efficient and is viewed as a good approximation to the next option. • MC dropout mimicks the training procedure, and averages the predicted probabilities over randomly sampled dropout masks. With one forward pass per sample, this can be rather expensive. There is some ambiguity as to what kind of averaging shall be applied: oftentimes the geometric average (GMC) is used, because of its close relationship to the loss, but the arithmetic average (AMC) is also widespread.
+
+Our goal in this section is to demonstrate the consequences of optimising a lower bound instead of the true objective. While it is easy to argue in general that objectives of more than one model may share any given lower bound, for dropout a particularly simple explicit construction of such a family of models is possible. As we will see, this allows for post-training model selection based on validation results given a trained set of parameters. In the absence of validation results to guide model selection, inspection of the tightness of the lower bound indicates the deterministic model as the most reasonable choice from the family.
+
+# 3.1 GEOMETRIC MODEL
+
+First, we investigate whether the geometric or the arithmetic mean is the correct choice for making predictions in the context of classification. Recall the predictive term of the MAP loss in Eq. 5:
+
+$\sum \ln p \big ( y _ { i } | x _ { i } , \hat { \omega } _ { i } \big )$ . Notice how with SGD and multiple epochs, for each data point several dropout masks are encountered, and the approximating quantity becomes the geometric mean of the predicted probabilities $p ( y _ { i } | x _ { i } , \omega )$ over the masked weights. For this reason, the posterior predictive distribution $p ( y ^ { * } | x ^ { * } , X , Y )$ is often computed as the renormalised geometric mean. This is in apparent conflict with the conditional model that prescribes the arithmetic mean (integrating $\omega$ out of Eq. 3). However, we can define another model where the conditional distribution is directly defined to be the renormalised geometric mean
+
+$$
+p ( y | x , \Theta ) = \frac { \exp \bigl ( \mathbb { E } _ { \hat { \omega } \sim p ( \omega | \Theta ) } \ln p ( y | x , \hat { \omega } ) \bigr ) } { Z ( x , \Theta ) } , \quad Z ( x , \Theta ) = \sum _ { c = 1 } ^ { C } \exp \big ( \underbrace { \mathbb { E } } _ { \hat { \omega } \sim p ( \omega | \Theta ) } \ln p ( c | x , \hat { \omega } ) \big )
+$$
+
+with a slight abuse of notation, due to using the symbol $p$ in $p ( \boldsymbol { y } | \boldsymbol { x } , \Theta )$ although $p ( \boldsymbol { y } | \boldsymbol { x } , \boldsymbol { \Theta } ) \neq$ $\mathbb { E } _ { \omega } p ( \omega | \Theta ) \bar { p } ( y | x , \omega )$ . It can be shown that the arithmetic model’s (Eq. 3) lower bound (Eq. 4) is a lower bound for this renormalised geometric model (Eq. 6), as well. See Appendix $\mathbf { D }$ for the derivation. The answer to the question whether we should use GMC or AMC is that it depends: they correspond to different models, but the dropout objective is a lower bound on the objectives of both models. So one can freely choose between GMC and AMC at evaluation time, doing model selection retrospectively after training.
+
+# 3.2 THE POWER MEAN MODEL FAMILY
+
+Having two models to choose from, it is natural to ask whether these are just instantiations of a larger class of models. We propose the power mean family of models to extend the set of models to a continuum between the geometric and arithmetic models described in $\ S 3 . 1$ and $\ S 2 . 1$ , respectively, and show that they have the same lower bound. The power mean is defined as:
+
+$$
+M _ { \alpha } ( x _ { 1 } , \ldots , x _ { n } ) = \left( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } x _ { i } ^ { \alpha } \right) ^ { 1 / \alpha }
+$$
+
+For $\alpha = 1$ we arrive at the arithmetic mean while the natural extension to $\alpha = 0$ is the geometric mean as it is the limit of $M _ { \alpha }$ at $\alpha  0$ , which can be proven with L’Hôpital’s rule. Similarly to the construction of the geometric model, we define the power mean model by directly conditioning on $\Theta$ :
+
+$$
+p ( y | x , \Theta ) = \frac { \sqrt [ \alpha ] { \mathbb { E } _ { \hat { \omega } \sim p ( \omega | \Theta ) } p ( y | x , \hat { \omega } ) ^ { \alpha } } } { Z ( x , \Theta ) } , \qquad Z ( x , \Theta ) = \sum _ { c = 1 } ^ { C } \sqrt [ \alpha ] { \mathbb { E } _ { \hat { \omega } \sim p ( \omega | \Theta ) } p ( c | x , \hat { \omega } ) ^ { \alpha } }
+$$
+
+where $Z ( x , \Theta )$ is at most 1 if $\alpha \in ( - \infty , 1 ]$ because $M _ { \alpha }$ is monotonically increasing in $\alpha$ and $Z$ is 1 for $\alpha = 1$ . Here we provide a concise derivation of a lower bound on the log posterior (the full derivation can be found in Appendix E):
+
+$$
+\begin{array} { r l } { \ln p ( \Theta | X , Y ) = \displaystyle \sum _ { i = 1 } ^ { N } \left[ \ln \sqrt { \underbrace { \mathbb { E } } _ { \left\{ \omega > p ( \omega | \Theta ) \right\} } p ( y _ { i } | x _ { i } , \hat { \omega } ) ^ { \alpha } } - \ln ( Z ( x _ { i } , \Theta ) ) \right] + \ln p ( \Theta ) - C _ { M A P } } & { } \\ { \displaystyle \geqslant \displaystyle \sum _ { i = 1 } ^ { N } \ln \sqrt { \underbrace { \mathbb { E } } _ { \left\{ \omega > p ( \omega | \Theta ) \right\} } p ( y _ { i } | x _ { i } , \hat { \omega } ) ^ { \alpha } } + \ln p ( \Theta ) - C _ { M A P } } & { } \\ { \displaystyle \geqslant \displaystyle \sum _ { i = 1 } ^ { N } \frac { 1 } { \alpha } \frac { \mathbb { E } } { \omega \sim p ( \omega | \Theta ) } \ln p ( y _ { i } | x _ { i } , \hat { \omega } ) ^ { \alpha } + \ln p ( \Theta ) - C _ { M A P } } & { } \\ { \displaystyle = \displaystyle \sum _ { i = 1 } ^ { N } \int p ( \omega | \Theta ) \ln p ( y _ { i } | x _ { i } , \omega ) d \omega + \ln p ( \Theta ) - C _ { M A P } } & { } \end{array}
+$$
+
+The first inequality above follows from $Z ( x , \Theta ) \leqslant 1$ for all $x , \Theta$ , while the second is an application of Jensen’s rule assuming $\alpha > 0$ . We arrived at the same lower bound on the objective as we had for the geometric (Eq. 6) and arithmetic models (Eq. 3), thus defining the power mean family with parameter $\alpha \in [ 0 , 1 ]$ of models from which we can choose at evaluation time. For $\alpha > 1$ , the normalising constant $Z$ would be greater than 1, and this would not be a lower bound in general.
+
+# 3.3 TIGHTNESS OF THE LOWER BOUND
+
+To better understand the quality of fit for models in the power mean family we examine the tightness of their lower bounds. There are two steps involving inequalities in the derivation of the bound: one where the normalisation constant $Z$ is dropped (Eq. 8) and another where the logarithm is moved inside the expectation (Eq. 9). We show that the gaps introduced by these steps can be made arbitrarily small by reducing the variance of $p ( \boldsymbol { y } | \boldsymbol { x } , \boldsymbol { \omega } )$ with respect to $\omega$ .
+
+Notice that the Jensen gap with the logarithm function is scale invariant:
+
+$$
+\ln ( \mathbb { E } [ \lambda L ] ) - \mathbb { E } \ln ( \lambda L ) = \ln ( \mathbb { E } L ) - \mathbb { E } \ln ( L )
+$$
+
+Intuitively, this suggests that $\mathrm { v a r } ( L ) / ( \mathbb { E } L ) ^ { 2 }$ is closely related to the size of the gap. Indeed, Maddison et al. (2017) show that if the first inverse moment of $L$ is finite, then
+
+$$
+\ln ( \mathbb { E } L ) - \mathbb { E } \ln ( L ) ) = { \frac { \operatorname { v a r } ( L ) } { 2 ( \mathbb { E } L ) ^ { 2 } } } + { \mathcal { O } } ( { \sqrt { \mathbb { E } [ ( L - \mathbb { E } L ) ^ { 6 } ] } } )
+$$
+
+Here we go a bit further and show that if there is a positive lower and upper bound on $L$ , then there are non-trivial lower and upper bounds on its Jensen gap and these are bounds are multiplicative in $\mathrm { v a r } ( L )$ . Let $L$ be a random variable such that $P ( \bar { L } \in ( a , b ) ) = 1$ where $- \infty \leqslant a < b \leqslant \infty$ . Furthermore, let $\varphi ( l )$ be a convex function. Jensen’s inequality states that $E [ \varphi ( L ) ] \geqslant \varphi ( \mathbb { E } [ L ] )$ . Liao & Berg (2017) show that the Jensen gap $E [ \varphi ( L ) ] - \varphi ( \bar { \mathbb { E } } [ L ] )$ can be bounded from below and above:
+
+$$
+\begin{array} { c } { \operatorname* { i n f } \{ h ( l ; \mu ) \mid l \in ( a , b ) \} \operatorname { v a r } ( L ) \leqslant \mathbb { E } [ \varphi ( L ) ] - \varphi ( \mathbb { E } [ L ] ) \leqslant \operatorname* { s u p } \{ h ( l ; \mu ) \mid l \in ( a , b ) \} \operatorname { v a r } ( L ) } \\ { h ( l ; \mu ) = \displaystyle \frac { \varphi ( l ) - \varphi ( \mu ) } { ( l - \mu ) ^ { 2 } } - \frac { \varphi ^ { \prime } ( \mu ) } { l - \mu } } \end{array}
+$$
+
+where $h ( l ; \mu )$ does not depend on the distribution of $L$ , only on its expected value $\mu$ and on the function $\varphi$ . Substituting $L = p ( c | x , \omega )$ (a random variable on $[ 0 , 1 ]$ due to the randomness of the dropout masks) and $\varphi ( l ) = - \ln ( l )$ , we can see that the gap introduced by Eq. 9 can be made smaller by decreasing the variance of the predictions while maintaining the expected value of $L$ (i.e. the expected probability), assuming that there is a positive lower and upper bound on them (so that the supremum is finite and the infimum is positive, respectively). A similar argument based on $\begin{array} { r } { \sum _ { c = 1 } ^ { C } M _ { \alpha } ( \mathbb { E } _ { \hat { \omega } } p ( c | x , \hat { \omega } ) ) = 1 } \end{array}$ shows that $Z$ approximately monotonically approaches 1 as the variance decreases, so the gap of Eq. 8 can also be reduced.
+
+Suppose we pick a base model from the power mean family and have a continuum of subvariants with gradually reduced variance in their predictions but the same expectation. Clearly, for each of them we can derive a lower bound the same way as we did for the power mean family. And as we showed above, the lower bounds will tend to increase as the variance of the predictions decreases (see Fig. 1a). They do not strictly increase, only tend to, due to how the Jensen gap is bounded from above and below and also due to the $\mathcal { O }$ term of Eq. 10. Nonetheless, as we approach determinism the lower bound is forced into increasingly tighter ranges with strictly monotonically increasing bounds around it, thus we can always reduce the variance such that there is no overlap between the ranges and we get a guaranteed improvement on the lower bound. This effect reaches its apex at the deterministic model whose lower bound is both exact and higher than any other model’s. Fig. 1b illustrates that regardless of the choice of base model, reducing the prediction variance will eventually transform it into the same deterministic model.
+
+# 3.4 THE EXTENDED POWER MEAN FAMILY: CONTROLLING THE TIGHTNESS OF THE BOUND
+
+Intuitively, in the absence of other sources of stochasticity the dropout rate controls the variance of the predictions and if it is low, the lower bound can be pretty snug. However, there are two problems.
+
+First, decreasing the dropout rate does not necessarily keep the expectation of the predictions the same. We offer no solution to this bias issue, but refer the reader to previous studies of dropout’s approximation properties such as (Baldi & Sadowski 2013) and our subsequent empirical results.
+
+Second, reducing the dropout rate would trade off generalisation for tighter bounds. But doing so only at evaluation time leaves the training time regularisation effect intact, and can be seen as picking another model whose lower bound tends to be higher than that of the base model. Having thus extended the dropout family further, we can now tweak both $\alpha$ and dropout rates at evaluation time.
+
+(a) Lower and upper bounds on the lower bound of the model objective as a function of prediction variance for any model in the power mean family.
+
+![](images/f57a0ac411df611128d5f354bd333f60ab55b0461115b4159e8c988c8efa3297.jpg)  
+(b) With reduced variance, all members of the power mean family (brown shading) converge to the deterministic model while their lower bounds tighten.   
+Figure 1: Tightness of lower bounds vs evaluation time prediction variance in the extended dropout family.
+
+Table 1: PTB training XEs with various dropout rate multipliers between deterministic and GMC. Observe the monotonic improvement in training fit when reducing the dropout rate at evaluation only.   
+
+<table><tr><td>×0.0</td><td>×0.1</td><td>×0.2</td><td>x0.3</td><td>×0.4</td><td>×0.5</td><td>x0.6</td><td>x0.7</td><td>×0.8</td><td>×0.9</td><td>×1.0</td></tr><tr><td>2.731</td><td>2.738</td><td>2.746</td><td>2.755</td><td>2.766</td><td>2.777</td><td>2.791</td><td>2.807</td><td>2.826</td><td>2.849</td><td>2.878</td></tr></table>
+
+Depending on the severity of the introduced bias compared to the benefits of having a tighter lower bound, the optimal variance may lie anywhere between the deterministic and the base model. We show experimentally that across a number of datasets the benefits of tighter bounds matter more, and observe monotonic improvement in model fit as evaluation time dropout rates are decreased all the way to full determinism. The experiment was conducted as follows. On an already trained model, the dropout rate was multiplied by $\lambda \in [ 0 , 1 ]$ . As Table 1 shows, the model fit as measured by cross entropy (XE) on the training set improves monotonically when reducing $\lambda$ . Results on other datasets and with other power mean models are very similar. We call the union of the reduced dropout rate subvariants of all power mean family models the extended dropout family paramaterised by $\alpha , \lambda$ .
+
+Therefore, we can say that dropout training optimises a deterministic model subject to regularisation constraints, and deterministic evaluation, widely believed to approximate MC evaluation, is the closest match to the true objective at our disposal. It is not that dropout evaluation has a deterministic approximation: dropout trains a deterministic model first and foremost and a continuum of stochastic ones to various extents.
+
+In summary, we described dropout training as optimising a common lower bound for a family of models. Since this lower bound is the same for all models in the family, we can nominate any of them at evaluation time. However, the tightness of the bound varies, which affects model fit. Having trained a model with dropout, the best fit is achieved by the deterministic model with no dropout. This result isolates the regularisation effects from the biases of the lower bound and the dropout family.
+
+# 4 APPLYING DROPOUT
+
+We investigate how members of the extended dropout model family perform in terms of generalisation. We follow the experimental setup of Melis et al. (2017) and base our work on their best performing model variant for each dataset. Unless explicitly stated, no retraining was performed and their model weights reused. In the experiments with the tuning objective, we follow their experimental setup, using Google Vizier (Golovin et al. 2017), a black-box hyperparameter tuner based on batched Gaussian Process Bandits.
+
+See Table 2 for results of image classification on MNIST, character based language modelling on Enwik8, word based language modelling on PTB and Wikitext-2. On MNIST, deterministic dropout is the best in terms of cross entropy, which matches our theoretical predictions. In contrast, on language modelling arithmetic averaging produces the best results, which necessitates further analysis.
+
+Table 2: Validation XEs on some datasets varying the power $\alpha$ and the dropout rate mulitiplier $\lambda$ . Deterministic dropout is not the best evaluation method for the language modelling datasets due to a simple smoothing effect.   
+
+<table><tr><td></td><td></td><td colspan="3">Geometric (α = 0)</td><td colspan="3">Power α = 0.5</td><td colspan="3">Arithmetic (α = 1)</td></tr><tr><td>Dataset</td><td>DET</td><td>×0.8</td><td>×0.9</td><td>×1.0</td><td>x0.8</td><td>×0.9</td><td>×1.0</td><td>×0.8</td><td>x0.9</td><td>×1.0</td></tr><tr><td>MNIST</td><td>0.070</td><td>0.087</td><td>0.087</td><td>0.088</td><td>0.92</td><td>0.93</td><td>0.93</td><td>0.100</td><td>0.100</td><td>0.100</td></tr><tr><td>Enwik8</td><td>0.886</td><td>0.879</td><td>0.878</td><td>0.881</td><td>0.877</td><td>0.877</td><td>0.877</td><td>0.875</td><td>0.875</td><td>0.875</td></tr><tr><td>PTB</td><td>4.110</td><td>4.090</td><td>4.090</td><td>4.093</td><td>4.072</td><td>4.070</td><td>4.073</td><td>4.061</td><td>4.064</td><td>4.080</td></tr><tr><td>Wikitext-2</td><td>4.236</td><td>4.229</td><td>4.231</td><td>4.235</td><td>4.025</td><td>4.026</td><td>4.208</td><td>4.203</td><td>4.212</td><td>4.228</td></tr></table>
+
+Table 3: PTB training and validation XEs for AMC at $\lambda \in \{ 0 , 0 . 8 , 1 \}$ per word frequency. Note how DET dominates AMC on the training set, but AMC is better for rare words in the validation set.   
+
+<table><tr><td></td><td>num</td><td colspan="3">training</td><td colspan="3">validation</td></tr><tr><td>frequency</td><td>targets</td><td>DET</td><td>×0.8</td><td>AMC</td><td>DET</td><td>×0.8</td><td>AMC</td></tr><tr><td>25000&lt;</td><td>13580</td><td>1.40</td><td>1.50</td><td>1.56</td><td>1.58</td><td>1.64</td><td>1.68</td></tr><tr><td>5000&lt;</td><td>26658</td><td>1.65</td><td>1.75</td><td>1.81</td><td>1.93</td><td>1.98</td><td>2.02</td></tr><tr><td>500&lt;</td><td>44702</td><td>2.19</td><td>2.30</td><td>2.36</td><td>2.58</td><td>2.63</td><td>2.66</td></tr><tr><td>&lt;500</td><td>29058</td><td>4.07</td><td>4.19</td><td>4.29</td><td>6.49</td><td>6.39</td><td>6.39</td></tr><tr><td>&lt;100</td><td>14222</td><td>4.24</td><td>4.38</td><td>4.49</td><td>7.81</td><td>7.64</td><td>7.61</td></tr><tr><td>&lt;20</td><td>5008</td><td>4.00</td><td>4.19</td><td>4.33</td><td>9.20</td><td>9.01</td><td>8.97</td></tr></table>
+
+We suspected that the particularly severe form of class imbalance exhibited by the power-law word distribution (Zipf 1935) might play a role. To verify this, we contrasted training and validation XEs on PTB for words grouped by frequency (see Table 3). On the training set, the gap between deterministic dropout and AMC is wider for low frequency words. On the validation set, AMC is worse for frequent words but better for rare words. The $\times 0 . 8$ dropout multiplier just finds a reasonable compromise.
+
+# 4.1 SOFTMAX TEMPERATURE
+
+The observed effect is consistent with smoothing, thus we posit that the reason MNIST results are worse with AMC is that the marginal distributions of labels in the training and test set are identical by construction and further smoothing is unnecessary. On the other hand, PTB and Wikitext-2 benefit from AMC’s smoothing because the penalty for underestimating low probabilities is harsh, hence the large improvement on rare words. The character based Enwik8 dataset lies somewhere in between: the training and test distributions are better matched and there are no very low probability characters.
+
+To test the hypothesis that AMC’s advantage lies in smoothing, we tested how performing smoothing by other means affects the results. In this experiment, on a trained model the temperature of the final softmax was optimised on the validation set and the model was applied with the optimal temperature to the validation and test sets. Our experimental results in Table 4 support the hypotheses that AMC smooths the predicted distribution as increasing the temperature improves DET and GMC considerably but not AMC. In fact, the optimal temperature for AMC with $\lambda = 1$ was slightly lower than 1, which corresponds to sharpening, not smoothing.
+
+Table 4: Validation and test perplexities on PTB and Wikitext-2 with various evaluation strategies and default or optimal validation softmax temperatures. Our baseline results correspond to DET at temperature 1. Note that AMC does not benefit from setting the optimal softmax temperature (“opt”), while DET is improved by it almost to the point of matching AMC which supports the smoothing hypothesis.   
+
+<table><tr><td colspan="4"></td><td colspan="3">Geometric (α = 0)</td><td colspan="3">Power α = 0.5</td><td colspan="3">Arithmetic (α = 1)</td></tr><tr><td colspan="2">Dataset</td><td>Temp</td><td>DET</td><td>×0.8</td><td>×0.9</td><td>×1.0</td><td>×0.8</td><td>×0.9</td><td>×1.0</td><td>×0.8</td><td>×0.9</td><td>×1.0</td></tr><tr><td rowspan="4">Viiapian</td><td rowspan="2">WT-2</td><td>1</td><td>69.1</td><td>68.6</td><td>68.8</td><td>69.1</td><td>67.0</td><td>67.2</td><td>67.2</td><td>66.9</td><td>67.5</td><td>68.6</td></tr><tr><td>opt</td><td>67.4</td><td>67.5</td><td>67.7</td><td>68.0</td><td>67.0</td><td>67.1</td><td>67.2</td><td>66.9</td><td>67.4</td><td>68.1</td></tr><tr><td rowspan="2">PTB</td><td>1</td><td>60.9</td><td>59.6</td><td>59.7</td><td>59.7</td><td>58.1</td><td>57.9</td><td>58.0</td><td>57.3</td><td>57.5</td><td>58.5</td></tr><tr><td>opt</td><td>57.5</td><td>57.5</td><td>57.9</td><td>58.3</td><td>57.1</td><td>57.3</td><td>57.8</td><td>57.1</td><td>57.5</td><td>58.4</td></tr><tr><td rowspan="4">3</td><td rowspan="2">WT-2</td><td>1</td><td>65.9</td><td>65.3</td><td>65.4</td><td>65.6</td><td>63.8</td><td>63.9</td><td>64.2</td><td>63.7</td><td>64.5</td><td>65.5</td></tr><tr><td>opt</td><td>64.5</td><td>64.7</td><td>64.8</td><td>64.9</td><td>63.8</td><td>63.8</td><td>64.2</td><td>63.7</td><td>64.2</td><td>64.9</td></tr><tr><td rowspan="2">PTB</td><td>1</td><td>58.6</td><td>57.3</td><td>57.4</td><td>57.4</td><td>56.0</td><td>55.8</td><td>55.9</td><td>55.3</td><td>55.5</td><td>56.5</td></tr><tr><td>opt</td><td>56.0</td><td>56.0</td><td>56.1</td><td>56.5</td><td>55.7</td><td>55.7</td><td>56.0</td><td>55.3</td><td>55.5</td><td>56.3</td></tr></table>
+
+Tuning the evaluation time softmax temperature is similar to label smoothing (Pereyra et al. 2017), the main difference being that our method does not affect training. While this is convenient, for tuning model hyperparameters, ideally we would determine the optimal evaluation parameters $\alpha$ $\lambda$ and the temperature for the calculation of the validation score for each set of hyperparameters tried, but this would be prohibitively expensive. Since deterministic evaluation coupled with the optimal temperature is very close to the best performing AMC model, it serves as a good proxy for the ideal tuning objective. The optimal temperature can be approximately determinined using a linear search on a subset of the validation data which is orders of magnitude faster than MC dropout. In our experiments, hyperparameter tuning with validation scores computed at the optimal softmax temperature did improve results, albeit very slightly (about half a perplexity point). Thus we can conclude that deterministic dropout is already a reasonable proxy for which to optimise.
+
+# 4.2 RESULTS
+
+We have improved the best test result of Melis et al. (2017) from 58.3 to 55.7 on PTB, and from 65.9 to 63.7 on Wikitext-2 using their model weights, only tuning the evaluation parameters $\alpha , \lambda$ and the softmax temperature on the validation set. By retuning the hyperparameters of the PTB model with optimal temperature deterministic evaluation, we improved to 55.3 on PTB. For lack of resources, we did not retune for Wikitext-2. For comparison, the state of the art in language modelling without resorting to dynamic evaluation or a continuous cache pointer is Mixture of Softmaxes (Yang et al. 2017) with 54.44 and 61.45 on PTB and Wikitext-2, respectively. At present, it is unclear whether the benefits of their approach and ours combine.
+
+In summary, we looked at how different models and evaluation methods rank in terms of generalisation. Across a number of tasks and datasets the ranking differed from what was observed on the training set. We found that AMC smooths the distribution of the prediction probabilities and we achieved a similar effect without resorting to expensive sampling simply by adjusting the temperature of the final softmax. Finally, we brought the tuning objective more in line with the improved evaluation by automatically determining the optimal softmax temperature when evaluating on the validation set which further improved results.
+
+# 5 IMPLICATIONS
+
+The construction of a conditional model family with a common lower bound on their objectives is applicable to other latent variable models with similar structure and inference method. This lower bound admits ambiguity as to what model is being fit to the data, which in turn allows for picking any such model at evaluation time. However, the tightness of the bound and the quality of the fit varies. For dropout, the deterministic model has the best fit even though the training objective is highly stochastic, but this result hinges on the approximation properties of deterministic dropout and will not carry over to other probabilistic models in general. In particular, standard VAEs (Kingma & Welling 2013) with their lower bound being very similar in construction to Eq. 1 cannot quite collapse to a deterministic model else they suffer an infinite KL penalty. Still, the lower bound being looser on the tails of $q$ is related to problem of underestimating posterior uncertainty (Turner & Sahani 2011).
+
+In related works, expectation-linear dropout (Ma et al. 2016) and fraternal dropout (Zolna et al. 2017) both try to reduce the “inference gap”: the mismatch between the training objective and deterministic evaluation. The gains reported in those works might be explained by reducing the bias of deterministic evaluation and also by encouraging small variance in the predictions and thus getting tighter bounds. Another recent work, activation regularisation (Merity et al. 2017), could be thought of as a mechanism to reduce the variance of predictions to a similar effect. In the context of language modelling, the connection between noise and smoothing was established by Xie et al. (2017). Our improved understanding further emphasises that connection, and at the same time challenges the way we think about dropout.
+
+# REFERENCES
+
+Pierre Baldi and Peter J Sadowski. Understanding dropout. In Advances in neural information processing systems, pp. 2814–2822, 2013.
+
+Justin Bayer, Christian Osendorfer, Daniela Korhammer, Nutan Chen, Sebastian Urban, and Patrick van der Smagt. On fast dropout and its applicability to recurrent networks. arXiv preprint arXiv:1311.0701, 2013.
+
+Yarin Gal and Zoubin Ghahramani. Dropout as a bayesian approximation: Representing model uncertainty in deep learning. In international conference on machine learning, pp. 1050–1059, 2016a.
+
+Yarin Gal and Zoubin Ghahramani. A theoretically grounded application of dropout in recurrent neural networks. In Advances in Neural Information Processing Systems, pp. 1019–1027, 2016b.
+
+Yarin Gal, Jiri Hron, and Alex Kendall. Concrete dropout. In Advances in Neural Information Processing Systems, pp. 3584–3593, 2017.
+
+Daniel Golovin, Benjamin Solnik, Subhodeep Moitra, Greg Kochanski, John Karro, and D Sculley. Google vizier: A service for black-box optimization. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 1487–1495. ACM, 2017.
+
+Alex Graves. Practical variational inference for neural networks. In Advances in Neural Information Processing Systems, pp. 2348–2356, 2011.
+
+Geoffrey E Hinton, Nitish Srivastava, Alex Krizhevsky, Ilya Sutskever, and Ruslan R Salakhutdinov. Improving neural networks by preventing co-adaptation of feature detectors. arXiv preprint arXiv:1207.0580, 2012.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.
+
+Diederik P Kingma, Tim Salimans, and Max Welling. Variational dropout and the local reparameterization trick. In Advances in Neural Information Processing Systems, pp. 2575–2583, 2015.
+
+JG Liao and Arthur Berg. Sharpening jensen’s inequality. The American Statistician, 2017.
+
+Xuezhe Ma, Yingkai Gao, Zhiting Hu, Yaoliang Yu, Yuntian Deng, and Eduard H. Hovy. Dropout with expectation-linear regularization. CoRR, abs/1609.08017, 2016. URL http://arxiv. org/abs/1609.08017.
+
+Chris J Maddison, John Lawson, George Tucker, Nicolas Heess, Mohammad Norouzi, Andriy Mnih, Arnaud Doucet, and Yee Teh. Filtering variational objectives. In Advances in Neural Information Processing Systems, pp. 6573–6583, 2017.
+
+Gábor Melis, Chris Dyer, and Phil Blunsom. On the state of the art of evaluation in neural language models. arXiv preprint arXiv:1707.05589, 2017.
+
+Stephen Merity, Nitish Shirish Keskar, and Richard Socher. Regularizing and optimizing lstm language models. arXiv preprint arXiv:1708.02182, 2017.
+
+Ian Osband. Risk versus uncertainty in deep learning: Bayes, bootstrap and the dangers of dropout. In NIPS Bayesian Deep Learning Workshop, 2016.
+
+Marius Pachitariu and Maneesh Sahani. Regularization and nonlinearities for neural language models: when are they needed? arXiv preprint arXiv:1301.5650, 2013.
+
+Gabriel Pereyra, George Tucker, Jan Chorowski, Łukasz Kaiser, and Geoffrey Hinton. Regularizing neural networks by penalizing confident output distributions. arXiv preprint arXiv:1701.06548, 2017.
+
+Stanislau Semeniuta, Aliaksei Severyn, and Erhardt Barth. Recurrent dropout without memory loss. arXiv preprint arXiv:1603.05118, 2016.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research, 15(1):1929–1958, 2014.   
+Richard E Turner and Maneesh Sahani. Two problems with variational expectation maximisation for time-series models. Bayesian Time series models, 1(3.1):3–1, 2011.   
+Sida Wang and Christopher Manning. Fast dropout training. In international conference on machine learning, pp. 118–126, 2013.   
+David Warde-Farley, Ian J Goodfellow, Aaron Courville, and Yoshua Bengio. An empirical analysis of dropout in piecewise linear networks. arXiv preprint arXiv:1312.6197, 2013.   
+Ziang Xie, Sida I Wang, Jiwei Li, Daniel Lévy, Aiming Nie, Dan Jurafsky, and Andrew Y Ng. Data noising as smoothing in neural network language models. arXiv preprint arXiv:1703.02573, 2017.   
+Zhilin Yang, Zihang Dai, Ruslan Salakhutdinov, and William W Cohen. Breaking the softmax bottleneck: a high-rank rnn language model. arXiv preprint arXiv:1711.03953, 2017.   
+Wojciech Zaremba, Ilya Sutskever, and Oriol Vinyals. Recurrent neural network regularization. arXiv preprint arXiv:1409.2329, 2014.   
+George Kingsley Zipf. The psycho-biology of language. Houghton, Mifflin, 1935.   
+Konrad Zolna, Devansh Arpit, Dendi Suhubdy, and Yoshua Bengio. Fraternal dropout. arXiv preprint arXiv:1711.00066, 2017.
+
+# APPENDIX A VARIATIONAL DROPOUT WITH NON-SHARED MASKS
+
+If $q$ and $p$ are redefined for the non-shared setting to be products of identical and independent, per time step factors, neither term of the variational objective requires rethinking: the MC approximation still works since $q$ is easy to sample from, while the KL term becomes a sum of componentwise KL divergences and can still be implemented as weight decay. Consequently, both shared and non-shared masks fit into the variational framework. For a detailed derivation see Appendix B.
+
+In related works, Pachitariu & Sahani (2013) in their investigation of regularisation of standard RNN based language models dismiss applying dropout to recurrent connections “to avoid introducing instabilities into the recurrent part of the LMs”. Bayer et al. (2013) echo this claim about RNNs, which is then cited by Zaremba et al. (2014), but their work is based on LSTMs not standard RNNs. Finally, Gal & Ghahramani (2016b) cite all of the above but also work with LSTMs. Their results indicate a large, about 15 perplexity point advantage to shared mask dropout for language modelling on the Penn Treebank (PTB) corpus (see Fig. 2 in their paper).
+
+Our experimental results obtained with careful and extensive hyperparameter tuning, listed in Table 5, indicate only a small difference between the two which is in agreement with the empirical study of Semeniuta et al. (2016).
+
+Table 5: Validation and test set perplexities on PTB with shared (S) or non-shared (NS) dropout masks for a small, 1 layer and a large, 4 layer LSTM with 10 and 24 million weights, respectively. Non-shared masks perform nearly as well as shared masks and as we have seen neither is “more variational” than the other.   
+
+<table><tr><td>dataset</td><td colspan="2">10M</td><td colspan="2">24M</td></tr><tr><td></td><td>S</td><td>NS</td><td>S</td><td>NS</td></tr><tr><td>validation</td><td>59.4</td><td>60.2</td><td>57.5</td><td>58.3</td></tr><tr><td>test</td><td>57.5</td><td>58.6</td><td>56.0</td><td>56.9</td></tr></table>
+
+In any case, non-shared masks, in addition to being variational, are also surprisingly competitive with shared masks for LSTMs (we make no claims about standard RNNs). We also tested whether embedding dropout (in which dropout is applied to entire vectors in the input embedding lookup table) proposed by Gal & Ghahramani (2016b) improves results, and find that embedding dropout does not offer any improvement on top of input dropout.
+
+# APPENDIX B DERIVATION OF VARIATIONAL DROPOUT WITH NON-SHARED MASKS
+
+In this section, we formulate naive (i.e. non-shared mask) dropout in the variational setting. In contrast to the shared mask case, where $\omega$ was a single set of weights, here $\omega ^ { 1 : T }$ (or $\omega$ , for short) has a set of weights for each time step that differ in their dropout masks. The variational posterior $q ( \omega )$ and the prior $p ( \omega )$ are both products of identical distributions over time:
+
+$$
+\begin{array} { l } { \displaystyle q ( \omega ^ { 1 : T } ) = \prod _ { t = 1 } ^ { T } q ^ { \prime } ( \omega ^ { t } ) = \prod _ { t = 1 } ^ { T } \big [ p \mathcal N ( \omega ^ { t } | 0 , \sigma ^ { 2 } ) + ( 1 - p ) \mathcal N ( \omega ^ { t } | \Theta , \sigma ^ { 2 } ) \big ] } \\ { \displaystyle p ( \omega ^ { 1 : T } ) = \prod _ { t = 1 } ^ { T } p ^ { \prime } ( \omega ^ { t } ) = \prod _ { t = 1 } ^ { T } \mathcal N ( \omega ^ { t } | 0 , \sigma _ { p } ^ { 2 } ) } \end{array}
+$$
+
+An unbiased approximation to the integrals in Eq. 1 is based on a single, easy to obtain sample $\hat { \omega } \sim q ( \omega )$ :
+
+$$
+\int q ( \omega ) \ln p ( y | x , \omega ) d \omega \approx \ln p ( y | x , \hat { \omega } )
+$$
+
+Showing that the KL term can still be approximated with weight decay with non-shared masks is not much more involved. Both distributions are products of densities over independent random variables,
+
+so the componentwise KL divergencies sum. In particular:
+
+$$
+\begin{array} { r l } {  { \operatorname { E I } ( \{ \boldsymbol { g } ( \omega ) \} \| \boldsymbol { \rho } ( \omega ) ) = \int ( \prod _ { t = 1 } ^ { T } q ^ { \prime } ( \omega ^ { * } ) ) \ln \prod _ { t = 1 } ^ { T } \dot { q } ^ { \prime } ( \omega ^ { * } ) } } \\ & { = \int ( \prod _ { t = 1 } ^ { T } q ^ { \prime } ( \omega ^ { * } ) ) \frac { T } { \epsilon = 1 } \ln \frac { q ^ { \prime } ( \omega ^ { * } ) } { \tilde { p } ^ { \prime } ( \omega ^ { * } ) } d \omega } \\ & { = \sum _ { t = 1 } ^ { T } \int ( \prod _ { t = 1 } ^ { T } q ^ { \prime } ( \omega ^ { * } ) ) \ln \frac { q ^ { \prime } ( \omega ^ { * } ) } { \tilde { p } ^ { \prime } ( \omega ^ { * } ) } d \omega } \\ & { = \frac { \sum } { t = 1 } ^ { T } \int [ \frac { 1 } { \epsilon = 1 } ^ { T } q ^ { \prime } ( \omega ^ { * } ) ] \ln \frac { q ^ { \prime } ( \omega ^ { * } ) } { \tilde { p } ^ { \prime } ( \omega ^ { * } ) } d \omega } \\ & { = \frac { \sum } { t = 1 } ^ { T } \int [ \frac { 1 } { \epsilon = 1 , \epsilon \epsilon \epsilon } q ^ { \prime } ( \omega ^ { * } ) ] [ \dot { q } ^ { \prime } ( \omega ^ { * } ) \ln \frac { \dot { q } ^ { \prime } ( \omega ^ { * } ) } { \tilde { p } ^ { \prime } ( \omega ^ { * } ) } ] d \omega } \\ & { = \frac { \sum } { t = 1 } ^ { T } [ \int \frac { 1 } { \epsilon = 1 , \epsilon \epsilon } q ^ { \prime } ( \omega ^ { * } ) d \omega ^ { * } ] [ \int q ^ { \prime } ( \omega ) \ln \frac { q ^ { \prime } ( \omega ^ { * } ) } { \tilde { p } ^ { \prime } ( \omega ^ { * } ) } d \omega ] } \\ & { = \Gamma \cdot \mathbb { E } [ \int _ { \epsilon = 1 } ^ { T } q ^ { \prime } ( \omega ) \mathrm { l i s } q ^ { \prime } ( \omega ^ { * } ) d \omega ^ { * } ] } \\ & { = T \cdot \mathbb { E } [ \mathrm { L G } [ ( \omega ) \mathrm { l i s } / \omega ^ { * } ) ] } \end{array}
+$$
+
+We partitioned the variables into two mutually exclusive sets $w ^ { t }$ and its complement $w ^ { \backslash t }$ , and split the multiple integral using Fubini’s theorem (or, equivalently, using the expectation of independent random variables rule). After the split, the first integral is trivially 1 and the second has no dependence on $T$ .
+
+What we end up with is a sum of identical KL terms of the same distributions as in the shared mask case, so the full KL can be approximated with weight decay.
+
+# APPENDIX C DERIVATION OF THE MAP LOWER BOUND FOR THE ARITHMETIC MODEL
+
+We can rewrite the posterior as:
+
+$$
+\begin{array} { l } { p ( \Theta | X , Y ) = \displaystyle \frac { p ( X , Y | \Theta ) p ( \Theta ) } { p ( X , Y ) } } \\ { \propto p ( X , Y | \Theta ) p ( \Theta ) } \\ { = \displaystyle \int p ( Y | X , \omega , \Theta ) p ( \omega | \Theta , X ) p ( \Theta | X ) p ( X ) d \omega } \\ { \propto \displaystyle \int p ( Y | X , \omega ) p ( \omega | \Theta ) p ( \Theta ) d \omega } \end{array}
+$$
+
+Moving to the log domain and using Jensen’s inequality allows us to construct a lower bound that is a sum of per data point terms (i.e. something that can be conveniently optimised):
+
+$$
+\begin{array} { l } { \displaystyle \ln p ( \Theta | X , Y ) = \ln \int p ( Y | X , \omega ) p ( \omega | \Theta ) p ( \Theta ) d \omega - C _ { M A P } } \\ { \displaystyle \qquad = \ln \int p ( \omega | \Theta ) \prod _ { i = 1 } ^ { N } p ( y _ { i } | x _ { i } , \omega ) d \omega + \ln p ( \Theta ) - C _ { M A P } } \\ { \displaystyle \qquad \geqslant \int p ( \omega | \Theta ) \ln \prod _ { i = 1 } ^ { N } p ( y _ { i } | x _ { i } , \omega ) d \omega + \ln p ( \Theta ) - C _ { M A P } } \\ { \displaystyle \qquad = \sum _ { i = 1 } ^ { N } \int p ( \omega | \Theta ) \ln p ( y _ { i } | x _ { i } , \omega ) d \omega + \ln p ( \Theta ) - C _ { M A P } } \end{array}
+$$
+
+# APPENDIX D DERIVATION OF THE MAP LOWER BOUND FOR THE GEOMETRIC MODEL
+
+From Eq. 6 recall that:
+
+$$
+p ( y | x , \Theta ) = \frac { \exp \left( \mathbb { E } _ { \hat { \omega } \sim p ( \omega | \Theta ) } \ln p ( y | x , \hat { \omega } ) \right) } { Z ( x , \Theta ) }
+$$
+
+The normalisation constant $Z$ is at most 1, due to the geometric mean being bounded from above by the arithmetic mean on a per class $c$ basis:
+
+$$
+\begin{array} { r l } & { Z ( x , \Theta ) = \displaystyle \sum _ { c = 1 } ^ { C } e x p \big ( \underset { \hat { \omega } \sim p ( \omega | \Theta ) } { \mathbb { E } } \ln p ( c | x , \hat { \omega } ) \big ) } \\ & { \qquad \leqslant \displaystyle \sum _ { c = 1 } ^ { C } \underset { \hat { \omega } \sim p ( \omega | \Theta ) } { \mathbb { E } } p ( c | x , \hat { \omega } ) } \\ & { \qquad = \underset { \hat { \omega } \sim p ( \omega | \Theta ) } { \mathbb { E } } \displaystyle \sum _ { c = 1 } ^ { C } p ( c | x , \hat { \omega } ) = 1 } \end{array}
+$$
+
+Since this a conditional model, we can rewrite the posterior as:
+
+$$
+\begin{array} { l } { \displaystyle p ( \Theta | X , Y ) = \frac { p ( X , Y | \Theta ) p ( \Theta ) } { p ( X , Y ) } } \\ { \displaystyle \propto p ( X , Y | \Theta ) p ( \Theta ) } \\ { \displaystyle = p ( Y | X , \Theta ) p ( X | \Theta ) p ( \Theta ) } \\ { \displaystyle \propto p ( Y | X , \Theta ) p ( \Theta ) } \end{array}
+$$
+
+$p ( X | \Theta )$ is dropped in the last step as it is constant. Moving to the log domain once again:
+
+$$
+\begin{array} { l } { \displaystyle \ln p ( \Theta | X , Y ) = \ln p ( Y | X , \Theta ) + \ln p ( \Theta ) - C _ { M A P } } \\ { \displaystyle = \ln \prod _ { i = 1 } ^ { N } p ( y _ { i } | x _ { i } , \Theta ) + \ln p ( \Theta ) - C _ { M A P } } \\ { \displaystyle = \sum _ { i = 1 } ^ { N } \left[ _ { \xi \sim p ( \omega | \Theta ) } \ln p ( y _ { i } | x _ { i } , \tilde { \omega } ) - \ln ( Z ( x _ { i } , \Theta ) ) \right] + \ln p ( \Theta ) - C _ { M A P } } \\ { \displaystyle \geqslant \sum _ { i = 1 } ^ { N } \frac { \mathbb { P } } { \delta \ - \nu p ( \omega | \Theta ) } \ln p ( y _ { i } | x _ { i } , \tilde { \omega } ) + \ln p ( \Theta ) - C _ { M A P } } \\ { \displaystyle = \sum _ { i = 1 } ^ { N } \int p ( \omega | \Theta ) \ln p ( y _ { i } | x _ { i } , \Theta ) d \omega + \ln p ( \Theta ) - C _ { M A P } } \end{array}
+$$
+
+where the lower bound arises due to $\forall i \colon Z ( x _ { i } , \Theta ) \leqslant 1$ .
+
+# APPENDIX E DERIVATION OF THE MAP LOWER BOUND FOR THE POWER MEAN FAMILY
+
+In $\ S 3 . 2$ we proved that $\forall i \colon Z ( x _ { i } , \Theta ) \leqslant 1$ . Starting from $p ( \Theta | X , Y ) \propto p ( Y | X , \Theta ) p ( \Theta )$ just like in the geometric case, we derive a lower bound in the log domain:
+
+$$
+\begin{array} { l } { \ln p ( \Theta | X , Y ) = \ln p ( Y | X , \Theta ) + \ln p ( \Theta ) - C _ { M A P } } \\ { \displaystyle \qquad = \ln \prod _ { i = 1 } ^ { N } p ( y _ { i } | x _ { i } , \Theta ) + \ln p ( \Theta ) - C _ { M A P } } \\ { \displaystyle \qquad = \sum _ { i = 1 } ^ { N } \left[ \ln \sqrt \ [ 6 ] { \underset { \displaystyle \hat { \omega } \sim p ( \omega | \Theta ) } { \mathbb { E } } p ( y _ { i } | x _ { i } , \hat { \omega } ) ^ { \alpha } } - \ln ( Z ( x _ { i } , \Theta ) ) \right] + \ln p ( \Theta ) - C _ { M A P } } \end{array}
+$$
+
+$$
+\begin{array} { r l } & { \lesssim \displaystyle \sum _ { i = 1 } ^ { N } \displaystyle \prod _ { \ell = \mathrm { e } p ( \omega | \Theta ) } p ( y | x _ { i } | x _ { i } , \hat { \omega } ) ^ { \alpha } + \operatorname* { l n } p ( \Theta ) - C _ { M i } , } \\ & { = \displaystyle \sum _ { i = 1 } ^ { N } \displaystyle \frac { 1 } { \alpha } \ln \bigg ( \int _ { ( - \mathrm { e } \mathbb { P } ^ { \alpha } ( \omega | \Theta ) ) } p ( y _ { i } | x _ { i } , \hat { \omega } ) ^ { \alpha } \bigg ) + \operatorname* { l n } p ( \Theta ) - C _ { M i } , } \\ & { \gg \displaystyle \sum _ { i = 1 } ^ { N } \frac { 1 } { \alpha } \int _ { ( - \mathrm { e } \mathbb { P } ^ { \alpha } ( i \omega | \Theta ) ) } \ln p ( y _ { i } | x _ { i } , \hat { \omega } ) ^ { \alpha } + \operatorname* { l n } p ( \Theta ) - C _ { M i } , } \\ & { = \displaystyle \sum _ { i = 1 } ^ { N } \mathrm { e } \int _ { ( - \mathrm { e } \mathbb { P } ^ { \alpha } ( i \omega | \Theta ) ) } \ln p ( y _ { i } | x _ { i } , \hat { \omega } ) + \operatorname* { l n } p ( \Theta ) - C _ { M i } , } \\ & { = \displaystyle \sum _ { i = 1 } ^ { N } \int _ { \mathbb { P } ^ { \alpha } ( i \omega | \Theta ) } \ln p ( y _ { i } | x _ { i } , \hat { \omega } ) + \operatorname* { l n } p ( \Theta ) - C _ { M i } , } \\ & { = \displaystyle \sum _ { i = 1 } ^ { N } \int _ { \mathbb { P } ^ { \alpha } ( i \omega | \Theta ) } \ln p ( y _ { i } | x _ { i } , \omega ) d \omega + \operatorname* { l n } p ( \Theta ) - C _ { M i } , } \end{array}
+$$

parse/train/rklwwo05Ym/rklwwo05Ym_content_list.json

@@ -0,0 +1,1653 @@
+[
+    {
+        "type": "text",
+        "text": "PUSHING THE BOUNDS OF DROPOUT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            101,
+            609,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            145,
+            400,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            210,
+            544,
+            224
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We show that dropout training is best understood as performing MAP estimation concurrently for a family of conditional models whose objectives are themselves lower bounded by the original dropout objective. This discovery allows us to pick any model from this family after training, which leads to a substantial improvement on regularisation-heavy language modelling. The family includes models that compute a power mean over the sampled dropout masks, and their less stochastic subvariants with tighter and higher lower bounds than the fully stochastic dropout objective. We argue that since the deterministic subvariant’s bound is equal to its objective, and the highest amongst these models, the predominant view of it as a good approximation to MC averaging is misleading. Rather, deterministic dropout is the best available approximation to the true objective. ",
+        "bbox": [
+            233,
+            241,
+            764,
+            393
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            420,
+            336,
+            435
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The regularisation technique known as dropout underpins numerous state-of-the-art results in deep learning (Hinton et al. 2012; Srivastava et al. 2014), and its application has received much attention in the form of optimisation (Wang & Manning 2013) and attempts at explaining or improving its approximation properties (Baldi & Sadowski 2013; Zolna et al. 2017; Ma et al. 2016). The dominant perspective today views dropout as either an implicit ensemble method (Warde-Farley et al. 2013) or averaging over an approximate Bayesian posterior (Gal & Ghahramani 2016a). Regardless of which view we take, dropout training is carried out the same way, by minimising the expectation of the loss over randomly sampled dropout masks. However, at test time these views naturally lead to different algorithms: the Bayesian approach computes an arithmetic average as it marginalises out the weight uncertainty, while the ensemble approach typically uses the geometric average due to its close relationship to the loss. Collectively they are called MC dropout and neither is clearly better than the other (Warde-Farley et al. 2013). A third way to make predictions is to “turn dropout off”, that is, propagate expected values through the network in a single, deterministic pass. This deterministic (also known as standard) dropout in considered to be an excellent approximation to MC dropout. ",
+        "bbox": [
+            174,
+            452,
+            825,
+            646
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This situation is unsatisfactory as it does not provide theoretical grounding for dropout, without which the choice of dropout variant remains arbitrary. In this paper, we provide such theoretical foundations. First, we prove the dropout objective to be a common lower bound on the objectives of a family of infinitely many models. This family includes models corresponding to the three aforementioned methods of evaluation: the arithmetic averaging, the geometric averaging, and the deterministic. Thus by maximising the dropout objective we get a single set of parameters and many models that all have the same parameters but differ in how they make predictions. This allows us to train once and perform model selection at validation time by evaluating the different methods of making predictions corresponding to individual models in the family. Second, we turn the conventional perspective on its head by showing that while dropout training performs stochastic regularisation, the trained model is best viewed as deterministic, not as a stochastic model with a deterministic approximation. ",
+        "bbox": [
+            174,
+            652,
+            825,
+            805
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper is structured as follows. In $\\ S 2$ , we revisit variational dropout (Gal & Ghahramani 2016a) and demonstrate that, despite common perception, sharing of masks is not necessary, neither in theory nor in practice. Then, by recasting dropout in a simple conditional form, we highlight the counterintuitive role played by the variational posterior. $\\ S 3$ contains our main contributions. Here we construct a family of conditional models whose MAP objectives are all lower bounded by the usual dropout objective, and identify a member of this family as best in terms of model fit. In $\\ S 4$ , we select the best of this family in terms of generalisation to improve language modelling. Finally, creating a cheap approximation to the bias of this model allows us to get better results from model tuning. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 VARIATIONAL DROPOUT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            406,
+            117
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Since its original publication (Hinton et al. 2012), dropout had been considered a stochastic regularisation method, implemented as a tweak to the loss function. That was until Gal & Ghahramani (2016a) grounded dropout in much-needed theory. Their subsequent work (Gal & Ghahramani 2016b) focused on RNNs, showing that if dropout masks are shared between time steps, the objective for their proposed variational model is the same as the commonly used dropout objective with an $\\ell _ { 2 }$ penalty. Their method became known as variational dropout, not to be confused with Kingma et al. (2015), and is used in state-of-the-art sequential models (Merity et al. 2017; Melis et al. 2017). Before we move on to a more general formulation we revisit it to better understand its critical features. ",
+        "bbox": [
+            173,
+            132,
+            826,
+            246
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "First, we recall the derivation of variational dropout. Consider an RNN that takes input $x$ and maps it to output $y$ and is trained on a set of $N$ data points in paired sets $X , Y$ . A variational lower bound on the log likelihood is obtained as follows: ",
+        "bbox": [
+            174,
+            251,
+            823,
+            292
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/83488694676c911736b8ddaeaf908d0f9cdbbc0868a944b6887ad7328464e48c.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\ln p ( \\boldsymbol { Y } | \\boldsymbol { X } ) = \\ln \\underset { \\omega \\sim q ( \\omega ) } { \\mathbb { E } } \\frac { p ( \\boldsymbol { Y } | \\boldsymbol { X } , \\omega ) p ( \\omega ) } { q ( \\omega ) } } \\\\ { \\displaystyle \\geqslant \\underset { \\omega \\sim q ( \\omega ) } { \\mathbb { E } } \\ln p ( \\boldsymbol { Y } | \\boldsymbol { X } , \\omega ) - \\mathrm { K L } ( q ( \\omega ) | | p ( \\omega ) ) } \\\\ { \\displaystyle = \\int q ( \\omega ) \\ln p ( \\boldsymbol { Y } | \\boldsymbol { X } , \\omega ) d \\omega - \\mathrm { K L } ( q ( \\omega ) | | p ( \\omega ) ) } \\\\ { \\displaystyle = \\sum _ { i = 1 } ^ { N } \\int q ( \\omega ) \\ln p ( y _ { i } | x _ { i } , \\omega ) d \\omega - \\mathrm { K L } ( q ( \\omega ) | | p ( \\omega ) ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            299,
+            705,
+            439
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $p ( \\boldsymbol { y } | \\boldsymbol { x } , \\boldsymbol { \\omega } )$ is defined by the RNN with weights $\\omega$ . Variational Bayesian methods then maximise this lower bound with respect to the variational distribution $q ( \\omega )$ . For variational dropout, $q ( \\omega )$ takes the form of a mixture of two gaussians with small variances: one with zero mean that represents the dropped out rows of weights, and another with mean $\\Theta$ : ",
+        "bbox": [
+            173,
+            444,
+            825,
+            500
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8b0b7269d44d27274049fdf4f8c08203d284a03f45d1ae3cfd1a7ea935569583.jpg",
+        "text": "$$\nq ( \\omega _ { r } ) = p \\mathcal { N } ( \\omega _ { r } | 0 , \\sigma ^ { 2 } \\mathrm { I } ) + ( 1 - p ) \\mathcal { N } ( \\omega _ { r } | \\Theta _ { r } , \\sigma ^ { 2 } \\mathrm { I } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            505,
+            663,
+            523
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the above, $r$ is the index of a row of a weight matrix. Dropping whole rows of weights is equivalent to the more familiar view of dropout over units. The prior over the weights is a zero mean gaussian: ",
+        "bbox": [
+            173,
+            529,
+            823,
+            558
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7aa94fc918d0cfe8ec6b2f96014821ab6fffadccdd37019e1664a71bb2458d4f.jpg",
+        "text": "$$\np ( \\omega ) = \\mathcal { N } ( \\omega | 0 , \\sigma _ { p } ^ { 2 } \\mathrm { I } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            563,
+            568,
+            583
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The loss is defined based on Eq. 1. The integrals are approximated using a single sample $\\hat { \\omega } \\sim q ( \\omega )$ and the KL term is approximated with weight decay on $\\Theta$ : ",
+        "bbox": [
+            171,
+            588,
+            823,
+            617
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7556c61ac51c43a9b10506dc0190bd56d288232412f7d3c9459e667ffdf982b3.jpg",
+        "text": "$$\n\\mathcal { L } = - \\sum _ { i = 1 } ^ { N } \\ln p ( y _ { i } | x _ { i } , \\hat { \\omega } _ { i } ) + \\mathrm { K L } ( q ( \\omega ) | | p ( \\omega ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            622,
+            648,
+            666
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The same dropout mask (and consequently the same $\\omega$ ) is employed at every time step. This sharing of masks is considered the defining characteristic of variational dropout, but we note in passing that the theory for the non-shared masks case is very similar and there is little between them in practice with LSTMs (see Appendix A). With this we conclude the recap of variational dropout, and describe our contributions in the rest of the paper. ",
+        "bbox": [
+            173,
+            678,
+            825,
+            748
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 DROPOUT AS A CONDITIONAL MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            765,
+            477,
+            779
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In variational inference the idea is to approximate the intractable and complicated posterior with a simple, parameterised distribution $q$ . Crucially, this approximation affects our inferences and predictions. If we are serious about it being an approximation to the posterior and want to reduce its distortion of the model $p$ , then $q$ can be made more flexible. But making $q$ more flexible in variational dropout can potentially ruin the regularisation effect. So the particular choice of $q$ plays an important, active role: it effectively performs posterior regularisation and acts as an integral part of the model. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Coming from another angle, Osband (2016) makes the point that in variational dropout the posterior over weights does not concentrate with more data, unlike for example in Graves (2011), which is unexpected behaviour from a Bayesian model. This conundrum is caused by encoding dropout with a fixed rate mixture of fixed variance components in $q$ , which also necessitates expensive tuning of the dropout rate. Gal et al. (2017) proposes a way to address these shortcomings. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To avoid getting bogged down in the issues surrounding the suitability of variational inference and ease interpretation, we construct a straightforward conditional model and lower bound its MAP objective in the same form as the variational objective. Suppose we want to do MAP estimation for the model parameters (the means of the distribution of weights, $\\Theta$ ): arg maxΘ $p ( \\Theta | X , Y )$ Consider a conditional model $p ( \\boldsymbol { Y } | \\boldsymbol { X } , \\Theta )$ as a crippled generative model with $p ( x _ { i } )$ constant, $x _ { i }$ and $\\Theta$ independent. Place a normal prior on the means $\\Theta$ and otherwise make the weights $\\omega$ conditional on $\\Theta$ the same way as they were in the variational posterior $q ( \\omega )$ : ",
+        "bbox": [
+            174,
+            138,
+            825,
+            237
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/85c7ff714dc8b9104df4799c435ff1421f7b9fe5c45065f3913dbd1b7fd823d2.jpg",
+        "text": "$$\n\\begin{array} { r l } & { ~ p ( \\Theta ) = N ( \\Theta | 0 , \\sigma _ { p } ^ { 2 } \\mathrm { I } ) } \\\\ & { ~ p ( \\omega _ { r } | \\Theta ) = p \\mathcal N ( \\omega _ { r } | 0 , \\sigma ^ { 2 } \\mathrm { I } ) + ( 1 - p ) \\mathcal N ( \\omega _ { r } | \\Theta _ { r } , \\sigma ^ { 2 } \\mathrm { I } ) } \\\\ & { p ( y , \\omega | x , \\Theta ) = p ( y | x , \\omega ) p ( \\omega | \\Theta ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            241,
+            686,
+            301
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The log posterior of this model has a similar lower bound to the variational objective (Eq. 1): ",
+        "bbox": [
+            169,
+            304,
+            781,
+            319
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/38873f63e470e920a2c41c8926b05121011fc39e8089ec1176342b67164c52b9.jpg",
+        "text": "$$\n\\ln p ( \\Theta | X , Y ) \\geqslant \\sum _ { i = 1 } ^ { N } \\int p ( \\omega | \\Theta ) \\ln p ( y _ { i } | x _ { i } , \\omega ) d \\omega + \\ln p ( \\Theta ) - C _ { M A P }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            323,
+            722,
+            367
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "See Appendix $\\textrm { C }$ for detailed derivation. Dropping the normalisation constant $C _ { M A P }$ that doesn’t depend on $\\Theta$ , and approximating the above integrals with a single sample, the loss corresponding to the MAP objective becomes: ",
+        "bbox": [
+            174,
+            372,
+            825,
+            414
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/61ec15b4e9c2f19196da88a1896e84c1a7e2c5bb277f1d0f5ed128e4c809f246.jpg",
+        "text": "$$\n\\mathcal { L } _ { M A P } = - \\sum _ { i = 1 } ^ { N } \\ln p ( y _ { i } | x _ { i } , \\hat { \\omega } _ { i } ) - \\ln p ( \\Theta )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            419,
+            632,
+            463
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The first term of this loss is identical to that of the loss for variational dropout (Eq 2). If the prior on $\\Theta$ is a zero mean gaussian, then the second term is equivalent to a weight decay penalty just like the KL term in the variational setup. With the two losses being effectively the same, in the following we focus on MAP estimation for the conditional model to sidestep any questions about whether variational inference makes sense in this case. ",
+        "bbox": [
+            174,
+            467,
+            825,
+            536
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 THE DROPOUT FAMILY OF MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            558,
+            496,
+            573
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Having developed a conditional model for dropout that leads to the same objective as variational dropout, we now derive a family of models whose objectives are all lower bounded by the usual dropout objective. We draw inspiration from the different evaluation methods employed for dropout: ",
+        "bbox": [
+            176,
+            588,
+            825,
+            631
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Deterministic dropout propagates the expectation of each unit through the network in single pass. This is very efficient and is viewed as a good approximation to the next option. • MC dropout mimicks the training procedure, and averages the predicted probabilities over randomly sampled dropout masks. With one forward pass per sample, this can be rather expensive. There is some ambiguity as to what kind of averaging shall be applied: oftentimes the geometric average (GMC) is used, because of its close relationship to the loss, but the arithmetic average (AMC) is also widespread. ",
+        "bbox": [
+            215,
+            642,
+            825,
+            744
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our goal in this section is to demonstrate the consequences of optimising a lower bound instead of the true objective. While it is easy to argue in general that objectives of more than one model may share any given lower bound, for dropout a particularly simple explicit construction of such a family of models is possible. As we will see, this allows for post-training model selection based on validation results given a trained set of parameters. In the absence of validation results to guide model selection, inspection of the tightness of the lower bound indicates the deterministic model as the most reasonable choice from the family. ",
+        "bbox": [
+            173,
+            755,
+            825,
+            853
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 GEOMETRIC MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            354,
+            883
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "First, we investigate whether the geometric or the arithmetic mean is the correct choice for making predictions in the context of classification. Recall the predictive term of the MAP loss in Eq. 5: ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$\\sum \\ln p \\big ( y _ { i } | x _ { i } , \\hat { \\omega } _ { i } \\big )$ . Notice how with SGD and multiple epochs, for each data point several dropout masks are encountered, and the approximating quantity becomes the geometric mean of the predicted probabilities $p ( y _ { i } | x _ { i } , \\omega )$ over the masked weights. For this reason, the posterior predictive distribution $p ( y ^ { * } | x ^ { * } , X , Y )$ is often computed as the renormalised geometric mean. This is in apparent conflict with the conditional model that prescribes the arithmetic mean (integrating $\\omega$ out of Eq. 3). However, we can define another model where the conditional distribution is directly defined to be the renormalised geometric mean ",
+        "bbox": [
+            173,
+            102,
+            826,
+            202
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/867c7a7c5fd2535a4e2cc0a9ded121fe85b077bec88713228912a79eaf384114.jpg",
+        "text": "$$\np ( y | x , \\Theta ) = \\frac { \\exp \\bigl ( \\mathbb { E } _ { \\hat { \\omega } \\sim p ( \\omega | \\Theta ) } \\ln p ( y | x , \\hat { \\omega } ) \\bigr ) } { Z ( x , \\Theta ) } , \\quad Z ( x , \\Theta ) = \\sum _ { c = 1 } ^ { C } \\exp \\big ( \\underbrace { \\mathbb { E } } _ { \\hat { \\omega } \\sim p ( \\omega | \\Theta ) } \\ln p ( c | x , \\hat { \\omega } ) \\big )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            191,
+            209,
+            785,
+            252
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "with a slight abuse of notation, due to using the symbol $p$ in $p ( \\boldsymbol { y } | \\boldsymbol { x } , \\Theta )$ although $p ( \\boldsymbol { y } | \\boldsymbol { x } , \\boldsymbol { \\Theta } ) \\neq$ $\\mathbb { E } _ { \\omega } p ( \\omega | \\Theta ) \\bar { p } ( y | x , \\omega )$ . It can be shown that the arithmetic model’s (Eq. 3) lower bound (Eq. 4) is a lower bound for this renormalised geometric model (Eq. 6), as well. See Appendix $\\mathbf { D }$ for the derivation. The answer to the question whether we should use GMC or AMC is that it depends: they correspond to different models, but the dropout objective is a lower bound on the objectives of both models. So one can freely choose between GMC and AMC at evaluation time, doing model selection retrospectively after training. ",
+        "bbox": [
+            173,
+            260,
+            826,
+            359
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 THE POWER MEAN MODEL FAMILY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            377,
+            452,
+            391
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Having two models to choose from, it is natural to ask whether these are just instantiations of a larger class of models. We propose the power mean family of models to extend the set of models to a continuum between the geometric and arithmetic models described in $\\ S 3 . 1$ and $\\ S 2 . 1$ , respectively, and show that they have the same lower bound. The power mean is defined as: ",
+        "bbox": [
+            173,
+            404,
+            826,
+            460
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/522a90559017e1f85277f8caf6ad958ca708a6643cf3a18663c454f5efa551f5.jpg",
+        "text": "$$\nM _ { \\alpha } ( x _ { 1 } , \\ldots , x _ { n } ) = \\left( \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } x _ { i } ^ { \\alpha } \\right) ^ { 1 / \\alpha }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            468,
+            620,
+            511
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For $\\alpha = 1$ we arrive at the arithmetic mean while the natural extension to $\\alpha = 0$ is the geometric mean as it is the limit of $M _ { \\alpha }$ at $\\alpha  0$ , which can be proven with L’Hôpital’s rule. Similarly to the construction of the geometric model, we define the power mean model by directly conditioning on $\\Theta$ : ",
+        "bbox": [
+            173,
+            517,
+            825,
+            560
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a0152361c213674b964ce48a0f92ab98b0986d237c701a3c17fa1f3575cdfad8.jpg",
+        "text": "$$\np ( y | x , \\Theta ) = \\frac { \\sqrt [ \\alpha ] { \\mathbb { E } _ { \\hat { \\omega } \\sim p ( \\omega | \\Theta ) } p ( y | x , \\hat { \\omega } ) ^ { \\alpha } } } { Z ( x , \\Theta ) } , \\qquad Z ( x , \\Theta ) = \\sum _ { c = 1 } ^ { C } \\sqrt [ \\alpha ] { \\mathbb { E } _ { \\hat { \\omega } \\sim p ( \\omega | \\Theta ) } p ( c | x , \\hat { \\omega } ) ^ { \\alpha } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            220,
+            568,
+            779,
+            612
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $Z ( x , \\Theta )$ is at most 1 if $\\alpha \\in ( - \\infty , 1 ]$ because $M _ { \\alpha }$ is monotonically increasing in $\\alpha$ and $Z$ is 1 for $\\alpha = 1$ . Here we provide a concise derivation of a lower bound on the log posterior (the full derivation can be found in Appendix E): ",
+        "bbox": [
+            173,
+            619,
+            825,
+            662
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bea7a4d7702ff2c9e99ba3f5deb6ce086efc4df3fdd6099acf13b6463817c6d9.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\ln p ( \\Theta | X , Y ) = \\displaystyle \\sum _ { i = 1 } ^ { N } \\left[ \\ln \\sqrt { \\underbrace { \\mathbb { E } } _ { \\left\\{ \\omega > p ( \\omega | \\Theta ) \\right\\} } p ( y _ { i } | x _ { i } , \\hat { \\omega } ) ^ { \\alpha } } - \\ln ( Z ( x _ { i } , \\Theta ) ) \\right] + \\ln p ( \\Theta ) - C _ { M A P } } & { } \\\\ { \\displaystyle \\geqslant \\displaystyle \\sum _ { i = 1 } ^ { N } \\ln \\sqrt { \\underbrace { \\mathbb { E } } _ { \\left\\{ \\omega > p ( \\omega | \\Theta ) \\right\\} } p ( y _ { i } | x _ { i } , \\hat { \\omega } ) ^ { \\alpha } } + \\ln p ( \\Theta ) - C _ { M A P } } & { } \\\\ { \\displaystyle \\geqslant \\displaystyle \\sum _ { i = 1 } ^ { N } \\frac { 1 } { \\alpha } \\frac { \\mathbb { E } } { \\omega \\sim p ( \\omega | \\Theta ) } \\ln p ( y _ { i } | x _ { i } , \\hat { \\omega } ) ^ { \\alpha } + \\ln p ( \\Theta ) - C _ { M A P } } & { } \\\\ { \\displaystyle = \\displaystyle \\sum _ { i = 1 } ^ { N } \\int p ( \\omega | \\Theta ) \\ln p ( y _ { i } | x _ { i } , \\omega ) d \\omega + \\ln p ( \\Theta ) - C _ { M A P } } & { } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            210,
+            670,
+            785,
+            848
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The first inequality above follows from $Z ( x , \\Theta ) \\leqslant 1$ for all $x , \\Theta$ , while the second is an application of Jensen’s rule assuming $\\alpha > 0$ . We arrived at the same lower bound on the objective as we had for the geometric (Eq. 6) and arithmetic models (Eq. 3), thus defining the power mean family with parameter $\\alpha \\in [ 0 , 1 ]$ of models from which we can choose at evaluation time. For $\\alpha > 1$ , the normalising constant $Z$ would be greater than 1, and this would not be a lower bound in general. ",
+        "bbox": [
+            173,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 TIGHTNESS OF THE LOWER BOUND",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            457,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To better understand the quality of fit for models in the power mean family we examine the tightness of their lower bounds. There are two steps involving inequalities in the derivation of the bound: one where the normalisation constant $Z$ is dropped (Eq. 8) and another where the logarithm is moved inside the expectation (Eq. 9). We show that the gaps introduced by these steps can be made arbitrarily small by reducing the variance of $p ( \\boldsymbol { y } | \\boldsymbol { x } , \\boldsymbol { \\omega } )$ with respect to $\\omega$ . ",
+        "bbox": [
+            173,
+            128,
+            825,
+            200
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Notice that the Jensen gap with the logarithm function is scale invariant: ",
+        "bbox": [
+            174,
+            205,
+            647,
+            222
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7cc2d0dcccbaa74f9f67dc3b761f79754f3734dacd93d5593a7e37188850cc5a.jpg",
+        "text": "$$\n\\ln ( \\mathbb { E } [ \\lambda L ] ) - \\mathbb { E } \\ln ( \\lambda L ) = \\ln ( \\mathbb { E } L ) - \\mathbb { E } \\ln ( L )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            351,
+            226,
+            647,
+            243
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, this suggests that $\\mathrm { v a r } ( L ) / ( \\mathbb { E } L ) ^ { 2 }$ is closely related to the size of the gap. Indeed, Maddison et al. (2017) show that if the first inverse moment of $L$ is finite, then ",
+        "bbox": [
+            173,
+            248,
+            825,
+            279
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4cec2c7c30e60cd5df8139e77888774e6f8b307990570263f3fec498784c7157.jpg",
+        "text": "$$\n\\ln ( \\mathbb { E } L ) - \\mathbb { E } \\ln ( L ) ) = { \\frac { \\operatorname { v a r } ( L ) } { 2 ( \\mathbb { E } L ) ^ { 2 } } } + { \\mathcal { O } } ( { \\sqrt { \\mathbb { E } [ ( L - \\mathbb { E } L ) ^ { 6 } ] } } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            282,
+            683,
+            316
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here we go a bit further and show that if there is a positive lower and upper bound on $L$ , then there are non-trivial lower and upper bounds on its Jensen gap and these are bounds are multiplicative in $\\mathrm { v a r } ( L )$ . Let $L$ be a random variable such that $P ( \\bar { L } \\in ( a , b ) ) = 1$ where $- \\infty \\leqslant a < b \\leqslant \\infty$ . Furthermore, let $\\varphi ( l )$ be a convex function. Jensen’s inequality states that $E [ \\varphi ( L ) ] \\geqslant \\varphi ( \\mathbb { E } [ L ] )$ . Liao & Berg (2017) show that the Jensen gap $E [ \\varphi ( L ) ] - \\varphi ( \\bar { \\mathbb { E } } [ L ] )$ can be bounded from below and above: ",
+        "bbox": [
+            174,
+            320,
+            825,
+            391
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5f03949653ffd21c96ddbd2e62e830a6239825f2cccea96238d75d048b63f51d.jpg",
+        "text": "$$\n\\begin{array} { c } { \\operatorname* { i n f } \\{ h ( l ; \\mu ) \\mid l \\in ( a , b ) \\} \\operatorname { v a r } ( L ) \\leqslant \\mathbb { E } [ \\varphi ( L ) ] - \\varphi ( \\mathbb { E } [ L ] ) \\leqslant \\operatorname* { s u p } \\{ h ( l ; \\mu ) \\mid l \\in ( a , b ) \\} \\operatorname { v a r } ( L ) } \\\\ { h ( l ; \\mu ) = \\displaystyle \\frac { \\varphi ( l ) - \\varphi ( \\mu ) } { ( l - \\mu ) ^ { 2 } } - \\frac { \\varphi ^ { \\prime } ( \\mu ) } { l - \\mu } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            204,
+            393,
+            792,
+            450
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $h ( l ; \\mu )$ does not depend on the distribution of $L$ , only on its expected value $\\mu$ and on the function $\\varphi$ . Substituting $L = p ( c | x , \\omega )$ (a random variable on $[ 0 , 1 ]$ due to the randomness of the dropout masks) and $\\varphi ( l ) = - \\ln ( l )$ , we can see that the gap introduced by Eq. 9 can be made smaller by decreasing the variance of the predictions while maintaining the expected value of $L$ (i.e. the expected probability), assuming that there is a positive lower and upper bound on them (so that the supremum is finite and the infimum is positive, respectively). A similar argument based on $\\begin{array} { r } { \\sum _ { c = 1 } ^ { C } M _ { \\alpha } ( \\mathbb { E } _ { \\hat { \\omega } } p ( c | x , \\hat { \\omega } ) ) = 1 } \\end{array}$ shows that $Z$ approximately monotonically approaches 1 as the variance decreases, so the gap of Eq. 8 can also be reduced. ",
+        "bbox": [
+            173,
+            453,
+            825,
+            568
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Suppose we pick a base model from the power mean family and have a continuum of subvariants with gradually reduced variance in their predictions but the same expectation. Clearly, for each of them we can derive a lower bound the same way as we did for the power mean family. And as we showed above, the lower bounds will tend to increase as the variance of the predictions decreases (see Fig. 1a). They do not strictly increase, only tend to, due to how the Jensen gap is bounded from above and below and also due to the $\\mathcal { O }$ term of Eq. 10. Nonetheless, as we approach determinism the lower bound is forced into increasingly tighter ranges with strictly monotonically increasing bounds around it, thus we can always reduce the variance such that there is no overlap between the ranges and we get a guaranteed improvement on the lower bound. This effect reaches its apex at the deterministic model whose lower bound is both exact and higher than any other model’s. Fig. 1b illustrates that regardless of the choice of base model, reducing the prediction variance will eventually transform it into the same deterministic model. ",
+        "bbox": [
+            173,
+            573,
+            825,
+            741
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 THE EXTENDED POWER MEAN FAMILY: CONTROLLING THE TIGHTNESS OF THE BOUND",
+        "text_level": 1,
+        "bbox": [
+            176,
+            758,
+            810,
+            772
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, in the absence of other sources of stochasticity the dropout rate controls the variance of the predictions and if it is low, the lower bound can be pretty snug. However, there are two problems. ",
+        "bbox": [
+            174,
+            784,
+            820,
+            811
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "First, decreasing the dropout rate does not necessarily keep the expectation of the predictions the same. We offer no solution to this bias issue, but refer the reader to previous studies of dropout’s approximation properties such as (Baldi & Sadowski 2013) and our subsequent empirical results. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Second, reducing the dropout rate would trade off generalisation for tighter bounds. But doing so only at evaluation time leaves the training time regularisation effect intact, and can be seen as picking another model whose lower bound tends to be higher than that of the base model. Having thus extended the dropout family further, we can now tweak both $\\alpha$ and dropout rates at evaluation time. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "(a) Lower and upper bounds on the lower bound of the model objective as a function of prediction variance for any model in the power mean family. ",
+        "bbox": [
+            173,
+            232,
+            493,
+            270
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/f57a0ac411df611128d5f354bd333f60ab55b0461115b4159e8c988c8efa3297.jpg",
+        "image_caption": [
+            "(b) With reduced variance, all members of the power mean family (brown shading) converge to the deterministic model while their lower bounds tighten. ",
+            "Figure 1: Tightness of lower bounds vs evaluation time prediction variance in the extended dropout family. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            99,
+            789,
+            224
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/e125cfbe5a91ae64bf9b944e441ef0264b8529e55ca4338070c2bb2f9b0c45ac.jpg",
+        "table_caption": [
+            "Table 1: PTB training XEs with various dropout rate multipliers between deterministic and GMC. Observe the monotonic improvement in training fit when reducing the dropout rate at evaluation only. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>×0.0</td><td>×0.1</td><td>×0.2</td><td>x0.3</td><td>×0.4</td><td>×0.5</td><td>x0.6</td><td>x0.7</td><td>×0.8</td><td>×0.9</td><td>×1.0</td></tr><tr><td>2.731</td><td>2.738</td><td>2.746</td><td>2.755</td><td>2.766</td><td>2.777</td><td>2.791</td><td>2.807</td><td>2.826</td><td>2.849</td><td>2.878</td></tr></table>",
+        "bbox": [
+            217,
+            356,
+            781,
+            398
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Depending on the severity of the introduced bias compared to the benefits of having a tighter lower bound, the optimal variance may lie anywhere between the deterministic and the base model. We show experimentally that across a number of datasets the benefits of tighter bounds matter more, and observe monotonic improvement in model fit as evaluation time dropout rates are decreased all the way to full determinism. The experiment was conducted as follows. On an already trained model, the dropout rate was multiplied by $\\lambda \\in [ 0 , 1 ]$ . As Table 1 shows, the model fit as measured by cross entropy (XE) on the training set improves monotonically when reducing $\\lambda$ . Results on other datasets and with other power mean models are very similar. We call the union of the reduced dropout rate subvariants of all power mean family models the extended dropout family paramaterised by $\\alpha , \\lambda$ . ",
+        "bbox": [
+            174,
+            431,
+            825,
+            558
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Therefore, we can say that dropout training optimises a deterministic model subject to regularisation constraints, and deterministic evaluation, widely believed to approximate MC evaluation, is the closest match to the true objective at our disposal. It is not that dropout evaluation has a deterministic approximation: dropout trains a deterministic model first and foremost and a continuum of stochastic ones to various extents. ",
+        "bbox": [
+            174,
+            564,
+            825,
+            633
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In summary, we described dropout training as optimising a common lower bound for a family of models. Since this lower bound is the same for all models in the family, we can nominate any of them at evaluation time. However, the tightness of the bound varies, which affects model fit. Having trained a model with dropout, the best fit is achieved by the deterministic model with no dropout. This result isolates the regularisation effects from the biases of the lower bound and the dropout family. ",
+        "bbox": [
+            174,
+            641,
+            825,
+            710
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 APPLYING DROPOUT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            741,
+            377,
+            756
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We investigate how members of the extended dropout model family perform in terms of generalisation. We follow the experimental setup of Melis et al. (2017) and base our work on their best performing model variant for each dataset. Unless explicitly stated, no retraining was performed and their model weights reused. In the experiments with the tuning objective, we follow their experimental setup, using Google Vizier (Golovin et al. 2017), a black-box hyperparameter tuner based on batched Gaussian Process Bandits. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            861
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "See Table 2 for results of image classification on MNIST, character based language modelling on Enwik8, word based language modelling on PTB and Wikitext-2. On MNIST, deterministic dropout is the best in terms of cross entropy, which matches our theoretical predictions. In contrast, on language modelling arithmetic averaging produces the best results, which necessitates further analysis. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/706a223a3751c4a057c7addc0e9df78248ad6dcba40bf24963abac42ab1b8c8f.jpg",
+        "table_caption": [
+            "Table 2: Validation XEs on some datasets varying the power $\\alpha$ and the dropout rate mulitiplier $\\lambda$ . Deterministic dropout is not the best evaluation method for the language modelling datasets due to a simple smoothing effect. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td colspan=\"3\">Geometric (α = 0)</td><td colspan=\"3\">Power α = 0.5</td><td colspan=\"3\">Arithmetic (α = 1)</td></tr><tr><td>Dataset</td><td>DET</td><td>×0.8</td><td>×0.9</td><td>×1.0</td><td>x0.8</td><td>×0.9</td><td>×1.0</td><td>×0.8</td><td>x0.9</td><td>×1.0</td></tr><tr><td>MNIST</td><td>0.070</td><td>0.087</td><td>0.087</td><td>0.088</td><td>0.92</td><td>0.93</td><td>0.93</td><td>0.100</td><td>0.100</td><td>0.100</td></tr><tr><td>Enwik8</td><td>0.886</td><td>0.879</td><td>0.878</td><td>0.881</td><td>0.877</td><td>0.877</td><td>0.877</td><td>0.875</td><td>0.875</td><td>0.875</td></tr><tr><td>PTB</td><td>4.110</td><td>4.090</td><td>4.090</td><td>4.093</td><td>4.072</td><td>4.070</td><td>4.073</td><td>4.061</td><td>4.064</td><td>4.080</td></tr><tr><td>Wikitext-2</td><td>4.236</td><td>4.229</td><td>4.231</td><td>4.235</td><td>4.025</td><td>4.026</td><td>4.208</td><td>4.203</td><td>4.212</td><td>4.228</td></tr></table>",
+        "bbox": [
+            200,
+            137,
+            797,
+            236
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/9beb052b1d18c18dea8c9d138fa93a16067b7d68537b681e7ff40715aa78f913.jpg",
+        "table_caption": [
+            "Table 3: PTB training and validation XEs for AMC at $\\lambda \\in \\{ 0 , 0 . 8 , 1 \\}$ per word frequency. Note how DET dominates AMC on the training set, but AMC is better for rare words in the validation set. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>num</td><td colspan=\"3\">training</td><td colspan=\"3\">validation</td></tr><tr><td>frequency</td><td>targets</td><td>DET</td><td>×0.8</td><td>AMC</td><td>DET</td><td>×0.8</td><td>AMC</td></tr><tr><td>25000&lt;</td><td>13580</td><td>1.40</td><td>1.50</td><td>1.56</td><td>1.58</td><td>1.64</td><td>1.68</td></tr><tr><td>5000&lt;</td><td>26658</td><td>1.65</td><td>1.75</td><td>1.81</td><td>1.93</td><td>1.98</td><td>2.02</td></tr><tr><td>500&lt;</td><td>44702</td><td>2.19</td><td>2.30</td><td>2.36</td><td>2.58</td><td>2.63</td><td>2.66</td></tr><tr><td>&lt;500</td><td>29058</td><td>4.07</td><td>4.19</td><td>4.29</td><td>6.49</td><td>6.39</td><td>6.39</td></tr><tr><td>&lt;100</td><td>14222</td><td>4.24</td><td>4.38</td><td>4.49</td><td>7.81</td><td>7.64</td><td>7.61</td></tr><tr><td>&lt;20</td><td>5008</td><td>4.00</td><td>4.19</td><td>4.33</td><td>9.20</td><td>9.01</td><td>8.97</td></tr></table>",
+        "bbox": [
+            287,
+            286,
+            710,
+            410
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We suspected that the particularly severe form of class imbalance exhibited by the power-law word distribution (Zipf 1935) might play a role. To verify this, we contrasted training and validation XEs on PTB for words grouped by frequency (see Table 3). On the training set, the gap between deterministic dropout and AMC is wider for low frequency words. On the validation set, AMC is worse for frequent words but better for rare words. The $\\times 0 . 8$ dropout multiplier just finds a reasonable compromise. ",
+        "bbox": [
+            173,
+            435,
+            825,
+            506
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 SOFTMAX TEMPERATURE",
+        "text_level": 1,
+        "bbox": [
+            174,
+            523,
+            390,
+            537
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The observed effect is consistent with smoothing, thus we posit that the reason MNIST results are worse with AMC is that the marginal distributions of labels in the training and test set are identical by construction and further smoothing is unnecessary. On the other hand, PTB and Wikitext-2 benefit from AMC’s smoothing because the penalty for underestimating low probabilities is harsh, hence the large improvement on rare words. The character based Enwik8 dataset lies somewhere in between: the training and test distributions are better matched and there are no very low probability characters. ",
+        "bbox": [
+            173,
+            549,
+            825,
+            633
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To test the hypothesis that AMC’s advantage lies in smoothing, we tested how performing smoothing by other means affects the results. In this experiment, on a trained model the temperature of the final softmax was optimised on the validation set and the model was applied with the optimal temperature to the validation and test sets. Our experimental results in Table 4 support the hypotheses that AMC smooths the predicted distribution as increasing the temperature improves DET and GMC considerably but not AMC. In fact, the optimal temperature for AMC with $\\lambda = 1$ was slightly lower than 1, which corresponds to sharpening, not smoothing. ",
+        "bbox": [
+            173,
+            640,
+            823,
+            669
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/53c35102c40907ed9f43347505d6f01ad3852aca8a9b2755f004b3e75427631a.jpg",
+        "table_caption": [
+            "Table 4: Validation and test perplexities on PTB and Wikitext-2 with various evaluation strategies and default or optimal validation softmax temperatures. Our baseline results correspond to DET at temperature 1. Note that AMC does not benefit from setting the optimal softmax temperature (“opt”), while DET is improved by it almost to the point of matching AMC which supports the smoothing hypothesis. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"4\"></td><td colspan=\"3\">Geometric (α = 0)</td><td colspan=\"3\">Power α = 0.5</td><td colspan=\"3\">Arithmetic (α = 1)</td></tr><tr><td colspan=\"2\">Dataset</td><td>Temp</td><td>DET</td><td>×0.8</td><td>×0.9</td><td>×1.0</td><td>×0.8</td><td>×0.9</td><td>×1.0</td><td>×0.8</td><td>×0.9</td><td>×1.0</td></tr><tr><td rowspan=\"4\">Viiapian</td><td rowspan=\"2\">WT-2</td><td>1</td><td>69.1</td><td>68.6</td><td>68.8</td><td>69.1</td><td>67.0</td><td>67.2</td><td>67.2</td><td>66.9</td><td>67.5</td><td>68.6</td></tr><tr><td>opt</td><td>67.4</td><td>67.5</td><td>67.7</td><td>68.0</td><td>67.0</td><td>67.1</td><td>67.2</td><td>66.9</td><td>67.4</td><td>68.1</td></tr><tr><td rowspan=\"2\">PTB</td><td>1</td><td>60.9</td><td>59.6</td><td>59.7</td><td>59.7</td><td>58.1</td><td>57.9</td><td>58.0</td><td>57.3</td><td>57.5</td><td>58.5</td></tr><tr><td>opt</td><td>57.5</td><td>57.5</td><td>57.9</td><td>58.3</td><td>57.1</td><td>57.3</td><td>57.8</td><td>57.1</td><td>57.5</td><td>58.4</td></tr><tr><td rowspan=\"4\">3</td><td rowspan=\"2\">WT-2</td><td>1</td><td>65.9</td><td>65.3</td><td>65.4</td><td>65.6</td><td>63.8</td><td>63.9</td><td>64.2</td><td>63.7</td><td>64.5</td><td>65.5</td></tr><tr><td>opt</td><td>64.5</td><td>64.7</td><td>64.8</td><td>64.9</td><td>63.8</td><td>63.8</td><td>64.2</td><td>63.7</td><td>64.2</td><td>64.9</td></tr><tr><td rowspan=\"2\">PTB</td><td>1</td><td>58.6</td><td>57.3</td><td>57.4</td><td>57.4</td><td>56.0</td><td>55.8</td><td>55.9</td><td>55.3</td><td>55.5</td><td>56.5</td></tr><tr><td>opt</td><td>56.0</td><td>56.0</td><td>56.1</td><td>56.5</td><td>55.7</td><td>55.7</td><td>56.0</td><td>55.3</td><td>55.5</td><td>56.3</td></tr></table>",
+        "bbox": [
+            184,
+            753,
+            812,
+            921
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Tuning the evaluation time softmax temperature is similar to label smoothing (Pereyra et al. 2017), the main difference being that our method does not affect training. While this is convenient, for tuning model hyperparameters, ideally we would determine the optimal evaluation parameters $\\alpha$ $\\lambda$ and the temperature for the calculation of the validation score for each set of hyperparameters tried, but this would be prohibitively expensive. Since deterministic evaluation coupled with the optimal temperature is very close to the best performing AMC model, it serves as a good proxy for the ideal tuning objective. The optimal temperature can be approximately determinined using a linear search on a subset of the validation data which is orders of magnitude faster than MC dropout. In our experiments, hyperparameter tuning with validation scores computed at the optimal softmax temperature did improve results, albeit very slightly (about half a perplexity point). Thus we can conclude that deterministic dropout is already a reasonable proxy for which to optimise. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            333
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            353,
+            277,
+            367
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We have improved the best test result of Melis et al. (2017) from 58.3 to 55.7 on PTB, and from 65.9 to 63.7 on Wikitext-2 using their model weights, only tuning the evaluation parameters $\\alpha , \\lambda$ and the softmax temperature on the validation set. By retuning the hyperparameters of the PTB model with optimal temperature deterministic evaluation, we improved to 55.3 on PTB. For lack of resources, we did not retune for Wikitext-2. For comparison, the state of the art in language modelling without resorting to dynamic evaluation or a continuous cache pointer is Mixture of Softmaxes (Yang et al. 2017) with 54.44 and 61.45 on PTB and Wikitext-2, respectively. At present, it is unclear whether the benefits of their approach and ours combine. ",
+        "bbox": [
+            174,
+            380,
+            825,
+            491
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In summary, we looked at how different models and evaluation methods rank in terms of generalisation. Across a number of tasks and datasets the ranking differed from what was observed on the training set. We found that AMC smooths the distribution of the prediction probabilities and we achieved a similar effect without resorting to expensive sampling simply by adjusting the temperature of the final softmax. Finally, we brought the tuning objective more in line with the improved evaluation by automatically determining the optimal softmax temperature when evaluating on the validation set which further improved results. ",
+        "bbox": [
+            174,
+            498,
+            825,
+            595
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 IMPLICATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            619,
+            326,
+            635
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The construction of a conditional model family with a common lower bound on their objectives is applicable to other latent variable models with similar structure and inference method. This lower bound admits ambiguity as to what model is being fit to the data, which in turn allows for picking any such model at evaluation time. However, the tightness of the bound and the quality of the fit varies. For dropout, the deterministic model has the best fit even though the training objective is highly stochastic, but this result hinges on the approximation properties of deterministic dropout and will not carry over to other probabilistic models in general. In particular, standard VAEs (Kingma & Welling 2013) with their lower bound being very similar in construction to Eq. 1 cannot quite collapse to a deterministic model else they suffer an infinite KL penalty. Still, the lower bound being looser on the tails of $q$ is related to problem of underestimating posterior uncertainty (Turner & Sahani 2011). ",
+        "bbox": [
+            174,
+            652,
+            825,
+            791
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In related works, expectation-linear dropout (Ma et al. 2016) and fraternal dropout (Zolna et al. 2017) both try to reduce the “inference gap”: the mismatch between the training objective and deterministic evaluation. The gains reported in those works might be explained by reducing the bias of deterministic evaluation and also by encouraging small variance in the predictions and thus getting tighter bounds. Another recent work, activation regularisation (Merity et al. 2017), could be thought of as a mechanism to reduce the variance of predictions to a similar effect. In the context of language modelling, the connection between noise and smoothing was established by Xie et al. (2017). Our improved understanding further emphasises that connection, and at the same time challenges the way we think about dropout. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pierre Baldi and Peter J Sadowski. Understanding dropout. In Advances in neural information processing systems, pp. 2814–2822, 2013. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Justin Bayer, Christian Osendorfer, Daniela Korhammer, Nutan Chen, Sebastian Urban, and Patrick van der Smagt. On fast dropout and its applicability to recurrent networks. arXiv preprint arXiv:1311.0701, 2013. ",
+        "bbox": [
+            173,
+            162,
+            823,
+            207
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yarin Gal and Zoubin Ghahramani. Dropout as a bayesian approximation: Representing model uncertainty in deep learning. In international conference on machine learning, pp. 1050–1059, 2016a. ",
+        "bbox": [
+            176,
+            215,
+            825,
+            258
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yarin Gal and Zoubin Ghahramani. A theoretically grounded application of dropout in recurrent neural networks. In Advances in Neural Information Processing Systems, pp. 1019–1027, 2016b. ",
+        "bbox": [
+            171,
+            267,
+            825,
+            296
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yarin Gal, Jiri Hron, and Alex Kendall. Concrete dropout. In Advances in Neural Information Processing Systems, pp. 3584–3593, 2017. ",
+        "bbox": [
+            173,
+            305,
+            825,
+            335
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Daniel Golovin, Benjamin Solnik, Subhodeep Moitra, Greg Kochanski, John Karro, and D Sculley. Google vizier: A service for black-box optimization. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 1487–1495. ACM, 2017. ",
+        "bbox": [
+            174,
+            343,
+            826,
+            387
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves. Practical variational inference for neural networks. In Advances in Neural Information Processing Systems, pp. 2348–2356, 2011. ",
+        "bbox": [
+            174,
+            395,
+            823,
+            425
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E Hinton, Nitish Srivastava, Alex Krizhevsky, Ilya Sutskever, and Ruslan R Salakhutdinov. Improving neural networks by preventing co-adaptation of feature detectors. arXiv preprint arXiv:1207.0580, 2012. ",
+        "bbox": [
+            173,
+            434,
+            826,
+            477
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013. ",
+        "bbox": [
+            173,
+            486,
+            823,
+            515
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma, Tim Salimans, and Max Welling. Variational dropout and the local reparameterization trick. In Advances in Neural Information Processing Systems, pp. 2575–2583, 2015. ",
+        "bbox": [
+            173,
+            523,
+            823,
+            554
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "JG Liao and Arthur Berg. Sharpening jensen’s inequality. The American Statistician, 2017. ",
+        "bbox": [
+            176,
+            561,
+            772,
+            578
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xuezhe Ma, Yingkai Gao, Zhiting Hu, Yaoliang Yu, Yuntian Deng, and Eduard H. Hovy. Dropout with expectation-linear regularization. CoRR, abs/1609.08017, 2016. URL http://arxiv. org/abs/1609.08017. ",
+        "bbox": [
+            174,
+            585,
+            828,
+            630
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chris J Maddison, John Lawson, George Tucker, Nicolas Heess, Mohammad Norouzi, Andriy Mnih, Arnaud Doucet, and Yee Teh. Filtering variational objectives. In Advances in Neural Information Processing Systems, pp. 6573–6583, 2017. ",
+        "bbox": [
+            176,
+            638,
+            825,
+            681
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gábor Melis, Chris Dyer, and Phil Blunsom. On the state of the art of evaluation in neural language models. arXiv preprint arXiv:1707.05589, 2017. ",
+        "bbox": [
+            169,
+            690,
+            825,
+            720
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Stephen Merity, Nitish Shirish Keskar, and Richard Socher. Regularizing and optimizing lstm language models. arXiv preprint arXiv:1708.02182, 2017. ",
+        "bbox": [
+            168,
+            728,
+            825,
+            758
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian Osband. Risk versus uncertainty in deep learning: Bayes, bootstrap and the dangers of dropout. In NIPS Bayesian Deep Learning Workshop, 2016. ",
+        "bbox": [
+            171,
+            767,
+            825,
+            796
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marius Pachitariu and Maneesh Sahani. Regularization and nonlinearities for neural language models: when are they needed? arXiv preprint arXiv:1301.5650, 2013. ",
+        "bbox": [
+            171,
+            805,
+            825,
+            834
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gabriel Pereyra, George Tucker, Jan Chorowski, Łukasz Kaiser, and Geoffrey Hinton. Regularizing neural networks by penalizing confident output distributions. arXiv preprint arXiv:1701.06548, 2017. ",
+        "bbox": [
+            174,
+            843,
+            825,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Stanislau Semeniuta, Aliaksei Severyn, and Erhardt Barth. Recurrent dropout without memory loss. arXiv preprint arXiv:1603.05118, 2016. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research, 15(1):1929–1958, 2014.   \nRichard E Turner and Maneesh Sahani. Two problems with variational expectation maximisation for time-series models. Bayesian Time series models, 1(3.1):3–1, 2011.   \nSida Wang and Christopher Manning. Fast dropout training. In international conference on machine learning, pp. 118–126, 2013.   \nDavid Warde-Farley, Ian J Goodfellow, Aaron Courville, and Yoshua Bengio. An empirical analysis of dropout in piecewise linear networks. arXiv preprint arXiv:1312.6197, 2013.   \nZiang Xie, Sida I Wang, Jiwei Li, Daniel Lévy, Aiming Nie, Dan Jurafsky, and Andrew Y Ng. Data noising as smoothing in neural network language models. arXiv preprint arXiv:1703.02573, 2017.   \nZhilin Yang, Zihang Dai, Ruslan Salakhutdinov, and William W Cohen. Breaking the softmax bottleneck: a high-rank rnn language model. arXiv preprint arXiv:1711.03953, 2017.   \nWojciech Zaremba, Ilya Sutskever, and Oriol Vinyals. Recurrent neural network regularization. arXiv preprint arXiv:1409.2329, 2014.   \nGeorge Kingsley Zipf. The psycho-biology of language. Houghton, Mifflin, 1935.   \nKonrad Zolna, Devansh Arpit, Dendi Suhubdy, and Yoshua Bengio. Fraternal dropout. arXiv preprint arXiv:1711.00066, 2017. ",
+        "bbox": [
+            171,
+            103,
+            826,
+            436
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX A VARIATIONAL DROPOUT WITH NON-SHARED MASKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            735,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "If $q$ and $p$ are redefined for the non-shared setting to be products of identical and independent, per time step factors, neither term of the variational objective requires rethinking: the MC approximation still works since $q$ is easy to sample from, while the KL term becomes a sum of componentwise KL divergences and can still be implemented as weight decay. Consequently, both shared and non-shared masks fit into the variational framework. For a detailed derivation see Appendix B. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            205
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In related works, Pachitariu & Sahani (2013) in their investigation of regularisation of standard RNN based language models dismiss applying dropout to recurrent connections “to avoid introducing instabilities into the recurrent part of the LMs”. Bayer et al. (2013) echo this claim about RNNs, which is then cited by Zaremba et al. (2014), but their work is based on LSTMs not standard RNNs. Finally, Gal & Ghahramani (2016b) cite all of the above but also work with LSTMs. Their results indicate a large, about 15 perplexity point advantage to shared mask dropout for language modelling on the Penn Treebank (PTB) corpus (see Fig. 2 in their paper). ",
+        "bbox": [
+            174,
+            212,
+            825,
+            310
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Our experimental results obtained with careful and extensive hyperparameter tuning, listed in Table 5, indicate only a small difference between the two which is in agreement with the empirical study of Semeniuta et al. (2016). ",
+        "bbox": [
+            176,
+            315,
+            823,
+            358
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/6f5546639e8f20fb0827c3f0478a8e60c34395c81c5b3e62a771d9eb3187b54f.jpg",
+        "table_caption": [
+            "Table 5: Validation and test set perplexities on PTB with shared (S) or non-shared (NS) dropout masks for a small, 1 layer and a large, 4 layer LSTM with 10 and 24 million weights, respectively. Non-shared masks perform nearly as well as shared masks and as we have seen neither is “more variational” than the other. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>dataset</td><td colspan=\"2\">10M</td><td colspan=\"2\">24M</td></tr><tr><td></td><td>S</td><td>NS</td><td>S</td><td>NS</td></tr><tr><td>validation</td><td>59.4</td><td>60.2</td><td>57.5</td><td>58.3</td></tr><tr><td>test</td><td>57.5</td><td>58.6</td><td>56.0</td><td>56.9</td></tr></table>",
+        "bbox": [
+            375,
+            422,
+            620,
+            497
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In any case, non-shared masks, in addition to being variational, are also surprisingly competitive with shared masks for LSTMs (we make no claims about standard RNNs). We also tested whether embedding dropout (in which dropout is applied to entire vectors in the input embedding lookup table) proposed by Gal & Ghahramani (2016b) improves results, and find that embedding dropout does not offer any improvement on top of input dropout. ",
+        "bbox": [
+            173,
+            512,
+            825,
+            584
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX B DERIVATION OF VARIATIONAL DROPOUT WITH NON-SHARED MASKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            606,
+            802,
+            638
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In this section, we formulate naive (i.e. non-shared mask) dropout in the variational setting. In contrast to the shared mask case, where $\\omega$ was a single set of weights, here $\\omega ^ { 1 : T }$ (or $\\omega$ , for short) has a set of weights for each time step that differ in their dropout masks. The variational posterior $q ( \\omega )$ and the prior $p ( \\omega )$ are both products of identical distributions over time: ",
+        "bbox": [
+            174,
+            655,
+            825,
+            713
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f5e91882f32c5b20d71d633e14f1b1ddbfd3c066b5789840accbd68f884f1edf.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle q ( \\omega ^ { 1 : T } ) = \\prod _ { t = 1 } ^ { T } q ^ { \\prime } ( \\omega ^ { t } ) = \\prod _ { t = 1 } ^ { T } \\big [ p \\mathcal N ( \\omega ^ { t } | 0 , \\sigma ^ { 2 } ) + ( 1 - p ) \\mathcal N ( \\omega ^ { t } | \\Theta , \\sigma ^ { 2 } ) \\big ] } \\\\ { \\displaystyle p ( \\omega ^ { 1 : T } ) = \\prod _ { t = 1 } ^ { T } p ^ { \\prime } ( \\omega ^ { t } ) = \\prod _ { t = 1 } ^ { T } \\mathcal N ( \\omega ^ { t } | 0 , \\sigma _ { p } ^ { 2 } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            274,
+            722,
+            723,
+            810
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "An unbiased approximation to the integrals in Eq. 1 is based on a single, easy to obtain sample $\\hat { \\omega } \\sim q ( \\omega )$ : ",
+        "bbox": [
+            169,
+            816,
+            823,
+            847
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4af7143a43070ae07409a66ffe0b17200fd5cbdcb31bd372af36a9f0a9d70b01.jpg",
+        "text": "$$\n\\int q ( \\omega ) \\ln p ( y | x , \\omega ) d \\omega \\approx \\ln p ( y | x , \\hat { \\omega } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            854,
+            625,
+            887
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Showing that the KL term can still be approximated with weight decay with non-shared masks is not much more involved. Both distributions are products of densities over independent random variables, ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "so the componentwise KL divergencies sum. In particular: ",
+        "bbox": [
+            173,
+            102,
+            558,
+            119
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5abf590292fcaf13344df4e894168b6179a1b5617578eeb07404273bfbce8be9.jpg",
+        "text": "$$\n\\begin{array} { r l } {  { \\operatorname { E I } ( \\{ \\boldsymbol { g } ( \\omega ) \\} \\| \\boldsymbol { \\rho } ( \\omega ) ) = \\int ( \\prod _ { t = 1 } ^ { T } q ^ { \\prime } ( \\omega ^ { * } ) ) \\ln \\prod _ { t = 1 } ^ { T } \\dot { q } ^ { \\prime } ( \\omega ^ { * } ) } } \\\\ & { = \\int ( \\prod _ { t = 1 } ^ { T } q ^ { \\prime } ( \\omega ^ { * } ) ) \\frac { T } { \\epsilon = 1 } \\ln \\frac { q ^ { \\prime } ( \\omega ^ { * } ) } { \\tilde { p } ^ { \\prime } ( \\omega ^ { * } ) } d \\omega } \\\\ & { = \\sum _ { t = 1 } ^ { T } \\int ( \\prod _ { t = 1 } ^ { T } q ^ { \\prime } ( \\omega ^ { * } ) ) \\ln \\frac { q ^ { \\prime } ( \\omega ^ { * } ) } { \\tilde { p } ^ { \\prime } ( \\omega ^ { * } ) } d \\omega } \\\\ & { = \\frac { \\sum } { t = 1 } ^ { T } \\int [ \\frac { 1 } { \\epsilon = 1 } ^ { T } q ^ { \\prime } ( \\omega ^ { * } ) ] \\ln \\frac { q ^ { \\prime } ( \\omega ^ { * } ) } { \\tilde { p } ^ { \\prime } ( \\omega ^ { * } ) } d \\omega } \\\\ & { = \\frac { \\sum } { t = 1 } ^ { T } \\int [ \\frac { 1 } { \\epsilon = 1 , \\epsilon \\epsilon \\epsilon } q ^ { \\prime } ( \\omega ^ { * } ) ] [ \\dot { q } ^ { \\prime } ( \\omega ^ { * } ) \\ln \\frac { \\dot { q } ^ { \\prime } ( \\omega ^ { * } ) } { \\tilde { p } ^ { \\prime } ( \\omega ^ { * } ) } ] d \\omega } \\\\ & { = \\frac { \\sum } { t = 1 } ^ { T } [ \\int \\frac { 1 } { \\epsilon = 1 , \\epsilon \\epsilon } q ^ { \\prime } ( \\omega ^ { * } ) d \\omega ^ { * } ] [ \\int q ^ { \\prime } ( \\omega ) \\ln \\frac { q ^ { \\prime } ( \\omega ^ { * } ) } { \\tilde { p } ^ { \\prime } ( \\omega ^ { * } ) } d \\omega ] } \\\\ & { = \\Gamma \\cdot \\mathbb { E } [ \\int _ { \\epsilon = 1 } ^ { T } q ^ { \\prime } ( \\omega ) \\mathrm { l i s } q ^ { \\prime } ( \\omega ^ { * } ) d \\omega ^ { * } ] } \\\\ & { = T \\cdot \\mathbb { E } [ \\mathrm { L G } [ ( \\omega ) \\mathrm { l i s } / \\omega ^ { * } ) ] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            259,
+            132,
+            735,
+            375
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We partitioned the variables into two mutually exclusive sets $w ^ { t }$ and its complement $w ^ { \\backslash t }$ , and split the multiple integral using Fubini’s theorem (or, equivalently, using the expectation of independent random variables rule). After the split, the first integral is trivially 1 and the second has no dependence on $T$ . ",
+        "bbox": [
+            173,
+            387,
+            825,
+            444
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "What we end up with is a sum of identical KL terms of the same distributions as in the shared mask case, so the full KL can be approximated with weight decay. ",
+        "bbox": [
+            173,
+            450,
+            823,
+            479
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX C DERIVATION OF THE MAP LOWER BOUND FOR THE ARITHMETIC MODEL ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            506,
+            728,
+            540
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We can rewrite the posterior as: ",
+        "bbox": [
+            174,
+            559,
+            382,
+            574
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a45c49b41adfd6c67b0ad91c6d77dcabbe14ec4ba6e8e0188b7e706fae334a09.jpg",
+        "text": "$$\n\\begin{array} { l } { p ( \\Theta | X , Y ) = \\displaystyle \\frac { p ( X , Y | \\Theta ) p ( \\Theta ) } { p ( X , Y ) } } \\\\ { \\propto p ( X , Y | \\Theta ) p ( \\Theta ) } \\\\ { = \\displaystyle \\int p ( Y | X , \\omega , \\Theta ) p ( \\omega | \\Theta , X ) p ( \\Theta | X ) p ( X ) d \\omega } \\\\ { \\propto \\displaystyle \\int p ( Y | X , \\omega ) p ( \\omega | \\Theta ) p ( \\Theta ) d \\omega } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            585,
+            692,
+            707
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Moving to the log domain and using Jensen’s inequality allows us to construct a lower bound that is a sum of per data point terms (i.e. something that can be conveniently optimised): ",
+        "bbox": [
+            171,
+            715,
+            823,
+            746
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/87523adf69e916e0e58837c7f765ee641235811dc1ee01c41ee40da0c646bef5.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\ln p ( \\Theta | X , Y ) = \\ln \\int p ( Y | X , \\omega ) p ( \\omega | \\Theta ) p ( \\Theta ) d \\omega - C _ { M A P } } \\\\ { \\displaystyle \\qquad = \\ln \\int p ( \\omega | \\Theta ) \\prod _ { i = 1 } ^ { N } p ( y _ { i } | x _ { i } , \\omega ) d \\omega + \\ln p ( \\Theta ) - C _ { M A P } } \\\\ { \\displaystyle \\qquad \\geqslant \\int p ( \\omega | \\Theta ) \\ln \\prod _ { i = 1 } ^ { N } p ( y _ { i } | x _ { i } , \\omega ) d \\omega + \\ln p ( \\Theta ) - C _ { M A P } } \\\\ { \\displaystyle \\qquad = \\sum _ { i = 1 } ^ { N } \\int p ( \\omega | \\Theta ) \\ln p ( y _ { i } | x _ { i } , \\omega ) d \\omega + \\ln p ( \\Theta ) - C _ { M A P } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            274,
+            757,
+            720,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX D DERIVATION OF THE MAP LOWER BOUND FOR THE GEOMETRIC MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            101,
+            825,
+            136
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "From Eq. 6 recall that: ",
+        "bbox": [
+            173,
+            150,
+            321,
+            166
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5495361d36f5d1cd1d9ef467359278880f0d234c8eba62f481cb5458af2772fd.jpg",
+        "text": "$$\np ( y | x , \\Theta ) = \\frac { \\exp \\left( \\mathbb { E } _ { \\hat { \\omega } \\sim p ( \\omega | \\Theta ) } \\ln p ( y | x , \\hat { \\omega } ) \\right) } { Z ( x , \\Theta ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            170,
+            640,
+            205
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The normalisation constant $Z$ is at most 1, due to the geometric mean being bounded from above by the arithmetic mean on a per class $c$ basis: ",
+        "bbox": [
+            173,
+            209,
+            825,
+            238
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/238dc4d405cce57d2a3f259de73c8dfc39f8840ba504cea35bec11b93600c990.jpg",
+        "text": "$$\n\\begin{array} { r l } & { Z ( x , \\Theta ) = \\displaystyle \\sum _ { c = 1 } ^ { C } e x p \\big ( \\underset { \\hat { \\omega } \\sim p ( \\omega | \\Theta ) } { \\mathbb { E } } \\ln p ( c | x , \\hat { \\omega } ) \\big ) } \\\\ & { \\qquad \\leqslant \\displaystyle \\sum _ { c = 1 } ^ { C } \\underset { \\hat { \\omega } \\sim p ( \\omega | \\Theta ) } { \\mathbb { E } } p ( c | x , \\hat { \\omega } ) } \\\\ & { \\qquad = \\underset { \\hat { \\omega } \\sim p ( \\omega | \\Theta ) } { \\mathbb { E } } \\displaystyle \\sum _ { c = 1 } ^ { C } p ( c | x , \\hat { \\omega } ) = 1 } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            242,
+            642,
+            375
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Since this a conditional model, we can rewrite the posterior as: ",
+        "bbox": [
+            171,
+            376,
+            586,
+            392
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5e13cf075113a378b5fef1a9e82af8bfa8d57ff3ae52bbc02725b2ddb28a5cf2.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle p ( \\Theta | X , Y ) = \\frac { p ( X , Y | \\Theta ) p ( \\Theta ) } { p ( X , Y ) } } \\\\ { \\displaystyle \\propto p ( X , Y | \\Theta ) p ( \\Theta ) } \\\\ { \\displaystyle = p ( Y | X , \\Theta ) p ( X | \\Theta ) p ( \\Theta ) } \\\\ { \\displaystyle \\propto p ( Y | X , \\Theta ) p ( \\Theta ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            395,
+            629,
+            486
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "$p ( X | \\Theta )$ is dropped in the last step as it is constant. Moving to the log domain once again: ",
+        "bbox": [
+            169,
+            487,
+            759,
+            502
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/04ebaf3aa9bbee84aff1665ed219a3360b4282e78b086470a994c7035231b404.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\ln p ( \\Theta | X , Y ) = \\ln p ( Y | X , \\Theta ) + \\ln p ( \\Theta ) - C _ { M A P } } \\\\ { \\displaystyle = \\ln \\prod _ { i = 1 } ^ { N } p ( y _ { i } | x _ { i } , \\Theta ) + \\ln p ( \\Theta ) - C _ { M A P } } \\\\ { \\displaystyle = \\sum _ { i = 1 } ^ { N } \\left[ _ { \\xi \\sim p ( \\omega | \\Theta ) } \\ln p ( y _ { i } | x _ { i } , \\tilde { \\omega } ) - \\ln ( Z ( x _ { i } , \\Theta ) ) \\right] + \\ln p ( \\Theta ) - C _ { M A P } } \\\\ { \\displaystyle \\geqslant \\sum _ { i = 1 } ^ { N } \\frac { \\mathbb { P } } { \\delta \\ - \\nu p ( \\omega | \\Theta ) } \\ln p ( y _ { i } | x _ { i } , \\tilde { \\omega } ) + \\ln p ( \\Theta ) - C _ { M A P } } \\\\ { \\displaystyle = \\sum _ { i = 1 } ^ { N } \\int p ( \\omega | \\Theta ) \\ln p ( y _ { i } | x _ { i } , \\Theta ) d \\omega + \\ln p ( \\Theta ) - C _ { M A P } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            220,
+            506,
+            776,
+            702
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where the lower bound arises due to $\\forall i \\colon Z ( x _ { i } , \\Theta ) \\leqslant 1$ . ",
+        "bbox": [
+            173,
+            705,
+            534,
+            722
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX E DERIVATION OF THE MAP LOWER BOUND FOR THE POWER MEAN FAMILY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            739,
+            790,
+            773
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In $\\ S 3 . 2$ we proved that $\\forall i \\colon Z ( x _ { i } , \\Theta ) \\leqslant 1$ . Starting from $p ( \\Theta | X , Y ) \\propto p ( Y | X , \\Theta ) p ( \\Theta )$ just like in the geometric case, we derive a lower bound in the log domain: ",
+        "bbox": [
+            173,
+            787,
+            823,
+            818
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7537cfe4f4b687f4152e2ee452ef0086a061bbe0c143876cdc1d78bc9f669e3b.jpg",
+        "text": "$$\n\\begin{array} { l } { \\ln p ( \\Theta | X , Y ) = \\ln p ( Y | X , \\Theta ) + \\ln p ( \\Theta ) - C _ { M A P } } \\\\ { \\displaystyle \\qquad = \\ln \\prod _ { i = 1 } ^ { N } p ( y _ { i } | x _ { i } , \\Theta ) + \\ln p ( \\Theta ) - C _ { M A P } } \\\\ { \\displaystyle \\qquad = \\sum _ { i = 1 } ^ { N } \\left[ \\ln \\sqrt \\ [ 6 ] { \\underset { \\displaystyle \\hat { \\omega } \\sim p ( \\omega | \\Theta ) } { \\mathbb { E } } p ( y _ { i } | x _ { i } , \\hat { \\omega } ) ^ { \\alpha } } - \\ln ( Z ( x _ { i } , \\Theta ) ) \\right] + \\ln p ( \\Theta ) - C _ { M A P } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            210,
+            820,
+            784,
+            930
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9ea93396c18e141d658527b49bc88138f7dd844522eff9c0a0e2cffe0619c267.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\lesssim \\displaystyle \\sum _ { i = 1 } ^ { N } \\displaystyle \\prod _ { \\ell = \\mathrm { e } p ( \\omega | \\Theta ) } p ( y | x _ { i } | x _ { i } , \\hat { \\omega } ) ^ { \\alpha } + \\operatorname* { l n } p ( \\Theta ) - C _ { M i } , } \\\\ & { = \\displaystyle \\sum _ { i = 1 } ^ { N } \\displaystyle \\frac { 1 } { \\alpha } \\ln \\bigg ( \\int _ { ( - \\mathrm { e } \\mathbb { P } ^ { \\alpha } ( \\omega | \\Theta ) ) } p ( y _ { i } | x _ { i } , \\hat { \\omega } ) ^ { \\alpha } \\bigg ) + \\operatorname* { l n } p ( \\Theta ) - C _ { M i } , } \\\\ & { \\gg \\displaystyle \\sum _ { i = 1 } ^ { N } \\frac { 1 } { \\alpha } \\int _ { ( - \\mathrm { e } \\mathbb { P } ^ { \\alpha } ( i \\omega | \\Theta ) ) } \\ln p ( y _ { i } | x _ { i } , \\hat { \\omega } ) ^ { \\alpha } + \\operatorname* { l n } p ( \\Theta ) - C _ { M i } , } \\\\ & { = \\displaystyle \\sum _ { i = 1 } ^ { N } \\mathrm { e } \\int _ { ( - \\mathrm { e } \\mathbb { P } ^ { \\alpha } ( i \\omega | \\Theta ) ) } \\ln p ( y _ { i } | x _ { i } , \\hat { \\omega } ) + \\operatorname* { l n } p ( \\Theta ) - C _ { M i } , } \\\\ & { = \\displaystyle \\sum _ { i = 1 } ^ { N } \\int _ { \\mathbb { P } ^ { \\alpha } ( i \\omega | \\Theta ) } \\ln p ( y _ { i } | x _ { i } , \\hat { \\omega } ) + \\operatorname* { l n } p ( \\Theta ) - C _ { M i } , } \\\\ & { = \\displaystyle \\sum _ { i = 1 } ^ { N } \\int _ { \\mathbb { P } ^ { \\alpha } ( i \\omega | \\Theta ) } \\ln p ( y _ { i } | x _ { i } , \\omega ) d \\omega + \\operatorname* { l n } p ( \\Theta ) - C _ { M i } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            99,
+            681,
+            321
+        ],
+        "page_idx": 13
+    }
+]