Add files using upload-large-folder tool

parse/train/BJ--gPcxl/BJ--gPcxl.md

@@ -0,0 +1,221 @@
+# SEMI-SUPERVISED LEARNING WITHCONTEXT-CONDITIONAL GENERATIVEADVERSARIAL NETWORKS
+
+Emily Denton Dept. of Computer Science Courant Institute, New York University denton@cs.nyu.edu
+
+Sam Gross   
+Facebook AI Research New York   
+sgross@fb.com Rob Fergus   
+Facebook AI Research New York   
+robfergus@fb.com
+
+# ABSTRACT
+
+We introduce a simple semi-supervised learning approach for images based on in-painting using an adversarial loss. Images with random patches removed are presented to a generator whose task is to fill in the hole, based on the surrounding pixels. The in-painted images are then presented to a discriminator network that judges if they are real (unaltered training images) or not. This task acts as a regularizer for standard supervised training of the discriminator. Using our approach we are able to directly train large VGG-style networks in a semi-supervised fashion. We evaluate on STL-10 and PASCAL datasets, where our approach obtains performance comparable or superior to existing methods.
+
+# 1 INTRODUCTION
+
+Deep neural networks have yielded dramatic performance gains in recent years on tasks such as object classification (Krizhevsky et al., 2012), text classification (Zhang et al., 2015) and machine translation (Sutskever et al., 2014; Bahdanau et al., 2015). These successes are heavily dependent on large training sets of manually annotated data. In many settings however, such large collections of labels may not be readily available, motivating the need for methods that can learn from data where labels are rare.
+
+We propose a method for harnessing unlabeled image data based on image in-painting. A generative model is trained to generate pixels within a missing hole, based on the context provided by surrounding parts of the image. These in-painted images are then used in an adversarial setting (Goodfellow et al., 2014) to train a large discriminator model whose task is to determine if the image was real (from the unlabeled training set) or fake (an in-painted image). The realistic looking fake examples provided by the generative model cause the discriminator to learn features that generalize to the related task of classifying objects. Thus adversarial training for the in-painting task can be used to regularize large discriminative models during supervised training on a handful of labeled images.
+
+# 1.1 RELATED WORK
+
+Learning From Context: The closest work to ours is the independently developed context-encoder approach of Pathak et al. (2016). This introduces an encoder-decoder framework, shown in Fig. 1(a), that is used to in-paint images where a patch has been randomly removed. After using this as a pre-training task, a classifier is added to the encoder and the model is fine-tuned using the labeled examples. Although both approaches use the concept of in-painting, they differ in several important ways. First, the architectures are different (see Fig. 1): in Pathak et al. (2016), the features for the classifier are taken from the encoder, whereas ours come from the discriminator network. In practice this makes an important difference as we are able to directly train large models such as VGG (Simonyan & Zisserman, 2015) using adversarial loss alone. By contrast, Pathak et al. (2016) report difficulties in training an AlexNet encoder with this loss. This leads to the second difference, namely that on account of these issues, they instead employ an $\ell _ { 2 }$ loss when training models for classification and detection (however they do use a joint $\ell _ { 2 }$ and adversarial loss to achieve impressive in-painting results). Finally, the unsupervised learning task differs between the two models. The context-encoder learns a feature representation suitable for in-painting whereas our model learns a feature representation suitable for differentiating real/fake in-paintings. Notably, while we also use a neural network to generate the in-paintings, this model is only used as an adversary for the discriminator, rather than as a feature extractor. In section 4, we compare the performance of our model to the context-encoder on the PASCAL dataset.
+
+![](images/653f69b4fb4d07b57d1405e1c9be333ecdac968a44279a554e551e716c3ac2fa.jpg)  
+Figure 1: (a) Context-encoder of Pathak et al. (2016), configured for object classification task. (b) Semi-supervised learning with GANs (SSL-GAN). (c) Semi-supervised learning with CC-GANs. In (a-c) the blue network indicates the feature representation being learned (encoder network in the context-encoder model and discriminator network in the GAN and CC-GAN models).
+
+Other forms of spatial context within images have recently been utilized for representation learning. Doersch et al. (2015) propose training a CNN to predict the spatial location of one image patch relative to another. Noroozi & Favaro (2016) propose a model that learns by unscrambling image patches, essentially solving a jigsaw puzzle to learn visual representations. In the text domain, context has been successfully leveraged as an unsupervised criterion for training useful word and sentence level representations (Collobert et al., 2011; Mikolov et al., 2015; Kiros et al., 2015).
+
+Deep unsupervised and semi-supervised learning: A popular method of utilizing unlabeled data is to layer-wise train a deep autoencoder or restricted Botlzmann machine (Hinton et al., 2006) and then fine tune with labels on a discriminative task. More recently, several autoencoding variants have been proposed for unsupervised and semi-supervised learning, such as the ladder network (Rasmus et al., 2015), stacked what-where autoencoders (Zhao et al., 2016) and variational autoencoders (Kingma & Welling, 2014; Kingma et al., 2014).
+
+Dosovitskiy et al. (2014) achieved state-of-the-art results by training a CNN with a different class for each training example and introducing a set of transformations to provide multiple examples per class. The pseudo-label approach (Lee, 2013) is a simple semi-supervised method that trains using the maximumly predicted class as a label when labels are unavailable. Springenberg (2015) propose a categorical generative adversarial network (CatGAN) which can be used for unsupervised and semi-supervised learning. The discriminator in a CatGAN outputs a distribution over classes and is trained to minimize the predicted entropy for real data and maximize the predicted entropy for fake data. Similar to our model, CatGANs use the feature space learned by the discriminator for the final supervised learning task. Salimans et al. (2016) recently proposed a semi-supervised GAN model in which the discriminator outputs a softmax over classes rather than a probability of real vs. fake. An additional ‘generated’ class is used as the target for generated samples. This method differs from our work in that it does not utilize context information and has only been applied to datasets of small resolution. However, the discriminator loss is similar to the one we propose and could be combined with our context-conditional approach.
+
+More traditional semi-supervised methods include graph-based approaches (Zhou et al., 2004; Zhu, 2006) that show impressive performance when good image representations are available. However, the focus of our work is on learning such representations.
+
+Generative models of images: Restricted Boltzmann machines (Salakhutdinov, 2015), de-noising autoencoders (Vincent et al., 2008) and variational autoencoders (Kingma & Welling, 2014) optimize a maximum likelihood criterion and thus learn decoders that map from latent space to image space. More recently, generative adversarial networks (Goodfellow et al., 2014) and generative moment matching networks (Li et al., 2015; Dziugaite et al., 2015) have been proposed. These methods ignore data likelihoods and instead directly train a generative model to produce realistic samples. Several extensions to the generative adversarial network framework have been proposed to scale the approach to larger images (Denton et al., 2015; Radford et al., 2016; Salimans et al., 2016). Our work draws on the insights of Radford et al. (2016) regarding adversarial training practices and architecture for the generator network, as well as the notion that the discriminator can produce useful features for classification tasks.
+
+Other models used recurrent approaches to generate images (Gregor et al., 2015; Theis & Bethge, 2015; Mansimov et al., 2016; van den Oord et al., 2016). Dosovitskiy et al. (2015) trained a CNN to generate objects with different shapes, viewpoints and color. Sohl-Dickstein et al. (2015) propose a generative model based on a reverse diffusion process. While our model does involve image generation, it differs from these approaches in that the main focus is on learning a good representation for classification tasks.
+
+Predictive generative models of videos aim to extrapolate from current frames to future ones and in doing so learn a feature representation that is useful for other tasks. In this vein, Ranzato et al. (2014) used an $\ell _ { 2 }$ -loss in pixel-space. Mathieu et al. (2015) combined an adversarial loss with $\ell _ { 2 }$ , giving models that generate crisper images. While our model is also predictive, it only considers interpolation within an image, rather than extrapolation in time.
+
+# 2 APPROACH
+
+We present a semi-supervised learning framework built on generative adversarial networks (GANs) of Goodfellow et al. (2014). We first review the generative adversarial network framework and then introduce context conditional generative adversarial networks (CC-GANs). Finally, we show how combining a classification objective and a CC-GAN objective provides a unified framework for semi-supervised learning.
+
+# 2.1 GENERATIVE ADVERSARIAL NETWORKS
+
+The generative adversarial network approach (Goodfellow et al., 2014) is a framework for training generative models, which we briefly review. It consists of two networks pitted against one another in a two player game: A generative model, $G$ , is trained to synthesize images resembling the data distribution and a discriminative model, $D$ , is trained to distinguish between samples drawn from $G$ and images drawn from the training data.
+
+More formally, let $\mathcal { X } = \{ \mathbf { x } ^ { 1 } , . . . , \mathbf { x } ^ { n } \}$ be a dataset of images of dimensionality $d$ . Let $D$ denote a discriminative function that takes as input an image $\mathbf { x } \in \mathbb { R } ^ { d }$ and outputs a scalar representing the probability of input $\mathbf { x }$ being a real sample. Let $G$ denote the generative function that takes as input a random vector $\mathbf { z } \in \mathbb { R } ^ { z }$ sampled from a prior noise distribution $p _ { \mathrm { N o i s e } }$ and outputs a synthesized image $\widetilde { \mathbf { x } } = G ( \mathbf { z } ) \in \mathbb { R } ^ { d }$ . Ideally, $D ( \mathbf { x } ) = 1$ when $\mathbf { x } \in \mathcal { X }$ and $D ( \mathbf { x } ) = 0$ when $\mathbf { x }$ was generated from $G$ . The GAN objective is given by:
+
+$$
+\operatorname* { m i n } _ { G } \operatorname* { m a x } _ { D } \ \mathbb { E } _ { \mathbf { x } \sim \mathcal { X } } [ \log D ( \mathbf { x } ) ] + \mathbb { E } _ { \mathbf { z } \sim p _ { \mathrm { N o i s e } } ( \mathbf { z } ) } [ \log ( 1 - D ( G ( \mathbf { z } ) ) ) ]
+$$
+
+The conditional generative adversarial network (Mirza $\&$ Osindero, 2014) is an extension of the GAN in which both $D$ and $G$ receive an additional vector of information $\mathbf { y }$ as input. The conditional GAN objective is given by:
+
+$$
+\operatorname* { m i n } _ { G } \operatorname* { m a x } _ { D } \ \mathbb { E } _ { \mathbf { x } , \mathbf { y } \sim \mathcal { X } } [ \log D ( \mathbf { x } , \mathbf { y } ) ] + \mathbb { E } _ { \mathbf { z } \sim p _ { \mathrm { N o i s e } } ( \mathbf { z } ) } [ \log ( 1 - D ( G ( \mathbf { z } , \mathbf { y } ) , \mathbf { x } ) ) ]
+$$
+
+# 2.2 CONTEXT-CONDITIONAL GENERATIVE ADVERSARIAL NETWORKS
+
+We propose context-conditional generative adversarial networks (CC-GANs) which are conditional GANs where the generator is trained to fill in a missing image patch and the generator and discriminator are conditioned on the surrounding pixels.
+
+In particular, the generator $G$ receives as input an image with a randomly masked out patch. The generator outputs an entire image. We fill in the missing patch from the generated output and then pass the completed image into $D$ . We pass the completed image into $D$ rather than the context and the patch as two separate inputs so as to prevent $D$ from simply learning to identify discontinuities along the edge of the missing patch.
+
+More formally, let $\mathbf { m } \in \mathbb { R } ^ { d }$ denote to a binary mask that will be used to drop out a specified portion of an image. The generator receives as input $\mathbf { m } \odot \mathbf { x }$ where $\odot$ denotes element-wise multiplication. The generator outputs $\mathbf { x _ { G } } = G ( \mathbf { m } \odot \mathbf { x } , \mathbf { z } ) \in \mathbb { R } ^ { d }$ and the in-painted image $\mathbf { x _ { I } }$ is given by:
+
+$$
+\mathbf { x _ { I } } = \left( 1 - \mathbf { m } \right) \odot \mathbf { x _ { G } } + \mathbf { m } \odot \mathbf { x }
+$$
+
+The CC-GAN objective is given by:
+
+$$
+\operatorname* { m i n } _ { G } \operatorname* { m a x } _ { D } \mathbb { E } _ { \mathbf { x } \sim \mathcal { X } } [ \log D ( \mathbf { x } ) ] + \mathbb { E } _ { \mathbf { x } \sim \mathcal { X } , \mathbf { m } \sim \mathcal { M } } [ \log ( 1 - D ( \mathbf { x _ { I } } ) ) ]
+$$
+
+# 2.3 COMBINED GAN AND CC-GAN
+
+While the generator of the CC-GAN outputs a full image, only a portion of it (corresponding to the missing hole) is seen by the discriminator. In the combined model, which we denote by $\mathrm { C C - \bar { G } A N ^ { 2 } }$ , the fake examples for the discriminator include both the in-painted image $\mathbf { x _ { I } }$ and the full image $\mathbf { x _ { G } }$ produced by the generator (i.e. not just the missing patch). By combining the GAN and CC-GAN approaches, we introduce a wider array of negative examples to the discriminator. The CC-GAN2 objective given by:
+
+$$
+\begin{array} { r l } {  { \operatorname* { m i n } \operatorname* { m a x } _ { D } \mathbb { E } _ { \mathbf { x } \sim \mathcal { X } } [ \log D ( \mathbf { x } ) ] } } \\ & { + \ \mathbb { E } _ { \mathbf { x } \sim \mathcal { X } , \mathbf { m } \sim \mathcal { M } } [ \log ( 1 - D ( \mathbf { x _ { I } } ) ) ] } \\ & { + \ \mathbb { E } _ { \mathbf { x } \sim \mathcal { X } , \mathbf { m } \sim \mathcal { M } } [ \log ( 1 - D ( \mathbf { x _ { G } } ) ) ] } \end{array}
+$$
+
+# 2.4 SEMI-SUPERVISED LEARNING WITH CC-GANS
+
+A common approach to semi-supervised learning is to combine a supervised and unsupervised objective during training. As a result unlabeled data can be leveraged to aid the supervised task.
+
+Intuitively, a GAN discriminator must learn something about the structure of natural images in order to effectively distinguish real from generated images. Recently, Radford et al. (2016) showed that a GAN discriminator learns a hierarchical image representation that is useful for object classification. Such results suggest that combining an unsupervised GAN objective with a supervised classification objective would produce a simple and effective semi-supervised learning method. This approach, denoted by SSL-GAN, is illustrated in Fig. 1(b). The discriminator network receives a gradient from the real/fake loss for every real and generated image. The discriminator also receives a gradient from the classification loss on the subset of (real) images for which labels are available.
+
+Generative adversarial networks have shown impressive performance on many diverse datasets. However, samples are most coherent when the set of images the network is trained on comes from a limited domain (eg. churches or faces). Additionally, it is difficult to train GANs on very large images. Both these issues suggest semi-supervised learning with vanilla GANs may not scale well to datasets of large diverse images. Rather than determining if a full image is real or fake, context conditional GANs address a different task: determining if a part of an image is real or fake given the surrounding context.
+
+Formally, let $\mathcal { X } _ { \mathcal { L } } = \{ ( \mathbf { x } ^ { 1 } , y ^ { 1 } ) , . . . , ( \mathbf { x } ^ { n } , y ^ { n } ) \}$ denote a dataset of labeled images. Let $D _ { c } ( x )$ denote the output of the classifier head on the discriminator (see Fig. 1(c) for details). Then the semisupervised CC-GAN objective is:
+
+$$
+\underset { G } { \mathrm { m i n } } \underset { D } { \mathrm { m a x } } \mathbb { E } _ { \mathbf { x } \sim \mathcal { X } } [ \log D ( \mathbf { x } ) ] + \mathbb { E } _ { \mathbf { x } \sim \mathcal { X } , \mathbf { m } \sim \mathcal { M } } [ \log ( 1 - D ( \mathbf { x _ { I } } ) ) ] + \lambda _ { c } \mathbb { E } _ { \mathbf { x } , y \sim \mathcal { X } _ { \mathcal { L } } } [ \log ( D _ { c } ( y | \mathbf { x } ) ) ]
+$$
+
+The hyperparameter $\lambda _ { c }$ balances the classification and adversarial losses. We only consider the CCGAN in the semi-supervised setting and thus drop the SSL notation when referring to this model.
+
+# 2.5 MODEL ARCHITECTURE AND TRAINING DETAILS
+
+The architecture of our generative model, $G$ , is inspired by the generator architecture of the DCGAN (Radford et al., 2016). The model consists of a sequence of convolutional layers with subsampling (but no pooling) followed by a sequence of fractionally-strided convolutional layers. For the discriminator, $D$ , we used the VGG-A network (Simonyan & Zisserman, 2015) without the fully connected layers (which we call the VGG-A’ architecture). Details of the generator and discriminator are given in Fig. 2. The input to the generator is an image with a patch zeroed out. In preliminary experiments we also tried passing in a separate mask to the generator to make the missing area more explicit but found this did not effect performance.
+
+![](images/75e463c4a6f6e0e416af86d2fb282f317b8f489cea266141a491353b03c04d11.jpg)  
+Figure 2: Architecture of our context-conditional generative adversarial network (CC-GAN). conv(64, $4 \times 4$ , $2 \times 2$ ) denotes a conv layer with 64 channels, 4x4 kernels and stride $2 \mathbf { x } 2$ . Each convolution layer is followed by a spatial batch normalization and rectified linear layer. Dashed lines indicate optional pathways.
+
+Even with the context conditioning it is difficult to generate large image patches that look realistic, making it problematic to scale our approach to high resolution images. To address this, we propose conditioning the generator on both the high resolution image with a missing patch and a low resolution version of the whole image (with no missing region). In this setting, the generators task becomes one of super-resolution on a portion of an image. However, the discriminator does not receive the low resolution image and thus is still faced with the same problem of determining if a given in-painting is viable or not. Where indicated, we used this approach in our PASCAL VOC 2007 experiments, with the original image being downsampled by a factor of 4. This provided enough information for the generator to fill in larger holes but not so much that it made the task trivial. This optional low resolution image is illustrated in Fig. 2(left) with the dotted line.
+
+We followed the training procedures of Radford et al. (2016). We used the Adam optimizer (Kingma & Ba, 2015) in all our experiments with learning rate of 0.0002, momentum term $\beta _ { 1 }$ of 0.5, and the remaining Adam hyperparameters set to their default values. We set $\lambda _ { c } = 1$ for all experiments.
+
+Table 1: Comparison of CC-GAN and other published results on STL-10.   
+
+<table><tr><td>Method</td><td>Accuracy</td></tr><tr><td>Multi-task Bayesian Optimization (Swersky et al.,2013) Exemplar CNN(Dosovitskiy et al.,2014) Stacked What-Where Autoencoder (Zhao et al.,2016)</td><td>70.10± 0.6 75.40 ± 0.3 74.33</td></tr><tr><td>Supervised VGG-A&#x27;</td><td>61.19 ± 1.1</td></tr><tr><td>SSL-GAN</td><td>73.81 ± 0.5</td></tr><tr><td>CC-GAN</td><td>75.67 ± 0.5</td></tr><tr><td>CC-GAN²</td><td>77.79 ± 0.8</td></tr></table>
+
+# 3 EXPERIMENTS
+
+# 3.1 STL-10 CLASSIFICATION
+
+STL-10 is a dataset of $9 6 \times 9 6$ color images with a 1:100 ratio of labeled to unlabeled examples, making it an ideal fit for our semi-supervised learning framework. The training set consists of 5000 labeled images, mapped to 10 pre-defined folds of 1000 images each, and 100,000 unlabeled images. The labeled images belong to 10 classes and were extracted from the ImageNet dataset and the unlabeled images come from a broader distribution of classes. We follow the standard testing protocol and train 10 different models on each of the 10 predefined folds of data. We then evaluate classification accuracy of each model on the test set and report the mean and standard deviation.
+
+We trained our CC-GAN and $\mathrm { C C - G A N ^ { 2 } }$ models on $6 4 \times 6 4$ crops of the $9 6 \times 9 6$ image. The hole was $3 2 \times 3 2$ pixels and the location of the hole varied randomly (see Fig. 3(top)). We trained for 100 epochs and then fine-tuned the discriminator on the $9 6 \mathbf { x } 9 6$ labeled images, stopping when training accuracy reached $100 \%$ . As shown in Table 1, the CC-GAN model performs comparably to current state of the art (Dosovitskiy et al., 2014) and the $\mathrm { C C - G A N ^ { 2 } }$ model improves upon it.
+
+We also trained two baseline models in an attempt to tease apart the contributions of adversarial training and context conditional adversarial training. The first is a purely supervised training of the VGG-A’ model (the same architecture as the discriminator in the CC-GAN framework). This was trained using a dropout of 0.5 on the final layer and weight decay of 0.001. The performance of this model is significantly worse than the CC-GAN model.
+
+We also trained a semi-supervised GAN (SSL-GAN, see Fig. 1(b)) on STL-10. This consisted of the same discriminator as the CC-GAN (VGG-A’ architecture) and generator from the DCGAN model (Radford et al., 2016). The training setup in this case is identical to the CC-GAN model. The SSLGAN performs almost as well as the CC-GAN, confirming our hypothesis that the GAN objective is a useful unsupervised criterion.
+
+# 3.2 PASCAL VOC CLASSIFICATION
+
+In order to compare against other methods that utilize spatial context we ran the CC-GAN model on PASCAL VOC 2007 dataset. This dataset consists of natural images coming from 20 classes. The dataset contains a large amount of variability with objects varying in size, pose, and position. The training and validation sets combined contain 5,011 images, and the test set contains 4,952 images. The standard measure of performance is mean average precision (mAP).
+
+We trained each model on the combined training and validation set for ${ \sim } 5 0 0 0$ epochs and evaluated on the test set once1. Following Pathak et al. (2016), we train using random cropping, and then evaluate using the average prediction from 10 random crops.
+
+Our best performing model was trained on images of resolution $1 2 8 \times 1 2 8$ with a hole size of $6 4 \times 6 4$ and a low resolution input of size $3 2 \times 3 2$ . Table 2 compares our CC-GAN method to other feature learning approaches on the PASCAL test set. It outperforms them, beating the current state of the art (Wang & Gupta, 2015) by $3 . 8 \%$ . It is important to note that our feature extractor is the VGGA’ model which is larger than the AlexNet architecture (Krizhevsky et al., 2012) used by other approaches in Table 2. However, purely supervised training of the two models reveals that VGG-A’ is less than $2 \%$ better than AlexNet. Furthermore, our model outperforms the supervised VGG-A’ baseline by a $7 \%$ margin ( $6 2 . 2 \%$ vs. $5 5 . 2 \%$ ). This suggests that our gains stem from the CC-GAN method rather than the use of a better architecture.
+
+Table 2: Comparison of CC-GAN and other methods (as reported by Pathak et al. (2016)) on PASCAL VOC 2007.   
+
+<table><tr><td>Method</td><td>mAP</td></tr><tr><td>Supervised AlexNet</td><td>53.3 %</td></tr><tr><td>Visual tracking from video (Wang &amp; Gupta, 2015)</td><td>58.4%</td></tr><tr><td>Context prediction (Doersch et al.,2015)</td><td>55.3%</td></tr><tr><td>Context encoders (Pathak et al., 2016)</td><td>56.5%</td></tr><tr><td>Supervised VGG-A&#x27;</td><td>55.2%</td></tr><tr><td>CC-GAN</td><td>62.2%</td></tr><tr><td>CC-GAN²</td><td>62.7%</td></tr></table>
+
+Table 3: Comparison of different CC-GAN variants on PASCAL VOC 2007.   
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Image size</td><td rowspan=1 colspan=1>Hole size</td><td rowspan=1 colspan=1>Low res size</td><td rowspan=1 colspan=1>mAP</td></tr><tr><td rowspan=1 colspan=1>Supervised VGG-A&#x27;CC-GAN</td><td rowspan=1 colspan=1>64×6464×64</td><td rowspan=1 colspan=1>32×32</td><td rowspan=1 colspan=1>=</td><td rowspan=1 colspan=1>52.97%56.79%</td></tr><tr><td rowspan=1 colspan=1>Supervised VGG-A&#x27;CC-GANCC-GAN</td><td rowspan=1 colspan=1>96×9696×9696×96</td><td rowspan=1 colspan=1>=48×4848×48</td><td rowspan=1 colspan=1>=24×24</td><td rowspan=1 colspan=1>55.22%60.38%60.98%</td></tr><tr><td rowspan=1 colspan=1>Supervised VGG-A&#x27;CC-GANCC-GAN</td><td rowspan=1 colspan=1>128×128128×128128×128</td><td rowspan=1 colspan=1>=64×6464×64</td><td rowspan=1 colspan=1>-=32×32</td><td rowspan=1 colspan=1>55.2%61.3%62.2%</td></tr></table>
+
+Table 3 shows the effect of training on different resolutions. The CC-GAN improves over the baseline CNN consistently regardless of image size. We found that conditioning on the low resolution image began to help when the hole size was largest $( 6 4 \times 6 4 )$ . We hypothesize that the low resolution conditioning would be more important for larger images, potentially allowing the method to scale to larger image sizes than we explored in this work.
+
+# 3.3 INPAINTING
+
+We now show some sample in-paintings produced by our CC-GAN generators. In our semisupervised learning experiments on STL-10 we remove a single fixed size hole from the image. The top row of Fig. 3 shows in-paintings produced by this model. We can also explored different masking schemes as illustrated in the remaining rows of Fig. 3 (however these did not improve classification results). In all cases we see that training the generator with the adversarial loss produces sharp semantically plausible in-painting results.
+
+Fig. 4 shows generated images and in-painted images from a model trained with the CC-GAN2 criterion. The output of a CC-GAN generator tends to be corrupted outside the patch used to inpaint the image (since gradients only flow back to the missing patch). However, in the CC-GAN2 model, we see that both the in-painted image and the generated image are coherent and semantically consistent with the masked input image.
+
+Fig. 5 shows in-painted images from a generator trained on $1 2 8 \times 1 2 8$ PASCAL images. Fig. 6 shows the effect of adding a low resolution $( 3 2 \times 3 2 )$ image as input to the generator. For comparison we also show the result of in-painting by filling in with a bi-linearly upsampled image. Here we see the generator produces high-frequency structure rather than simply learning to copy the low resolution patch.
+
+# 4 DISCUSSION
+
+We have presented a simple semi-supervised learning framework based on in-painting with an adversarial loss. The generator in our CC-GAN model is capable of producing semantically meaningful in-paintings and the discriminator performs comparable to or better than existing semi-supervised methods on two classification benchmarks.
+
+![](images/84e72393ad78ba91756006fb5a57e6c9cb91c209426da709b0af98f36dd5292e.jpg)  
+Figure 3: STL-10 in-painting with CC-GAN training and varying methods of dropping out the image.
+
+![](images/e3c40c35812801b637189c53c273f3f7a1c66f8ffea838a8a4e23d1dbf0c1bcc.jpg)  
+Figure 4: STL-10 in-painting with combined CC-GAN2 training.
+
+![](images/7c2cc9d7e2e34e5d761bccd468b83b706503506dcc091649f12805a89d06b2a3.jpg)  
+Figure 5: PASCAL in-painting with CC-GAN.
+
+![](images/69cca881be43870bc111ff5f24aaf4848fbd7c70d7b79aa7280b9ffb4ffe5286.jpg)  
+Figure 6: PASCAL in-painting with CC-GAN conditioned on low resolution image. Top two rows show input to generator. Third row shows inpainting my bilinear upsampling. Bottom row shows inpainted image by generator.
+
+Since discrimination of real/fake in-paintings is more closely related to the target task of object classification than extracting a feature representation suitable for in-filling, it is not surprising that we are able to exceed the performance of Pathak et al. (2016) on PASCAL classification. Furthermore, since our model operates on images half the resolution as those used by other approaches ( $1 2 8 \times 1 2 8$ vs. $2 2 4 \times 2 4 4$ , there is potential for further gains if improvements in the generator resolution can be made. Our models and code are available at https://github.com/edenton/cc-gan.
+
+Acknowledgements: Emily Denton is supported by a Google Fellowship. Rob Fergus is grateful for the support of CIFAR.
+
+# REFERENCES
+
+D. Bahdanau, K. Cho, and Y. Bengio. Neural machine translation by jointly learning to align and translate. In The International Conference on Learning Representations, 2015.   
+R. Collobert, J. Weston, L. Bottou, M. Karlen, K. Kavukcuoglu, and P. Kuksa. Natural language processing (almost) from scratch. Journal of Machine Learning Research, 2011.   
+Emily Denton, Soumith Chintala, Arthur Szlam, and Rob Fergus. Deep generative image models using a laplacian pyramid of adversarial networks. In Advances in Neural Information Processing Systems 28, 2015.   
+Carl Doersch, Abhinav Gupta, and Alexei A. Efros. Unsupervised visual representation learning by context prediction. In International Conference on Computer Vision, 2015.   
+Alexey Dosovitskiy, Jost Tobias Springenberg, Martin Riedmiller, and Thomas Brox. Discriminative unsupervised feature learning with convolutional neural networks. In Advances in Neural Information Processing Systems 27, 2014.   
+Alexey Dosovitskiy, Jost Tobias Springenberg, and Thomas Brox. Learning to generate chairs, tables and cars with convolutional networks. In Computer Vision and Pattern Recognition, 2015.   
+Gintare Karolina Dziugaite, Daniel M. Roy, and Zoubin Ghahramani. Training generative neural networks via maximum mean discrepancy optimization. In Uncertainty in Artificial Intelligence, 2015.   
+Ian J. Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in Neural Information Processing Systems 27, 2014.   
+Karol Gregor, Ivo Danihelka, Alex Graves, Danilo Jimenez Rezende, and Daan Wierstra. Draw: A recurrent neural network for image generation. In International Conference on Machine Learning, 2015.   
+G. E. Hinton, S. Osindero, and Y. Teh. A fast learning algorithm for deep belief nets. Neural Computation, 18, 2006.   
+D.P. Kingma and J. Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations, 2015.   
+D.P. Kingma and M. Welling. Auto-encoding variational bayes. In International Conference on Learning Representations, 2014.   
+D.P. Kingma, D.J. Rezende, S. Mohamed, and M. Welling. Semi-supervised learning with deep generative models. In Advances in Neural Information Processing Systems 27, 2014.   
+Ryan Kiros, Yukun Zhu, Ruslan Salakhutdinov, Richard S. Zemel, Antonio Torralba, Raquel Urtasun, and Sanja Fidler. Skip-thought vectors. In Advances in Neural Information Processing Systems 28, 2015.   
+Alex Krizhevsky, Ilya Sutskever, and Geoff Hinton. Imagenet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems 25, pp. 1106–1114, 2012.   
+D. H. Lee. Pseudo-label: The simple and efficient semi-supervised learning method for deep neural networks. In Workshop on Challenges in Representation Learning, ICML, 2013.   
+Yujia Li, Kevin Swersky, and Richard Zemel. Generative moment matching networks. In ICML, 2015.   
+Elman Mansimov, Emilio Parisotto, Jimmy Ba, and Ruslan Salakhutdinov. Generating images from captions with attention. In The International Conference on Learning Representations, 2016.
+
+Michael Mathieu, Camille Couprie, and Yann LeCun. Deep multi-scale video prediction beyond mean square ¨ error. arXiv 1511.05440, 2015.   
+T. Mikolov, I. Sutskever, K. Chen, G. S. Corrado, and J. Dean. Distributed representations of words and phrases and their compositionality. In Advances in Neural Information Processing Systems 28, 2015.   
+Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. CoRR, abs/1411.1784, 2014.   
+Mehdi Noroozi and Paolo Favaro. Unsupervised learning of visual representations by solving jigsaw puzzles. CoRR, abs/1603.09246, 2016.   
+Deepak Pathak, Philipp Krahenbuhl, Jeff Donahue, Trevor Darrell, and Alexei A. Efros. Context encoders: Feature learning by inpainting. In Computer Vision and Pattern Recognition, 2016.   
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. In The International Conference on Learning Representations, 2016.   
+Marc’Aurelio Ranzato, Arthur Szlam, Joan Bruna, Michael Mathieu, Ronan Collobert, and Sumit Chopra. ¨ Video (language) modeling: a baseline for generative models of natural videos. arXiv 1412.6604, 2014.   
+Antti Rasmus, Mathias Berglund, Mikko Honkala, Harri Valpola, and Tapani Raiko. Semi-supervised learning with ladder network. In Advances in Neural Information Processing Systems 28, 2015.   
+Ruslan Salakhutdinov. Learning deep generative models. Annual Review of Statistics and Its Application, 2: 361–385, 2015.   
+Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. In Advances in Neural Information Processing Systems 29, 2016.   
+K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. In The International Conference on Learning Representations, 2015.   
+Jascha Sohl-Dickstein, Eric A. Weiss, Niru Maheswaranathan, and Surya Ganguli. Deep unsupervised learning using nonequilibrium thermodynamics. CoRR, abs/1503.03585, 2015.   
+Jost Tobias Springenberg. Unsupervised and semi-supervised learning with categorical generative adversarial networks. arXiv 1511.06390, 2015.   
+Ilya Sutskever, Oriol Vinyals, and Quoc Le. Sequence to sequence learning with neural networks. In Advances in Neural Information Processing Systems 27, 2014.   
+Kevin Swersky, Jasper Snoek, and Ryan P. Adams. Multi-task bayesian optimization. In Advances in Neural Information Processing Systems 26, 2013.   
+L. Theis and M. Bethge. Generative image modeling using spatial lstms. In Advances in Neural Information Processing Systems 28, 2015.   
+Aaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks. In ICML, 2016.   
+P. Vincent, H. Larochelle, Y. Bengio, and P.A. Manzagol. Extracting and composing robust features with denoising autoencoders. In International Conference on Machine Learning, 2008.   
+Xiaolong Wang and Abhinav Gupta. Unsupervised learning of visual representations using videos. In ICCV, 2015.   
+Xiang Zhang, Junbo Zhao, and Yann LeCun. Character-level convolutional networks for text classification. In Advances in Neural Information Processing Systems 28, 2015.   
+Junbo Zhao, Michael Mathieu, Ross Goroshin, and Yann LeCun. Stacked what-where auto-encoders. In International Conference on Learning Representations, 2016.   
+D. Zhou, O. Bousquet, T. Lal, J. Weston, and B. Schoelkopf. Learning with local and global consistency. In Advances in Neural Information Processing Systemsi 17, 2004.
+
+Xiaojin Zhu. Semi-supervised learning literature survey, 2006.

parse/train/BJ--gPcxl/BJ--gPcxl_content_list.json

@@ -0,0 +1,1004 @@
+[
+    {
+        "type": "text",
+        "text": "SEMI-SUPERVISED LEARNING WITHCONTEXT-CONDITIONAL GENERATIVEADVERSARIAL NETWORKS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            642,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Emily Denton Dept. of Computer Science Courant Institute, New York University denton@cs.nyu.edu ",
+        "bbox": [
+            183,
+            195,
+            442,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sam Gross   \nFacebook AI Research New York   \nsgross@fb.com Rob Fergus   \nFacebook AI Research New York   \nrobfergus@fb.com ",
+        "bbox": [
+            468,
+            195,
+            619,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            645,
+            195,
+            805,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            270,
+            544,
+            285
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We introduce a simple semi-supervised learning approach for images based on in-painting using an adversarial loss. Images with random patches removed are presented to a generator whose task is to fill in the hole, based on the surrounding pixels. The in-painted images are then presented to a discriminator network that judges if they are real (unaltered training images) or not. This task acts as a regularizer for standard supervised training of the discriminator. Using our approach we are able to directly train large VGG-style networks in a semi-supervised fashion. We evaluate on STL-10 and PASCAL datasets, where our approach obtains performance comparable or superior to existing methods. ",
+        "bbox": [
+            233,
+            300,
+            764,
+            425
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            444,
+            336,
+            460
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks have yielded dramatic performance gains in recent years on tasks such as object classification (Krizhevsky et al., 2012), text classification (Zhang et al., 2015) and machine translation (Sutskever et al., 2014; Bahdanau et al., 2015). These successes are heavily dependent on large training sets of manually annotated data. In many settings however, such large collections of labels may not be readily available, motivating the need for methods that can learn from data where labels are rare. ",
+        "bbox": [
+            174,
+            470,
+            825,
+            554
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose a method for harnessing unlabeled image data based on image in-painting. A generative model is trained to generate pixels within a missing hole, based on the context provided by surrounding parts of the image. These in-painted images are then used in an adversarial setting (Goodfellow et al., 2014) to train a large discriminator model whose task is to determine if the image was real (from the unlabeled training set) or fake (an in-painted image). The realistic looking fake examples provided by the generative model cause the discriminator to learn features that generalize to the related task of classifying objects. Thus adversarial training for the in-painting task can be used to regularize large discriminative models during supervised training on a handful of labeled images. ",
+        "bbox": [
+            174,
+            560,
+            825,
+            672
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1.1 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            680,
+            331,
+            694
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Learning From Context: The closest work to ours is the independently developed context-encoder approach of Pathak et al. (2016). This introduces an encoder-decoder framework, shown in Fig. 1(a), that is used to in-paint images where a patch has been randomly removed. After using this as a pre-training task, a classifier is added to the encoder and the model is fine-tuned using the labeled examples. Although both approaches use the concept of in-painting, they differ in several important ways. First, the architectures are different (see Fig. 1): in Pathak et al. (2016), the features for the classifier are taken from the encoder, whereas ours come from the discriminator network. In practice this makes an important difference as we are able to directly train large models such as VGG (Simonyan & Zisserman, 2015) using adversarial loss alone. By contrast, Pathak et al. (2016) report difficulties in training an AlexNet encoder with this loss. This leads to the second difference, namely that on account of these issues, they instead employ an $\\ell _ { 2 }$ loss when training models for classification and detection (however they do use a joint $\\ell _ { 2 }$ and adversarial loss to achieve impressive in-painting results). Finally, the unsupervised learning task differs between the two models. The context-encoder learns a feature representation suitable for in-painting whereas our model learns a feature representation suitable for differentiating real/fake in-paintings. Notably, while we also use a neural network to generate the in-paintings, this model is only used as an adversary for the discriminator, rather than as a feature extractor. In section 4, we compare the performance of our model to the context-encoder on the PASCAL dataset. ",
+        "bbox": [
+            174,
+            702,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/653f69b4fb4d07b57d1405e1c9be333ecdac968a44279a554e551e716c3ac2fa.jpg",
+        "image_caption": [
+            "Figure 1: (a) Context-encoder of Pathak et al. (2016), configured for object classification task. (b) Semi-supervised learning with GANs (SSL-GAN). (c) Semi-supervised learning with CC-GANs. In (a-c) the blue network indicates the feature representation being learned (encoder network in the context-encoder model and discriminator network in the GAN and CC-GAN models). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            98,
+            823,
+            297
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            401,
+            823,
+            429
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Other forms of spatial context within images have recently been utilized for representation learning. Doersch et al. (2015) propose training a CNN to predict the spatial location of one image patch relative to another. Noroozi & Favaro (2016) propose a model that learns by unscrambling image patches, essentially solving a jigsaw puzzle to learn visual representations. In the text domain, context has been successfully leveraged as an unsupervised criterion for training useful word and sentence level representations (Collobert et al., 2011; Mikolov et al., 2015; Kiros et al., 2015). ",
+        "bbox": [
+            174,
+            436,
+            825,
+            520
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Deep unsupervised and semi-supervised learning: A popular method of utilizing unlabeled data is to layer-wise train a deep autoencoder or restricted Botlzmann machine (Hinton et al., 2006) and then fine tune with labels on a discriminative task. More recently, several autoencoding variants have been proposed for unsupervised and semi-supervised learning, such as the ladder network (Rasmus et al., 2015), stacked what-where autoencoders (Zhao et al., 2016) and variational autoencoders (Kingma & Welling, 2014; Kingma et al., 2014). ",
+        "bbox": [
+            174,
+            526,
+            825,
+            611
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Dosovitskiy et al. (2014) achieved state-of-the-art results by training a CNN with a different class for each training example and introducing a set of transformations to provide multiple examples per class. The pseudo-label approach (Lee, 2013) is a simple semi-supervised method that trains using the maximumly predicted class as a label when labels are unavailable. Springenberg (2015) propose a categorical generative adversarial network (CatGAN) which can be used for unsupervised and semi-supervised learning. The discriminator in a CatGAN outputs a distribution over classes and is trained to minimize the predicted entropy for real data and maximize the predicted entropy for fake data. Similar to our model, CatGANs use the feature space learned by the discriminator for the final supervised learning task. Salimans et al. (2016) recently proposed a semi-supervised GAN model in which the discriminator outputs a softmax over classes rather than a probability of real vs. fake. An additional ‘generated’ class is used as the target for generated samples. This method differs from our work in that it does not utilize context information and has only been applied to datasets of small resolution. However, the discriminator loss is similar to the one we propose and could be combined with our context-conditional approach. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            811
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "More traditional semi-supervised methods include graph-based approaches (Zhou et al., 2004; Zhu, 2006) that show impressive performance when good image representations are available. However, the focus of our work is on learning such representations. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Generative models of images: Restricted Boltzmann machines (Salakhutdinov, 2015), de-noising autoencoders (Vincent et al., 2008) and variational autoencoders (Kingma & Welling, 2014) optimize a maximum likelihood criterion and thus learn decoders that map from latent space to image space. More recently, generative adversarial networks (Goodfellow et al., 2014) and generative moment matching networks (Li et al., 2015; Dziugaite et al., 2015) have been proposed. These methods ignore data likelihoods and instead directly train a generative model to produce realistic samples. Several extensions to the generative adversarial network framework have been proposed to scale the approach to larger images (Denton et al., 2015; Radford et al., 2016; Salimans et al., 2016). Our work draws on the insights of Radford et al. (2016) regarding adversarial training practices and architecture for the generator network, as well as the notion that the discriminator can produce useful features for classification tasks. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            200
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Other models used recurrent approaches to generate images (Gregor et al., 2015; Theis & Bethge, 2015; Mansimov et al., 2016; van den Oord et al., 2016). Dosovitskiy et al. (2015) trained a CNN to generate objects with different shapes, viewpoints and color. Sohl-Dickstein et al. (2015) propose a generative model based on a reverse diffusion process. While our model does involve image generation, it differs from these approaches in that the main focus is on learning a good representation for classification tasks. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            291
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Predictive generative models of videos aim to extrapolate from current frames to future ones and in doing so learn a feature representation that is useful for other tasks. In this vein, Ranzato et al. (2014) used an $\\ell _ { 2 }$ -loss in pixel-space. Mathieu et al. (2015) combined an adversarial loss with $\\ell _ { 2 }$ , giving models that generate crisper images. While our model is also predictive, it only considers interpolation within an image, rather than extrapolation in time. ",
+        "bbox": [
+            174,
+            297,
+            825,
+            368
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 APPROACH",
+        "text_level": 1,
+        "bbox": [
+            174,
+            380,
+            299,
+            396
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We present a semi-supervised learning framework built on generative adversarial networks (GANs) of Goodfellow et al. (2014). We first review the generative adversarial network framework and then introduce context conditional generative adversarial networks (CC-GANs). Finally, we show how combining a classification objective and a CC-GAN objective provides a unified framework for semi-supervised learning. ",
+        "bbox": [
+            174,
+            406,
+            825,
+            477
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 GENERATIVE ADVERSARIAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            484,
+            500,
+            498
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The generative adversarial network approach (Goodfellow et al., 2014) is a framework for training generative models, which we briefly review. It consists of two networks pitted against one another in a two player game: A generative model, $G$ , is trained to synthesize images resembling the data distribution and a discriminative model, $D$ , is trained to distinguish between samples drawn from $G$ and images drawn from the training data. ",
+        "bbox": [
+            174,
+            505,
+            825,
+            575
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "More formally, let $\\mathcal { X } = \\{ \\mathbf { x } ^ { 1 } , . . . , \\mathbf { x } ^ { n } \\}$ be a dataset of images of dimensionality $d$ . Let $D$ denote a discriminative function that takes as input an image $\\mathbf { x } \\in \\mathbb { R } ^ { d }$ and outputs a scalar representing the probability of input $\\mathbf { x }$ being a real sample. Let $G$ denote the generative function that takes as input a random vector $\\mathbf { z } \\in \\mathbb { R } ^ { z }$ sampled from a prior noise distribution $p _ { \\mathrm { N o i s e } }$ and outputs a synthesized image $\\widetilde { \\mathbf { x } } = G ( \\mathbf { z } ) \\in \\mathbb { R } ^ { d }$ . Ideally, $D ( \\mathbf { x } ) = 1$ when $\\mathbf { x } \\in \\mathcal { X }$ and $D ( \\mathbf { x } ) = 0$ when $\\mathbf { x }$ was generated from $G$ . The GAN objective is given by: ",
+        "bbox": [
+            174,
+            582,
+            825,
+            666
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cd55540991498b61f346789720e7e33bb93fed9e81b812e1097b290d5236b595.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { G } \\operatorname* { m a x } _ { D } \\ \\mathbb { E } _ { \\mathbf { x } \\sim \\mathcal { X } } [ \\log D ( \\mathbf { x } ) ] + \\mathbb { E } _ { \\mathbf { z } \\sim p _ { \\mathrm { N o i s e } } ( \\mathbf { z } ) } [ \\log ( 1 - D ( G ( \\mathbf { z } ) ) ) ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            669,
+            702,
+            693
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The conditional generative adversarial network (Mirza $\\&$ Osindero, 2014) is an extension of the GAN in which both $D$ and $G$ receive an additional vector of information $\\mathbf { y }$ as input. The conditional GAN objective is given by: ",
+        "bbox": [
+            176,
+            703,
+            826,
+            746
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/42e15f9a7473f19c91c51e344a4475bdd01c04069d38b3d803f26cd67a5636d9.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { G } \\operatorname* { m a x } _ { D } \\ \\mathbb { E } _ { \\mathbf { x } , \\mathbf { y } \\sim \\mathcal { X } } [ \\log D ( \\mathbf { x } , \\mathbf { y } ) ] + \\mathbb { E } _ { \\mathbf { z } \\sim p _ { \\mathrm { N o i s e } } ( \\mathbf { z } ) } [ \\log ( 1 - D ( G ( \\mathbf { z } , \\mathbf { y } ) , \\mathbf { x } ) ) ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            259,
+            748,
+            735,
+            772
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 CONTEXT-CONDITIONAL GENERATIVE ADVERSARIAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            784,
+            676,
+            797
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We propose context-conditional generative adversarial networks (CC-GANs) which are conditional GANs where the generator is trained to fill in a missing image patch and the generator and discriminator are conditioned on the surrounding pixels. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            848
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In particular, the generator $G$ receives as input an image with a randomly masked out patch. The generator outputs an entire image. We fill in the missing patch from the generated output and then pass the completed image into $D$ . We pass the completed image into $D$ rather than the context and the patch as two separate inputs so as to prevent $D$ from simply learning to identify discontinuities along the edge of the missing patch. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "More formally, let $\\mathbf { m } \\in \\mathbb { R } ^ { d }$ denote to a binary mask that will be used to drop out a specified portion of an image. The generator receives as input $\\mathbf { m } \\odot \\mathbf { x }$ where $\\odot$ denotes element-wise multiplication. The generator outputs $\\mathbf { x _ { G } } = G ( \\mathbf { m } \\odot \\mathbf { x } , \\mathbf { z } ) \\in \\mathbb { R } ^ { d }$ and the in-painted image $\\mathbf { x _ { I } }$ is given by: ",
+        "bbox": [
+            173,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b08d51b758b56a25fbd92132723b48f0ebc6c37e8caf179d9936cdcfc82fd613.jpg",
+        "text": "$$\n\\mathbf { x _ { I } } = \\left( 1 - \\mathbf { m } \\right) \\odot \\mathbf { x _ { G } } + \\mathbf { m } \\odot \\mathbf { x }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            154,
+            602,
+            170
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The CC-GAN objective is given by: ",
+        "bbox": [
+            176,
+            184,
+            411,
+            199
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/63f3c23806a52b6f1cd546afb3f83caaf20f29375d10c2beadfc081fa8fc15c4.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { G } \\operatorname* { m a x } _ { D } \\mathbb { E } _ { \\mathbf { x } \\sim \\mathcal { X } } [ \\log D ( \\mathbf { x } ) ] + \\mathbb { E } _ { \\mathbf { x } \\sim \\mathcal { X } , \\mathbf { m } \\sim \\mathcal { M } } [ \\log ( 1 - D ( \\mathbf { x _ { I } } ) ) ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            205,
+            699,
+            229
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 COMBINED GAN AND CC-GAN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            243,
+            441,
+            258
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "While the generator of the CC-GAN outputs a full image, only a portion of it (corresponding to the missing hole) is seen by the discriminator. In the combined model, which we denote by $\\mathrm { C C - \\bar { G } A N ^ { 2 } }$ , the fake examples for the discriminator include both the in-painted image $\\mathbf { x _ { I } }$ and the full image $\\mathbf { x _ { G } }$ produced by the generator (i.e. not just the missing patch). By combining the GAN and CC-GAN approaches, we introduce a wider array of negative examples to the discriminator. The CC-GAN2 objective given by: ",
+        "bbox": [
+            173,
+            265,
+            826,
+            349
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f6216d9f08f1bd9f49dd7e560cc09cdec6aacbe671994376e8ac9209e0283ced.jpg",
+        "text": "$$\n\\begin{array} { r l } {  { \\operatorname* { m i n } \\operatorname* { m a x } _ { D } \\mathbb { E } _ { \\mathbf { x } \\sim \\mathcal { X } } [ \\log D ( \\mathbf { x } ) ] } } \\\\ & { + \\ \\mathbb { E } _ { \\mathbf { x } \\sim \\mathcal { X } , \\mathbf { m } \\sim \\mathcal { M } } [ \\log ( 1 - D ( \\mathbf { x _ { I } } ) ) ] } \\\\ & { + \\ \\mathbb { E } _ { \\mathbf { x } \\sim \\mathcal { X } , \\mathbf { m } \\sim \\mathcal { M } } [ \\log ( 1 - D ( \\mathbf { x _ { G } } ) ) ] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            356,
+            635,
+            419
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.4 SEMI-SUPERVISED LEARNING WITH CC-GANS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            430,
+            542,
+            445
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A common approach to semi-supervised learning is to combine a supervised and unsupervised objective during training. As a result unlabeled data can be leveraged to aid the supervised task. ",
+        "bbox": [
+            173,
+            452,
+            821,
+            481
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, a GAN discriminator must learn something about the structure of natural images in order to effectively distinguish real from generated images. Recently, Radford et al. (2016) showed that a GAN discriminator learns a hierarchical image representation that is useful for object classification. Such results suggest that combining an unsupervised GAN objective with a supervised classification objective would produce a simple and effective semi-supervised learning method. This approach, denoted by SSL-GAN, is illustrated in Fig. 1(b). The discriminator network receives a gradient from the real/fake loss for every real and generated image. The discriminator also receives a gradient from the classification loss on the subset of (real) images for which labels are available. ",
+        "bbox": [
+            173,
+            486,
+            825,
+            598
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Generative adversarial networks have shown impressive performance on many diverse datasets. However, samples are most coherent when the set of images the network is trained on comes from a limited domain (eg. churches or faces). Additionally, it is difficult to train GANs on very large images. Both these issues suggest semi-supervised learning with vanilla GANs may not scale well to datasets of large diverse images. Rather than determining if a full image is real or fake, context conditional GANs address a different task: determining if a part of an image is real or fake given the surrounding context. ",
+        "bbox": [
+            173,
+            604,
+            825,
+            703
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Formally, let $\\mathcal { X } _ { \\mathcal { L } } = \\{ ( \\mathbf { x } ^ { 1 } , y ^ { 1 } ) , . . . , ( \\mathbf { x } ^ { n } , y ^ { n } ) \\}$ denote a dataset of labeled images. Let $D _ { c } ( x )$ denote the output of the classifier head on the discriminator (see Fig. 1(c) for details). Then the semisupervised CC-GAN objective is: ",
+        "bbox": [
+            176,
+            708,
+            825,
+            752
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/50d531740f74295750ae505cde4b9fd0c47309bde8eec5e5f1f05e10655552b0.jpg",
+        "text": "$$\n\\underset { G } { \\mathrm { m i n } } \\underset { D } { \\mathrm { m a x } } \\mathbb { E } _ { \\mathbf { x } \\sim \\mathcal { X } } [ \\log D ( \\mathbf { x } ) ] + \\mathbb { E } _ { \\mathbf { x } \\sim \\mathcal { X } , \\mathbf { m } \\sim \\mathcal { M } } [ \\log ( 1 - D ( \\mathbf { x _ { I } } ) ) ] + \\lambda _ { c } \\mathbb { E } _ { \\mathbf { x } , y \\sim \\mathcal { X } _ { \\mathcal { L } } } [ \\log ( D _ { c } ( y | \\mathbf { x } ) ) ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            192,
+            758,
+            784,
+            781
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The hyperparameter $\\lambda _ { c }$ balances the classification and adversarial losses. We only consider the CCGAN in the semi-supervised setting and thus drop the SSL notation when referring to this model. ",
+        "bbox": [
+            176,
+            796,
+            825,
+            825
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.5 MODEL ARCHITECTURE AND TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            832,
+            560,
+            847
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The architecture of our generative model, $G$ , is inspired by the generator architecture of the DCGAN (Radford et al., 2016). The model consists of a sequence of convolutional layers with subsampling (but no pooling) followed by a sequence of fractionally-strided convolutional layers. For the discriminator, $D$ , we used the VGG-A network (Simonyan & Zisserman, 2015) without the fully connected layers (which we call the VGG-A’ architecture). Details of the generator and discriminator are given in Fig. 2. The input to the generator is an image with a patch zeroed out. In preliminary experiments we also tried passing in a separate mask to the generator to make the missing area more explicit but found this did not effect performance. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/75e463c4a6f6e0e416af86d2fb282f317b8f489cea266141a491353b03c04d11.jpg",
+        "image_caption": [
+            "Figure 2: Architecture of our context-conditional generative adversarial network (CC-GAN). conv(64, $4 \\times 4$ , $2 \\times 2$ ) denotes a conv layer with 64 channels, 4x4 kernels and stride $2 \\mathbf { x } 2$ . Each convolution layer is followed by a spatial batch normalization and rectified linear layer. Dashed lines indicate optional pathways. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            228,
+            95,
+            764,
+            526
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            671,
+            825,
+            713
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Even with the context conditioning it is difficult to generate large image patches that look realistic, making it problematic to scale our approach to high resolution images. To address this, we propose conditioning the generator on both the high resolution image with a missing patch and a low resolution version of the whole image (with no missing region). In this setting, the generators task becomes one of super-resolution on a portion of an image. However, the discriminator does not receive the low resolution image and thus is still faced with the same problem of determining if a given in-painting is viable or not. Where indicated, we used this approach in our PASCAL VOC 2007 experiments, with the original image being downsampled by a factor of 4. This provided enough information for the generator to fill in larger holes but not so much that it made the task trivial. This optional low resolution image is illustrated in Fig. 2(left) with the dotted line. ",
+        "bbox": [
+            174,
+            719,
+            825,
+            859
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We followed the training procedures of Radford et al. (2016). We used the Adam optimizer (Kingma & Ba, 2015) in all our experiments with learning rate of 0.0002, momentum term $\\beta _ { 1 }$ of 0.5, and the remaining Adam hyperparameters set to their default values. We set $\\lambda _ { c } = 1$ for all experiments. ",
+        "bbox": [
+            174,
+            866,
+            821,
+            909
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/83930ec27c79baafb2fbd31eb6562bffee5e021bd31aa54342f0011f237c4d3b.jpg",
+        "table_caption": [
+            "Table 1: Comparison of CC-GAN and other published results on STL-10. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Accuracy</td></tr><tr><td>Multi-task Bayesian Optimization (Swersky et al.,2013) Exemplar CNN(Dosovitskiy et al.,2014) Stacked What-Where Autoencoder (Zhao et al.,2016)</td><td>70.10± 0.6 75.40 ± 0.3 74.33</td></tr><tr><td>Supervised VGG-A&#x27;</td><td>61.19 ± 1.1</td></tr><tr><td>SSL-GAN</td><td>73.81 ± 0.5</td></tr><tr><td>CC-GAN</td><td>75.67 ± 0.5</td></tr><tr><td>CC-GAN²</td><td>77.79 ± 0.8</td></tr></table>",
+        "bbox": [
+            267,
+            99,
+            727,
+            210
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            267,
+            328,
+            284
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1 STL-10 CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            295,
+            390,
+            309
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "STL-10 is a dataset of $9 6 \\times 9 6$ color images with a 1:100 ratio of labeled to unlabeled examples, making it an ideal fit for our semi-supervised learning framework. The training set consists of 5000 labeled images, mapped to 10 pre-defined folds of 1000 images each, and 100,000 unlabeled images. The labeled images belong to 10 classes and were extracted from the ImageNet dataset and the unlabeled images come from a broader distribution of classes. We follow the standard testing protocol and train 10 different models on each of the 10 predefined folds of data. We then evaluate classification accuracy of each model on the test set and report the mean and standard deviation. ",
+        "bbox": [
+            173,
+            316,
+            825,
+            414
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We trained our CC-GAN and $\\mathrm { C C - G A N ^ { 2 } }$ models on $6 4 \\times 6 4$ crops of the $9 6 \\times 9 6$ image. The hole was $3 2 \\times 3 2$ pixels and the location of the hole varied randomly (see Fig. 3(top)). We trained for 100 epochs and then fine-tuned the discriminator on the $9 6 \\mathbf { x } 9 6$ labeled images, stopping when training accuracy reached $100 \\%$ . As shown in Table 1, the CC-GAN model performs comparably to current state of the art (Dosovitskiy et al., 2014) and the $\\mathrm { C C - G A N ^ { 2 } }$ model improves upon it. ",
+        "bbox": [
+            174,
+            420,
+            825,
+            491
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also trained two baseline models in an attempt to tease apart the contributions of adversarial training and context conditional adversarial training. The first is a purely supervised training of the VGG-A’ model (the same architecture as the discriminator in the CC-GAN framework). This was trained using a dropout of 0.5 on the final layer and weight decay of 0.001. The performance of this model is significantly worse than the CC-GAN model. ",
+        "bbox": [
+            174,
+            497,
+            825,
+            568
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also trained a semi-supervised GAN (SSL-GAN, see Fig. 1(b)) on STL-10. This consisted of the same discriminator as the CC-GAN (VGG-A’ architecture) and generator from the DCGAN model (Radford et al., 2016). The training setup in this case is identical to the CC-GAN model. The SSLGAN performs almost as well as the CC-GAN, confirming our hypothesis that the GAN objective is a useful unsupervised criterion. ",
+        "bbox": [
+            174,
+            574,
+            825,
+            643
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 PASCAL VOC CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            651,
+            439,
+            666
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In order to compare against other methods that utilize spatial context we ran the CC-GAN model on PASCAL VOC 2007 dataset. This dataset consists of natural images coming from 20 classes. The dataset contains a large amount of variability with objects varying in size, pose, and position. The training and validation sets combined contain 5,011 images, and the test set contains 4,952 images. The standard measure of performance is mean average precision (mAP). ",
+        "bbox": [
+            174,
+            674,
+            825,
+            743
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We trained each model on the combined training and validation set for ${ \\sim } 5 0 0 0$ epochs and evaluated on the test set once1. Following Pathak et al. (2016), we train using random cropping, and then evaluate using the average prediction from 10 random crops. ",
+        "bbox": [
+            174,
+            751,
+            825,
+            792
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our best performing model was trained on images of resolution $1 2 8 \\times 1 2 8$ with a hole size of $6 4 \\times 6 4$ and a low resolution input of size $3 2 \\times 3 2$ . Table 2 compares our CC-GAN method to other feature learning approaches on the PASCAL test set. It outperforms them, beating the current state of the art (Wang & Gupta, 2015) by $3 . 8 \\%$ . It is important to note that our feature extractor is the VGGA’ model which is larger than the AlexNet architecture (Krizhevsky et al., 2012) used by other approaches in Table 2. However, purely supervised training of the two models reveals that VGG-A’ is less than $2 \\%$ better than AlexNet. Furthermore, our model outperforms the supervised VGG-A’ baseline by a $7 \\%$ margin ( $6 2 . 2 \\%$ vs. $5 5 . 2 \\%$ ). This suggests that our gains stem from the CC-GAN method rather than the use of a better architecture. ",
+        "bbox": [
+            173,
+            799,
+            825,
+            883
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/9cf929429a7fedc6d30cae15830981583f8293831fe4446a994435a4feeef545.jpg",
+        "table_caption": [
+            "Table 2: Comparison of CC-GAN and other methods (as reported by Pathak et al. (2016)) on PASCAL VOC 2007. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>mAP</td></tr><tr><td>Supervised AlexNet</td><td>53.3 %</td></tr><tr><td>Visual tracking from video (Wang &amp; Gupta, 2015)</td><td>58.4%</td></tr><tr><td>Context prediction (Doersch et al.,2015)</td><td>55.3%</td></tr><tr><td>Context encoders (Pathak et al., 2016)</td><td>56.5%</td></tr><tr><td>Supervised VGG-A&#x27;</td><td>55.2%</td></tr><tr><td>CC-GAN</td><td>62.2%</td></tr><tr><td>CC-GAN²</td><td>62.7%</td></tr></table>",
+        "bbox": [
+            267,
+            99,
+            727,
+            209
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/f0961dc5be29f291e8ea8c70039be171b9df89f2fc33011ac60992d382e28b1e.jpg",
+        "table_caption": [
+            "Table 3: Comparison of different CC-GAN variants on PASCAL VOC 2007. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Image size</td><td rowspan=1 colspan=1>Hole size</td><td rowspan=1 colspan=1>Low res size</td><td rowspan=1 colspan=1>mAP</td></tr><tr><td rowspan=1 colspan=1>Supervised VGG-A&#x27;CC-GAN</td><td rowspan=1 colspan=1>64×6464×64</td><td rowspan=1 colspan=1>32×32</td><td rowspan=1 colspan=1>=</td><td rowspan=1 colspan=1>52.97%56.79%</td></tr><tr><td rowspan=1 colspan=1>Supervised VGG-A&#x27;CC-GANCC-GAN</td><td rowspan=1 colspan=1>96×9696×9696×96</td><td rowspan=1 colspan=1>=48×4848×48</td><td rowspan=1 colspan=1>=24×24</td><td rowspan=1 colspan=1>55.22%60.38%60.98%</td></tr><tr><td rowspan=1 colspan=1>Supervised VGG-A&#x27;CC-GANCC-GAN</td><td rowspan=1 colspan=1>128×128128×128128×128</td><td rowspan=1 colspan=1>=64×6464×64</td><td rowspan=1 colspan=1>-=32×32</td><td rowspan=1 colspan=1>55.2%61.3%62.2%</td></tr></table>",
+        "bbox": [
+            236,
+            279,
+            758,
+            404
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            472,
+            821,
+            513
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 3 shows the effect of training on different resolutions. The CC-GAN improves over the baseline CNN consistently regardless of image size. We found that conditioning on the low resolution image began to help when the hole size was largest $( 6 4 \\times 6 4 )$ . We hypothesize that the low resolution conditioning would be more important for larger images, potentially allowing the method to scale to larger image sizes than we explored in this work. ",
+        "bbox": [
+            174,
+            521,
+            825,
+            590
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3 INPAINTING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            599,
+            299,
+            613
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We now show some sample in-paintings produced by our CC-GAN generators. In our semisupervised learning experiments on STL-10 we remove a single fixed size hole from the image. The top row of Fig. 3 shows in-paintings produced by this model. We can also explored different masking schemes as illustrated in the remaining rows of Fig. 3 (however these did not improve classification results). In all cases we see that training the generator with the adversarial loss produces sharp semantically plausible in-painting results. ",
+        "bbox": [
+            174,
+            621,
+            825,
+            704
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Fig. 4 shows generated images and in-painted images from a model trained with the CC-GAN2 criterion. The output of a CC-GAN generator tends to be corrupted outside the patch used to inpaint the image (since gradients only flow back to the missing patch). However, in the CC-GAN2 model, we see that both the in-painted image and the generated image are coherent and semantically consistent with the masked input image. ",
+        "bbox": [
+            174,
+            710,
+            823,
+            781
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Fig. 5 shows in-painted images from a generator trained on $1 2 8 \\times 1 2 8$ PASCAL images. Fig. 6 shows the effect of adding a low resolution $( 3 2 \\times 3 2 )$ image as input to the generator. For comparison we also show the result of in-painting by filling in with a bi-linearly upsampled image. Here we see the generator produces high-frequency structure rather than simply learning to copy the low resolution patch. ",
+        "bbox": [
+            174,
+            787,
+            825,
+            858
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            869,
+            310,
+            886
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We have presented a simple semi-supervised learning framework based on in-painting with an adversarial loss. The generator in our CC-GAN model is capable of producing semantically meaningful in-paintings and the discriminator performs comparable to or better than existing semi-supervised methods on two classification benchmarks. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/84e72393ad78ba91756006fb5a57e6c9cb91c209426da709b0af98f36dd5292e.jpg",
+        "image_caption": [
+            "Figure 3: STL-10 in-painting with CC-GAN training and varying methods of dropping out the image. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            101,
+            821,
+            329
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/e3c40c35812801b637189c53c273f3f7a1c66f8ffea838a8a4e23d1dbf0c1bcc.jpg",
+        "image_caption": [
+            "Figure 4: STL-10 in-painting with combined CC-GAN2 training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            390,
+            823,
+            493
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/7c2cc9d7e2e34e5d761bccd468b83b706503506dcc091649f12805a89d06b2a3.jpg",
+        "image_caption": [
+            "Figure 5: PASCAL in-painting with CC-GAN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            540,
+            823,
+            622
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/69cca881be43870bc111ff5f24aaf4848fbd7c70d7b79aa7280b9ffb4ffe5286.jpg",
+        "image_caption": [
+            "Figure 6: PASCAL in-painting with CC-GAN conditioned on low resolution image. Top two rows show input to generator. Third row shows inpainting my bilinear upsampling. Bottom row shows inpainted image by generator. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            670,
+            821,
+            830
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Since discrimination of real/fake in-paintings is more closely related to the target task of object classification than extracting a feature representation suitable for in-filling, it is not surprising that we are able to exceed the performance of Pathak et al. (2016) on PASCAL classification. Furthermore, since our model operates on images half the resolution as those used by other approaches ( $1 2 8 \\times 1 2 8$ vs. $2 2 4 \\times 2 4 4$ , there is potential for further gains if improvements in the generator resolution can be made. Our models and code are available at https://github.com/edenton/cc-gan. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            223
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements: Emily Denton is supported by a Google Fellowship. Rob Fergus is grateful for the support of CIFAR. ",
+        "bbox": [
+            173,
+            229,
+            823,
+            257
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            270,
+            285,
+            285
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "D. Bahdanau, K. Cho, and Y. Bengio. Neural machine translation by jointly learning to align and translate. In The International Conference on Learning Representations, 2015.   \nR. Collobert, J. Weston, L. Bottou, M. Karlen, K. Kavukcuoglu, and P. Kuksa. Natural language processing (almost) from scratch. Journal of Machine Learning Research, 2011.   \nEmily Denton, Soumith Chintala, Arthur Szlam, and Rob Fergus. Deep generative image models using a laplacian pyramid of adversarial networks. In Advances in Neural Information Processing Systems 28, 2015.   \nCarl Doersch, Abhinav Gupta, and Alexei A. Efros. Unsupervised visual representation learning by context prediction. In International Conference on Computer Vision, 2015.   \nAlexey Dosovitskiy, Jost Tobias Springenberg, Martin Riedmiller, and Thomas Brox. Discriminative unsupervised feature learning with convolutional neural networks. In Advances in Neural Information Processing Systems 27, 2014.   \nAlexey Dosovitskiy, Jost Tobias Springenberg, and Thomas Brox. Learning to generate chairs, tables and cars with convolutional networks. In Computer Vision and Pattern Recognition, 2015.   \nGintare Karolina Dziugaite, Daniel M. Roy, and Zoubin Ghahramani. Training generative neural networks via maximum mean discrepancy optimization. In Uncertainty in Artificial Intelligence, 2015.   \nIan J. Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in Neural Information Processing Systems 27, 2014.   \nKarol Gregor, Ivo Danihelka, Alex Graves, Danilo Jimenez Rezende, and Daan Wierstra. Draw: A recurrent neural network for image generation. In International Conference on Machine Learning, 2015.   \nG. E. Hinton, S. Osindero, and Y. Teh. A fast learning algorithm for deep belief nets. Neural Computation, 18, 2006.   \nD.P. Kingma and J. Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations, 2015.   \nD.P. Kingma and M. Welling. Auto-encoding variational bayes. In International Conference on Learning Representations, 2014.   \nD.P. Kingma, D.J. Rezende, S. Mohamed, and M. Welling. Semi-supervised learning with deep generative models. In Advances in Neural Information Processing Systems 27, 2014.   \nRyan Kiros, Yukun Zhu, Ruslan Salakhutdinov, Richard S. Zemel, Antonio Torralba, Raquel Urtasun, and Sanja Fidler. Skip-thought vectors. In Advances in Neural Information Processing Systems 28, 2015.   \nAlex Krizhevsky, Ilya Sutskever, and Geoff Hinton. Imagenet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems 25, pp. 1106–1114, 2012.   \nD. H. Lee. Pseudo-label: The simple and efficient semi-supervised learning method for deep neural networks. In Workshop on Challenges in Representation Learning, ICML, 2013.   \nYujia Li, Kevin Swersky, and Richard Zemel. Generative moment matching networks. In ICML, 2015.   \nElman Mansimov, Emilio Parisotto, Jimmy Ba, and Ruslan Salakhutdinov. Generating images from captions with attention. In The International Conference on Learning Representations, 2016. ",
+        "bbox": [
+            169,
+            282,
+            826,
+            917
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            897,
+            826,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michael Mathieu, Camille Couprie, and Yann LeCun. Deep multi-scale video prediction beyond mean square ¨ error. arXiv 1511.05440, 2015.   \nT. Mikolov, I. Sutskever, K. Chen, G. S. Corrado, and J. Dean. Distributed representations of words and phrases and their compositionality. In Advances in Neural Information Processing Systems 28, 2015.   \nMehdi Mirza and Simon Osindero. Conditional generative adversarial nets. CoRR, abs/1411.1784, 2014.   \nMehdi Noroozi and Paolo Favaro. Unsupervised learning of visual representations by solving jigsaw puzzles. CoRR, abs/1603.09246, 2016.   \nDeepak Pathak, Philipp Krahenbuhl, Jeff Donahue, Trevor Darrell, and Alexei A. Efros. Context encoders: Feature learning by inpainting. In Computer Vision and Pattern Recognition, 2016.   \nAlec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. In The International Conference on Learning Representations, 2016.   \nMarc’Aurelio Ranzato, Arthur Szlam, Joan Bruna, Michael Mathieu, Ronan Collobert, and Sumit Chopra. ¨ Video (language) modeling: a baseline for generative models of natural videos. arXiv 1412.6604, 2014.   \nAntti Rasmus, Mathias Berglund, Mikko Honkala, Harri Valpola, and Tapani Raiko. Semi-supervised learning with ladder network. In Advances in Neural Information Processing Systems 28, 2015.   \nRuslan Salakhutdinov. Learning deep generative models. Annual Review of Statistics and Its Application, 2: 361–385, 2015.   \nTim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. In Advances in Neural Information Processing Systems 29, 2016.   \nK. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. In The International Conference on Learning Representations, 2015.   \nJascha Sohl-Dickstein, Eric A. Weiss, Niru Maheswaranathan, and Surya Ganguli. Deep unsupervised learning using nonequilibrium thermodynamics. CoRR, abs/1503.03585, 2015.   \nJost Tobias Springenberg. Unsupervised and semi-supervised learning with categorical generative adversarial networks. arXiv 1511.06390, 2015.   \nIlya Sutskever, Oriol Vinyals, and Quoc Le. Sequence to sequence learning with neural networks. In Advances in Neural Information Processing Systems 27, 2014.   \nKevin Swersky, Jasper Snoek, and Ryan P. Adams. Multi-task bayesian optimization. In Advances in Neural Information Processing Systems 26, 2013.   \nL. Theis and M. Bethge. Generative image modeling using spatial lstms. In Advances in Neural Information Processing Systems 28, 2015.   \nAaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks. In ICML, 2016.   \nP. Vincent, H. Larochelle, Y. Bengio, and P.A. Manzagol. Extracting and composing robust features with denoising autoencoders. In International Conference on Machine Learning, 2008.   \nXiaolong Wang and Abhinav Gupta. Unsupervised learning of visual representations using videos. In ICCV, 2015.   \nXiang Zhang, Junbo Zhao, and Yann LeCun. Character-level convolutional networks for text classification. In Advances in Neural Information Processing Systems 28, 2015.   \nJunbo Zhao, Michael Mathieu, Ross Goroshin, and Yann LeCun. Stacked what-where auto-encoders. In International Conference on Learning Representations, 2016.   \nD. Zhou, O. Bousquet, T. Lal, J. Weston, and B. Schoelkopf. Learning with local and global consistency. In Advances in Neural Information Processing Systemsi 17, 2004. ",
+        "bbox": [
+            171,
+            65,
+            828,
+            875
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiaojin Zhu. Semi-supervised learning literature survey, 2006. ",
+        "bbox": [
+            173,
+            867,
+            544,
+            881
+        ],
+        "page_idx": 9
+    }
+]

parse/train/D9I3drBz4UC/D9I3drBz4UC.md

@@ -0,0 +1,353 @@
+# LONG-TAILED RECOGNITION BYROUTING DIVERSE DISTRIBUTION-AWARE EXPERTS
+
+Xudong Wang1, Long Lian1, Zhongqi Miao1, Ziwei Liu2, Stella X. $\mathbf { Y u } ^ { 1 }$
+
+1UC Berkeley / ICSI, 2Nanyang Technological University {xdwang,longlian,zhongqi.miao,stellayu}@berkeley.edu ziwei.liu@ntu.edu.sg
+
+# ABSTRACT
+
+Natural data are often long-tail distributed over semantic classes. Existing recognition methods tackle this imbalanced classification by placing more emphasis on the tail data, through class re-balancing/re-weighting or ensembling over different data groups, resulting in increased tail accuracies but reduced head accuracies.
+
+We take a dynamic view of the training data and provide a principled model bias and variance analysis as the training data fluctuates: Existing long-tail classifiers invariably increase the model variance and the head-tail model bias gap remains large, due to more and larger confusion with hard negatives for the tail.
+
+We propose a new long-tailed classifier called RoutIng Diverse Experts (RIDE). It reduces the model variance with multiple experts, reduces the model bias with a distribution-aware diversity loss, reduces the computational cost with a dynamic expert routing module. RIDE outperforms the state-of-the-art by $5 \%$ to $7 \%$ on CIFAR100-LT, ImageNet-LT and iNaturalist 2018 benchmarks. It is also a universal framework that is applicable to various backbone networks, long-tailed algorithms, and training mechanisms for consistent performance gains. Our code is available at: https://github.com/frank-xwang/RIDE-LongTailRecognition.
+
+# 1 INTRODUCTION
+
+Real-world data are often long-tail distributed over semantic classes: A few classes contain many instances, whereas most classes contain only a few instances. Long-tailed recognition is challenging, as it needs to handle not only a multitude of small-data learning problems on the tail classes, but also extreme imbalanced classification over all the classes.
+
+There are two ways to prevent the many head instances from overwhelming the few tail instances in the classifier training objective: 1) class re-balancing/re-weighting which gives more importance to tail instances (Cao et al., 2019; Kang et al., 2020; Liu et al., 2019), 2) ensembling over different data distributions which re-organizes long-tailed data into groups, trains a model per group, and then combines individual models in a multi-expert framework (Zhou et al., 2020; Xiang et al., 2020).
+
+We compare three state-of-the-art (SOTA) long-tail classifiers against the standard cross-entropy (CE) classifier: cRT and $\tau$ -norm (Kang et al., 2020) which adopt a two-stage optimization, first representation learning and then classification learning, and LDAM (Cao et al., 2019), which is trained end-to-end with a marginal loss. In terms of the classification accuracy, a common metric for model selection on a fixed training set, Fig. 1a shows that, all these existing long-tail methods increase the overall, medium- and few-shot accuracies over CE, but decrease the many-shot accuracy.
+
+These intuitive solutions and their experimental results seem to suggest that there is a head-tail performance trade-off in long-tailed recognition. We need a principled performance analysis approach that could shed light on such a limitation if it exists and provide guidance on how to overcome it.
+
+Our insight comes from a dynamic view of the training set: It is merely a sample set of some underlying data distribution. Instead of evaluating how a long-tailed classifier performs on the fixed training set, we evaluate how it performs as the training set fluctuates according to the data distribution.
+
+<table><tr><td rowspan="2"></td><td colspan="3">All</td><td colspan="3">Many-shot</td><td colspan="3">Med-shot</td><td colspan="3">Few-shot</td></tr><tr><td>acc</td><td>bias</td><td>var</td><td>acc</td><td>bias</td><td>var</td><td>acc</td><td>bias</td><td>var</td><td>acc</td><td>bias</td><td>var</td></tr><tr><td>CE</td><td>31.6</td><td>0.60</td><td>0.47</td><td>57.3</td><td>0.28</td><td>0.35</td><td>28.2</td><td>0.61</td><td>0.51</td><td>6.3</td><td>0.94</td><td>0.57</td></tr><tr><td>T-norm</td><td>35.8</td><td>0.52</td><td>0.49</td><td>55.9</td><td>0.28</td><td>0.37</td><td>33.2</td><td>0.53</td><td>0.52</td><td>16.1</td><td>0.78</td><td>0.60</td></tr><tr><td>cRT</td><td>36.4</td><td>0.50</td><td>0.50</td><td>51.3</td><td>0.32</td><td>0.41</td><td>38.6</td><td>0.44</td><td>0.50</td><td>17.0</td><td>0.76</td><td>0.61</td></tr><tr><td>LDAM</td><td>34.4</td><td>0.53</td><td>0.51</td><td>55.1</td><td>0.28</td><td>0.38</td><td>31.9</td><td>0.53</td><td>0.54</td><td>13.9</td><td>0.81</td><td>0.63</td></tr><tr><td>RIDE + LDAM</td><td>40.5</td><td>0.50</td><td>0.42</td><td>60.5</td><td>0.28</td><td>0.30</td><td>38.7</td><td>0.50</td><td>0.44</td><td>20.1</td><td>0.74</td><td>0.52</td></tr></table>
+
+(a) Comparisons of the mean accuracy, per-class bias and variance of baselines and our RIDE method. Better (worse) metrics than the distribution-unaware cross entropy (CE) reference are marked in green (red).
+
+![](images/1b1cf846f346b6cdd587ca59d616df0ee927280983b0f7037c4506e0f6a87532.jpg)  
+(b) Histograms of the largest softmax score of the other classes (the hardest negative) per instance.   
+Figure 1: Our method RIDE outperforms SOTA by reducing both model bias and variance. a) These metrics are evaluated over 20 independently trained models, each on a random sampled set of CIFAR100 with an imbalance ratio of 100 and 300 samples for class 0. Compared to the standard head performance loss from increased classifier variance. The low tail perfor-CE classifier, existing SOTA methods almost always increase the variance and some reduce the tail mance manifests itself in large between-class confusion and high classifier vari-bias at the cost of increasing the head bias. b) The metrics are evaluated over CIFAR100-LT Liu ance. We aim to reduce both the bias and the variance of a long-tailed classifieret al. (2019). LDAM is more likely to confuse the tail (rather than head) classes with the hardest by RoutIng Diverse Experts (RIDE). It has three components: 1) a shared archi-negative class, with an average score of 0.59. RIDE with LDAM can greatly reduce the confusion tecture for multiple classifiers (experts); 2) a distribution-aware diversity loss thatwith the nearest negative class, especially for samples from the few-shot categories.
+
+to additional expertConsider the training data $D$ With on-par computational complexity, RIDE significantlyas a random variable. The prediction error of model $h$ on instance $x$ outwith output $Y$ forms the state-of-the-art methodvaries with the realization of $D$ y 5% to 7% on all the benchmarks in-. The expected variance with respect to variable $D$ cluding CIFAR100-LT, ImageNet-LT andhas a well-known bias-variance decomposition:
+
+$$
+\operatorname { E r r o r } ( x ; h ) = E [ ( h ( x ; D ) - Y ) ^ { 2 } ] = \operatorname { B i a s } ( x ; h ) + \operatorname { V a r i a n c e } ( x ; h ) + { \mathrm { i r r e d u c i b l e ~ e r r o r } } ( x ) .
+$$
+
+For the above L2 loss on regression $h ( x )  Y$ , the model bias measures the accuracy of the prediction with respect to the true value, the variance measures the stability of the prediction, and the irreducible error measures the precision of the prediction and is irrelevant to the model $h$ .
+
+Empirically, for $n$ random sample sets of data, $D ^ { ( 1 ) } , \ldots , D ^ { ( n ) }$ , the $k$ -th model trained on $D ^ { ( k ) }$ The natupredicts $y ^ { ( k ) }$ ata we encou on instance $x$ er in practice often has a long tail distribution: A, and collectively they have a mean prediction $y _ { m }$ classes contain. For the L2 regression many instances, while most classes contain only a feloss, the model bias is simply the L2 loss between $y _ { m }$ stances. Learningand ground-truth $t = E [ Y ]$ ation among, whereas the model them is challenging, as the fvariance is the variance of $y ^ { ( k ) }$ il instances can be easily overwith respect to their mean $y _ { m }$ l:
+
+$$
+\begin{array} { r l } { \displaystyle \mathcal { L } ( y ; z ) = ( y - z ) ^ { 2 } } \\ { \displaystyle y _ { m } = \frac { 1 } { n } \sum _ { k = 1 } ^ { n } y ^ { ( k ) } } & { ~ = \mathrm { a r g } \operatorname* { m i n } _ { z } E _ { D } [ \mathcal { L } \left( h ( x ) ; z ) \right] } \\ { \displaystyle \mathrm { B i a s } ( x ; h ) = ( y _ { m } - t ) ^ { 2 } } & { ~ = \mathcal { L } \left( y _ { m } ; t \right) } \\ { \displaystyle \mathrm { V a r i a n c e } ( x ; h ) = \frac { 1 } { n } \sum _ { k = 1 } ^ { n } \left( y ^ { ( k ) } - y _ { m } \right) ^ { 2 } } & { ~ = E _ { D } [ \mathcal { L } \left( h ( x ) ; y _ { m } \right) ] . } \end{array}
+$$
+
+We analyze the performance of a long-tail classifier in terms of bias and variance with respectAs shown on the above right, these concepts can be expressed entirely in terms of L2 loss $\mathcal { L }$ . We can fluctuations in the training set: We randomly sample CIFAR100 (Krizhevthus extended them to classification (Domingos, 2000) by replacing $\mathcal { L }$ y, 200 with $\mathcal { L } _ { 0 - 1 }$ cording to afor classification:
+
+The mean prediction $y _ { m }$ minimizes $\begin{array} { r } { \sum _ { k = 1 } ^ { n } \mathcal { L } _ { 0 - 1 } \left( y ^ { ( k ) } ; y _ { m } \right) } \end{array}$ and becomes the most often or main prediction. The bias and variance terms become $\mathcal { L } _ { 0 - 1 } ( y _ { m } ; t )$ and $\begin{array} { r } { \frac { 1 } { n } \sum _ { k = 1 } ^ { n } \mathcal { L } _ { 0 - 1 } ( y ^ { ( k ) } ; y _ { m } ) } \end{array}$ respectively.
+
+We apply such bias and variance analysis to the CE and long-tail classifiers. We sample CIFAR100 (Krizhevsky, 2009) according to a long-tail distribution multiple times. For each method, we train a model per long-tail sampled dataset and then estimate the per-class bias and variance over these multiple models on the balanced test set of CIFAR100-LT Liu et al. (2019). Fig. 1a shows that:
+
+1. On the model bias: The head bias is significantly smaller than the tail bias, at 0.3 vs. 0.9 for CE. All the existing long-tail methods reduce the overall bias by primarily reducing the tail bias. However, the head-tail bias gap remains large at 0.3 vs. 0.8.   
+2. On the model variance: All the existing long-tail methods increase the model variance across all class splits, with a slight reduction in the medium-shot variance for cRT.
+
+That is, existing long-tail methods reduce the model bias for the tail at the cost of increased model variance for all the classes, and the head-tail model bias gap remains large.
+
+We conduct further statistical analysis to understand the head-tail model bias gap. We examine the largest softmax score in the other classes of $\{ c : c \neq t \}$ , where $t$ is the ground-truth class of an instance. The smaller this hardest negative score is, the less the confusion, and the lower the model bias. Fig. 1b shows that there is increasingly more and larger confusion from the head to the tail.
+
+Guided by our model bias/variance and confusion pattern analysis, we propose a new long-tail classifier with four distinctive features: 1) It reduces the model variance for all the classes with multiple experts. 2) It reduces the model bias for the tail with an additional distribution-aware diversity loss. 3) It reduces the computational complexity that comes with multiple experts with a dynamic expert routing module which deploys another trained distinctive expert for a second (or third, ...) opinion only when it is called for. 4) The routing module and a shared architecture for experts of reduced complexity effectively cut down the computational cost of our multi-expert model, to a level that could be even lower than the commonly adopted baseline with the same backbone.
+
+Our so-called RoutIng Diverse Experts (RIDE) not only reduces the model variance for all the classes, but also significantly reduces the model bias for the tail classes and increases the mean accuracies for all class splits, all of which existing long-tail methods fail to accomplish.
+
+RIDE delivers $5 \% \sim 7 \%$ higher accuracies than the current SOTA methods on CIFAR100-LT, ImageNet-LT (Liu et al., 2019) and iNaturalist (Van Horn et al., 2018). RIDE is also a universal framework that can be applied to different backbone networks for improving existing long-tail algorithms such as focal loss (Lin et al., 2017), LDAM (Cao et al., 2019), $\tau$ -norm (Kang et al., 2020).
+
+# 2 RELATED WORKS
+
+Few-shot learning. To generalize from small training data, meta-learning (Bertinetto et al., 2016; Ravi & Larochelle, 2017; Santoro et al., 2016; Finn et al., 2017; Yang et al., 2018) and data augmentation/generation are two most studied approaches (Chen et al., 2019; Schwartz et al., 2018; Zhang et al., 2019; Liu et al., 2018). Matching Network (Vinyals et al., 2016) and Prototypical Network (Snell et al., 2017) learn discriminative features that can be transferred to new classes through meta-learners without big training data. Hariharan & Girshick (2017), Wang et al. (2018) and Liu et al. (2018) utilize samples from a generative model to augment the training data. However, fewshot learning relies on balanced training data, whereas long-tail recognition has to deal with highly imbalanced training data, e.g., from hundreds in the head to a few instances in the tail.
+
+Re-balancing/re-weighting. A direct approach to achieve sample balance is to under- or oversample training instances according to their class sizes (He & Garcia, 2009). Another option is data augmentation, where additional samples are generated to supplement tail classes, sometimes directly in the feature space (Liu et al., 2020; Chu et al., 2020; Kim et al., 2020). Re-weighting modifies the loss function and puts larger weights on tail classes (Lin et al., 2017; Cui et al., 2019; Cao et al., 2019; Wu et al., 2020) or randomly ignoring gradients from head classes (Tan et al., 2020). However, both sample-wise and loss-wise balancing focus on tail classes, resulting in more sensitivity to fluctuations in the small tail classes and thus much increased model variances (Fig. 1a).
+
+Knowledge transfer. OLTR (Liu et al., 2019) and inflated memory (Zhu & Yang, 2020) use memory banks to store and transfer mid- and high-level features from head to tail classes, enhancing feature generalization for the tail. However, this line of work (Liu et al., 2019; Zhu & Yang, 2020; Kang et al., 2020; Jamal et al., 2020; Wang et al., 2017) usually does not have effective control over the knowledge transfer process, often resulting in head performance loss.
+
+Ensembling and grouping. One way to counter imbalance is to separate training instances into different groups based their class sizes. Models trained on individual groups are ensembled together in a multi-expert framework. BBN (Zhou et al., 2020) adaptively fuses two-branches that each focus on the head and the tail respectively. LFME (Xiang et al., 2020) distills multiple teacher models into a unified model, each teacher focusing on a relatively balanced group such as many-shot classes, medium-shot classes, and few-shot classes. BBN and LFME still lose head performance and overall generalizability, as no expert has a balanced access to the entire dataset.
+
+Our RIDE is a non-traditional ensemble method. 1) Its experts have shared earlier layers and reduced later channels, less prone to small tail overfitting. 2) Its experts are jointly optimized. 3) It deploys experts on an as-needed basis for individual instances with a dynamic expert assignment module. 4) It reaches higher accuracies with a smaller model complexity and computational cost.
+
+# 3 RIDE: ROUTING DIVERSE DISTRIBUTION-AWARE EXPERTS
+
+We propose a novel multi-expert model (Fig. 2) with shared earlier layers $f _ { \theta }$ and $n$ independent channel-reduced later layers $\Psi = \{ \psi _ { \theta _ { 1 } } , . . . , \psi _ { \theta _ { n } } \}$ . They are jointly optimized at Stage 1 and dynamically deployed with a learned expert assignment module at Stage 2. At the inference time, all the $m$ active experts are averaged together in their logits for final ensemble softmax classification:
+
+$$
+\mathbf { p } = \mathrm { s o f t m a x } \left( \frac { 1 } { m } \sum _ { i = 1 } ^ { m } \psi _ { \theta _ { i } } \left( f _ { \theta } ( x ) \right) \right) .
+$$
+
+Softmax of the average logits is equivalent to the product of individual classification probabilities, which approximates their joint probability if individual experts makes independent decisions.
+
+Experts with a shared early backbone and reduced later channels. Consider $n$ independent experts of the same convolutional neural network (CNN) architecture. Since early layers of a CNN tend to encode generic low-level features, we adopt the common practice in transfer learning and have all the $n$ experts share the same backbone $f _ { \theta }$ . Each expert retains independent later layers $\psi _ { \boldsymbol { \theta } _ { i } }$ , $i = 1 , \ldots , n$ . To reduce overfitting to small training data in the tail classes, we reduce the number of filter channels in $\psi _ { \theta _ { i } }$ , e.g., by $1 / 4$ . All these $n$ experts are trained together on long-tailed data distribution-aware diversity loss $\mathcal { L } _ { \mathrm { D } }$ -Diversify and classification loss $\mathcal { L } _ { \mathrm { C l a s s i f y } }$ , such as CE and LDAM.
+
+Individual expert classification loss. One way to combine multiple experts is to apply the classification loss to the aggregated logits of individual experts. While this idea works for several recently proposed multi-expert models (Zhou et al., 2020; Xiang et al., 2020), it does not work for our shared experts: Its performance is on-par with an equal-sized single-expert model. Let $\mathcal { L }$ denote the classification loss (e.g. CE) over instance $x$ and its label $y$ . We call such an aggregation loss collaborative:
+
+![](images/0d63952f3af398ad49a8d8ddd426a0d1eab5f99c76968cf24f009158bc101969.jpg)  
+Figure 2: RIDE learns experts and their router in two stages. a) We first jointly optimize multiple experts with individual classification losses and mutual distribution-aware diversity losses. b) We then train a router that dynamically assigns ambiguous samples to additional experts on an as-needed basis. The distribution of instances seen by each expert shows that head instances need fewer experts and the imbalance between classes gets reduced for later experts. At the test time, we collect the logits of assigned experts to make a final decision. c) RIDE outperforms SOTA methods (i.e. LFME (Xiang et al., 2020) for CIFAR100-LT, LWS (Kang et al., 2020) for ImageNet-LT and BBN (Zhou et al., 2020) for iNaturalist) on all the benchmarks.
+
+$$
+\mathcal { L } ^ { \mathrm { c o l l a b o r a t i v e } } ( x , y ) = \mathcal { L } \left( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \psi _ { \theta _ { i } } \left( f _ { \theta } ( x ) \right) , y \right)
+$$
+
+as it leads to correlated instead of complementary experts. To discourage correlation, we require each expert to do the job well by itself. Such an aggregation loss is essentially an individual loss, and it contributes a large portion of our performance gain in most of our experiments:
+
+$$
+\mathcal { L } ^ { \mathrm { i n d i v i d u a l } } ( x , y ) = \sum _ { i = 1 } ^ { n } \mathcal { L } \left( \psi _ { \theta _ { i } } \left( f _ { \theta } ( x ) \right) , y \right) .
+$$
+
+Distribution-aware diversity loss. The individual classification loss and random initialization lead to diversified experts with a shared backbone. For long-tailed data, we add a regularization term to encourage complementary decisions from multiple experts. That is, we maximize the KL-divergence between different experts’ classification probabilities on instance $x$ in class $y$ over a total of $c$ classes:
+
+$$
+\begin{array} { r l r l } & { \mathrm { d i v e r s i t y ~ l o s s : } \quad } & { \mathcal { L } _ { \mathrm { D - D i v e r s i f y } } ( x , y ; \theta _ { i } ) = \displaystyle \frac { - 1 } { n - 1 } \sum _ { j = 1 , j \neq i } ^ { n } D _ { \mathrm { K L } } \left( \mathbf { p } ^ { ( i ) } ( x , y ) \| \mathbf { p } ^ { ( j ) } ( x , y ) \right) } \\ & { \mathrm { K L ~ d i v e r g e n c e : } \quad } & { D _ { \mathrm { K L } } ( \mathbf { p } \| \mathbf { q } ) = \displaystyle \sum _ { k = 1 } ^ { c } \mathbf { p } _ { k } \log \left( \frac { \mathbf { p } _ { k } } { \mathbf { q } _ { k } } \right) } \\ & { \mathrm { c l a s s i f i c a t i o n ~ b y } \theta _ { i } : \quad } & { \mathbf { p } ^ { ( i ) } ( x , y ) = \mathrm { s o f t m a x } \left( \left[ \frac { \psi _ { \theta _ { i } } ( f _ { \theta } ( x ) ) _ { 1 } } { T _ { 1 } } \quad . . . \quad \frac { \psi _ { \theta _ { i } } ( f _ { \theta } ( x ) ) _ { c } } { T _ { c } } \right] \right) . } \end{array}
+$$
+
+We vary the temperature $T$ (or concentration) (Hadsell et al., 2006; Wu et al., 2018) applied to class $k$ ’s logit $\psi _ { \boldsymbol { \theta } _ { i } } ( f _ { \boldsymbol { \theta } } ( \boldsymbol { x } ) ) _ { k }$ : For class $k$ with $n _ { k }$ instances, the smaller the $n _ { k }$ , the lower the temperature $T _ { k }$ , the more sensitive the classification probability $\mathbf { p }$ is to a change in the feature $\psi$ . Specifically,
+
+class-wise temperature:
+
+normalized class size:
+
+$$
+\begin{array} { r l } & { T _ { k } = \alpha \left( \beta _ { k } + 1 - \underset { j } { \operatorname* { m a x } } \beta _ { j } \right) } \\ & { \beta _ { k } = \gamma \cdot \frac { n _ { k } } { \frac { 1 } { c } \sum _ { s = 1 } ^ { c } n _ { s } } + ( 1 - \gamma ) . } \end{array}
+$$
+
+$T$ scales linearly with the class size, ensuring $\beta _ { k } = 1 , T _ { k } = \alpha$ for a balanced set. This simple adaptation allows us to find classifiers of enough complexity for the head and enough robustness for the tail: On one hand, we need strong classifiers to handle large sample variations within head classes; on the other hand, such classifiers are prone to overfit small training data within tail classes. We adapt the temperature only after the CNN network is trained for several epochs and the feature is stabilized, similar to the training scheme for deferred reweighting (Cao et al., 2019).
+
+Joint expert optimization. For our $n$ experts $\theta _ { 1 }$ , . . . , $\theta _ { n }$ with a shared backbone $\theta$ , we optimize their individual classification losses ${ \mathcal { L } } _ { \mathrm { C l a s s i f y } } = { \mathcal { L } }$ , any classification loss such as CE, LDAM, and focal loss) and their mutual distribution-aware divergency losses, weighted by hyperparameter $\lambda$ :
+
+$$
+\mathcal { L } _ { \mathrm { T o t a l } } ( x , y ) = \sum _ { i = 1 } ^ { n } \left( \mathcal { L } _ { \mathrm { C l a s s i f y } } ( x , y ; \theta _ { i } ) + \lambda \cdot \mathcal { L } _ { \mathrm { D - D i v e r s i f y } } ( x , y ; \theta _ { i } ) \right) .
+$$
+
+Since these loss terms are completely symmetrical with respect to each other, the $n$ experts learned at Stage 1 are equally good and distinctive from each other.
+
+Routing diversified experts. To cut down the test-time computational cost that comes with multiple experts, we train a router at Stage 2 to deploy these (arbitrarily ordered) experts sequentially on an as-needed basis. Assume that the first $k$ experts have been deployed for instance $x$ . The router takes in the image feature and the mean logits from the first to the $k$ -th expert, and makes a binary decision $y _ { \mathrm { o n } }$ on whether to deploy the $k + 1$ -th expert. If the $k$ -th expert wrongly classifies $x$ , but one of the rest $n - k$ experts correctly classifies $x$ , ideally the router should switch on, i.e., output $y _ { \mathrm { o n } } = 1$ , and otherwise $y _ { \mathrm { o n } } = 0$ . We construct a simple binary classifier with two fully connected layers to learn each router. Each of the $n - 1$ routers for $n$ experts has a shared component to reduce the feature dimensions and an individual component to make decisions.
+
+Specifically, we normalize the image feature $f _ { \boldsymbol { \theta } } ( \boldsymbol { x } )$ (for training stability), reduce the feature dimension (to e.g. 16 in our experiments) by a fully connected layer $\mathbf { W } _ { 1 }$ which is shared with all routers, followed by ReLU and flattening, concatenate with the top- $s$ ranked mean logits from the first to $k$ - th expert $\textstyle { \frac { 1 } { k } } \sum _ { i = 1 } ^ { k } \psi _ { \theta _ { i } } ( f _ { \theta } ( x ) )$ , project it to a scalar by $\mathbf { W } _ { 2 } ^ { ( k ) }$ which is independent between routers, and finally apply Sigmoid function $\begin{array} { r } { S ( x ) = \frac { 1 } { 1 + e ^ { - x } } } \end{array}$ to get a continuous activation value in [0,1]:
+
+$$
+\mathrm { r o u t e r \ a c t i v a t i o n ; } \ r ( x ) = S \left( \mathbf { W } _ { 2 } ^ { ( k ) } \left[ \begin{array} { c } { \mathrm { f a t t e n } \cdot \mathrm { R e L U } \left( \mathbf { W } _ { 1 } \frac { f _ { \theta } ( x ) } { \vert \vert f _ { \theta } ( x ) \vert \vert } \right) } \\ { \frac { 1 } { k } \sum _ { i = 1 } ^ { k } \psi _ { \theta _ { k } } ( f _ { \theta } ( x ) ) \vert _ { \mathrm { t o p } \cdot s \cdot \mathrm { c o m p o n e n t s } } } \end{array} \right] \right) .
+$$
+
+The router has a negligible size and compute, where $s$ ranges from 30 for CIFAR100 to 50 for iNaturalist (8,142 classes). It is optimized with a weighted variant of binary CE loss:
+
+$$
+\mathcal { L } _ { \mathrm { R o u t i n g } } ( r ( x ) , y _ { \mathrm { o n } } ) = - \omega _ { \mathrm { o n } } y _ { \mathrm { o n } } \log \left( r ( x ) \right) - ( 1 - y _ { \mathrm { o n } } ) \log \left( 1 - r ( x ) \right)
+$$
+
+where $\omega _ { \mathrm { o n } }$ controls the easiness to switch on the router. We find $\omega _ { \mathrm { o n } } = 1 0 0$ to be a good trade-off between classification accuracy and computational cost for all our experiments. At the test time, we simply threshold the activation with 0.5: If $r ( x ) < 0 . 5$ , the classifier makes the final decision with the current collective logits, otherwise it proceeds to the next expert.
+
+Optional self-distillation. While existing long-tail classifiers such as BBN Zhou et al. (2020) and LFME Xiang et al. (2020) have a fixed number of experts, our method could have an arbitrary number of experts to balance classification accuracy and computation cost. We can optionally apply self-distillation from a model with more (6 in our setting) experts to the same model with fewer experts for further performance gain $0 . 4 \% \sim 0 . 8 \%$ for most experiments). We choose knowledge distillation (Hinton et al., 2015) by default. Implementation details and comparisons with various distillation algorithms such as CRD (Tian et al., 2019) are investigated in Appendix Section A.2.
+
+# 4 EXPERIMENTS
+
+We experiment on major long-tailed recognition benchmarks and various backbone networks.
+
+1. CIFAR100-LT (Cao et al., 2019): CIFAR100 is sampled by class per an exponential decay across classes. We choose imbalance factor 100 and ResNet-32 (He et al., 2016) backbone.
+
+2. ImageNet-LT (Liu et al., 2019): Multiple backbone networks are experimented on ImageNetLT, including ResNet-10, ResNet-50 and ResNeXt-50 (Xie et al., 2017). All backbone networks are trained with a batch size of 256 on 8 RTX 2080Ti GPUs for 100 epochs using SGD with an initial learning rate of 0.1 decayed by 0.1 at 60 epochs and 80 epochs. See more details and results on other backbones in Appendix.
+
+3. iNaturalist 2018 (Van Horn et al., 2018): It is a naturally imbalanced fine-grained dataset with 8,142 categories. We use ResNet-50 as the backbone and apply the same training recipe as for ImageNet-LT except batch size 512, as in (Kang et al., 2020).
+
+CIFAR100-LT Results. Table 1 shows that RIDE outperforms SOTA by a large margin on CIFAR100-LT. The average computational cost is even about $10 \%$ less than baseline models with two experts as in BBN. RIDE surpasses multi-expert methods, LFME (Xiang et al., 2020) and BBN (Zhou et al., 2020), by more than $5 . 3 \%$ and $6 . 5 \%$ respectively.
+
+![](images/93ea4d77db3384af3de52450596f2d525a817497ee8de8c71fb7fc30f3af19a8.jpg)  
+Figure 3: RIDE is a universal framework that can be extended to various long-tail recognition methods and obtain a consistent top-1 accuracy increase. RIDE is experimented on CIFAR100- LT and applied to various training mechanisms. By using RIDE, cross-entropy loss (without any re-balancing strategies) can even outperforms previous SOTA method on CIFAR100-LT. Although higher accuracy can be obtained using distillation, we did not apply it here.
+
+Table 1: RIDE achieves the state-of-the-art results on CIFAR100-LT without sacrificing the performance of many-shot classes like all previous methods. Compared with BBN (Zhou et al., 2020) and LFME (Xiang et al., 2020), which also contain multiple experts (or branches), RIDE (2 experts) outperforms them by a large margin with fewer GFlops. The relative computation cost (averaged on testing set) with respect to the baseline model and absolute improvements against SOTA (colored in green) are reported. $\dagger$ denotes our reproduced results with released code. $\ddagger$ denotes results copied from (Cao et al., 2019) and the imbalance ratio is 100.   
+
+<table><tr><td rowspan=1 colspan=2>Methods</td><td rowspan=1 colspan=1>MFlops</td><td rowspan=1 colspan=1>All</td><td rowspan=1 colspan=4>Many</td><td rowspan=1 colspan=1>Med</td><td rowspan=1 colspan=1>Few</td></tr><tr><td rowspan=1 colspan=2>Cross Entropy (CE) tCross Entropy (CE) t</td><td rowspan=1 colspan=1>69.5 (1.0x)69.5 (1.0x)</td><td rowspan=1 colspan=1>38.339.1</td><td rowspan=1 colspan=4>166.1</td><td rowspan=1 colspan=1>-37.3</td><td rowspan=1 colspan=1>110.6</td></tr><tr><td rowspan=6 colspan=2>Focal Loss t (Lin et al., 2017)OLTR † (Liu et al., 2019)LDAM + DRW (Cao et al.,2019)LDAM + DRW + (Cao et al., 2019)BBN (Zhou et al., 2020)T-norm t (Kang et al., 2020)cRT + (Kang et al., 2020)M2m (Kim et al., 2020)LFME (Xiang et al., 2020)</td><td rowspan=6 colspan=1>69.5 (1.0x)69.5 (1.0x)69.5 (1.0x)74.3 (1.1x)69.5 (1.0x)69.5 (1.0x)11</td><td rowspan=5 colspan=1>38.441.242.042.042.643.243.343.5</td><td rowspan=2 colspan=4>161.8161.5</td><td rowspan=2 colspan=1>141.4-41.7</td><td rowspan=1 colspan=1>117.61</td></tr><tr><td rowspan=1 colspan=1>20.2</td></tr><tr><td rowspan=4 colspan=4>165.764.011</td><td rowspan=1 colspan=1>-43.6</td><td rowspan=4 colspan=1>■17.318.111</td></tr><tr><td rowspan=1 colspan=1>44.8</td></tr><tr><td rowspan=2 colspan=1>11</td></tr><tr><td rowspan=1 colspan=1>43.8</td><td rowspan=1 colspan=2>1</td></tr><tr><td rowspan=1 colspan=1>RIDE (2 experts)RIDE (3 experts)RIDE (4 experts)</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>64.8 (0.9x)77.8 (1.1x)91.9 (1.3x)</td><td rowspan=1 colspan=1>47.0 (+3.2)48.0 (+4.2)49.1 (+5.3)</td><td rowspan=1 colspan=3>67.9</td><td rowspan=1 colspan=2>67.968.169.3</td><td rowspan=1 colspan=1>48.449.249.3</td></tr></table>
+
+Table 2: RIDE achieves state-of-the-art results on ImageNet-LT (Liu et al., 2019) and obtains consistent performance improvements on various backbones. The top-1 accuracy and computational cost are compared with the state-of-the-art methods on ImageNet-LT, with ResNet-50 and ResNeXt50 as the backbone networks. Results marked with $\dagger$ are copied from (Kang et al., 2020). Detailed results on each split are listed in appendix materials.   
+
+<table><tr><td rowspan="2">Methods</td><td colspan="2">ResNet-50</td><td colspan="2">ResNeXt-50</td></tr><tr><td>GFlops</td><td>Acc. (%)</td><td>GFlops</td><td>Acc. (%)</td></tr><tr><td>Cross Entropy (CE) t</td><td>4.11 (1.0x)</td><td>41.6</td><td>4.26 (1.0x)</td><td>44.4</td></tr><tr><td>OLTR † (Liu et al., 2019)</td><td></td><td>、</td><td></td><td>46.3</td></tr><tr><td>NCM (Kang et al., 2020)</td><td>4.11 (1.0x)</td><td>44.3</td><td>4.26 (1.0x)</td><td>47.3</td></tr><tr><td>T-norm (Kang et al.,2020)</td><td>4.11 (1.0x)</td><td>46.7</td><td>4.26 (1.0x)</td><td>49.4</td></tr><tr><td>cRT (Kang et al., 2020)</td><td>4.11 (1.0x)</td><td>47.3</td><td>4.26 (1.0x)</td><td>49.6</td></tr><tr><td>LWS (Kang et al., 2020)</td><td>4.11 (1.0x)</td><td>47.7</td><td>4.26 (1.0x)</td><td>49.9</td></tr><tr><td>RIDE (2 experts)</td><td>3.71 (0.9x)</td><td>54.4 (+6.7)</td><td>3.92 (0.9x)</td><td>55.9 (+6.0)</td></tr><tr><td>RIDE (3 experts)</td><td>4.36 (1.1x)</td><td>54.9 (+7.2)</td><td>4.69 (1.1x)</td><td>56.4 (+6.5)</td></tr><tr><td>RIDE (4 experts)</td><td>5.15 (1.3x)</td><td>55.4 (+7.7)</td><td>5.19 (1.2x)</td><td>56.8 (+6.9)</td></tr></table>
+
+RIDE as a universal framework. Fig. 3 shows that RIDE consistently benefits from better loss functions and training processes. Whether the model is trained end-to-end (focal loss, CE, LDAM) or in two stages (cRT, $\tau$ -norm, cosine), RIDE delivers consistent accuracy gains. In particular, RIDE with a simple cosine classifier, which we constructed by normalizing the classifier weights and retraining them with a long-tail re-sampling strategy (similar to cRT), achieves on-par performance with the current SOTA methods. Fig. 3 also shows that two-stage methods are generally better than single-stage ones. Nevertheless, since they require an additional training stage, for simplicity, we use the single-stage LDAM as the default $\mathcal { L } _ { \mathrm { C l a s s i f y } }$ in RIDE throughout our remaining experiments.
+
+ImageNet-LT Results. Table 2 shows that RIDE outperforms SOTA, LWS and cRT, by more than $7 . 7 \%$ with ResNet-50. ResNeXt-50 is based on group convolution (Xie et al., 2017), which divides all filters into several groups and aggregates information from multiple groups. ResNeXt-50 generally performs better than ResNet-50 on multiple tasks. It provides $6 . 9 \%$ gain on ImageNet-LT.
+
+iNaturalist 2018 Results. Table 3 shows that RIDE outperforms current SOTA by $6 . 3 \%$ . Surprisingly, RIDE obtains very similar results on many-shots, medium-shots and few-shots, ideal for long tailed recognition. Current SOTA method BBN also uses multiple experts; however, it significantly decreases the performance on many-shots by about $23 \%$ . RIDE is remarkable at increasing the few-shot accuracy without reducing the many-shot accuracy.
+
+Table 3: RIDE outperforms previous state-of-the-art methods on challenging iNaturalist 2018 (Van Horn et al., 2018) dataset, which contains 8,142 classes, by a large margin. Relative improvements to SOTA result of each split (colored with gray) are also listed, with the largest boost from few-shot classes. Compared with previous SOTA method BBN, which also contains multiple “experts”, RIDE achieves more than $20 \%$ higher top-1 accuracy on many-shot classes. Results marked with $\dagger$ are from BBN (Zhou et al., 2020) and Decouple (Kang et al., 2020). BBN’s results are from the released checkpoint.   
+
+<table><tr><td>Methods</td><td>GFlops</td><td>All</td><td>Many</td><td>Medium</td><td>Few</td></tr><tr><td>CE+</td><td>4.14 (1.0x)</td><td>61.7</td><td>72.2</td><td>63.0</td><td>57.2</td></tr><tr><td>CB-Focal t</td><td>4.14 (1.0x)</td><td>61.1</td><td>1</td><td>1</td><td>1</td></tr><tr><td>OLTR</td><td>4.14 (1.0x)</td><td>63.9</td><td>59.0</td><td>64.1</td><td>64.9</td></tr><tr><td>LDAM + DRW †</td><td>4.14 (1.0x)</td><td>64.6</td><td>1</td><td>1</td><td>1</td></tr><tr><td>cRT</td><td>4.14 (1.0x)</td><td>65.2</td><td>69.0</td><td>66.0</td><td>63.2</td></tr><tr><td>T-norm</td><td>4.14 (1.0x)</td><td>65.6</td><td>65.6</td><td>65.3</td><td>65.9</td></tr><tr><td>LWS</td><td>4.14 (1.0x)</td><td>65.9</td><td>65.0</td><td>66.3</td><td>65.5</td></tr><tr><td>BBN</td><td>4.36 (1.1x)</td><td>66.3</td><td>49.4</td><td>70.8</td><td>65.3</td></tr><tr><td>RIDE (2 experts)</td><td>3.67 (0.9x)</td><td>71.4 4 (+5.1)</td><td>70.2 (+1.2)</td><td>71.3 (+0.5)</td><td>71.7 (+5.8)</td></tr><tr><td>RIDE (3 experts)</td><td>4.17 (1.0x)</td><td>72.2 (+5.9)</td><td>70.2 (+1.2)</td><td>72.2 (+1.4)</td><td>72.7 (+6.8)</td></tr><tr><td>RIDE (4 experts)</td><td>4.51 (1.1x)</td><td>72.6 (+6.3)</td><td>70.9 (+1.9)</td><td>72.4 (+1.6)</td><td>73.1 (+7.2)</td></tr></table>
+
+![](images/b2b3787077638275c5a73098091370295779f41ab43823667b14776dbc013444.jpg)  
+Figure 4: Compared to SOTAs, RIDE improves top-1 accuracy on all three splits (many-/med-/fewshot). The absolute accuracy differences of RIDE (blue) over iNaturalist’s current state-of-theart method BBN (Zhou et al., 2020) (left) and ImageNet-LT’s current state-of-the-art method cRT (Kang et al., 2020) (right) are shown. RIDE improves the performance of few- and medium-shots categories without sacrificing the accuracy on many-shots, and outperforms BBN on many-shots by a large margin.
+
+Comparing with SOTAs on iNaturalist and ImageNet-LT. As illustrated in Fig. 4, our approach provides a comprehensive treatment to all the many-shot, medium-shot and few-shot classes, achieving substantial improvements to current state-of-the-art on all aspects. Compared with cRT which reduces the performance on the many-shot classes, RIDE can achieves significantly better performance on the few-shot classes without impairing the many-shot classes. Similar observations can be obtained in the comparison with the state-of-the-art method BBN (Zhou et al., 2020) on iNaturalist.
+
+Contribution of each component of RIDE. RIDE is jointly trained with $\mathcal { L } _ { \mathrm { D - D i v e r s i f y } }$ and $\mathcal { L } _ { \mathrm { C l a s s i f y } }$ , we use LDAM for $\mathcal { L } _ { \mathrm { C l a s s i f y } }$ by default. Table 4 shows that the architectural change from the original ResNet-32 to the RIDE variant with $2 \sim 4$ experts contributes $2 . 7 \% \sim 4 . 3 \%$ gain. Applying the individual classification loss instead of the collaborative loss brings $1 . 5 \%$ gain. Adding the diversity loss further improves about $0 . 9 \%$ . The computational cost is greatly reduced by adding the dynamic expert router. Knowledge distillation from RIDE with 6 experts obtains another $0 . 6 \%$ gain. All these components deliver $7 . 1 \%$ gain over baseline LDAM.
+
+Impact of the number of experts. Fig. 5 shows that whether in terms of relative or absolute gains, few-shots benefit more with more experts. For example, the relative gain is $16 \%$ vs. $3 . 8 \%$ for few-shots and many-shots respectively. No distillation is applied in this comparison.
+
+Table 4: Ablation studies on the effectiveness of each component on CIFAR100-LT. LDAM is used as our classification loss. The first 3 RIDE models only have architectural change without changes in training method. The performance without $\mathcal { L } _ { \mathrm { { I n d i v i d u a l } } }$ checked indicates directly applying classification loss onto the final model output, which is the mean expert logits. This is referred to as collaborative loss above. In contrast, if $\mathcal { L } _ { \mathrm { { I n d i v i d u a l } } }$ if checked, we apply individual loss to each individual expert. The difference between collaborative loss and individual loss is described above. By adding the router module, the computational cost of RIDE can be significantly reduced, while the accuracy degradation is negligible. Knowledge distillation step is optional if further improvements are desired. Various knowledge distillation techniques are compared in the appendix.
+
+<table><tr><td>Methods</td><td>#expert</td><td>LIndividual</td><td>LD-Diversify</td><td>Router</td><td>distill</td><td>GFlops</td><td>Acc.(%)</td></tr><tr><td>LDAM+DRW</td><td>1</td><td></td><td></td><td></td><td></td><td></td><td>42.0</td></tr><tr><td rowspan="7">RIDE</td><td>2</td><td></td><td></td><td></td><td></td><td>1.1x</td><td>44.7 (+2.7)</td></tr><tr><td>3</td><td></td><td></td><td></td><td></td><td>1.5x</td><td>46.1 (+4.1)</td></tr><tr><td>4</td><td></td><td></td><td></td><td></td><td>1.8x</td><td>46.3 (+4.3)</td></tr><tr><td>4</td><td></td><td></td><td></td><td></td><td>1.8x</td><td>47.8 (+5.8)</td></tr><tr><td>4</td><td>&lt;</td><td>√</td><td></td><td></td><td>1.8x</td><td>48.7 (+6.7)</td></tr><tr><td>4</td><td>√</td><td>√</td><td></td><td>1</td><td>1.8x</td><td>49.3 (+7.3)</td></tr><tr><td>4</td><td>√</td><td>&lt;</td><td>√</td><td></td><td>1.3x</td><td>49.1 (+7.1)</td></tr></table>
+
+![](images/8cf6029a1e2ab72917f85036752a1e85a7545e1164698474f0fb18f990efe206.jpg)  
+Figure 5: # experts vs. top-1 accuracy for each split (All, Many/Medium/Few) of CIFAR100- LT. Compared with the many-shot split, which is $3 . 8 \%$ relatively improved by adding more experts, the few-shot split can get more benefits, that is, a relative improvement of $1 6 . 1 \%$ .
+
+![](images/1631bd4dd73a9a43fc47a06387029dba617d11f1c20c50069ba839f092929c00.jpg)  
+Figure 6: The proportion of the number of experts allocated to each split of CIFAR100-LT. For RIDE with 3 or 4 experts, more than half of many-shot instances only require one expert. On the contrary, more than $76 \%$ samples of few-shot classes require opinions from additional experts.
+
+The number of experts allocated to each split. Fig. 6 shows that instances in few-shots need more experts whereas most instances in many-shots just need the first expert. That is, low confidence in tail instances often requires the model to seek a second (or a third, ...) opinion.
+
+# 5 SUMMARY
+
+We take a dynamic view of training data and study long-tailed recognition with model bias and variance analysis. Existing long-tail classifiers do not reduce head-tail model bias gap enough while increasing model variance across all the classes. We propose a novel multi-expert model called RIDE to reduce model biases and variances throughout. It trains partially shared diverse distributionaware experts and routes an instance to additional experts when necessary, with computational costs comparable to a single expert. RIDE outperforms SOTA by a large margin. It is also a universal framework that works with various backbones and training schemes for consistent gains.
+
+Acknowledgments. This work was supported, in part, by Berkeley Deep Drive, US Government fund through Etegent Technologies on Low-Shot Detection and Semi-supervised Detection, and NTU NAP and A\*STAR via Industry Alignment Fund: Industry Collaboration Projects Grant.
+
+# REFERENCES
+
+Luca Bertinetto, Joao F Henriques, Jack Valmadre, Philip Torr, and Andrea Vedaldi. Learning feed- ˜ forward one-shot learners. In NeurIPS, 2016.
+
+Kaidi Cao, Colin Wei, Adrien Gaidon, Nikos Arechiga, and Tengyu Ma. Learning imbalanced datasets with label-distribution-aware margin loss. In Advances in Neural Information Processing Systems, pp. 1567–1578, 2019.
+
+Zitian Chen, Yanwei Fu, Yu-Xiong Wang, Lin Ma, Wei Liu, and Martial Hebert. Image deformation meta-networks for one-shot learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 8680–8689, 2019.
+
+Peng Chu, Xiao Bian, Shaopeng Liu, and Haibin Ling. Feature space augmentation for long-tailed data. arXiv preprint arXiv:2008.03673, 2020.
+
+Yin Cui, Menglin Jia, Tsung-Yi Lin, Yang Song, and Serge Belongie. Class-balanced loss based on effective number of samples. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 9268–9277, 2019.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 248–255, 2009.
+
+Pedro Domingos. A unified bias-variance decomposition. In Proceedings of 17th International Conference on Machine Learning, pp. 231–238, 2000.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. arXiv preprint arXiv:1703.03400, 2017.
+
+Raia Hadsell, Sumit Chopra, and Yann LeCun. Dimensionality reduction by learning an invariant mapping. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 1735–1742, 2006.
+
+Bharath Hariharan and Ross Girshick. Low-shot visual recognition by shrinking and hallucinating features. In Proceedings of the IEEE International Conference on Computer Vision, pp. 3018– 3027, 2017.
+
+Haibo He and Edwardo A Garcia. Learning from imbalanced data. IEEE Transactions on knowledge and data engineering, 21(9):1263–1284, 2009.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 770–778, 2016.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.
+
+Muhammad Abdullah Jamal, Matthew Brown, Ming-Hsuan Yang, Liqiang Wang, and Boqing Gong. Rethinking class-balanced methods for long-tailed visual recognition from a domain adaptation perspective. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 7610–7619, 2020.
+
+Bingyi Kang, Saining Xie, Marcus Rohrbach, Zhicheng Yan, Albert Gordo, Jiashi Feng, and Yannis Kalantidis. Learning imbalanced datasets with label-distribution-aware margin loss. In International Conference on Learning Representations, pp. 1567–1578, 2020.
+
+Jaehyung Kim, Jongheon Jeong, and Jinwoo Shin. M2m: Imbalanced classification via major-tominor translation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 13896–13905, 2020.
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009.
+
+Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollar. Focal loss for dense ´ object detection. In Proceedings of the IEEE international conference on computer vision, pp. 2980–2988, 2017.
+
+Bo Liu, Xudong Wang, Mandar Dixit, Roland Kwitt, and Nuno Vasconcelos. Feature space transfer for data augmentation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 9090–9098, 2018.
+
+Jialun Liu, Yifan Sun, Chuchu Han, Zhaopeng Dou, and Wenhui Li. Deep representation learning on long-tailed data: A learnable embedding augmentation perspective. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 2970–2979, 2020.
+
+Ziwei Liu, Zhongqi Miao, Xiaohang Zhan, Jiayun Wang, Boqing Gong, and Stella X Yu. Largescale long-tailed recognition in an open world. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 2537–2546, 2019.
+
+Hyun Oh Song, Yu Xiang, Stefanie Jegelka, and Silvio Savarese. Deep metric learning via lifted structured feature embedding. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 4004–4012, 2016.
+
+Nikolaos Passalis and Anastasios Tefas. Learning deep representations with probabilistic knowledge transfer. In Proceedings of the European Conference on Computer Vision, pp. 268–284, 2018.
+
+Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. In ICLR, 2017.
+
+Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy Lillicrap. Metalearning with memory-augmented neural networks. In ICML, 2016.
+
+Eli Schwartz, Leonid Karlinsky, Joseph Shtok, Sivan Harary, Mattias Marder, Rogerio Feris, Abhishek Kumar, Raja Giryes, and Alex M Bronstein. Delta-encoder: an effective sample synthesis method for few-shot object recognition. arXiv preprint arXiv:1806.04734, 2018.
+
+Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In NeurIPS, 2017.
+
+Jingru Tan, Changbao Wang, Buyu Li, Quanquan Li, Wanli Ouyang, Changqing Yin, and Junjie Yan. Equalization loss for long-tailed object recognition. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 11662–11671, 2020.
+
+Yonglong Tian, Dilip Krishnan, and Phillip Isola. Contrastive representation distillation. In International Conference on Learning Representations, 2019.
+
+Frederick Tung and Greg Mori. Similarity-preserving knowledge distillation. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1365–1374, 2019.
+
+Grant Van Horn, Oisin Mac Aodha, Yang Song, Yin Cui, Chen Sun, Alex Shepard, Hartwig Adam, Pietro Perona, and Serge Belongie. The iNaturalist species classification and detection dataset. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 8769–8778, 2018.
+
+Oriol Vinyals, Charles Blundell, Tim Lillicrap, and Daan Wierstra. Matching networks for one shot learning. In NeurIPS, 2016.
+
+Yu-Xiong Wang, Deva Ramanan, and Martial Hebert. Learning to model the tail. In Advances in Neural Information Processing Systems, pp. 7029–7039, 2017.
+
+Yu-Xiong Wang, Ross Girshick, Martial Hebert, and Bharath Hariharan. Low-shot learning from imaginary data. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 7278–7286, 2018.
+
+Tong Wu, Qingqiu Huang, Ziwei Liu, Yu Wang, and Dahua Lin. Distribution-balanced loss for multi-label classification in long-tailed datasets. In Proceedings of the European Conference on Computer Vision, pp. 162–178. Springer, 2020.
+
+Zhirong Wu, Yuanjun Xiong, Stella X Yu, and Dahua Lin. Unsupervised feature learning via nonparametric instance discrimination. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 3733–3742, 2018.
+
+Liuyu Xiang, Guiguang Ding, and Jungong Han. Learning from multiple experts: Self-paced knowledge distillation for long-tailed classification. In Proceedings of the European Conference on Computer Vision, pp. 247–263. Springer, 2020.
+
+Saining Xie, Ross Girshick, Piotr Dollar, Zhuowen Tu, and Kaiming He. Aggregated residual trans-´ formations for deep neural networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 1492–1500, 2017.
+
+Flood Sung Yongxin Yang, Li Zhang, Tao Xiang, Philip HS Torr, and Timothy M Hospedales. Learning to compare: Relation network for few-shot learning. In CVPR, 2018.
+
+Hongguang Zhang, Jing Zhang, and Piotr Koniusz. Few-shot learning via saliency-guided hallucination of samples. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 2770–2779, 2019.
+
+Xiao Zhang, Zhiyuan Fang, Yandong Wen, Zhifeng Li, and Yu Qiao. Range loss for deep face recognition with long-tailed training data. In Proceedings of the IEEE International Conference on Computer Vision, pp. 5409–5418, 2017.
+
+Boyan Zhou, Quan Cui, Xiu-Shen Wei, and Zhao-Min Chen. BBN: Bilateral-branch network with cumulative learning for long-tailed visual recognition. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 9719–9728, 2020.
+
+Linchao Zhu and Yi Yang. Inflated episodic memory with region self-attention for long-tailed visual recognition. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 4344–4353, 2020.
+
+# A APPENDIX
+
+# A.1 DATASETS AND IMPLEMENTATIONS
+
+We conduct experiments on three major long-tailed recognition benchmarks and different backbone networks to prove the effectiveness and universality of RIDE:
+
+1.CIFAR100-LT (Krizhevsky, 2009; Cao et al., 2019): The original version of CIFAR-100 contains 50,000 images on training set and 10,000 images on validation set with 100 categories. The long-tailed version of CIFAR-100 follows an exponential decay in sample sizes across different categories. We conduct experiment on CIFAR100-LT with an imbalance factor of 100, i.e. the ratio between the most frequent class and the least frequent class.
+
+To make fair comparison with previous works, we follow the training recipe of (Cao et al., 2019) on CIFAR100-LT. We train the ResNet-32 (He et al., 2016) backbone network by SGD optimizer with a momentum of 0.9. CIFAR100-LT is trained for 200 epochs with standard data augmentations (He et al., 2016) and a batch size of 128 on one RTX 2080Ti GPU. The learning rate is initialized as 0.1 and decayed by 0.01 at epoch 120 and 160 respectively.
+
+2.ImageNet-LT (Deng et al., 2009; Liu et al., 2019): ImageNet-LT is constructed by sampling a subset of ImageNet-2012 following the Pareto distribution with the power value $\alpha = 6$ (Liu et al., 2019). ImageNet-LT consists of $1 1 5 . 8 \mathrm { k }$ images from 1,000 categories, with the largest and smallest categories containing 1,280 and 5 images, respectively.
+
+Multiple backbone networks are experimented on ImageNet-LT, including ResNet-10, ResNet-50 and ResNeXt-50 (Xie et al., 2017). All backbone networks are trained with a batch size of 256 on 8 RTX 2080Ti GPUs for 100 epochs using SGD with an initial learning rate of 0.1 decayed by 0.1 at 60 epochs and 80 epochs. We utilize standard data augmentations as in (He et al., 2016).
+
+3.iNaturalist (Van Horn et al., 2018): The iNaturalist-2018 dataset is an imbalanced datasets with 437,513 training images from 8,142 classes with a balanced test set of 24,426 images. We use ResNet-50 as the backbone network and apply the same training recipe as ImageNet-LT, except that we use a batch size of 512.
+
+# A.2 ADDITIONAL EXPERIMENTS
+
+Ablation study on distillation methods. Self-distillation step is optional but recommended if further improvements $( 0 . 4 \% \sim 0 . 8 \%$ for most experiments) are desired. We apply distillation from a more powerful model with more experts into a model with fewer experts. A simple way to transfer knowledge is knowledge distillation (KD) (Hinton et al., 2015), which applies KD loss $( \mathcal { L } _ { \mathrm { K D } } = T ^ { 2 } D _ { \mathrm { K L } } ( \tilde { \vec { l } _ { \mathrm { t e a c h e r } } } / T , \vec { l } _ { \mathrm { e x p e r t } _ { i } } / T ) )$ to match the distribution of logits of a teacher and a student. We found that for teacher model with more experts using smaller distillation loss factor gives better performance. We hypothesize that since we distill from the same teachers, giving large distillation factor prevents the branches from becoming as diversified as it is able to. We also explored other distillation methods, such as CRD (Tian et al., 2019), PKT (Passalis & Tefas, 2018), and SP (Tung & Mori, 2019), and compared the differences in Table 5. Although adding other methods along with KD may boost performance, the difference is small. Therefore, we opt for simplicity and use KD only unless otherwise noticed.
+
+Detailed results for ImageNet-LT experiments. We list details of our ResNet-50 experiments in ImageNet-LT on Table 7. With 2 experts, we are able to achieve about $7 \%$ gain in accuracy with computational cost about $10 \%$ less than baseline. In contrast to previous methods that sacrifice many-shot accuracy to get few-shot accuracy, we improve on all three splits on ImageNet-LT. From 3 experts to 4 experts, we keep the same many-shot accuracy while increasing the few-shot accuracy, indicating that we are using the additional computational power to improve on the hardest part of the data rather than uniformly applying to all samples.
+
+We also list our ResNet-10 and ResNeXt-50 experiments on Table 6 and 8, respectively, to compare against other works evaluated on these backbones. Our method also achieves lower computational cost and higher performance when compared to other methods.
+
+Comparison with ensemble method. Since our method requires the joint decision from several experts, which raw ensembles also do, we also compare against ensembles of LDAM in Fig.7 on
+
+Table 5: Comparison of different distillation methods. We transfer from a model based on ResNet-32 with 6 experts to a model of the same type, except with fewer experts. We use CIFAR100- LT for the following comparison. No expert assignment module is used in the following experiments. Following the procedure for CRD (Tian et al., 2019), we also apply KD when we transfer from a teacher to students with other distillation methods.
+
+RIDE and Ensembles of LDAM   
+
+<table><tr><td>Model Type</td><td>#expert</td><td>DistillationMethod</td><td>Accuracy (%)</td></tr><tr><td>Teacher</td><td>6</td><td></td><td>49.7</td></tr><tr><td rowspan="10">Student</td><td>2</td><td>No Distillation</td><td>46.6</td></tr><tr><td>2</td><td>KD (Hinton et al., 2015)</td><td>47.3</td></tr><tr><td>2</td><td>CRD (Tian et al., 2019)</td><td>47.5</td></tr><tr><td>2</td><td>PKT (Passalis &amp; Tefas,2018)</td><td>47.2</td></tr><tr><td>2</td><td>SP(Tung&amp;Mori,2019)</td><td>47.2</td></tr><tr><td>3 3</td><td>No Distillation</td><td>47.9</td></tr><tr><td></td><td>KD (Hinton et al., 2015)</td><td>48.4</td></tr><tr><td>3</td><td>CRD (Tian et al., 2019)</td><td>48.5</td></tr><tr><td>3</td><td>PKT (Passalis &amp; Tefas,2018)</td><td>48.3</td></tr><tr><td>3 4</td><td>SP(Tung&amp; Mori,2019)</td><td>48.7</td></tr><tr><td></td><td>No Distillation</td><td></td><td>48.7</td></tr><tr><td></td><td>4</td><td>KD (Hinton et al., 2015)</td><td>49.3</td></tr><tr><td></td><td>4</td><td>CRD (Tian et al., 2019)</td><td>49.0</td></tr><tr><td></td><td>4</td><td>PKT (Passalis &amp; Tefas,2018)</td><td>48.9</td></tr><tr><td>4</td><td></td><td>SP (Tung&amp; Mori,2019)</td><td>49.0</td></tr></table>
+
+![](images/ed58db4791e1f89ea35cfff8e371d2ead6b40c0516b6979d8bf036e41da4d9b4.jpg)  
+Figure 7: Comparison between our method and multiple LDAM models ensembled together. In the figure, ensembles of LDAM start from 1 ensemble (original LDAM) to 7 ensembles, and RIDE starts from 2 experts to 4 experts. Our method achieves higher accuracy with substantially less computational cost compared to ensemble method.
+
+CIFAR100-LT. In the figure, even our method with 4 experts has less computational cost than the minimum computational cost for the ensemble of 2 LDAM models. This indicates that our model is much more efficient and powerful in terms of computational cost and accuracy than ensemble on long-tailed datasets.
+
+![](images/e6115ad05a8234a5953def47587d79cb117043662a85d302d1fee6d35a65ae44.jpg)  
+Figure 8: t-SNE visualization of LDAM’s and our model’s embedding space of CIFAR100-LT. The feature embedding of RIDE is more compact for both head and tail classes and better separated. This behavior greatly reduces the difficulty for the classifier to distinguish the tail category.
+
+t-SNE visualization. We also provide the t-SNE visualization of embedding space on CIFAR100- LT as in Fig. 8. Compared with the baseline method LDAM, the feature embedding of RIDE is more compact for both the head and tail classes and better separated from the neighboring classes. This greatly reduces the difficulty for the classifier to distinguish the tail category.
+
+What if we apply RIDE to balanced datasets? We also conducted experiments on CIFAR100 to check if our method can achieve similar performance gains on balanced datasets. However, we only obtained an improvement of about $1 \%$ , which is much smaller than the improvements observed on the CIFAR100-LT. Compared with balanced datasets, long-tailed datasets can get more benefits from RIDE.
+
+Table 6: Top-1 accuracy comparison with state-of-the-art methods on ImageNet-LT (Liu et al., 2019) with ResNet-10. Performance on Many-shot $( > 1 0 0 )$ , Medum-shot $\leq 1 0 0$ & ${ > } 2 0$ ) and Fewshot $( \leq 2 0 )$ are also provided. Results marked with $\dagger$ are copied from (Liu et al., 2019). Results with $\ddagger$ are from (Xiang et al., 2020).   
+
+<table><tr><td>Methods</td><td>GFlops</td><td>Many</td><td>Medium</td><td>Few</td><td>Overall</td></tr><tr><td>Cross Entropy(CE) t</td><td>0.89 (1.0x)</td><td>40.9</td><td>10.7</td><td>0.4</td><td>20.9</td></tr><tr><td>Focal Loss † (Lin et al.,2017)</td><td>0.89 (1.0x) 0.89 (1.0x)</td><td>36.4</td><td>29.9</td><td>16.0</td><td>30.5</td></tr><tr><td>Range Loss † (Zhang et al., 2017) Lifted Loss † (Oh Song et al., 2016)</td><td>0.89 (1.0x)</td><td>35.8</td><td>30.3</td><td>17.6</td><td>30.7</td></tr><tr><td></td><td></td><td>35.8</td><td>30.4</td><td>17.9</td><td>30.8</td></tr><tr><td>OLTR (Liu et al., 2019) LFME (Xiang et al., 2020)</td><td>0.89 (1.0x)</td><td>43.2</td><td>35.1</td><td>18.5</td><td>35.6</td></tr><tr><td>Many-shot only t</td><td>- 1</td><td>47.0 59.3</td><td>37.9</td><td>19.2</td><td>38.8</td></tr><tr><td>Medium-shot only t</td><td>1</td><td></td><td>35.9</td><td></td><td></td></tr><tr><td>Few-shot only ‡</td><td>1</td><td></td><td></td><td>14.3</td><td></td></tr><tr><td>RIDE (2 experts)</td><td>0.85 (1.0x)</td><td>57.5</td><td>40.8</td><td>26.9</td><td>45.3 (+6.5)</td></tr><tr><td>RIDE (3 experts)</td><td>0.97 (1.1x)</td><td>57.6</td><td>41.7</td><td>28.0</td><td>45.9 (+7.1)</td></tr><tr><td>RIDE (4 experts)</td><td>1.07 (1.2x)</td><td>58.5</td><td>42.4</td><td>27.7</td><td>46.6 ( (+7.8)</td></tr></table>
+
+Table 7: Top-1 accuracy comparison with state-of-the-art methods on ImageNet-LT (Liu et al., 2019) with ResNet-50. Performance on Many-shot $( > 1 0 0 )$ , Medum-shot $( \leq 1 0 0$ & ${ > } 2 0$ ) and Fewshot $( \leq 2 0 )$ are also provided. Results marked with $\dagger$ are copied from (Kang et al., 2020).   
+
+<table><tr><td>Methods</td><td>GFlops</td><td>Many</td><td>Medium</td><td>Few</td><td>Overall</td></tr><tr><td>Cross Entropy (CE) t</td><td>4.11 (1.0x)</td><td>64.0</td><td>33.8</td><td>5.8</td><td>41.6</td></tr><tr><td>NCM (Kang et al., 2020)</td><td>=</td><td>53.1</td><td>42.3</td><td>26.5</td><td>44.3</td></tr><tr><td>cRT (Kang et al., 2020)</td><td>4.11 (1.0x)</td><td>58.8</td><td>44.0</td><td>26.1</td><td>47.3</td></tr><tr><td>T-norm (Kang et al., 2020)</td><td>4.11 (1.0x)</td><td>56.6</td><td>44.2</td><td>27.4</td><td>46.7</td></tr><tr><td>LWS (Kang et al., 2020)</td><td>4.11 (1.0x)</td><td>57.1</td><td>45.2</td><td>29.3</td><td>47.7</td></tr><tr><td>RIDE (2 experts)</td><td>3.71 (0.9x)</td><td>65.8</td><td>51.0</td><td>34.6</td><td>54.4 (+6.7)</td></tr><tr><td>RIDE (3 experts)</td><td>4.36 (1.1x)</td><td>66.2</td><td>51.7</td><td>34.9</td><td>54.9 (+7.2)</td></tr><tr><td>RIDE (4 experts)</td><td>5.15 (1.3x)</td><td>66.2</td><td>52.3</td><td>36.5</td><td> 55.4 (+7.7)</td></tr></table>
+
+Table 8: Top-1 accuracy comparison with state-of-the-art methods on ImageNet-LT (Liu et al., 2019) with ResNeXt-50. Performance on Many-shot $( > 1 0 0 )$ , Medum-shot $( \leq 1 0 0$ & ${ > } 2 0 _ { , }$ ) and Few-shot $( \leq 2 0 )$ are also provided. Results marked with $\dagger$ are copied from (Kang et al., 2020).   
+
+<table><tr><td>Methods</td><td>GFlops</td><td>Many</td><td>Medium</td><td>Few</td><td>Overall</td></tr><tr><td>Cross Entropy(CE) + NCM (Kang et al., 2020)</td><td>4.26 (1.0x)</td><td>65.9</td><td>37.5</td><td>7.7</td><td>44.4</td></tr><tr><td>cRT (Kang et al., 2020)</td><td>4.26 (1.0x)</td><td>56.6 61.8</td><td>45.3 46.2</td><td>28.1 27.4</td><td>47.3 49.6</td></tr><tr><td>T-norm (Kang et al., 2020)</td><td>4.26 (1.0x)</td><td>59.1</td><td>46.9</td><td>30.7</td><td>49.4</td></tr><tr><td>LWS (Kang et al., 2020)</td><td>4.26 (1.0x)</td><td>60.2</td><td>47.2</td><td>30.3</td><td></td></tr><tr><td></td><td>3.92 (0.9x)</td><td>67.6</td><td>52.5</td><td>35.0</td><td>49.9</td></tr><tr><td>RIDE (2 experts)</td><td>4.69 (1.1x)</td><td>67.6</td><td>53.5</td><td>35.9</td><td>55.9 (+6.0)</td></tr><tr><td>RIDE (3 experts)</td><td>5.19 (1.2x)</td><td></td><td></td><td></td><td>56.4 (+6.5)</td></tr><tr><td>RIDE (4 experts)</td><td></td><td>68.2</td><td>53.8</td><td>36.0</td><td>56.8 (+6.9)</td></tr></table>

parse/train/D9I3drBz4UC/D9I3drBz4UC_content_list.json

@@ -0,0 +1,1845 @@
+[
+    {
+        "type": "text",
+        "text": "LONG-TAILED RECOGNITION BYROUTING DIVERSE DISTRIBUTION-AWARE EXPERTS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            805,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Xudong Wang1, Long Lian1, Zhongqi Miao1, Ziwei Liu2, Stella X. $\\mathbf { Y u } ^ { 1 }$ ",
+        "bbox": [
+            184,
+            169,
+            674,
+            185
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1UC Berkeley / ICSI, 2Nanyang Technological University {xdwang,longlian,zhongqi.miao,stellayu}@berkeley.edu ziwei.liu@ntu.edu.sg ",
+        "bbox": [
+            184,
+            185,
+            691,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            263,
+            544,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Natural data are often long-tail distributed over semantic classes. Existing recognition methods tackle this imbalanced classification by placing more emphasis on the tail data, through class re-balancing/re-weighting or ensembling over different data groups, resulting in increased tail accuracies but reduced head accuracies. ",
+        "bbox": [
+            233,
+            297,
+            764,
+            354
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We take a dynamic view of the training data and provide a principled model bias and variance analysis as the training data fluctuates: Existing long-tail classifiers invariably increase the model variance and the head-tail model bias gap remains large, due to more and larger confusion with hard negatives for the tail. ",
+        "bbox": [
+            233,
+            359,
+            764,
+            415
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose a new long-tailed classifier called RoutIng Diverse Experts (RIDE). It reduces the model variance with multiple experts, reduces the model bias with a distribution-aware diversity loss, reduces the computational cost with a dynamic expert routing module. RIDE outperforms the state-of-the-art by $5 \\%$ to $7 \\%$ on CIFAR100-LT, ImageNet-LT and iNaturalist 2018 benchmarks. It is also a universal framework that is applicable to various backbone networks, long-tailed algorithms, and training mechanisms for consistent performance gains. Our code is available at: https://github.com/frank-xwang/RIDE-LongTailRecognition. ",
+        "bbox": [
+            233,
+            420,
+            764,
+            531
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            568,
+            336,
+            583
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Real-world data are often long-tail distributed over semantic classes: A few classes contain many instances, whereas most classes contain only a few instances. Long-tailed recognition is challenging, as it needs to handle not only a multitude of small-data learning problems on the tail classes, but also extreme imbalanced classification over all the classes. ",
+        "bbox": [
+            174,
+            602,
+            823,
+            657
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "There are two ways to prevent the many head instances from overwhelming the few tail instances in the classifier training objective: 1) class re-balancing/re-weighting which gives more importance to tail instances (Cao et al., 2019; Kang et al., 2020; Liu et al., 2019), 2) ensembling over different data distributions which re-organizes long-tailed data into groups, trains a model per group, and then combines individual models in a multi-expert framework (Zhou et al., 2020; Xiang et al., 2020). ",
+        "bbox": [
+            174,
+            665,
+            825,
+            734
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We compare three state-of-the-art (SOTA) long-tail classifiers against the standard cross-entropy (CE) classifier: cRT and $\\tau$ -norm (Kang et al., 2020) which adopt a two-stage optimization, first representation learning and then classification learning, and LDAM (Cao et al., 2019), which is trained end-to-end with a marginal loss. In terms of the classification accuracy, a common metric for model selection on a fixed training set, Fig. 1a shows that, all these existing long-tail methods increase the overall, medium- and few-shot accuracies over CE, but decrease the many-shot accuracy. ",
+        "bbox": [
+            174,
+            741,
+            825,
+            825
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "These intuitive solutions and their experimental results seem to suggest that there is a head-tail performance trade-off in long-tailed recognition. We need a principled performance analysis approach that could shed light on such a limitation if it exists and provide guidance on how to overcome it. ",
+        "bbox": [
+            176,
+            833,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our insight comes from a dynamic view of the training set: It is merely a sample set of some underlying data distribution. Instead of evaluating how a long-tailed classifier performs on the fixed training set, we evaluate how it performs as the training set fluctuates according to the data distribution. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "table",
+        "img_path": "images/de3d797b0da934214264aa007c0ae0473262e22bf2e1e01c7d1d49322ac90f13.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"3\">All</td><td colspan=\"3\">Many-shot</td><td colspan=\"3\">Med-shot</td><td colspan=\"3\">Few-shot</td></tr><tr><td>acc</td><td>bias</td><td>var</td><td>acc</td><td>bias</td><td>var</td><td>acc</td><td>bias</td><td>var</td><td>acc</td><td>bias</td><td>var</td></tr><tr><td>CE</td><td>31.6</td><td>0.60</td><td>0.47</td><td>57.3</td><td>0.28</td><td>0.35</td><td>28.2</td><td>0.61</td><td>0.51</td><td>6.3</td><td>0.94</td><td>0.57</td></tr><tr><td>T-norm</td><td>35.8</td><td>0.52</td><td>0.49</td><td>55.9</td><td>0.28</td><td>0.37</td><td>33.2</td><td>0.53</td><td>0.52</td><td>16.1</td><td>0.78</td><td>0.60</td></tr><tr><td>cRT</td><td>36.4</td><td>0.50</td><td>0.50</td><td>51.3</td><td>0.32</td><td>0.41</td><td>38.6</td><td>0.44</td><td>0.50</td><td>17.0</td><td>0.76</td><td>0.61</td></tr><tr><td>LDAM</td><td>34.4</td><td>0.53</td><td>0.51</td><td>55.1</td><td>0.28</td><td>0.38</td><td>31.9</td><td>0.53</td><td>0.54</td><td>13.9</td><td>0.81</td><td>0.63</td></tr><tr><td>RIDE + LDAM</td><td>40.5</td><td>0.50</td><td>0.42</td><td>60.5</td><td>0.28</td><td>0.30</td><td>38.7</td><td>0.50</td><td>0.44</td><td>20.1</td><td>0.74</td><td>0.52</td></tr></table>",
+        "bbox": [
+            174,
+            102,
+            821,
+            199
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(a) Comparisons of the mean accuracy, per-class bias and variance of baselines and our RIDE method. Better (worse) metrics than the distribution-unaware cross entropy (CE) reference are marked in green (red). ",
+        "bbox": [
+            173,
+            205,
+            821,
+            231
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/1b1cf846f346b6cdd587ca59d616df0ee927280983b0f7037c4506e0f6a87532.jpg",
+        "image_caption": [
+            "(b) Histograms of the largest softmax score of the other classes (the hardest negative) per instance. ",
+            "Figure 1: Our method RIDE outperforms SOTA by reducing both model bias and variance. a) These metrics are evaluated over 20 independently trained models, each on a random sampled set of CIFAR100 with an imbalance ratio of 100 and 300 samples for class 0. Compared to the standard head performance loss from increased classifier variance. The low tail perfor-CE classifier, existing SOTA methods almost always increase the variance and some reduce the tail mance manifests itself in large between-class confusion and high classifier vari-bias at the cost of increasing the head bias. b) The metrics are evaluated over CIFAR100-LT Liu ance. We aim to reduce both the bias and the variance of a long-tailed classifieret al. (2019). LDAM is more likely to confuse the tail (rather than head) classes with the hardest by RoutIng Diverse Experts (RIDE). It has three components: 1) a shared archi-negative class, with an average score of 0.59. RIDE with LDAM can greatly reduce the confusion tecture for multiple classifiers (experts); 2) a distribution-aware diversity loss thatwith the nearest negative class, especially for samples from the few-shot categories. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            238,
+            820,
+            332
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "to additional expertConsider the training data $D$ With on-par computational complexity, RIDE significantlyas a random variable. The prediction error of model $h$ on instance $x$ outwith output $Y$ forms the state-of-the-art methodvaries with the realization of $D$ y 5% to 7% on all the benchmarks in-. The expected variance with respect to variable $D$ cluding CIFAR100-LT, ImageNet-LT andhas a well-known bias-variance decomposition: ",
+        "bbox": [
+            173,
+            497,
+            825,
+            540
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d456d2e6152dcecb364cef8b2a36eda341b097599bccfc5646aa530c4c639cb4.jpg",
+        "text": "$$\n\\operatorname { E r r o r } ( x ; h ) = E [ ( h ( x ; D ) - Y ) ^ { 2 } ] = \\operatorname { B i a s } ( x ; h ) + \\operatorname { V a r i a n c e } ( x ; h ) + { \\mathrm { i r r e d u c i b l e ~ e r r o r } } ( x ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            196,
+            542,
+            781,
+            560
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For the above L2 loss on regression $h ( x )  Y$ , the model bias measures the accuracy of the prediction with respect to the true value, the variance measures the stability of the prediction, and the irreducible error measures the precision of the prediction and is irrelevant to the model $h$ . ",
+        "bbox": [
+            176,
+            564,
+            823,
+            607
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Empirically, for $n$ random sample sets of data, $D ^ { ( 1 ) } , \\ldots , D ^ { ( n ) }$ , the $k$ -th model trained on $D ^ { ( k ) }$ The natupredicts $y ^ { ( k ) }$ ata we encou on instance $x$ er in practice often has a long tail distribution: A, and collectively they have a mean prediction $y _ { m }$ classes contain. For the L2 regression many instances, while most classes contain only a feloss, the model bias is simply the L2 loss between $y _ { m }$ stances. Learningand ground-truth $t = E [ Y ]$ ation among, whereas the model them is challenging, as the fvariance is the variance of $y ^ { ( k ) }$ il instances can be easily overwith respect to their mean $y _ { m }$ l: ",
+        "bbox": [
+            174,
+            612,
+            823,
+            674
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cc97362fbc6e41a7680904b5d96a98055cd18adb96ca3ac3c608c656a3637bc9.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\displaystyle \\mathcal { L } ( y ; z ) = ( y - z ) ^ { 2 } } \\\\ { \\displaystyle y _ { m } = \\frac { 1 } { n } \\sum _ { k = 1 } ^ { n } y ^ { ( k ) } } & { ~ = \\mathrm { a r g } \\operatorname* { m i n } _ { z } E _ { D } [ \\mathcal { L } \\left( h ( x ) ; z ) \\right] } \\\\ { \\displaystyle \\mathrm { B i a s } ( x ; h ) = ( y _ { m } - t ) ^ { 2 } } & { ~ = \\mathcal { L } \\left( y _ { m } ; t \\right) } \\\\ { \\displaystyle \\mathrm { V a r i a n c e } ( x ; h ) = \\frac { 1 } { n } \\sum _ { k = 1 } ^ { n } \\left( y ^ { ( k ) } - y _ { m } \\right) ^ { 2 } } & { ~ = E _ { D } [ \\mathcal { L } \\left( h ( x ) ; y _ { m } \\right) ] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            675,
+            787,
+            801
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We analyze the performance of a long-tail classifier in terms of bias and variance with respectAs shown on the above right, these concepts can be expressed entirely in terms of L2 loss $\\mathcal { L }$ . We can fluctuations in the training set: We randomly sample CIFAR100 (Krizhevthus extended them to classification (Domingos, 2000) by replacing $\\mathcal { L }$ y, 200 with $\\mathcal { L } _ { 0 - 1 }$ cording to afor classification: ",
+        "bbox": [
+            176,
+            803,
+            823,
+            832
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The mean prediction $y _ { m }$ minimizes $\\begin{array} { r } { \\sum _ { k = 1 } ^ { n } \\mathcal { L } _ { 0 - 1 } \\left( y ^ { ( k ) } ; y _ { m } \\right) } \\end{array}$ and becomes the most often or main prediction. The bias and variance terms become $\\mathcal { L } _ { 0 - 1 } ( y _ { m } ; t )$ and $\\begin{array} { r } { \\frac { 1 } { n } \\sum _ { k = 1 } ^ { n } \\mathcal { L } _ { 0 - 1 } ( y ^ { ( k ) } ; y _ { m } ) } \\end{array}$ respectively. ",
+        "bbox": [
+            176,
+            856,
+            823,
+            890
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We apply such bias and variance analysis to the CE and long-tail classifiers. We sample CIFAR100 (Krizhevsky, 2009) according to a long-tail distribution multiple times. For each method, we train a model per long-tail sampled dataset and then estimate the per-class bias and variance over these multiple models on the balanced test set of CIFAR100-LT Liu et al. (2019). Fig. 1a shows that: ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1. On the model bias: The head bias is significantly smaller than the tail bias, at 0.3 vs. 0.9 for CE. All the existing long-tail methods reduce the overall bias by primarily reducing the tail bias. However, the head-tail bias gap remains large at 0.3 vs. 0.8.   \n2. On the model variance: All the existing long-tail methods increase the model variance across all class splits, with a slight reduction in the medium-shot variance for cRT. ",
+        "bbox": [
+            173,
+            143,
+            825,
+            217
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "That is, existing long-tail methods reduce the model bias for the tail at the cost of increased model variance for all the classes, and the head-tail model bias gap remains large. ",
+        "bbox": [
+            173,
+            229,
+            823,
+            257
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We conduct further statistical analysis to understand the head-tail model bias gap. We examine the largest softmax score in the other classes of $\\{ c : c \\neq t \\}$ , where $t$ is the ground-truth class of an instance. The smaller this hardest negative score is, the less the confusion, and the lower the model bias. Fig. 1b shows that there is increasingly more and larger confusion from the head to the tail. ",
+        "bbox": [
+            174,
+            265,
+            825,
+            320
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Guided by our model bias/variance and confusion pattern analysis, we propose a new long-tail classifier with four distinctive features: 1) It reduces the model variance for all the classes with multiple experts. 2) It reduces the model bias for the tail with an additional distribution-aware diversity loss. 3) It reduces the computational complexity that comes with multiple experts with a dynamic expert routing module which deploys another trained distinctive expert for a second (or third, ...) opinion only when it is called for. 4) The routing module and a shared architecture for experts of reduced complexity effectively cut down the computational cost of our multi-expert model, to a level that could be even lower than the commonly adopted baseline with the same backbone. ",
+        "bbox": [
+            174,
+            327,
+            825,
+            439
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our so-called RoutIng Diverse Experts (RIDE) not only reduces the model variance for all the classes, but also significantly reduces the model bias for the tail classes and increases the mean accuracies for all class splits, all of which existing long-tail methods fail to accomplish. ",
+        "bbox": [
+            174,
+            445,
+            825,
+            488
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "RIDE delivers $5 \\% \\sim 7 \\%$ higher accuracies than the current SOTA methods on CIFAR100-LT, ImageNet-LT (Liu et al., 2019) and iNaturalist (Van Horn et al., 2018). RIDE is also a universal framework that can be applied to different backbone networks for improving existing long-tail algorithms such as focal loss (Lin et al., 2017), LDAM (Cao et al., 2019), $\\tau$ -norm (Kang et al., 2020). ",
+        "bbox": [
+            174,
+            494,
+            823,
+            550
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            570,
+            380,
+            587
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Few-shot learning. To generalize from small training data, meta-learning (Bertinetto et al., 2016; Ravi & Larochelle, 2017; Santoro et al., 2016; Finn et al., 2017; Yang et al., 2018) and data augmentation/generation are two most studied approaches (Chen et al., 2019; Schwartz et al., 2018; Zhang et al., 2019; Liu et al., 2018). Matching Network (Vinyals et al., 2016) and Prototypical Network (Snell et al., 2017) learn discriminative features that can be transferred to new classes through meta-learners without big training data. Hariharan & Girshick (2017), Wang et al. (2018) and Liu et al. (2018) utilize samples from a generative model to augment the training data. However, fewshot learning relies on balanced training data, whereas long-tail recognition has to deal with highly imbalanced training data, e.g., from hundreds in the head to a few instances in the tail. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            728
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Re-balancing/re-weighting. A direct approach to achieve sample balance is to under- or oversample training instances according to their class sizes (He & Garcia, 2009). Another option is data augmentation, where additional samples are generated to supplement tail classes, sometimes directly in the feature space (Liu et al., 2020; Chu et al., 2020; Kim et al., 2020). Re-weighting modifies the loss function and puts larger weights on tail classes (Lin et al., 2017; Cui et al., 2019; Cao et al., 2019; Wu et al., 2020) or randomly ignoring gradients from head classes (Tan et al., 2020). However, both sample-wise and loss-wise balancing focus on tail classes, resulting in more sensitivity to fluctuations in the small tail classes and thus much increased model variances (Fig. 1a). ",
+        "bbox": [
+            173,
+            736,
+            825,
+            847
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Knowledge transfer. OLTR (Liu et al., 2019) and inflated memory (Zhu & Yang, 2020) use memory banks to store and transfer mid- and high-level features from head to tail classes, enhancing feature generalization for the tail. However, this line of work (Liu et al., 2019; Zhu & Yang, 2020; Kang et al., 2020; Jamal et al., 2020; Wang et al., 2017) usually does not have effective control over the knowledge transfer process, often resulting in head performance loss. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Ensembling and grouping. One way to counter imbalance is to separate training instances into different groups based their class sizes. Models trained on individual groups are ensembled together in a multi-expert framework. BBN (Zhou et al., 2020) adaptively fuses two-branches that each focus on the head and the tail respectively. LFME (Xiang et al., 2020) distills multiple teacher models into a unified model, each teacher focusing on a relatively balanced group such as many-shot classes, medium-shot classes, and few-shot classes. BBN and LFME still lose head performance and overall generalizability, as no expert has a balanced access to the entire dataset. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our RIDE is a non-traditional ensemble method. 1) Its experts have shared earlier layers and reduced later channels, less prone to small tail overfitting. 2) Its experts are jointly optimized. 3) It deploys experts on an as-needed basis for individual instances with a dynamic expert assignment module. 4) It reaches higher accuracies with a smaller model complexity and computational cost. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            265
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 RIDE: ROUTING DIVERSE DISTRIBUTION-AWARE EXPERTS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            285,
+            704,
+            303
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We propose a novel multi-expert model (Fig. 2) with shared earlier layers $f _ { \\theta }$ and $n$ independent channel-reduced later layers $\\Psi = \\{ \\psi _ { \\theta _ { 1 } } , . . . , \\psi _ { \\theta _ { n } } \\}$ . They are jointly optimized at Stage 1 and dynamically deployed with a learned expert assignment module at Stage 2. At the inference time, all the $m$ active experts are averaged together in their logits for final ensemble softmax classification: ",
+        "bbox": [
+            174,
+            316,
+            825,
+            373
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/86ff879e2e4553da7ea865b051bb87f9860ca5af8add36cd9dbae870f5a51980.jpg",
+        "text": "$$\n\\mathbf { p } = \\mathrm { s o f t m a x } \\left( \\frac { 1 } { m } \\sum _ { i = 1 } ^ { m } \\psi _ { \\theta _ { i } } \\left( f _ { \\theta } ( x ) \\right) \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            381,
+            624,
+            424
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Softmax of the average logits is equivalent to the product of individual classification probabilities, which approximates their joint probability if individual experts makes independent decisions. ",
+        "bbox": [
+            173,
+            431,
+            823,
+            459
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Experts with a shared early backbone and reduced later channels. Consider $n$ independent experts of the same convolutional neural network (CNN) architecture. Since early layers of a CNN tend to encode generic low-level features, we adopt the common practice in transfer learning and have all the $n$ experts share the same backbone $f _ { \\theta }$ . Each expert retains independent later layers $\\psi _ { \\boldsymbol { \\theta } _ { i } }$ , $i = 1 , \\ldots , n$ . To reduce overfitting to small training data in the tail classes, we reduce the number of filter channels in $\\psi _ { \\theta _ { i } }$ , e.g., by $1 / 4$ . All these $n$ experts are trained together on long-tailed data distribution-aware diversity loss $\\mathcal { L } _ { \\mathrm { D } }$ -Diversify and classification loss $\\mathcal { L } _ { \\mathrm { C l a s s i f y } }$ , such as CE and LDAM. ",
+        "bbox": [
+            173,
+            465,
+            825,
+            564
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Individual expert classification loss. One way to combine multiple experts is to apply the classification loss to the aggregated logits of individual experts. While this idea works for several recently proposed multi-expert models (Zhou et al., 2020; Xiang et al., 2020), it does not work for our shared experts: Its performance is on-par with an equal-sized single-expert model. Let $\\mathcal { L }$ denote the classification loss (e.g. CE) over instance $x$ and its label $y$ . We call such an aggregation loss collaborative: ",
+        "bbox": [
+            173,
+            570,
+            825,
+            627
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/0d63952f3af398ad49a8d8ddd426a0d1eab5f99c76968cf24f009158bc101969.jpg",
+        "image_caption": [
+            "Figure 2: RIDE learns experts and their router in two stages. a) We first jointly optimize multiple experts with individual classification losses and mutual distribution-aware diversity losses. b) We then train a router that dynamically assigns ambiguous samples to additional experts on an as-needed basis. The distribution of instances seen by each expert shows that head instances need fewer experts and the imbalance between classes gets reduced for later experts. At the test time, we collect the logits of assigned experts to make a final decision. c) RIDE outperforms SOTA methods (i.e. LFME (Xiang et al., 2020) for CIFAR100-LT, LWS (Kang et al., 2020) for ImageNet-LT and BBN (Zhou et al., 2020) for iNaturalist) on all the benchmarks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            650,
+            823,
+            801
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            102,
+            823,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ecf8313c4b59e5378af2bbb8225487f87fb0a8fd9f7053e6879b3dc21b612012.jpg",
+        "text": "$$\n\\mathcal { L } ^ { \\mathrm { c o l l a b o r a t i v e } } ( x , y ) = \\mathcal { L } \\left( \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } \\psi _ { \\theta _ { i } } \\left( f _ { \\theta } ( x ) \\right) , y \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            125,
+            653,
+            167
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "as it leads to correlated instead of complementary experts. To discourage correlation, we require each expert to do the job well by itself. Such an aggregation loss is essentially an individual loss, and it contributes a large portion of our performance gain in most of our experiments: ",
+        "bbox": [
+            174,
+            174,
+            825,
+            217
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fa0e3550101c76d64a4aec4485ac5ebb6390c5e9fe4cc2e60246e829f1a9f8a9.jpg",
+        "text": "$$\n\\mathcal { L } ^ { \\mathrm { i n d i v i d u a l } } ( x , y ) = \\sum _ { i = 1 } ^ { n } \\mathcal { L } \\left( \\psi _ { \\theta _ { i } } \\left( f _ { \\theta } ( x ) \\right) , y \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            223,
+            635,
+            265
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Distribution-aware diversity loss. The individual classification loss and random initialization lead to diversified experts with a shared backbone. For long-tailed data, we add a regularization term to encourage complementary decisions from multiple experts. That is, we maximize the KL-divergence between different experts’ classification probabilities on instance $x$ in class $y$ over a total of $c$ classes: ",
+        "bbox": [
+            174,
+            270,
+            823,
+            328
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2d867ff75a0ff5f86155415b5bfb9f9950f7d295b5ff852a4548e7de2e3b4b20.jpg",
+        "text": "$$\n\\begin{array} { r l r l } & { \\mathrm { d i v e r s i t y ~ l o s s : } \\quad } & { \\mathcal { L } _ { \\mathrm { D - D i v e r s i f y } } ( x , y ; \\theta _ { i } ) = \\displaystyle \\frac { - 1 } { n - 1 } \\sum _ { j = 1 , j \\neq i } ^ { n } D _ { \\mathrm { K L } } \\left( \\mathbf { p } ^ { ( i ) } ( x , y ) \\| \\mathbf { p } ^ { ( j ) } ( x , y ) \\right) } \\\\ & { \\mathrm { K L ~ d i v e r g e n c e : } \\quad } & { D _ { \\mathrm { K L } } ( \\mathbf { p } \\| \\mathbf { q } ) = \\displaystyle \\sum _ { k = 1 } ^ { c } \\mathbf { p } _ { k } \\log \\left( \\frac { \\mathbf { p } _ { k } } { \\mathbf { q } _ { k } } \\right) } \\\\ & { \\mathrm { c l a s s i f i c a t i o n ~ b y } \\theta _ { i } : \\quad } & { \\mathbf { p } ^ { ( i ) } ( x , y ) = \\mathrm { s o f t m a x } \\left( \\left[ \\frac { \\psi _ { \\theta _ { i } } ( f _ { \\theta } ( x ) ) _ { 1 } } { T _ { 1 } } \\quad . . . \\quad \\frac { \\psi _ { \\theta _ { i } } ( f _ { \\theta } ( x ) ) _ { c } } { T _ { c } } \\right] \\right) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            187,
+            333,
+            779,
+            449
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We vary the temperature $T$ (or concentration) (Hadsell et al., 2006; Wu et al., 2018) applied to class $k$ ’s logit $\\psi _ { \\boldsymbol { \\theta } _ { i } } ( f _ { \\boldsymbol { \\theta } } ( \\boldsymbol { x } ) ) _ { k }$ : For class $k$ with $n _ { k }$ instances, the smaller the $n _ { k }$ , the lower the temperature $T _ { k }$ , the more sensitive the classification probability $\\mathbf { p }$ is to a change in the feature $\\psi$ . Specifically, ",
+        "bbox": [
+            174,
+            453,
+            826,
+            496
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "class-wise temperature: ",
+        "bbox": [
+            267,
+            512,
+            424,
+            527
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "normalized class size: ",
+        "bbox": [
+            267,
+            542,
+            413,
+            558
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fd058a7abbc2be72ddb1f18819c8d1464f41b6118d4588c5d07d42605ced1462.jpg",
+        "text": "$$\n\\begin{array} { r l } & { T _ { k } = \\alpha \\left( \\beta _ { k } + 1 - \\underset { j } { \\operatorname* { m a x } } \\beta _ { j } \\right) } \\\\ & { \\beta _ { k } = \\gamma \\cdot \\frac { n _ { k } } { \\frac { 1 } { c } \\sum _ { s = 1 } ^ { c } n _ { s } } + ( 1 - \\gamma ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            514,
+            502,
+            730,
+            571
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$T$ scales linearly with the class size, ensuring $\\beta _ { k } = 1 , T _ { k } = \\alpha$ for a balanced set. This simple adaptation allows us to find classifiers of enough complexity for the head and enough robustness for the tail: On one hand, we need strong classifiers to handle large sample variations within head classes; on the other hand, such classifiers are prone to overfit small training data within tail classes. We adapt the temperature only after the CNN network is trained for several epochs and the feature is stabilized, similar to the training scheme for deferred reweighting (Cao et al., 2019). ",
+        "bbox": [
+            173,
+            575,
+            825,
+            661
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Joint expert optimization. For our $n$ experts $\\theta _ { 1 }$ , . . . , $\\theta _ { n }$ with a shared backbone $\\theta$ , we optimize their individual classification losses ${ \\mathcal { L } } _ { \\mathrm { C l a s s i f y } } = { \\mathcal { L } }$ , any classification loss such as CE, LDAM, and focal loss) and their mutual distribution-aware divergency losses, weighted by hyperparameter $\\lambda$ : ",
+        "bbox": [
+            173,
+            666,
+            825,
+            709
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/27618f1031b0366f0aff1a10ff3bd9c301c3d00370b18cc77fe9ce00b98f15f3.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { T o t a l } } ( x , y ) = \\sum _ { i = 1 } ^ { n } \\left( \\mathcal { L } _ { \\mathrm { C l a s s i f y } } ( x , y ; \\theta _ { i } ) + \\lambda \\cdot \\mathcal { L } _ { \\mathrm { D - D i v e r s i f y } } ( x , y ; \\theta _ { i } ) \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            715,
+            710,
+            757
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Since these loss terms are completely symmetrical with respect to each other, the $n$ experts learned at Stage 1 are equally good and distinctive from each other. ",
+        "bbox": [
+            173,
+            763,
+            823,
+            792
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Routing diversified experts. To cut down the test-time computational cost that comes with multiple experts, we train a router at Stage 2 to deploy these (arbitrarily ordered) experts sequentially on an as-needed basis. Assume that the first $k$ experts have been deployed for instance $x$ . The router takes in the image feature and the mean logits from the first to the $k$ -th expert, and makes a binary decision $y _ { \\mathrm { o n } }$ on whether to deploy the $k + 1$ -th expert. If the $k$ -th expert wrongly classifies $x$ , but one of the rest $n - k$ experts correctly classifies $x$ , ideally the router should switch on, i.e., output $y _ { \\mathrm { o n } } = 1$ , and otherwise $y _ { \\mathrm { o n } } = 0$ . We construct a simple binary classifier with two fully connected layers to learn each router. Each of the $n - 1$ routers for $n$ experts has a shared component to reduce the feature dimensions and an individual component to make decisions. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Specifically, we normalize the image feature $f _ { \\boldsymbol { \\theta } } ( \\boldsymbol { x } )$ (for training stability), reduce the feature dimension (to e.g. 16 in our experiments) by a fully connected layer $\\mathbf { W } _ { 1 }$ which is shared with all routers, followed by ReLU and flattening, concatenate with the top- $s$ ranked mean logits from the first to $k$ - th expert $\\textstyle { \\frac { 1 } { k } } \\sum _ { i = 1 } ^ { k } \\psi _ { \\theta _ { i } } ( f _ { \\theta } ( x ) )$ , project it to a scalar by $\\mathbf { W } _ { 2 } ^ { ( k ) }$ which is independent between routers, and finally apply Sigmoid function $\\begin{array} { r } { S ( x ) = \\frac { 1 } { 1 + e ^ { - x } } } \\end{array}$ to get a continuous activation value in [0,1]: ",
+        "bbox": [
+            173,
+            102,
+            825,
+            181
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c9041762c812a29be0eeb2d2cd2b33a3d59b73dc23c100ef3e205aa756676fe5.jpg",
+        "text": "$$\n\\mathrm { r o u t e r \\ a c t i v a t i o n ; } \\ r ( x ) = S \\left( \\mathbf { W } _ { 2 } ^ { ( k ) } \\left[ \\begin{array} { c } { \\mathrm { f a t t e n } \\cdot \\mathrm { R e L U } \\left( \\mathbf { W } _ { 1 } \\frac { f _ { \\theta } ( x ) } { \\vert \\vert f _ { \\theta } ( x ) \\vert \\vert } \\right) } \\\\ { \\frac { 1 } { k } \\sum _ { i = 1 } ^ { k } \\psi _ { \\theta _ { k } } ( f _ { \\theta } ( x ) ) \\vert _ { \\mathrm { t o p } \\cdot s \\cdot \\mathrm { c o m p o n e n t s } } } \\end{array} \\right] \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            248,
+            188,
+            746,
+            233
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The router has a negligible size and compute, where $s$ ranges from 30 for CIFAR100 to 50 for iNaturalist (8,142 classes). It is optimized with a weighted variant of binary CE loss: ",
+        "bbox": [
+            173,
+            238,
+            823,
+            267
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/25e29ddc6d40f26f304073bb72ce1bdba8efb9cdaa6b5dff5436ba071e4cec22.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { R o u t i n g } } ( r ( x ) , y _ { \\mathrm { o n } } ) = - \\omega _ { \\mathrm { o n } } y _ { \\mathrm { o n } } \\log \\left( r ( x ) \\right) - ( 1 - y _ { \\mathrm { o n } } ) \\log \\left( 1 - r ( x ) \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            274,
+            273,
+            723,
+            291
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\omega _ { \\mathrm { o n } }$ controls the easiness to switch on the router. We find $\\omega _ { \\mathrm { o n } } = 1 0 0$ to be a good trade-off between classification accuracy and computational cost for all our experiments. At the test time, we simply threshold the activation with 0.5: If $r ( x ) < 0 . 5$ , the classifier makes the final decision with the current collective logits, otherwise it proceeds to the next expert. ",
+        "bbox": [
+            173,
+            297,
+            825,
+            354
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Optional self-distillation. While existing long-tail classifiers such as BBN Zhou et al. (2020) and LFME Xiang et al. (2020) have a fixed number of experts, our method could have an arbitrary number of experts to balance classification accuracy and computation cost. We can optionally apply self-distillation from a model with more (6 in our setting) experts to the same model with fewer experts for further performance gain $0 . 4 \\% \\sim 0 . 8 \\%$ for most experiments). We choose knowledge distillation (Hinton et al., 2015) by default. Implementation details and comparisons with various distillation algorithms such as CRD (Tian et al., 2019) are investigated in Appendix Section A.2. ",
+        "bbox": [
+            173,
+            359,
+            825,
+            458
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            478,
+            326,
+            494
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We experiment on major long-tailed recognition benchmarks and various backbone networks. ",
+        "bbox": [
+            174,
+            510,
+            785,
+            525
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1. CIFAR100-LT (Cao et al., 2019): CIFAR100 is sampled by class per an exponential decay across classes. We choose imbalance factor 100 and ResNet-32 (He et al., 2016) backbone. ",
+        "bbox": [
+            174,
+            536,
+            823,
+            564
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "2. ImageNet-LT (Liu et al., 2019): Multiple backbone networks are experimented on ImageNetLT, including ResNet-10, ResNet-50 and ResNeXt-50 (Xie et al., 2017). All backbone networks are trained with a batch size of 256 on 8 RTX 2080Ti GPUs for 100 epochs using SGD with an initial learning rate of 0.1 decayed by 0.1 at 60 epochs and 80 epochs. See more details and results on other backbones in Appendix. ",
+        "bbox": [
+            174,
+            566,
+            825,
+            636
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3. iNaturalist 2018 (Van Horn et al., 2018): It is a naturally imbalanced fine-grained dataset with 8,142 categories. We use ResNet-50 as the backbone and apply the same training recipe as for ImageNet-LT except batch size 512, as in (Kang et al., 2020). ",
+        "bbox": [
+            178,
+            638,
+            823,
+            681
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "CIFAR100-LT Results. Table 1 shows that RIDE outperforms SOTA by a large margin on CIFAR100-LT. The average computational cost is even about $10 \\%$ less than baseline models with two experts as in BBN. RIDE surpasses multi-expert methods, LFME (Xiang et al., 2020) and BBN (Zhou et al., 2020), by more than $5 . 3 \\%$ and $6 . 5 \\%$ respectively. ",
+        "bbox": [
+            173,
+            693,
+            825,
+            750
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/93ea4d77db3384af3de52450596f2d525a817497ee8de8c71fb7fc30f3af19a8.jpg",
+        "image_caption": [
+            "Figure 3: RIDE is a universal framework that can be extended to various long-tail recognition methods and obtain a consistent top-1 accuracy increase. RIDE is experimented on CIFAR100- LT and applied to various training mechanisms. By using RIDE, cross-entropy loss (without any re-balancing strategies) can even outperforms previous SOTA method on CIFAR100-LT. Although higher accuracy can be obtained using distillation, we did not apply it here. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            767,
+            477,
+            922
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/df7986dba57577abeabffc08f5fc8623f0d47f24b0e4ace2df45d9f4c5e14044.jpg",
+        "table_caption": [
+            "Table 1: RIDE achieves the state-of-the-art results on CIFAR100-LT without sacrificing the performance of many-shot classes like all previous methods. Compared with BBN (Zhou et al., 2020) and LFME (Xiang et al., 2020), which also contain multiple experts (or branches), RIDE (2 experts) outperforms them by a large margin with fewer GFlops. The relative computation cost (averaged on testing set) with respect to the baseline model and absolute improvements against SOTA (colored in green) are reported. $\\dagger$ denotes our reproduced results with released code. $\\ddagger$ denotes results copied from (Cao et al., 2019) and the imbalance ratio is 100. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=2>Methods</td><td rowspan=1 colspan=1>MFlops</td><td rowspan=1 colspan=1>All</td><td rowspan=1 colspan=4>Many</td><td rowspan=1 colspan=1>Med</td><td rowspan=1 colspan=1>Few</td></tr><tr><td rowspan=1 colspan=2>Cross Entropy (CE) tCross Entropy (CE) t</td><td rowspan=1 colspan=1>69.5 (1.0x)69.5 (1.0x)</td><td rowspan=1 colspan=1>38.339.1</td><td rowspan=1 colspan=4>166.1</td><td rowspan=1 colspan=1>-37.3</td><td rowspan=1 colspan=1>110.6</td></tr><tr><td rowspan=6 colspan=2>Focal Loss t (Lin et al., 2017)OLTR † (Liu et al., 2019)LDAM + DRW (Cao et al.,2019)LDAM + DRW + (Cao et al., 2019)BBN (Zhou et al., 2020)T-norm t (Kang et al., 2020)cRT + (Kang et al., 2020)M2m (Kim et al., 2020)LFME (Xiang et al., 2020)</td><td rowspan=6 colspan=1>69.5 (1.0x)69.5 (1.0x)69.5 (1.0x)74.3 (1.1x)69.5 (1.0x)69.5 (1.0x)11</td><td rowspan=5 colspan=1>38.441.242.042.042.643.243.343.5</td><td rowspan=2 colspan=4>161.8161.5</td><td rowspan=2 colspan=1>141.4-41.7</td><td rowspan=1 colspan=1>117.61</td></tr><tr><td rowspan=1 colspan=1>20.2</td></tr><tr><td rowspan=4 colspan=4>165.764.011</td><td rowspan=1 colspan=1>-43.6</td><td rowspan=4 colspan=1>■17.318.111</td></tr><tr><td rowspan=1 colspan=1>44.8</td></tr><tr><td rowspan=2 colspan=1>11</td></tr><tr><td rowspan=1 colspan=1>43.8</td><td rowspan=1 colspan=2>1</td></tr><tr><td rowspan=1 colspan=1>RIDE (2 experts)RIDE (3 experts)RIDE (4 experts)</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>64.8 (0.9x)77.8 (1.1x)91.9 (1.3x)</td><td rowspan=1 colspan=1>47.0 (+3.2)48.0 (+4.2)49.1 (+5.3)</td><td rowspan=1 colspan=3>67.9</td><td rowspan=1 colspan=2>67.968.169.3</td><td rowspan=1 colspan=1>48.449.249.3</td></tr></table>",
+        "bbox": [
+            183,
+            209,
+            813,
+            424
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/84213c61afdf462e5fbdb1fceb3614a0fa3a0abe4212422587f9e6d114dc56c1.jpg",
+        "table_caption": [
+            "Table 2: RIDE achieves state-of-the-art results on ImageNet-LT (Liu et al., 2019) and obtains consistent performance improvements on various backbones. The top-1 accuracy and computational cost are compared with the state-of-the-art methods on ImageNet-LT, with ResNet-50 and ResNeXt50 as the backbone networks. Results marked with $\\dagger$ are copied from (Kang et al., 2020). Detailed results on each split are listed in appendix materials. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Methods</td><td colspan=\"2\">ResNet-50</td><td colspan=\"2\">ResNeXt-50</td></tr><tr><td>GFlops</td><td>Acc. (%)</td><td>GFlops</td><td>Acc. (%)</td></tr><tr><td>Cross Entropy (CE) t</td><td>4.11 (1.0x)</td><td>41.6</td><td>4.26 (1.0x)</td><td>44.4</td></tr><tr><td>OLTR † (Liu et al., 2019)</td><td></td><td>、</td><td></td><td>46.3</td></tr><tr><td>NCM (Kang et al., 2020)</td><td>4.11 (1.0x)</td><td>44.3</td><td>4.26 (1.0x)</td><td>47.3</td></tr><tr><td>T-norm (Kang et al.,2020)</td><td>4.11 (1.0x)</td><td>46.7</td><td>4.26 (1.0x)</td><td>49.4</td></tr><tr><td>cRT (Kang et al., 2020)</td><td>4.11 (1.0x)</td><td>47.3</td><td>4.26 (1.0x)</td><td>49.6</td></tr><tr><td>LWS (Kang et al., 2020)</td><td>4.11 (1.0x)</td><td>47.7</td><td>4.26 (1.0x)</td><td>49.9</td></tr><tr><td>RIDE (2 experts)</td><td>3.71 (0.9x)</td><td>54.4 (+6.7)</td><td>3.92 (0.9x)</td><td>55.9 (+6.0)</td></tr><tr><td>RIDE (3 experts)</td><td>4.36 (1.1x)</td><td>54.9 (+7.2)</td><td>4.69 (1.1x)</td><td>56.4 (+6.5)</td></tr><tr><td>RIDE (4 experts)</td><td>5.15 (1.3x)</td><td>55.4 (+7.7)</td><td>5.19 (1.2x)</td><td>56.8 (+6.9)</td></tr></table>",
+        "bbox": [
+            187,
+            526,
+            808,
+            686
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "RIDE as a universal framework. Fig. 3 shows that RIDE consistently benefits from better loss functions and training processes. Whether the model is trained end-to-end (focal loss, CE, LDAM) or in two stages (cRT, $\\tau$ -norm, cosine), RIDE delivers consistent accuracy gains. In particular, RIDE with a simple cosine classifier, which we constructed by normalizing the classifier weights and retraining them with a long-tail re-sampling strategy (similar to cRT), achieves on-par performance with the current SOTA methods. Fig. 3 also shows that two-stage methods are generally better than single-stage ones. Nevertheless, since they require an additional training stage, for simplicity, we use the single-stage LDAM as the default $\\mathcal { L } _ { \\mathrm { C l a s s i f y } }$ in RIDE throughout our remaining experiments. ",
+        "bbox": [
+            173,
+            699,
+            825,
+            813
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "ImageNet-LT Results. Table 2 shows that RIDE outperforms SOTA, LWS and cRT, by more than $7 . 7 \\%$ with ResNet-50. ResNeXt-50 is based on group convolution (Xie et al., 2017), which divides all filters into several groups and aggregates information from multiple groups. ResNeXt-50 generally performs better than ResNet-50 on multiple tasks. It provides $6 . 9 \\%$ gain on ImageNet-LT. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "iNaturalist 2018 Results. Table 3 shows that RIDE outperforms current SOTA by $6 . 3 \\%$ . Surprisingly, RIDE obtains very similar results on many-shots, medium-shots and few-shots, ideal for long tailed recognition. Current SOTA method BBN also uses multiple experts; however, it significantly decreases the performance on many-shots by about $23 \\%$ . RIDE is remarkable at increasing the few-shot accuracy without reducing the many-shot accuracy. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/19c27112fd3b0a560438f8a2135d5c8c963afd8b2ceb57b3d23fd919f267269f.jpg",
+        "table_caption": [
+            "Table 3: RIDE outperforms previous state-of-the-art methods on challenging iNaturalist 2018 (Van Horn et al., 2018) dataset, which contains 8,142 classes, by a large margin. Relative improvements to SOTA result of each split (colored with gray) are also listed, with the largest boost from few-shot classes. Compared with previous SOTA method BBN, which also contains multiple “experts”, RIDE achieves more than $20 \\%$ higher top-1 accuracy on many-shot classes. Results marked with $\\dagger$ are from BBN (Zhou et al., 2020) and Decouple (Kang et al., 2020). BBN’s results are from the released checkpoint. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td>GFlops</td><td>All</td><td>Many</td><td>Medium</td><td>Few</td></tr><tr><td>CE+</td><td>4.14 (1.0x)</td><td>61.7</td><td>72.2</td><td>63.0</td><td>57.2</td></tr><tr><td>CB-Focal t</td><td>4.14 (1.0x)</td><td>61.1</td><td>1</td><td>1</td><td>1</td></tr><tr><td>OLTR</td><td>4.14 (1.0x)</td><td>63.9</td><td>59.0</td><td>64.1</td><td>64.9</td></tr><tr><td>LDAM + DRW †</td><td>4.14 (1.0x)</td><td>64.6</td><td>1</td><td>1</td><td>1</td></tr><tr><td>cRT</td><td>4.14 (1.0x)</td><td>65.2</td><td>69.0</td><td>66.0</td><td>63.2</td></tr><tr><td>T-norm</td><td>4.14 (1.0x)</td><td>65.6</td><td>65.6</td><td>65.3</td><td>65.9</td></tr><tr><td>LWS</td><td>4.14 (1.0x)</td><td>65.9</td><td>65.0</td><td>66.3</td><td>65.5</td></tr><tr><td>BBN</td><td>4.36 (1.1x)</td><td>66.3</td><td>49.4</td><td>70.8</td><td>65.3</td></tr><tr><td>RIDE (2 experts)</td><td>3.67 (0.9x)</td><td>71.4 4 (+5.1)</td><td>70.2 (+1.2)</td><td>71.3 (+0.5)</td><td>71.7 (+5.8)</td></tr><tr><td>RIDE (3 experts)</td><td>4.17 (1.0x)</td><td>72.2 (+5.9)</td><td>70.2 (+1.2)</td><td>72.2 (+1.4)</td><td>72.7 (+6.8)</td></tr><tr><td>RIDE (4 experts)</td><td>4.51 (1.1x)</td><td>72.6 (+6.3)</td><td>70.9 (+1.9)</td><td>72.4 (+1.6)</td><td>73.1 (+7.2)</td></tr></table>",
+        "bbox": [
+            184,
+            209,
+            812,
+            382
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/b2b3787077638275c5a73098091370295779f41ab43823667b14776dbc013444.jpg",
+        "image_caption": [
+            "Figure 4: Compared to SOTAs, RIDE improves top-1 accuracy on all three splits (many-/med-/fewshot). The absolute accuracy differences of RIDE (blue) over iNaturalist’s current state-of-theart method BBN (Zhou et al., 2020) (left) and ImageNet-LT’s current state-of-the-art method cRT (Kang et al., 2020) (right) are shown. RIDE improves the performance of few- and medium-shots categories without sacrificing the accuracy on many-shots, and outperforms BBN on many-shots by a large margin. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            409,
+            823,
+            525
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            651,
+            823,
+            680
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Comparing with SOTAs on iNaturalist and ImageNet-LT. As illustrated in Fig. 4, our approach provides a comprehensive treatment to all the many-shot, medium-shot and few-shot classes, achieving substantial improvements to current state-of-the-art on all aspects. Compared with cRT which reduces the performance on the many-shot classes, RIDE can achieves significantly better performance on the few-shot classes without impairing the many-shot classes. Similar observations can be obtained in the comparison with the state-of-the-art method BBN (Zhou et al., 2020) on iNaturalist. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            770
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Contribution of each component of RIDE. RIDE is jointly trained with $\\mathcal { L } _ { \\mathrm { D - D i v e r s i f y } }$ and $\\mathcal { L } _ { \\mathrm { C l a s s i f y } }$ , we use LDAM for $\\mathcal { L } _ { \\mathrm { C l a s s i f y } }$ by default. Table 4 shows that the architectural change from the original ResNet-32 to the RIDE variant with $2 \\sim 4$ experts contributes $2 . 7 \\% \\sim 4 . 3 \\%$ gain. Applying the individual classification loss instead of the collaborative loss brings $1 . 5 \\%$ gain. Adding the diversity loss further improves about $0 . 9 \\%$ . The computational cost is greatly reduced by adding the dynamic expert router. Knowledge distillation from RIDE with 6 experts obtains another $0 . 6 \\%$ gain. All these components deliver $7 . 1 \\%$ gain over baseline LDAM. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            875
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Impact of the number of experts. Fig. 5 shows that whether in terms of relative or absolute gains, few-shots benefit more with more experts. For example, the relative gain is $16 \\%$ vs. $3 . 8 \\%$ for few-shots and many-shots respectively. No distillation is applied in this comparison. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Ablation studies on the effectiveness of each component on CIFAR100-LT. LDAM is used as our classification loss. The first 3 RIDE models only have architectural change without changes in training method. The performance without $\\mathcal { L } _ { \\mathrm { { I n d i v i d u a l } } }$ checked indicates directly applying classification loss onto the final model output, which is the mean expert logits. This is referred to as collaborative loss above. In contrast, if $\\mathcal { L } _ { \\mathrm { { I n d i v i d u a l } } }$ if checked, we apply individual loss to each individual expert. The difference between collaborative loss and individual loss is described above. By adding the router module, the computational cost of RIDE can be significantly reduced, while the accuracy degradation is negligible. Knowledge distillation step is optional if further improvements are desired. Various knowledge distillation techniques are compared in the appendix. ",
+        "bbox": [
+            173,
+            92,
+            825,
+            218
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/2604146ecf077b01f67970cfdfd832e7fdf6971321e6c8935454f8549028f8bf.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td>#expert</td><td>LIndividual</td><td>LD-Diversify</td><td>Router</td><td>distill</td><td>GFlops</td><td>Acc.(%)</td></tr><tr><td>LDAM+DRW</td><td>1</td><td></td><td></td><td></td><td></td><td></td><td>42.0</td></tr><tr><td rowspan=\"7\">RIDE</td><td>2</td><td></td><td></td><td></td><td></td><td>1.1x</td><td>44.7 (+2.7)</td></tr><tr><td>3</td><td></td><td></td><td></td><td></td><td>1.5x</td><td>46.1 (+4.1)</td></tr><tr><td>4</td><td></td><td></td><td></td><td></td><td>1.8x</td><td>46.3 (+4.3)</td></tr><tr><td>4</td><td></td><td></td><td></td><td></td><td>1.8x</td><td>47.8 (+5.8)</td></tr><tr><td>4</td><td>&lt;</td><td>√</td><td></td><td></td><td>1.8x</td><td>48.7 (+6.7)</td></tr><tr><td>4</td><td>√</td><td>√</td><td></td><td>1</td><td>1.8x</td><td>49.3 (+7.3)</td></tr><tr><td>4</td><td>√</td><td>&lt;</td><td>√</td><td></td><td>1.3x</td><td>49.1 (+7.1)</td></tr></table>",
+        "bbox": [
+            179,
+            227,
+            818,
+            357
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/8cf6029a1e2ab72917f85036752a1e85a7545e1164698474f0fb18f990efe206.jpg",
+        "image_caption": [
+            "Figure 5: # experts vs. top-1 accuracy for each split (All, Many/Medium/Few) of CIFAR100- LT. Compared with the many-shot split, which is $3 . 8 \\%$ relatively improved by adding more experts, the few-shot split can get more benefits, that is, a relative improvement of $1 6 . 1 \\%$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            386,
+            482,
+            547
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/1631bd4dd73a9a43fc47a06387029dba617d11f1c20c50069ba839f092929c00.jpg",
+        "image_caption": [
+            "Figure 6: The proportion of the number of experts allocated to each split of CIFAR100-LT. For RIDE with 3 or 4 experts, more than half of many-shot instances only require one expert. On the contrary, more than $76 \\%$ samples of few-shot classes require opinions from additional experts. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            504,
+            383,
+            823,
+            547
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The number of experts allocated to each split. Fig. 6 shows that instances in few-shots need more experts whereas most instances in many-shots just need the first expert. That is, low confidence in tail instances often requires the model to seek a second (or a third, ...) opinion. ",
+        "bbox": [
+            176,
+            671,
+            825,
+            713
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 SUMMARY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            741,
+            294,
+            757
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We take a dynamic view of training data and study long-tailed recognition with model bias and variance analysis. Existing long-tail classifiers do not reduce head-tail model bias gap enough while increasing model variance across all the classes. We propose a novel multi-expert model called RIDE to reduce model biases and variances throughout. It trains partially shared diverse distributionaware experts and routes an instance to additional experts when necessary, with computational costs comparable to a single expert. RIDE outperforms SOTA by a large margin. It is also a universal framework that works with various backbones and training schemes for consistent gains. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            875
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments. This work was supported, in part, by Berkeley Deep Drive, US Government fund through Etegent Technologies on Low-Shot Detection and Semi-supervised Detection, and NTU NAP and A\\*STAR via Industry Alignment Fund: Industry Collaboration Projects Grant. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Luca Bertinetto, Joao F Henriques, Jack Valmadre, Philip Torr, and Andrea Vedaldi. Learning feed- ˜ forward one-shot learners. In NeurIPS, 2016. ",
+        "bbox": [
+            171,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaidi Cao, Colin Wei, Adrien Gaidon, Nikos Arechiga, and Tengyu Ma. Learning imbalanced datasets with label-distribution-aware margin loss. In Advances in Neural Information Processing Systems, pp. 1567–1578, 2019. ",
+        "bbox": [
+            174,
+            165,
+            823,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zitian Chen, Yanwei Fu, Yu-Xiong Wang, Lin Ma, Wei Liu, and Martial Hebert. Image deformation meta-networks for one-shot learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 8680–8689, 2019. ",
+        "bbox": [
+            173,
+            218,
+            821,
+            262
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Peng Chu, Xiao Bian, Shaopeng Liu, and Haibin Ling. Feature space augmentation for long-tailed data. arXiv preprint arXiv:2008.03673, 2020. ",
+        "bbox": [
+            171,
+            271,
+            823,
+            301
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yin Cui, Menglin Jia, Tsung-Yi Lin, Yang Song, and Serge Belongie. Class-balanced loss based on effective number of samples. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 9268–9277, 2019. ",
+        "bbox": [
+            173,
+            310,
+            825,
+            354
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 248–255, 2009. ",
+        "bbox": [
+            173,
+            363,
+            825,
+            407
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pedro Domingos. A unified bias-variance decomposition. In Proceedings of 17th International Conference on Machine Learning, pp. 231–238, 2000. ",
+        "bbox": [
+            171,
+            417,
+            823,
+            446
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. arXiv preprint arXiv:1703.03400, 2017. ",
+        "bbox": [
+            171,
+            457,
+            823,
+            486
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Raia Hadsell, Sumit Chopra, and Yann LeCun. Dimensionality reduction by learning an invariant mapping. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 1735–1742, 2006. ",
+        "bbox": [
+            173,
+            496,
+            825,
+            540
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bharath Hariharan and Ross Girshick. Low-shot visual recognition by shrinking and hallucinating features. In Proceedings of the IEEE International Conference on Computer Vision, pp. 3018– 3027, 2017. ",
+        "bbox": [
+            173,
+            549,
+            823,
+            593
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Haibo He and Edwardo A Garcia. Learning from imbalanced data. IEEE Transactions on knowledge and data engineering, 21(9):1263–1284, 2009. ",
+        "bbox": [
+            169,
+            603,
+            823,
+            632
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            173,
+            642,
+            823,
+            685
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015. ",
+        "bbox": [
+            173,
+            695,
+            823,
+            724
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Muhammad Abdullah Jamal, Matthew Brown, Ming-Hsuan Yang, Liqiang Wang, and Boqing Gong. Rethinking class-balanced methods for long-tailed visual recognition from a domain adaptation perspective. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 7610–7619, 2020. ",
+        "bbox": [
+            173,
+            734,
+            825,
+            791
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bingyi Kang, Saining Xie, Marcus Rohrbach, Zhicheng Yan, Albert Gordo, Jiashi Feng, and Yannis Kalantidis. Learning imbalanced datasets with label-distribution-aware margin loss. In International Conference on Learning Representations, pp. 1567–1578, 2020. ",
+        "bbox": [
+            173,
+            801,
+            823,
+            845
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jaehyung Kim, Jongheon Jeong, and Jinwoo Shin. M2m: Imbalanced classification via major-tominor translation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 13896–13905, 2020. ",
+        "bbox": [
+            174,
+            856,
+            821,
+            898
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009. ",
+        "bbox": [
+            169,
+            909,
+            803,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollar. Focal loss for dense ´ object detection. In Proceedings of the IEEE international conference on computer vision, pp. 2980–2988, 2017. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bo Liu, Xudong Wang, Mandar Dixit, Roland Kwitt, and Nuno Vasconcelos. Feature space transfer for data augmentation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 9090–9098, 2018. ",
+        "bbox": [
+            176,
+            155,
+            823,
+            198
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jialun Liu, Yifan Sun, Chuchu Han, Zhaopeng Dou, and Wenhui Li. Deep representation learning on long-tailed data: A learnable embedding augmentation perspective. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 2970–2979, 2020. ",
+        "bbox": [
+            174,
+            207,
+            823,
+            251
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ziwei Liu, Zhongqi Miao, Xiaohang Zhan, Jiayun Wang, Boqing Gong, and Stella X Yu. Largescale long-tailed recognition in an open world. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 2537–2546, 2019. ",
+        "bbox": [
+            176,
+            260,
+            823,
+            303
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hyun Oh Song, Yu Xiang, Stefanie Jegelka, and Silvio Savarese. Deep metric learning via lifted structured feature embedding. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 4004–4012, 2016. ",
+        "bbox": [
+            173,
+            311,
+            825,
+            356
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nikolaos Passalis and Anastasios Tefas. Learning deep representations with probabilistic knowledge transfer. In Proceedings of the European Conference on Computer Vision, pp. 268–284, 2018. ",
+        "bbox": [
+            173,
+            364,
+            823,
+            395
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. In ICLR, 2017. ",
+        "bbox": [
+            171,
+            402,
+            816,
+            419
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy Lillicrap. Metalearning with memory-augmented neural networks. In ICML, 2016. ",
+        "bbox": [
+            171,
+            428,
+            821,
+            457
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Eli Schwartz, Leonid Karlinsky, Joseph Shtok, Sivan Harary, Mattias Marder, Rogerio Feris, Abhishek Kumar, Raja Giryes, and Alex M Bronstein. Delta-encoder: an effective sample synthesis method for few-shot object recognition. arXiv preprint arXiv:1806.04734, 2018. ",
+        "bbox": [
+            176,
+            465,
+            821,
+            510
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In NeurIPS, 2017. ",
+        "bbox": [
+            171,
+            517,
+            823,
+            547
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jingru Tan, Changbao Wang, Buyu Li, Quanquan Li, Wanli Ouyang, Changqing Yin, and Junjie Yan. Equalization loss for long-tailed object recognition. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 11662–11671, 2020. ",
+        "bbox": [
+            173,
+            556,
+            821,
+            601
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yonglong Tian, Dilip Krishnan, and Phillip Isola. Contrastive representation distillation. In International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            173,
+            608,
+            820,
+            638
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Frederick Tung and Greg Mori. Similarity-preserving knowledge distillation. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1365–1374, 2019. ",
+        "bbox": [
+            173,
+            647,
+            823,
+            678
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Grant Van Horn, Oisin Mac Aodha, Yang Song, Yin Cui, Chen Sun, Alex Shepard, Hartwig Adam, Pietro Perona, and Serge Belongie. The iNaturalist species classification and detection dataset. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 8769–8778, 2018. ",
+        "bbox": [
+            173,
+            685,
+            825,
+            742
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Charles Blundell, Tim Lillicrap, and Daan Wierstra. Matching networks for one shot learning. In NeurIPS, 2016. ",
+        "bbox": [
+            169,
+            751,
+            825,
+            781
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yu-Xiong Wang, Deva Ramanan, and Martial Hebert. Learning to model the tail. In Advances in Neural Information Processing Systems, pp. 7029–7039, 2017. ",
+        "bbox": [
+            171,
+            790,
+            823,
+            820
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yu-Xiong Wang, Ross Girshick, Martial Hebert, and Bharath Hariharan. Low-shot learning from imaginary data. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 7278–7286, 2018. ",
+        "bbox": [
+            174,
+            829,
+            823,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tong Wu, Qingqiu Huang, Ziwei Liu, Yu Wang, and Dahua Lin. Distribution-balanced loss for multi-label classification in long-tailed datasets. In Proceedings of the European Conference on Computer Vision, pp. 162–178. Springer, 2020. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            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/CVF Conference on Computer Vision and Pattern Recognition, pp. 3733–3742, 2018. ",
+        "bbox": [
+            176,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Liuyu Xiang, Guiguang Ding, and Jungong Han. Learning from multiple experts: Self-paced knowledge distillation for long-tailed classification. In Proceedings of the European Conference on Computer Vision, pp. 247–263. Springer, 2020. ",
+        "bbox": [
+            176,
+            155,
+            820,
+            198
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Saining Xie, Ross Girshick, Piotr Dollar, Zhuowen Tu, and Kaiming He. Aggregated residual trans-´ formations for deep neural networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 1492–1500, 2017. ",
+        "bbox": [
+            174,
+            207,
+            821,
+            250
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Flood Sung Yongxin Yang, Li Zhang, Tao Xiang, Philip HS Torr, and Timothy M Hospedales. Learning to compare: Relation network for few-shot learning. In CVPR, 2018. ",
+        "bbox": [
+            173,
+            257,
+            818,
+            286
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hongguang Zhang, Jing Zhang, and Piotr Koniusz. Few-shot learning via saliency-guided hallucination of samples. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 2770–2779, 2019. ",
+        "bbox": [
+            174,
+            295,
+            825,
+            338
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xiao Zhang, Zhiyuan Fang, Yandong Wen, Zhifeng Li, and Yu Qiao. Range loss for deep face recognition with long-tailed training data. In Proceedings of the IEEE International Conference on Computer Vision, pp. 5409–5418, 2017. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            390
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Boyan Zhou, Quan Cui, Xiu-Shen Wei, and Zhao-Min Chen. BBN: Bilateral-branch network with cumulative learning for long-tailed visual recognition. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 9719–9728, 2020. ",
+        "bbox": [
+            173,
+            398,
+            825,
+            441
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Linchao Zhu and Yi Yang. Inflated episodic memory with region self-attention for long-tailed visual recognition. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 4344–4353, 2020. ",
+        "bbox": [
+            176,
+            450,
+            821,
+            493
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            297,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1 DATASETS AND IMPLEMENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            133,
+            462,
+            148
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We conduct experiments on three major long-tailed recognition benchmarks and different backbone networks to prove the effectiveness and universality of RIDE: ",
+        "bbox": [
+            174,
+            160,
+            823,
+            188
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1.CIFAR100-LT (Krizhevsky, 2009; Cao et al., 2019): The original version of CIFAR-100 contains 50,000 images on training set and 10,000 images on validation set with 100 categories. The long-tailed version of CIFAR-100 follows an exponential decay in sample sizes across different categories. We conduct experiment on CIFAR100-LT with an imbalance factor of 100, i.e. the ratio between the most frequent class and the least frequent class. ",
+        "bbox": [
+            174,
+            200,
+            825,
+            270
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "To make fair comparison with previous works, we follow the training recipe of (Cao et al., 2019) on CIFAR100-LT. We train the ResNet-32 (He et al., 2016) backbone network by SGD optimizer with a momentum of 0.9. CIFAR100-LT is trained for 200 epochs with standard data augmentations (He et al., 2016) and a batch size of 128 on one RTX 2080Ti GPU. The learning rate is initialized as 0.1 and decayed by 0.01 at epoch 120 and 160 respectively. ",
+        "bbox": [
+            174,
+            272,
+            823,
+            342
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2.ImageNet-LT (Deng et al., 2009; Liu et al., 2019): ImageNet-LT is constructed by sampling a subset of ImageNet-2012 following the Pareto distribution with the power value $\\alpha = 6$ (Liu et al., 2019). ImageNet-LT consists of $1 1 5 . 8 \\mathrm { k }$ images from 1,000 categories, with the largest and smallest categories containing 1,280 and 5 images, respectively. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            404
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Multiple backbone networks are experimented on ImageNet-LT, including ResNet-10, ResNet-50 and ResNeXt-50 (Xie et al., 2017). All backbone networks are trained with a batch size of 256 on 8 RTX 2080Ti GPUs for 100 epochs using SGD with an initial learning rate of 0.1 decayed by 0.1 at 60 epochs and 80 epochs. We utilize standard data augmentations as in (He et al., 2016). ",
+        "bbox": [
+            174,
+            405,
+            825,
+            462
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3.iNaturalist (Van Horn et al., 2018): The iNaturalist-2018 dataset is an imbalanced datasets with 437,513 training images from 8,142 classes with a balanced test set of 24,426 images. We use ResNet-50 as the backbone network and apply the same training recipe as ImageNet-LT, except that we use a batch size of 512. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            522
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.2 ADDITIONAL EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            540,
+            413,
+            554
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ablation study on distillation methods. Self-distillation step is optional but recommended if further improvements $( 0 . 4 \\% \\sim 0 . 8 \\%$ for most experiments) are desired. We apply distillation from a more powerful model with more experts into a model with fewer experts. A simple way to transfer knowledge is knowledge distillation (KD) (Hinton et al., 2015), which applies KD loss $( \\mathcal { L } _ { \\mathrm { K D } } = T ^ { 2 } D _ { \\mathrm { K L } } ( \\tilde { \\vec { l } _ { \\mathrm { t e a c h e r } } } / T , \\vec { l } _ { \\mathrm { e x p e r t } _ { i } } / T ) )$ to match the distribution of logits of a teacher and a student. We found that for teacher model with more experts using smaller distillation loss factor gives better performance. We hypothesize that since we distill from the same teachers, giving large distillation factor prevents the branches from becoming as diversified as it is able to. We also explored other distillation methods, such as CRD (Tian et al., 2019), PKT (Passalis & Tefas, 2018), and SP (Tung & Mori, 2019), and compared the differences in Table 5. Although adding other methods along with KD may boost performance, the difference is small. Therefore, we opt for simplicity and use KD only unless otherwise noticed. ",
+        "bbox": [
+            173,
+            565,
+            825,
+            734
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Detailed results for ImageNet-LT experiments. We list details of our ResNet-50 experiments in ImageNet-LT on Table 7. With 2 experts, we are able to achieve about $7 \\%$ gain in accuracy with computational cost about $10 \\%$ less than baseline. In contrast to previous methods that sacrifice many-shot accuracy to get few-shot accuracy, we improve on all three splits on ImageNet-LT. From 3 experts to 4 experts, we keep the same many-shot accuracy while increasing the few-shot accuracy, indicating that we are using the additional computational power to improve on the hardest part of the data rather than uniformly applying to all samples. ",
+        "bbox": [
+            174,
+            742,
+            825,
+            840
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We also list our ResNet-10 and ResNeXt-50 experiments on Table 6 and 8, respectively, to compare against other works evaluated on these backbones. Our method also achieves lower computational cost and higher performance when compared to other methods. ",
+        "bbox": [
+            174,
+            847,
+            823,
+            888
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Comparison with ensemble method. Since our method requires the joint decision from several experts, which raw ensembles also do, we also compare against ensembles of LDAM in Fig.7 on ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 5: Comparison of different distillation methods. We transfer from a model based on ResNet-32 with 6 experts to a model of the same type, except with fewer experts. We use CIFAR100- LT for the following comparison. No expert assignment module is used in the following experiments. Following the procedure for CRD (Tian et al., 2019), we also apply KD when we transfer from a teacher to students with other distillation methods. ",
+        "bbox": [
+            173,
+            101,
+            825,
+            170
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/67c24892b146eae20888ff65f6fe77f98cba76c3d2300f11ad54c6105dfa0786.jpg",
+        "table_caption": [
+            "RIDE and Ensembles of LDAM "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model Type</td><td>#expert</td><td>DistillationMethod</td><td>Accuracy (%)</td></tr><tr><td>Teacher</td><td>6</td><td></td><td>49.7</td></tr><tr><td rowspan=\"10\">Student</td><td>2</td><td>No Distillation</td><td>46.6</td></tr><tr><td>2</td><td>KD (Hinton et al., 2015)</td><td>47.3</td></tr><tr><td>2</td><td>CRD (Tian et al., 2019)</td><td>47.5</td></tr><tr><td>2</td><td>PKT (Passalis &amp; Tefas,2018)</td><td>47.2</td></tr><tr><td>2</td><td>SP(Tung&amp;Mori,2019)</td><td>47.2</td></tr><tr><td>3 3</td><td>No Distillation</td><td>47.9</td></tr><tr><td></td><td>KD (Hinton et al., 2015)</td><td>48.4</td></tr><tr><td>3</td><td>CRD (Tian et al., 2019)</td><td>48.5</td></tr><tr><td>3</td><td>PKT (Passalis &amp; Tefas,2018)</td><td>48.3</td></tr><tr><td>3 4</td><td>SP(Tung&amp; Mori,2019)</td><td>48.7</td></tr><tr><td></td><td>No Distillation</td><td></td><td>48.7</td></tr><tr><td></td><td>4</td><td>KD (Hinton et al., 2015)</td><td>49.3</td></tr><tr><td></td><td>4</td><td>CRD (Tian et al., 2019)</td><td>49.0</td></tr><tr><td></td><td>4</td><td>PKT (Passalis &amp; Tefas,2018)</td><td>48.9</td></tr><tr><td>4</td><td></td><td>SP (Tung&amp; Mori,2019)</td><td>49.0</td></tr></table>",
+        "bbox": [
+            250,
+            189,
+            746,
+            430
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/ed58db4791e1f89ea35cfff8e371d2ead6b40c0516b6979d8bf036e41da4d9b4.jpg",
+        "image_caption": [
+            "Figure 7: Comparison between our method and multiple LDAM models ensembled together. In the figure, ensembles of LDAM start from 1 ensemble (original LDAM) to 7 ensembles, and RIDE starts from 2 experts to 4 experts. Our method achieves higher accuracy with substantially less computational cost compared to ensemble method. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            465,
+            490,
+            617
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "CIFAR100-LT. In the figure, even our method with 4 experts has less computational cost than the minimum computational cost for the ensemble of 2 LDAM models. This indicates that our model is much more efficient and powerful in terms of computational cost and accuracy than ensemble on long-tailed datasets. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            684
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/e6115ad05a8234a5953def47587d79cb117043662a85d302d1fee6d35a65ae44.jpg",
+        "image_caption": [
+            "Figure 8: t-SNE visualization of LDAM’s and our model’s embedding space of CIFAR100-LT. The feature embedding of RIDE is more compact for both head and tail classes and better separated. This behavior greatly reduces the difficulty for the classifier to distinguish the tail category. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            699,
+            816,
+            797
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "t-SNE visualization. We also provide the t-SNE visualization of embedding space on CIFAR100- LT as in Fig. 8. Compared with the baseline method LDAM, the feature embedding of RIDE is more compact for both the head and tail classes and better separated from the neighboring classes. This greatly reduces the difficulty for the classifier to distinguish the tail category. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "What if we apply RIDE to balanced datasets? We also conducted experiments on CIFAR100 to check if our method can achieve similar performance gains on balanced datasets. However, we only obtained an improvement of about $1 \\%$ , which is much smaller than the improvements observed on the CIFAR100-LT. Compared with balanced datasets, long-tailed datasets can get more benefits from RIDE. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/f396f564beb65f78ce35f7478298dc1ad3e54b303feea6c358a392f5dfb3cda2.jpg",
+        "table_caption": [
+            "Table 6: Top-1 accuracy comparison with state-of-the-art methods on ImageNet-LT (Liu et al., 2019) with ResNet-10. Performance on Many-shot $( > 1 0 0 )$ , Medum-shot $\\leq 1 0 0$ & ${ > } 2 0$ ) and Fewshot $( \\leq 2 0 )$ are also provided. Results marked with $\\dagger$ are copied from (Liu et al., 2019). Results with $\\ddagger$ are from (Xiang et al., 2020). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td>GFlops</td><td>Many</td><td>Medium</td><td>Few</td><td>Overall</td></tr><tr><td>Cross Entropy(CE) t</td><td>0.89 (1.0x)</td><td>40.9</td><td>10.7</td><td>0.4</td><td>20.9</td></tr><tr><td>Focal Loss † (Lin et al.,2017)</td><td>0.89 (1.0x) 0.89 (1.0x)</td><td>36.4</td><td>29.9</td><td>16.0</td><td>30.5</td></tr><tr><td>Range Loss † (Zhang et al., 2017) Lifted Loss † (Oh Song et al., 2016)</td><td>0.89 (1.0x)</td><td>35.8</td><td>30.3</td><td>17.6</td><td>30.7</td></tr><tr><td></td><td></td><td>35.8</td><td>30.4</td><td>17.9</td><td>30.8</td></tr><tr><td>OLTR (Liu et al., 2019) LFME (Xiang et al., 2020)</td><td>0.89 (1.0x)</td><td>43.2</td><td>35.1</td><td>18.5</td><td>35.6</td></tr><tr><td>Many-shot only t</td><td>- 1</td><td>47.0 59.3</td><td>37.9</td><td>19.2</td><td>38.8</td></tr><tr><td>Medium-shot only t</td><td>1</td><td></td><td>35.9</td><td></td><td></td></tr><tr><td>Few-shot only ‡</td><td>1</td><td></td><td></td><td>14.3</td><td></td></tr><tr><td>RIDE (2 experts)</td><td>0.85 (1.0x)</td><td>57.5</td><td>40.8</td><td>26.9</td><td>45.3 (+6.5)</td></tr><tr><td>RIDE (3 experts)</td><td>0.97 (1.1x)</td><td>57.6</td><td>41.7</td><td>28.0</td><td>45.9 (+7.1)</td></tr><tr><td>RIDE (4 experts)</td><td>1.07 (1.2x)</td><td>58.5</td><td>42.4</td><td>27.7</td><td>46.6 ( (+7.8)</td></tr></table>",
+        "bbox": [
+            179,
+            258,
+            818,
+            445
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/a68c86c223d1604da2c563c318f76bd864457ef48096ba37b6cc0704c0c992c5.jpg",
+        "table_caption": [
+            "Table 7: Top-1 accuracy comparison with state-of-the-art methods on ImageNet-LT (Liu et al., 2019) with ResNet-50. Performance on Many-shot $( > 1 0 0 )$ , Medum-shot $( \\leq 1 0 0$ & ${ > } 2 0$ ) and Fewshot $( \\leq 2 0 )$ are also provided. Results marked with $\\dagger$ are copied from (Kang et al., 2020). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td>GFlops</td><td>Many</td><td>Medium</td><td>Few</td><td>Overall</td></tr><tr><td>Cross Entropy (CE) t</td><td>4.11 (1.0x)</td><td>64.0</td><td>33.8</td><td>5.8</td><td>41.6</td></tr><tr><td>NCM (Kang et al., 2020)</td><td>=</td><td>53.1</td><td>42.3</td><td>26.5</td><td>44.3</td></tr><tr><td>cRT (Kang et al., 2020)</td><td>4.11 (1.0x)</td><td>58.8</td><td>44.0</td><td>26.1</td><td>47.3</td></tr><tr><td>T-norm (Kang et al., 2020)</td><td>4.11 (1.0x)</td><td>56.6</td><td>44.2</td><td>27.4</td><td>46.7</td></tr><tr><td>LWS (Kang et al., 2020)</td><td>4.11 (1.0x)</td><td>57.1</td><td>45.2</td><td>29.3</td><td>47.7</td></tr><tr><td>RIDE (2 experts)</td><td>3.71 (0.9x)</td><td>65.8</td><td>51.0</td><td>34.6</td><td>54.4 (+6.7)</td></tr><tr><td>RIDE (3 experts)</td><td>4.36 (1.1x)</td><td>66.2</td><td>51.7</td><td>34.9</td><td>54.9 (+7.2)</td></tr><tr><td>RIDE (4 experts)</td><td>5.15 (1.3x)</td><td>66.2</td><td>52.3</td><td>36.5</td><td> 55.4 (+7.7)</td></tr></table>",
+        "bbox": [
+            209,
+            532,
+            789,
+            664
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/f371a6c094ee4c012f0474f893d8eaaa39350cb8654b956a2835a31d56985897.jpg",
+        "table_caption": [
+            "Table 8: Top-1 accuracy comparison with state-of-the-art methods on ImageNet-LT (Liu et al., 2019) with ResNeXt-50. Performance on Many-shot $( > 1 0 0 )$ , Medum-shot $( \\leq 1 0 0$ & ${ > } 2 0 _ { , }$ ) and Few-shot $( \\leq 2 0 )$ are also provided. Results marked with $\\dagger$ are copied from (Kang et al., 2020). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td>GFlops</td><td>Many</td><td>Medium</td><td>Few</td><td>Overall</td></tr><tr><td>Cross Entropy(CE) + NCM (Kang et al., 2020)</td><td>4.26 (1.0x)</td><td>65.9</td><td>37.5</td><td>7.7</td><td>44.4</td></tr><tr><td>cRT (Kang et al., 2020)</td><td>4.26 (1.0x)</td><td>56.6 61.8</td><td>45.3 46.2</td><td>28.1 27.4</td><td>47.3 49.6</td></tr><tr><td>T-norm (Kang et al., 2020)</td><td>4.26 (1.0x)</td><td>59.1</td><td>46.9</td><td>30.7</td><td>49.4</td></tr><tr><td>LWS (Kang et al., 2020)</td><td>4.26 (1.0x)</td><td>60.2</td><td>47.2</td><td>30.3</td><td></td></tr><tr><td></td><td>3.92 (0.9x)</td><td>67.6</td><td>52.5</td><td>35.0</td><td>49.9</td></tr><tr><td>RIDE (2 experts)</td><td>4.69 (1.1x)</td><td>67.6</td><td>53.5</td><td>35.9</td><td>55.9 (+6.0)</td></tr><tr><td>RIDE (3 experts)</td><td>5.19 (1.2x)</td><td></td><td></td><td></td><td>56.4 (+6.5)</td></tr><tr><td>RIDE (4 experts)</td><td></td><td>68.2</td><td>53.8</td><td>36.0</td><td>56.8 (+6.9)</td></tr></table>",
+        "bbox": [
+            209,
+            751,
+            789,
+            882
+        ],
+        "page_idx": 14
+    }
+]

parse/train/HJ0UKP9ge/HJ0UKP9ge.md

@@ -0,0 +1,285 @@
+# BI-DIRECTIONAL ATTENTION FLOW FOR MACHINE COMPREHENSION
+
+Minjoon $\mathbf { S e o ^ { 1 * } }$ Aniruddha Kembhavi2 Ali Farhadi1,2 Hananneh Hajishirzi1 University of Washington1, Allen Institute for Artificial Intelligence2 {minjoon,ali,hannaneh}@cs.washington.edu, $\{ \mathtt { a n i k } \} \ @ \mathtt { a l l e n a i . o r g }$
+
+# ABSTRACT
+
+Machine comprehension (MC), answering a query about a given context paragraph, requires modeling complex interactions between the context and the query. Recently, attention mechanisms have been successfully extended to MC. Typically these methods use attention to focus on a small portion of the context and summarize it with a fixed-size vector, couple attentions temporally, and/or often form a uni-directional attention. In this paper we introduce the Bi-Directional Attention Flow (BIDAF) network, a multi-stage hierarchical process that represents the context at different levels of granularity and uses bidirectional attention flow mechanism to obtain a query-aware context representation without early summarization. Our experimental evaluations show that our model achieves the state-of-the-art results in Stanford Question Answering Dataset (SQuAD) and CNN/DailyMail cloze test.
+
+# 1 INTRODUCTION
+
+The tasks of machine comprehension (MC) and question answering (QA) have gained significant popularity over the past few years within the natural language processing and computer vision communities. Systems trained end-to-end now achieve promising results on a variety of tasks in the text and image domains. One of the key factors to the advancement has been the use of neural attention mechanism, which enables the system to focus on a targeted area within a context paragraph (for MC) or within an image (for Visual QA), that is most relevant to answer the question (Weston et al., 2015; Antol et al., 2015; Xiong et al., 2016a). Attention mechanisms in previous works typically have one or more of the following characteristics. First, the computed attention weights are often used to extract the most relevant information from the context for answering the question by summarizing the context into a fixed-size vector. Second, in the text domain, they are often temporally dynamic, whereby the attention weights at the current time step are a function of the attended vector at the previous time step. Third, they are usually uni-directional, wherein the query attends on the context paragraph or the image.
+
+In this paper, we introduce the Bi-Directional Attention Flow (BIDAF) network, a hierarchical multi-stage architecture for modeling the representations of the context paragraph at different levels of granularity (Figure 1). BIDAF includes character-level, word-level, and contextual embeddings, and uses bi-directional attention flow to obtain a query-aware context representation. Our attention mechanism offers following improvements to the previously popular attention paradigms. First, our attention layer is not used to summarize the context paragraph into a fixed-size vector. Instead, the attention is computed for every time step, and the attended vector at each time step, along with the representations from previous layers, is allowed to flow through to the subsequent modeling layer. This reduces the information loss caused by early summarization. Second, we use a memory-less attention mechanism. That is, while we iteratively compute attention through time as in Bahdanau et al. (2015), the attention at each time step is a function of only the query and the context paragraph at the current time step and does not directly depend on the attention at the previous time step. We hypothesize that this simplification leads to the division of labor between the attention layer and the modeling layer. It forces the attention layer to focus on learning the attention between the query and the context, and enables the modeling layer to focus on learning the interaction within the query-aware context representation (the output of the attention layer). It also allows the attention at each time step to be unaffected from incorrect attendances at previous time steps. Our experiments show that memory-less attention gives a clear advantage over dynamic attention. Third, we use attention mechanisms in both directions, query-to-context and context-to-query, which provide complimentary information to each other.
+
+![](images/8ae29f18b08da1ee65cc07b50c3d43461883b2cbc78ed590d8d2592a92dfe01e.jpg)  
+Figure 1: BiDirectional Attention Flow Model (best viewed in color)
+
+Our BIDAF model1 outperforms all previous approaches on the highly-competitive Stanford Question Answering Dataset (SQuAD) test set leaderboard at the time of submission. With a modification to only the output layer, BIDAF achieves the state-of-the-art results on the CNN/DailyMail cloze test. We also provide an in-depth ablation study of our model on the SQuAD development set, visualize the intermediate feature spaces in our model, and analyse its performance as compared to a more traditional language model for machine comprehension (Rajpurkar et al., 2016).
+
+# 2 MODEL
+
+Our machine comprehension model is a hierarchical multi-stage process and consists of six layers (Figure 1):
+
+1. Character Embedding Layer maps each word to a vector space using character-level CNNs.   
+2. Word Embedding Layer maps each word to a vector space using a pre-trained word embedding model.   
+3. Contextual Embedding Layer utilizes contextual cues from surrounding words to refine the embedding of the words. These first three layers are applied to both the query and context.   
+4. Attention Flow Layer couples the query and context vectors and produces a set of queryaware feature vectors for each word in the context.   
+5. Modeling Layer employs a Recurrent Neural Network to scan the context.   
+6. Output Layer provides an answer to the query.
+
+1. Character Embedding Layer. Character embedding layer is responsible for mapping each word to a high-dimensional vector space. Let $\{ \pmb { x } _ { 1 } , \hdots \pmb { x } _ { T } \}$ and $\{ q _ { 1 } , \dots q _ { J } \}$ represent the words in the input context paragraph and query, respectively. Following Kim (2014), we obtain the characterlevel embedding of each word using Convolutional Neural Networks (CNN). Characters are embedded into vectors, which can be considered as 1D inputs to the CNN, and whose size is the input channel size of the CNN. The outputs of the CNN are max-pooled over the entire width to obtain a fixed-size vector for each word.
+
+2. Word Embedding Layer. Word embedding layer also maps each word to a high-dimensional vector space. We use pre-trained word vectors, GloVe (Pennington et al., 2014), to obtain the fixed word embedding of each word.
+
+The concatenation of the character and word embedding vectors is passed to a two-layer Highway Network (Srivastava et al., 2015). The outputs of the Highway Network are two sequences of $d$ - dimensional vectors, or more conveniently, two matrices: $\breve { \mathbf { X } } \in \breve { \mathbb { R } } ^ { d \times T }$ for the context and $\mathbf { Q } \in \mathbb { R } ^ { d \times J }$ for the query.
+
+3. Contextual Embedding Layer. We use a Long Short-Term Memory Network (LSTM) (Hochreiter & Schmidhuber, 1997) on top of the embeddings provided by the previous layers to model the temporal interactions between words. We place an LSTM in both directions, and concatenate the outputs of the two LSTMs. Hence we obtain $\mathbf { H } \in \mathbb { R } ^ { 2 d \times T }$ from the context word vectors $\mathbf { X }$ , and $\mathbf { U } \in \mathbb { R } ^ { 2 d \times J }$ from query word vectors $\mathbf { Q }$ . Note that each column vector of $\mathbf { H }$ and $\mathbf { U }$ is $2 d$ -dimensional because of the concatenation of the outputs of the forward and backward LSTMs, each with $d .$ -dimensional output.
+
+It is worth noting that the first three layers of the model are computing features from the query and context at different levels of granularity, akin to the multi-stage feature computation of convolutional neural networks in the computer vision field.
+
+4. Attention Flow Layer. Attention flow layer is responsible for linking and fusing information from the context and the query words. Unlike previously popular attention mechanisms (Weston et al., 2015; Hill et al., 2016; Sordoni et al., 2016; Shen et al., 2016), the attention flow layer is not used to summarize the query and context into single feature vectors. Instead, the attention vector at each time step, along with the embeddings from previous layers, are allowed to flow through to the subsequent modeling layer. This reduces the information loss caused by early summarization.
+
+The inputs to the layer are contextual vector representations of the context H and the query U. The outputs of the layer are the query-aware vector representations of the context words, $\mathbf { G }$ , along with the contextual embeddings from the previous layer.
+
+In this layer, we compute attentions in two directions: from context to query as well as from query to context. Both of these attentions, which will be discussed below, are derived from a shared similarity matrix, $\mathbf { S } \in \mathbb { R } ^ { T \times J }$ , between the contextual embeddings of the context $( \mathbf { H } )$ and the query (U), where $\mathbf { S } _ { t j }$ indicates the similarity between $t$ -th context word and $j$ -th query word. The similarity matrix is computed by
+
+$$
+\mathbf { S } _ { t j } = \alpha ( \mathbf { H } _ { : t } , \mathbf { U } _ { : j } ) \in \mathbb { R }
+$$
+
+where $\alpha$ is a trainable scalar function that encodes the similarity between its two input vectors, $\mathbf { H } _ { : t }$ is $t$ -th column vector of $\mathbf { H }$ , and $\mathbf { U } _ { : j }$ is $j$ -th column vector of $\mathbf { U }$ , We choose $\alpha ( \mathbf { h } , \mathbf { u } ) { \bf \bar { \alpha } } = \mathbf { w } _ { ( \mathbf { s } ) } ^ { \top } [ \mathbf { h } ; \mathbf { u } ; \mathbf { h } \circ$ $\mathbf { u } ]$ , where $\mathbf { w } _ { ( \mathbf { S } ) } \in \mathbb { R } ^ { 6 d }$ is a trainable weight vector, $\circ$ is elementwise multiplication, $[ ; ]$ is vector concatenation across row, and implicit multiplication is matrix multiplication. Now we use $\mathbf { S }$ to obtain the attentions and the attended vectors in both directions.
+
+Context-to-query Attention. Context-to-query (C2Q) attention signifies which query words are most relevant to each context word. Let $\mathbf { a } _ { t } \in \mathbf { \overline { { \mathbb { R } } } } ^ { J }$ represent the attention weights on the query words by $t { \cdot }$ -th context word, $\textstyle \sum { \mathbf { a } } _ { t j } = 1$ for all $t$ . The attention weight is computed by $\mathbf { a } _ { t } = \mathrm { s o f t m a x } ( \mathbf { S } _ { t : } ) \in$ $\mathbb { R } ^ { J }$ , and subsequently each attended query vector is $\begin{array} { r } { \tilde { \mathbf { U } } _ { : t } = \sum _ { j } \mathbf { a } _ { t j } \mathbf { U } _ { : j } } \end{array}$ . Hence $\tilde { \textbf { U } }$ is a $2 d$ -by- $\mathcal { T }$ matrix containing the attended query vectors for the entire context.
+
+Query-to-context Attention. Query-to-context (Q2C) attention signifies which context words have the closest similarity to one of the query words and are hence critical for answering the query.
+
+We obtain the attention weights on the context words by $\mathbf { b } = \mathrm { s o f t m a x } ( \operatorname* { m a x } _ { c o l } ( \mathbf { S } ) ) \in \mathbb { R } ^ { T }$ , where the maximum function $( \mathrm { m a x } _ { c o l } )$ is performed across the column. Then the attended context vector is $\begin{array} { r } { \tilde { \mathbf { h } } = \sum _ { t } \mathbf { b } _ { t } \mathbf { H } _ { : t } \in \mathbb { R } ^ { 2 d } } \end{array}$ . This vector indicates the weighted sum of the most important words in the context with respect to the query. $\tilde { \mathbf { h } }$ is tiled $T$ times across the column, thus giving $\tilde { \mathbf { H } } \in \mathbb { R } ^ { 2 d \times T }$ .
+
+Finally, the contextual embeddings and the attention vectors are combined together to yield $\mathbf { G }$ , where each column vector can be considered as the query-aware representation of each context word. We define $\mathbf { G }$ by
+
+$$
+\mathbf { G } _ { : t } = \beta ( \mathbf { H } _ { : t } , \tilde { \mathbf { U } } _ { : t } , \tilde { \mathbf { H } } _ { : t } ) \in \mathbb { R } ^ { d _ { \mathbf { G } } }
+$$
+
+where $\mathbf { G } _ { : t }$ is the $t { \cdot }$ -th column vector (corresponding to $t$ -th context word), $\beta$ is a trainable vector function that fuses its (three) input vectors, and $d _ { \mathbf { G } }$ is the output dimension of the $\beta$ function. While the $\beta$ function can be an arbitrary trainable neural network, such as multi-layer perceptron, a simple concatenation as following still shows good performance in our experiments: $\bar { \beta } ( { \bf h } , \bar { \tilde { \bf u } } , \tilde { \bf h } ) =$ $[ \mathbf { h } ; \tilde { \mathbf { u } } ; \mathbf { h } \circ \tilde { \mathbf { u } } ; \mathbf { h } \circ \tilde { \mathbf { h } } ] \in \mathbb { R } ^ { 8 d \times T }$ (i.e., $d _ { \mathbf { G } } = 8 d _ { \mathbf { \rho } }$ ).
+
+5. Modeling Layer. The input to the modeling layer is $\mathbf { G }$ , which encodes the query-aware representations of context words. The output of the modeling layer captures the interaction among the context words conditioned on the query. This is different from the contextual embedding layer, which captures the interaction among context words independent of the query. We use two layers of bi-directional LSTM, with the output size of $d$ for each direction. Hence we obtain a matrix $\mathbf { M } \in \mathbb { R } ^ { 2 d \times T }$ , which is passed onto the output layer to predict the answer. Each column vector of M is expected to contain contextual information about the word with respect to the entire context paragraph and the query.
+
+6. Output Layer. The output layer is application-specific. The modular nature of BIDAF allows us to easily swap out the output layer based on the task, with the rest of the architecture remaining exactly the same. Here, we describe the output layer for the QA task. In section 5, we use a slight modification of this output layer for cloze-style comprehension.
+
+The QA task requires the model to find a sub-phrase of the paragraph to answer the query. The phrase is derived by predicting the start and the end indices of the phrase in the paragraph. We obtain the probability distribution of the start index over the entire paragraph by
+
+$$
+\mathbf { p } ^ { 1 } = \mathrm { s o f t m a x } ( \mathbf { w } _ { ( \mathbf { p } ^ { 1 } ) } ^ { \top } [ \mathbf { G } ; \mathbf { M } ] ) ,
+$$
+
+where $\mathbf { w } _ { ( \mathbf { p } ^ { 1 } ) } \in \mathbb { R } ^ { 1 0 d }$ is a trainable weight vector. For the end index of the answer phrase, we pass $\mathbf { M }$ to another bidirectional LSTM layer and obtain $\mathbf { M } ^ { 2 } \in \mathbb { R } ^ { 2 d \times T }$ . Then we use $\mathbf { M } ^ { 2 }$ to obtain the probability distribution of the end index in a similar manner:
+
+$$
+\mathbf { p } ^ { 2 } = \mathrm { s o f t m a x } ( \mathbf { w } _ { ( \mathbf { p } ^ { 2 } ) } ^ { \top } [ \mathbf { G } ; \mathbf { M } ^ { 2 } ] )
+$$
+
+Training. We define the training loss (to be minimized) as the sum of the negative log probabilities of the true start and end indices by the predicted distributions, averaged over all examples:
+
+$$
+L ( \theta ) = - \frac { 1 } { N } \sum _ { i } ^ { N } \log ( \mathbf { p } _ { y _ { i } ^ { 1 } } ^ { 1 } ) + \log ( \mathbf { p } _ { y _ { i } ^ { 2 } } ^ { 2 } )
+$$
+
+where $\theta$ is the set of all trainable weights in the model (the weights and biases of CNN filters and LSTM cells, $\mathbf { w } _ { ( \mathbf { S } ) } , \mathbf { w } _ { ( \mathbf { p } ^ { 1 } ) }$ and $\mathbf { w } _ { ( \mathbf { p } ^ { 2 } ) , }$ ), $N$ is the number of examples in the dataset, $y _ { i } ^ { 1 }$ and $y _ { i } ^ { 2 }$ are the true start and end indices of the $i$ -th example, respectively, and $\mathbf { p } _ { k }$ indicates the $k$ -th value of the vector $\mathbf { p }$ .
+
+Test. The answer span $( k , l )$ where $k \leq l$ with the maximum value of $\mathbf { p } _ { k } ^ { 1 } \mathbf { p } _ { l } ^ { 2 }$ is chosen, which can be computed in linear time with dynamic programming.
+
+# 3 RELATED WORK
+
+Machine comprehension. A significant contributor to the advancement of MC models has been the availability of large datasets. Early datasets such as MCTest (Richardson et al., 2013) were too small to train end-to-end neural models. Massive cloze test datasets (CNN/DailyMail by Hermann et al. (2015) and Childrens Book Test by Hill et al. (2016)), enabled the application of deep neural architectures to this task. More recently, Rajpurkar et al. (2016) released the Stanford Question Answering (SQuAD) dataset with over 100,000 questions. We evaluate the performance of our comprehension system on both SQuAD and CNN/DailyMail datasets.
+
+Previous works in end-to-end machine comprehension use attention mechanisms in three distinct ways. The first group (largely inspired by Bahdanau et al. (2015)) uses a dynamic attention mechanism, in which the attention weights are updated dynamically given the query and the context as well as the previous attention. Hermann et al. (2015) argue that the dynamic attention model performs better than using a single fixed query vector to attend on context words on CNN & DailyMail datasets. Chen et al. (2016) show that simply using bilinear term for computing the attention weights in the same model drastically improves the accuracy. Wang & Jiang (2016) reverse the direction of the attention (attending on query words as the context RNN progresses) for SQuAD. In contrast to these models, BIDAF uses a memory-less attention mechanism.
+
+The second group computes the attention weights once, which are then fed into an output layer for final prediction (e.g., Kadlec et al. (2016)). Attention-over-attention model (Cui et al., 2016) uses a 2D similarity matrix between the query and context words (similar to Equation 1) to compute the weighted average of query-to-context attention. In contrast to these models, BIDAF does not summarize the two modalities in the attention layer and instead lets the attention vectors flow into the modeling (RNN) layer.
+
+The third group (considered as variants of Memory Network (Weston et al., 2015)) repeats computing an attention vector between the query and the context through multiple layers, typically referred to as multi-hop (Sordoni et al., 2016; Dhingra et al., 2016). Shen et al. (2016) combine Memory Networks with Reinforcement Learning in order to dynamically control the number of hops. One can also extend our BIDAF model to incorporate multiple hops.
+
+Visual question answering. The task of question answering has also gained a lot of interest in the computer vision community. Early works on visual question answering (VQA) involved encoding the question using an RNN, encoding the image using a CNN and combining them to answer the question (Antol et al., 2015; Malinowski et al., 2015). Attention mechanisms have also been successfully employed for the VQA task and can be broadly clustered based on the granularity of their attention and the approach to construct the attention matrix. At the coarse level of granularity, the question attends to different patches in the image (Zhu et al., 2016; Xiong et al., 2016a). At a finer level, each question word attends to each image patch and the highest attention value for each spatial location (Xu & Saenko, 2016) is adopted. A hybrid approach is to combine questions representations at multiple levels of granularity (unigrams, bigrams, trigrams) (Yang et al., 2015). Several approaches to constructing the attention matrix have been used including element-wise product, element-wise sum, concatenation and Multimodal Compact Bilinear Pooling (Fukui et al., 2016).
+
+Lu et al. (2016) have recently shown that in addition to attending from the question to image patches, attending from the image back to the question words provides an improvement on the VQA task. This finding in the visual domain is consistent with our finding in the language domain, where our bi-directional attention between the query and context provides improved results. Their model, however, uses the attention weights directly in the output layer and does not take advantage of the attention flow to the modeling layer.
+
+# 4 QUESTION ANSWERING EXPERIMENTS
+
+In this section, we evaluate our model on the task of question answering using the recently released SQuAD (Rajpurkar et al., 2016), which has gained a huge attention over a few months. In the next section, we evaluate our model on the task of cloze-style reading comprehension.
+
+Dataset. SQuAD is a machine comprehension dataset on a large set of Wikipedia articles, with more than 100,000 questions. The answer to each question is always a span in the context. The model is given a credit if its answer matches one of the human written answers. Two metrics are used to evaluate models: Exact Match (EM) and a softer metric, F1 score, which measures the weighted average of the precision and recall rate at character level. The dataset consists of $9 0 \mathrm { k } / 1 0 \mathrm { k }$
+
+<table><tr><td></td><td colspan="2">Single Model</td><td colspan="2">Ensemble</td></tr><tr><td></td><td>EM</td><td>F1</td><td>EM</td><td>F1</td></tr><tr><td>Logistic Regression Baselinea</td><td>40.4</td><td>51.0</td><td>-</td><td>-</td></tr><tr><td>Dynamic Chunk Readerb</td><td>62.5</td><td>71.0</td><td>-</td><td>-</td></tr><tr><td>Fine-Grained Gatingc</td><td>62.5</td><td>73.3</td><td>1</td><td>-</td></tr><tr><td>Match-LSTMd</td><td>64.7</td><td>73.7</td><td>67.9</td><td>77.0</td></tr><tr><td>Multi-Perspective Matchinge</td><td>65.5</td><td>75.1</td><td>68.2</td><td>77.2</td></tr><tr><td>Dynamic Coattention Networksf</td><td>66.2</td><td>75.9</td><td>71.6</td><td>80.4</td></tr><tr><td>R-Net9</td><td>68.4</td><td>77.5</td><td>72.1</td><td>79.7</td></tr><tr><td>BIDAF (Ours)</td><td>68.0</td><td>77.3</td><td>73.3</td><td>81.1</td></tr></table>
+
+(a) Results on the SQuAD test set
+
+<table><tr><td></td><td>EM</td><td>F1</td></tr><tr><td>No char embedding No word embedding No C2Q attention</td><td>65.0 55.5 57.2</td><td>75.4 66.8 67.7</td></tr><tr><td>No Q2C attention Dynamic attention</td><td>63.6 63.5</td><td>73.7 73.6</td></tr><tr><td>BIDAF (single)</td><td>67.7</td><td>77.3</td></tr><tr><td>BIDAF (ensemble)</td><td>72.6</td><td>80.7</td></tr></table>
+
+(b) Ablations on the SQuAD dev set
+
+Table 1: (1a) The performance of our model BIDAF and competing approaches by Rajpurkar et al. $( 2 0 1 6 ) ^ { a }$ , Yu et al. $( 2 0 1 6 ) ^ { b }$ , Yang et al. $( 2 0 1 6 ) ^ { c }$ , Wang & Jiang $( 2 0 1 6 ) ^ { d }$ , IBM Watsone (unpublished), Xiong et al. $( 2 0 1 6 \mathrm { b } ) ^ { f }$ , and Microsoft Research $\mathrm { A s i a } ^ { g }$ (unpublished) on the SQuAD test set. A concurrent work by Lee et al. (2016) does not report the test scores. All results shown here reflect the SQuAD leaderboard (stanford-qa.com) as of 6 Dec 2016, $1 2 \mathrm { p m }$ PST. (1b) The performance of our model and its ablations on the SQuAD dev set. Ablation results are presented only for single runs.
+
+train/dev question-context tuples with a large hidden test set. It is one of the largest available MC datasets with human-written questions and serves as a great test bed for our model.
+
+Model Details. The model architecture used for this task is depicted in Figure 1. Each paragraph and question are tokenized by a regular-expression-based word tokenizer (PTB Tokenizer) and fed into the model. We use $1 0 0 ~ 1 \mathrm { D }$ filters for CNN char embedding, each with a width of 5. The hidden state size $( d )$ of the model is 100. The model has about 2.6 million parameters. We use the AdaDelta (Zeiler, 2012) optimizer, with a minibatch size of 60 and an initial learning rate of 0.5, for 12 epochs. A dropout (Srivastava et al., 2014) rate of 0.2 is used for the CNN, all LSTM layers, and the linear transformation before the softmax for the answers. During training, the moving averages of all weights of the model are maintained with the exponential decay rate of 0.999. At test time, the moving averages instead of the raw weights are used. The training process takes roughly 20 hours on a single Titan X GPU. We also train an ensemble model consisting of 12 training runs with the identical architecture and hyper-parameters. At test time, we choose the answer with the highest sum of confidence scores amongst the 12 runs for each question.
+
+Results. The results of our model and competing approaches on the hidden test are summarized in Table 1a. BIDAF (ensemble) achieves an EM score of 73.3 and an F1 score of 81.1, outperforming all previous approaches.
+
+Ablations. Table 1b shows the performance of our model and its ablations on the SQuAD dev set. Both char-level and word-level embeddings contribute towards the model’s performance. We conjecture that word-level embedding is better at representing the semantics of each word as a whole, while char-level embedding can better handle out-of-vocab (OOV) or rare words. To evaluate bidirectional attention, we remove C2Q and Q2C attentions. For ablating C2Q attention, we replace the attended question vector $\tilde { \textbf { U } }$ with the average of the output vectors of the question’s contextual embedding layer (LSTM). C2Q attention proves to be critical with a drop of more than 10 points on both metrics. For ablating Q2C attention, the output of the attention layer, G, does not include terms that have the attended Q2C vectors, $\tilde { \bf H }$ . To evaluate the attention flow, we study a dynamic attention model, where the attention is dynamically computed within the modeling layer’s LSTM, following previous work (Bahdanau et al., 2015; Wang & Jiang, 2016). This is in contrast with our approach, where the attention is pre-computed before flowing to the modeling layer. Despite being a simpler attention mechanism, our proposed static attention outperforms the dynamically computed attention by more than 3 points. We conjecture that separating out the attention layer results in a richer set of features computed in the first 4 layers which are then incorporated by the modeling layer. We also show the performance of BIDAF with several different definitions of $\alpha$ and $\beta$ functions (Equation 1 and 2) in Appendix B.
+
+<table><tr><td>Layer</td><td>Query</td><td>Closest words in the Context using cosine similarity</td></tr><tr><td>Word</td><td>When</td><td>when,When,After,after,He,he,But,but,before,Before</td></tr><tr><td>Contextual</td><td>When</td><td>When, when,1945,1991,1971,1967,1990,1972,1965,1953</td></tr><tr><td>Word</td><td>Where</td><td>Where,where,It,IT,it,they,They,that,That,city</td></tr><tr><td>Contextual</td><td>Where</td><td>where,Where,Rotterdam,area,Nearby,location,outside,Area,across,locations</td></tr><tr><td>Word Contextual</td><td>Who Who</td><td>Who,who,He,he,had,have,she,She,They,they who,whose,whom,Guiscard, person, John,Thomas,families,Elway,Louis</td></tr><tr><td>Word Contextual</td><td>city</td><td>City,city, town,Town, Capital,capital, district, cities,province,Downtown</td></tr><tr><td>Word</td><td>city January</td><td>city,City,Angeles,Paris,Prague,Chicago,Port,Pittsburgh,London,Manhattan July,December,June,October,Juary,eptember,February,April,November,rch</td></tr><tr><td>Contextual</td><td>January</td><td>January,March,December,August,December,July,July,July,March,December</td></tr><tr><td>Word</td><td>Seahawks</td><td>Seahawks,Broncos,49ers,Ravens,Chargers,Steelers,quarterback,Vikings,Colts,NFL</td></tr><tr><td>Contextual Word</td><td>Seahawks</td><td>Seahawks,Broncos,Panthers,Vikings,Packers,Ravens,Patriots,Falcons,Steelers,Chargers</td></tr><tr><td>Contextual</td><td>date</td><td>date,dates,until,Until,June,July,Year,year,December,deadline</td></tr><tr><td></td><td>date</td><td>date,dates,December,July,January,October,June,November,March,February</td></tr></table>
+
+![](images/7757c7656332a6a3b06f97b0ebf7763ba27b455d0c2af2acf07a0dcd8b41d2e2.jpg)  
+Table 2: Closest context words to a given query word, using a cosine similarity metric computed in the Word Embedding feature space and the Phrase Embedding feature space.   
+Figure 2: (a) t-SNE visualizations of the months names embedded in the two feature spaces. The contextual embedding layer is able to distinguish the two usages of the word May using context from the surrounding text. (b) Venn diagram of the questions answered correctly by our model and the more traditional baseline (Rajpurkar et al., 2016). (c) Correctly answered questions broken down by the 10 most frequent first words in the question.
+
+Visualizations. We now provide a qualitative analysis of our model on the SQuAD dev set. First, we visualize the feature spaces after the word and contextual embedding layers. These two layers are responsible for aligning the embeddings between the query and context words which are the inputs to the subsequent attention layer. To visualize the embeddings, we choose a few frequent query words in the dev data and look at the context words that have the highest cosine similarity to the query words (Table 2). At the word embedding layer, query words such as When, Where and Who are not well aligned to possible answers in the context, but this dramatically changes in the contextual embedding layer which has access to context from surrounding words and is just 1 layer below the attention layer. When begins to match years, Where matches locations, and Who matches names.
+
+We also visualize these two feature spaces using t-SNE in Figure 2. t-SNE is performed on a large fraction of dev data but we only plot data points corresponding to the months of the year. An interesting pattern emerges in the Word space, where May is separated from the rest of the months because May has multiple meanings in the English language. The contextual embedding layer uses contextual cues from surrounding words and is able to separate the usages of the word May. Finally we visualize the attention matrices for some question-context tuples in the dev data in Figure 3. In the first example, Where matches locations and in the second example, many matches quantities and numerical symbols. Also, entities in the question typically attend to the same entities in the context, thus providing a feature for the model to localize possible answers.
+
+Discussions. We analyse the performance of our our model with a traditional language-featurebased baseline (Rajpurkar et al., 2016). Figure 2b shows a Venn diagram of the dev set questions correctly answered by the models. Our model is able to answer more than $86 \%$ of the questions correctly answered by the baseline. The $14 \%$ that are incorrectly answered does not have a clear pattern. This suggests that neural architectures are able to exploit much of the information captured by the language features. We also break this comparison down by the first words in the questions (Figure 2c). Our model outperforms the traditional baseline comfortably in every category.
+
+![](images/26d62f32002af2aad3857c67045cb6f5ec597c54027d4550e780e69ce794908c.jpg)  
+Figure 3: Attention matrices for question-context tuples. The left palette shows the context paragraph (correct answer in red and underlined), the middle palette shows the attention matrix (each row is a question word, each column is a context word), and the right palette shows the top attention points for each question word, above a threshold.
+
+Error Analysis. We randomly select 50 incorrect questions (based on EM) and categorize them into 6 classes. $50 \%$ of errors are due to the imprecise boundaries of the answers, $28 \%$ involve syntactic complications and ambiguities, $14 \%$ are paraphrase problems, $4 \%$ require external knowledge, $2 \%$ need multiple sentences to answer, and $2 \%$ are due to mistakes during tokenization. See Appendix A for the examples of the error modes.
+
+# 5 CLOZE TEST EXPERIMENTS
+
+We also evaluate our model on the task of cloze-style reading comprehension using the CNN and Daily Mail datasets (Hermann et al., 2015).
+
+Dataset. In a cloze test, the reader is asked to fill in words that have been removed from a passage, for measuring one’s ability to comprehend text. Hermann et al. (2015) have recently compiled a massive Cloze-style comprehension dataset, consisting of $3 0 0 \mathrm { k } / 4 \mathrm { k } / 3 \mathrm { k }$ and 879k/65k/53k (train/dev/test) examples from CNN and DailyMail news articles, respectively. Each example has a news article and an incomplete sentence extracted from the human-written summary of the article. To distinguish this task from language modeling and force one to refer to the article to predict the correct missing word, the missing word is always a named entity, anonymized with a random ID. Also, the IDs must be shuffled constantly during test, which is also critical for full anonymization.
+
+Model Details. The model architecture used for this task is very similar to that for SQuAD (Section 4) with only a few small changes to adapt it to the cloze test. Since each answer in the CNN/DailyMail datasets is always a single word (entity), we only need to predict the start index $( \mathbf { p } ^ { 1 } )$ ; the prediction for the end index $( \mathbf { p } ^ { 2 } )$ is omitted from the loss function. Also, we mask out all non-entity words in the final classification layer so that they are forced to be excluded from possible answers. Another important difference from SQuAD is that the answer entity might appear more than once in the context paragraph. To address this, we follow a similar strategy from Kadlec et al. (2016). During training, after we obtain $\mathbf { p } ^ { 1 }$ , we sum all probability values of the entity instances in the context that correspond to the correct answer. Then the loss function is computed from the summed probability. We use a minibatch size of 48 and train for 8 epochs, with early stop when the accuracy on validation data starts to drop. Inspired by the window-based method (Hill et al., 2016), we split each article into short sentences where each sentence is a 19-word window around each entity (hence the same word might appear in multiple sentences). The RNNs in BIDAF are not feed-forwarded or back-propagated across sentences, which speed up the training process by parallelization. The entire training process takes roughly 60 hours on eight Titan X GPUs. The other hyper-parameters are identical to the model described in Section 4.
+
+Results. The results of our single-run models and competing approaches on the CNN/DailyMail datasets are summarized in Table 3. ∗ indicates ensemble methods. BIDAF outperforms previous single-run models on both datasets for both val and test data. On the DailyMail test, our single-run model even outperforms the best ensemble method.
+
+Table 3: Results on CNN/DailyMail datasets. We also include the results of previous ensemble methods (marked with $^ *$ ) for completeness.   
+
+<table><tr><td rowspan="2"></td><td colspan="2">CNN</td><td colspan="2">DailyMail</td></tr><tr><td>val</td><td>test</td><td>val</td><td>test</td></tr><tr><td>Attentive Reader (Hermann et al.,2015)</td><td>61.6</td><td>63.0</td><td>70.5</td><td>69.0</td></tr><tr><td>MemNN (Hill et al.,2016)</td><td>63.4</td><td>6.8</td><td>=</td><td></td></tr><tr><td>AS Reader (Kadlec et al.,2016)</td><td>68.6</td><td>69.5</td><td>75.0</td><td>73.9</td></tr><tr><td>DER Network (Kobayashi et al.,2016)</td><td>71.3</td><td>72.9</td><td>1</td><td>-</td></tr><tr><td>Iterative Attention (Sordoni et al.,2016)</td><td>72.6</td><td>73.3</td><td>-</td><td>=</td></tr><tr><td>EpiReader (Trischler et al.,2016) Stanford AR (Chen et al.,2016)</td><td>73.4</td><td>74.0</td><td>=</td><td>-</td></tr><tr><td>GAReader (Dhingra et al.,2016)</td><td>73.8</td><td>73.6</td><td>77.6</td><td>76.6</td></tr><tr><td>AoA Reader (Cui et al., 2016)</td><td>73.0</td><td>73.8</td><td>76.7</td><td>75.7</td></tr><tr><td></td><td>73.1</td><td>74.4</td><td></td><td>=</td></tr><tr><td>ReasoNet (Shen et al.,2016) BIDAF (Ours)</td><td>72.9</td><td>74.7</td><td>77.6</td><td>76.6</td></tr><tr><td>MemNN* (Hill et al., 2016)</td><td>76.3</td><td>76.9</td><td>80.3</td><td>79.6</td></tr><tr><td></td><td>66.2</td><td>69.4</td><td>-</td><td>=</td></tr><tr><td>ASReader* (Kadlec et al.,2016)</td><td>73.9</td><td>75.4</td><td>78.7</td><td>77.7</td></tr><tr><td>Iterative Attention*(Sordoni et al.,2016)</td><td>74.5</td><td>75.7</td><td>-</td><td>-</td></tr><tr><td>GA Reader* (Dhingra et al.,2016)</td><td>76.4</td><td>77.4</td><td>79.1</td><td>78.1</td></tr><tr><td>Stanford AR*(Chen et al., 2016)</td><td>77.2</td><td>77.6</td><td>80.2</td><td>79.2</td></tr></table>
+
+# 6 CONCLUSION
+
+In this paper, we introduce BIDAF, a multi-stage hierarchical process that represents the context at different levels of granularity and uses a bi-directional attention flow mechanism to achieve a queryaware context representation without early summarization. The experimental evaluations show that our model achieves the state-of-the-art results in Stanford Question Answering Dataset (SQuAD) and CNN/DailyMail cloze test. The ablation analyses demonstrate the importance of each component in our model. The visualizations and discussions show that our model is learning a suitable representation for MC and is capable of answering complex questions by attending to correct locations in the given paragraph. Future work involves extending our approach to incorporate multiple hops of the attention layer.
+
+# ACKNOWLEDGMENTS
+
+This research was supported by the NSF (IIS 1616112), NSF (III 1703166), Allen Institute for AI (66-9175), Allen Distinguished Investigator Award, Google Research Faculty Award, and Samsung GRO Award. We thank the anonymous reviewers for their helpful comments.
+
+# REFERENCES
+
+Stanislaw Antol, Aishwarya Agrawal, Jiasen Lu, Margaret Mitchell, Dhruv Batra, C Lawrence Zitnick, and Devi Parikh. Vqa: Visual question answering. In ICCV, 2015.
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. ICLR, 2015.
+
+Danqi Chen, Jason Bolton, and Christopher D. Manning. A thorough examination of the cnn/daily mail reading comprehension task. In ACL, 2016.
+
+Yiming Cui, Zhipeng Chen, Si Wei, Shijin Wang, Ting Liu, and Guoping Hu. Attention-overattention neural networks for reading comprehension. arXiv preprint arXiv:1607.04423, 2016.
+
+Bhuwan Dhingra, Hanxiao Liu, William W Cohen, and Ruslan Salakhutdinov. Gated-attention readers for text comprehension. arXiv preprint arXiv:1606.01549, 2016.
+
+Akira Fukui, Dong Huk Park, Daylen Yang, Anna Rohrbach, Trevor Darrell, and Marcus Rohrbach. Multimodal compact bilinear pooling for visual question answering and visual grounding. In EMNLP, 2016.
+
+Karl Moritz Hermann, Tomas Kocisk ´ y, Edward Grefenstette, Lasse Espeholt, Will Kay, Mustafa ´ Suleyman, and Phil Blunsom. Teaching machines to read and comprehend. In NIPS, 2015.
+
+Felix Hill, Antoine Bordes, Sumit Chopra, and Jason Weston. The goldilocks principle: Reading children’s books with explicit memory representations. In ICLR, 2016.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. Neural Computation, 1997.
+
+Rudolf Kadlec, Martin Schmid, Ondrej Bajgar, and Jan Kleindienst. Text understanding with the attention sum reader network. In ACL, 2016.
+
+Yoon Kim. Convolutional neural networks for sentence classification. In EMNLP, 2014.
+
+Sosuke Kobayashi, Ran Tian, Naoaki Okazaki, and Kentaro Inui. Dynamic entity representation with max-pooling improves machine reading. In NAACL-HLT, 2016.
+
+Kenton Lee, Tom Kwiatkowski, Ankur Parikh, and Dipanjan Das. Learning recurrent span representations for extractive question answering. arXiv preprint arXiv:1611.01436, 2016.
+
+Jiasen Lu, Jianwei Yang, Dhruv Batra, and Devi Parikh. Hierarchical question-image co-attention for visual question answering. In NIPS, 2016.
+
+Mateusz Malinowski, Marcus Rohrbach, and Mario Fritz. Ask your neurons: A neural-based approach to answering questions about images. In ICCV, 2015.
+
+Jeffrey Pennington, Richard Socher, and Christopher D Manning. Glove: Global vectors for word representation. In EMNLP, 2014.
+
+Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: $1 0 0 { , } 0 0 0 { + }$ questions for machine comprehension of text. In EMNLP, 2016.
+
+Matthew Richardson, Christopher JC Burges, and Erin Renshaw. Mctest: A challenge dataset for the open-domain machine comprehension of text. In EMNLP, 2013.
+
+Yelong Shen, Po-Sen Huang, Jianfeng Gao, and Weizhu Chen. Reasonet: Learning to stop reading in machine comprehension. arXiv preprint arXiv:1609.05284, 2016.
+
+Alessandro Sordoni, Phillip Bachman, and Yoshua Bengio. Iterative alternating neural attention for machine reading. arXiv preprint arXiv:1606.02245, 2016.
+
+Nitish Srivastava, Geoffrey E. Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. JMLR, 2014.
+
+Rupesh Kumar Srivastava, Klaus Greff, and Jurgen Schmidhuber. Highway networks. ¨ arXiv preprint arXiv:1505.00387, 2015.
+
+Adam Trischler, Zheng Ye, Xingdi Yuan, and Kaheer Suleman. Natural language comprehension with the epireader. In EMNLP, 2016.   
+Shuohang Wang and Jing Jiang. Machine comprehension using match-lstm and answer pointer. arXiv preprint arXiv:1608.07905, 2016.   
+Jason Weston, Sumit Chopra, and Antoine Bordes. Memory networks. In ICLR, 2015.   
+Caiming Xiong, Stephen Merity, and Richard Socher. Dynamic memory networks for visual and textual question answering. In ICML, 2016a.   
+Caiming Xiong, Victor Zhong, and Richard Socher. Dynamic coattention networks for question answering. arXiv preprint arXiv:1611.01604, 2016b.   
+Huijuan Xu and Kate Saenko. Ask, attend and answer: Exploring question-guided spatial attention for visual question answering. In ECCV, 2016.   
+Zhilin Yang, Bhuwan Dhingra, Ye Yuan, Junjie Hu, William W Cohen, and Ruslan Salakhutdinov. Words or characters? fine-grained gating for reading comprehension. arXiv preprint arXiv:1611.01724, 2016.   
+Zichao Yang, Xiaodong He, Jianfeng Gao, Li Deng, and Alex Smola. Stacked attention networks for image question answering. arXiv preprint arXiv:1511.02274, 2015.   
+Yang Yu, Wei Zhang, Kazi Hasan, Mo Yu, Bing Xiang, and Bowen Zhou. End-to-end reading comprehension with dynamic answer chunk ranking. arXiv preprint arXiv:1610.09996, 2016.   
+Matthew D Zeiler. Adadelta: an adaptive learning rate method. arXiv preprint arXiv:1212.5701, 2012.   
+Yuke Zhu, Oliver Groth, Michael S. Bernstein, and Li Fei-Fei. Visual7w: Grounded question answering in images. In CVPR, 2016.
+
+# A ERROR ANALYSIS
+
+Table 4 summarizes the modes of errors by BIDAF and shows examples for each category of error in SQuAD.   
+
+<table><tr><td>Error type</td><td>Ratio (%)</td><td>Example</td></tr><tr><td>Imprecise answer boundaries</td><td>50</td><td>Context: “The Free Movement of Workers Regulation articles 1 to 7 set out the main provisions on equal treatment of workers.” Question:“Which articles of the Free Movement of Workers Regulation set out the primary provisions on equal treatment of workers?” Prediction: “1 to 7&quot;, Answer: “articles 1 to 7”</td></tr><tr><td>Syntactic complications and ambiguities</td><td>28</td><td>Context: “A piece of paper was later found on which Luther had written his last statement.” Question: “What was later discovered written by Luther?&quot; Prediction: “A piece of paper&quot;,Answer: “his last statement&quot;</td></tr><tr><td>Paraphrase problems</td><td>14</td><td>tier model which includes primary education (primary schools), followed by secondary education (secondary schools/high schools） and tertiary education (universities and/or TAFE colleges).” Question:“What is the first model of education, in the Aus- tralian system?” Prediction: “three-tier”,Answer: “primary education&quot;</td></tr><tr><td>External knowledge</td><td>4</td><td>Context:“On June 4， 2014， the NFL announced that the practice of branding Super Bowl games with Roman numerals, a practice established at Super Bowl V,would be temporarily suspended,and that the game would be named using Arabic numerals as Super Bowl 50 as opposed to Super Bowl L.&quot; Question: “If Roman numerals were used in the naming of the 50th Super Bowl, which one would have been used?&#x27; Prediction: “Super Bowl 5O”, Answer: “L&quot;</td></tr><tr><td>Multi- sentence</td><td>2 starting in the mid-1980s.&quot;</td><td>interactive connections the network was enhanced to support terminal to host connections，host to host batch connections (remote job submission,remote printing,batch file transfer), interactive file transfer, gateways to the Tymnet and Telenet public data networks, X.25 host atachments, gateways to X.25 data networks,Ethernet attached hosts,and eventually TCP/IP and additional public universities in Michigan join the network. All of this set the stage for Merit&#x27;s role in the NSFNET project Question: “What set the stage for Merits role in NSFNET&quot; Prediction:“All of this set the stage for Merit &#x27;s role in the</td></tr><tr><td>Incorrect preprocessing</td><td>2</td><td>this work by showing that fire requires only a part of air that he called spiritus nitroaereus or just nitroaereus.&quot; Question: “John Mayow died in what year?&quot; Prediction: “1641-1679&quot;,Answer: “1679&quot;</td></tr></table>
+
+into 6 different categories. Only relevant sentence(s) from the context shown for brevity.
+
+# B VARIATIONS OF SIMILARITY AND FUSION FUNCTIONS
+
+<table><tr><td></td><td>EM</td><td>F1</td></tr><tr><td>Eqn. 1: dot product Eqn. 1: linear Eqn. 1: bilinear</td><td>65.5 59.5 61.6</td><td>75.5 69.7 71.8</td></tr><tr><td>Eqn. 1: linear after MLP</td><td>66.2</td><td>76.4</td></tr><tr><td>Eqn. 2: MLP after concat</td><td>67.1</td><td>77.0</td></tr><tr><td>BIDAF (single)</td><td>68.0</td><td>77.3</td></tr></table>
+
+Table 5: Variations of similarity function $\alpha$ (Equation 1) and fusion function $\beta$ (Equation 2) and their performance on the dev data of SQuAD. See Appendix B for the details of each variation.
+
+In this appendix section, we experimentally demonstrate how different choices of the similarity function $\alpha$ (Equation 1) and the fusion function $\beta$ (Equation 2) impact the performance of our model. Each variation is defined as following:
+
+Eqn. 1: dot product. Dot product $\alpha$ is defined as
+
+$$
+\alpha ( \mathbf { h } , \mathbf { u } ) = \mathbf { h } ^ { \top } \mathbf { u }
+$$
+
+where $\top$ indicates matrix transpose. Dot product has been used for the measurement of similarity between two vectors by Hill et al. (2016).
+
+Eqn. 1: linear. Linear $\alpha$ is defined as
+
+$$
+\alpha ( \mathbf { h } , \mathbf { u } ) = \mathbf { w } _ { \mathrm { l i n } } ^ { \top } [ \mathbf { h } ; \mathbf { u } ]
+$$
+
+where $\mathbf { w } _ { \mathrm { l i n } } ^ { \top } \in \mathbb { R } ^ { 4 d }$ is a trainable weight matrix. This can be considered as the simplification of Equation 1 by dropping the term $\mathbf { h } \circ \mathbf { u }$ in the concatenation.
+
+Eqn. 1: bilinear. Bilinear $\alpha$ is defined as
+
+$$
+\alpha ( \mathbf { h } , \mathbf { u } ) = \mathbf { h } ^ { \top } \mathbf { W } _ { \mathbf { \mathrm { b i } } } \mathbf { u }
+$$
+
+where $\mathbf { W _ { \mathrm { b i } } } \in \mathbb { R } ^ { 2 d \times 2 d }$ is a trainable weight matrix. Bilinear term has been used by Chen et al.   
+(2016).
+
+Eqn. 1: linear after MLP. We can also perform linear mapping after single layer of perceptron:
+
+$$
+\alpha ( \mathbf { h } , \mathbf { u } ) = \mathbf { w } _ { \mathrm { l i n } } ^ { \top } \operatorname { t a n h } ( \mathbf { W } _ { \mathrm { m l p } } [ \mathbf { h } ; \mathbf { u } ] + \mathbf { b } _ { \mathrm { m l p } } )
+$$
+
+where $\mathbf { W } _ { \mathrm { m l p } }$ and $\mathbf { b } _ { \mathrm { m l p } }$ are trainable weight matrix and bias, respectively. Linear mapping after perceptron layer has been used by Hermann et al. (2015).
+
+Eqn. 2: MLP after concatenation. We can define $\beta$ as
+
+$$
+\beta ( \mathbf { h } , { \tilde { \mathbf { u } } } , { \tilde { \mathbf { h } } } ) = \operatorname* { m a x } ( 0 , \mathbf { W } _ { \mathrm { m l p } } [ \mathbf { h } ; { \tilde { \mathbf { u } } } ; \mathbf { h } \circ { \tilde { \mathbf { u } } } ; \mathbf { h } \circ { \tilde { \mathbf { h } } } ] + \mathbf { b } _ { \mathrm { m l p } } )
+$$
+
+where $\mathbf { W } _ { \mathrm { m l p } } \in \mathbb { R } ^ { 2 d \times 8 d }$ and ${ \bf b } _ { \mathrm { m l p } } \in \mathbb { R } ^ { 2 d }$ are trainable weight matrix and bias. This is equivalent to adding ReLU after linearly transforming the original definition of $\beta$ . Since the output dimension of $\beta$ changes, the input dimension of the first LSTM of the modeling layer will change as well.
+
+The results of these variations on the dev data of SQuAD are shown in Table 5. It is important to note that there are non-trivial gaps between our definition of $\alpha$ and other definitions employed by previous work. Adding MLP in $\beta$ does not seem to help, yielding slightly worse result than $\beta$ without MLP.

parse/train/HJ0UKP9ge/HJ0UKP9ge_content_list.json

@@ -0,0 +1,1417 @@
+[
+    {
+        "type": "text",
+        "text": "BI-DIRECTIONAL ATTENTION FLOW FOR MACHINE COMPREHENSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            611,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Minjoon $\\mathbf { S e o ^ { 1 * } }$ Aniruddha Kembhavi2 Ali Farhadi1,2 Hananneh Hajishirzi1 University of Washington1, Allen Institute for Artificial Intelligence2 {minjoon,ali,hannaneh}@cs.washington.edu, $\\{ \\mathtt { a n i k } \\} \\ @ \\mathtt { a l l e n a i . o r g }$ ",
+        "bbox": [
+            183,
+            169,
+            789,
+            213
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            250,
+            544,
+            265
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Machine comprehension (MC), answering a query about a given context paragraph, requires modeling complex interactions between the context and the query. Recently, attention mechanisms have been successfully extended to MC. Typically these methods use attention to focus on a small portion of the context and summarize it with a fixed-size vector, couple attentions temporally, and/or often form a uni-directional attention. In this paper we introduce the Bi-Directional Attention Flow (BIDAF) network, a multi-stage hierarchical process that represents the context at different levels of granularity and uses bidirectional attention flow mechanism to obtain a query-aware context representation without early summarization. Our experimental evaluations show that our model achieves the state-of-the-art results in Stanford Question Answering Dataset (SQuAD) and CNN/DailyMail cloze test. ",
+        "bbox": [
+            233,
+            281,
+            764,
+            446
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            474,
+            336,
+            489
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The tasks of machine comprehension (MC) and question answering (QA) have gained significant popularity over the past few years within the natural language processing and computer vision communities. Systems trained end-to-end now achieve promising results on a variety of tasks in the text and image domains. One of the key factors to the advancement has been the use of neural attention mechanism, which enables the system to focus on a targeted area within a context paragraph (for MC) or within an image (for Visual QA), that is most relevant to answer the question (Weston et al., 2015; Antol et al., 2015; Xiong et al., 2016a). Attention mechanisms in previous works typically have one or more of the following characteristics. First, the computed attention weights are often used to extract the most relevant information from the context for answering the question by summarizing the context into a fixed-size vector. Second, in the text domain, they are often temporally dynamic, whereby the attention weights at the current time step are a function of the attended vector at the previous time step. Third, they are usually uni-directional, wherein the query attends on the context paragraph or the image. ",
+        "bbox": [
+            174,
+            506,
+            825,
+            686
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we introduce the Bi-Directional Attention Flow (BIDAF) network, a hierarchical multi-stage architecture for modeling the representations of the context paragraph at different levels of granularity (Figure 1). BIDAF includes character-level, word-level, and contextual embeddings, and uses bi-directional attention flow to obtain a query-aware context representation. Our attention mechanism offers following improvements to the previously popular attention paradigms. First, our attention layer is not used to summarize the context paragraph into a fixed-size vector. Instead, the attention is computed for every time step, and the attended vector at each time step, along with the representations from previous layers, is allowed to flow through to the subsequent modeling layer. This reduces the information loss caused by early summarization. Second, we use a memory-less attention mechanism. That is, while we iteratively compute attention through time as in Bahdanau et al. (2015), the attention at each time step is a function of only the query and the context paragraph at the current time step and does not directly depend on the attention at the previous time step. We hypothesize that this simplification leads to the division of labor between the attention layer and the modeling layer. It forces the attention layer to focus on learning the attention between the query and the context, and enables the modeling layer to focus on learning the interaction within the query-aware context representation (the output of the attention layer). It also allows the attention at each time step to be unaffected from incorrect attendances at previous time steps. Our experiments show that memory-less attention gives a clear advantage over dynamic attention. Third, we use attention mechanisms in both directions, query-to-context and context-to-query, which provide complimentary information to each other. ",
+        "bbox": [
+            174,
+            693,
+            825,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/8ae29f18b08da1ee65cc07b50c3d43461883b2cbc78ed590d8d2592a92dfe01e.jpg",
+        "image_caption": [
+            "Figure 1: BiDirectional Attention Flow Model (best viewed in color) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            102,
+            841,
+            401
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            458,
+            825,
+            527
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our BIDAF model1 outperforms all previous approaches on the highly-competitive Stanford Question Answering Dataset (SQuAD) test set leaderboard at the time of submission. With a modification to only the output layer, BIDAF achieves the state-of-the-art results on the CNN/DailyMail cloze test. We also provide an in-depth ablation study of our model on the SQuAD development set, visualize the intermediate feature spaces in our model, and analyse its performance as compared to a more traditional language model for machine comprehension (Rajpurkar et al., 2016). ",
+        "bbox": [
+            174,
+            535,
+            825,
+            618
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            640,
+            267,
+            656
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our machine comprehension model is a hierarchical multi-stage process and consists of six layers (Figure 1): ",
+        "bbox": [
+            176,
+            672,
+            825,
+            700
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. Character Embedding Layer maps each word to a vector space using character-level CNNs.   \n2. Word Embedding Layer maps each word to a vector space using a pre-trained word embedding model.   \n3. Contextual Embedding Layer utilizes contextual cues from surrounding words to refine the embedding of the words. These first three layers are applied to both the query and context.   \n4. Attention Flow Layer couples the query and context vectors and produces a set of queryaware feature vectors for each word in the context.   \n5. Modeling Layer employs a Recurrent Neural Network to scan the context.   \n6. Output Layer provides an answer to the query. ",
+        "bbox": [
+            210,
+            713,
+            825,
+            900
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. Character Embedding Layer. Character embedding layer is responsible for mapping each word to a high-dimensional vector space. Let $\\{ \\pmb { x } _ { 1 } , \\hdots \\pmb { x } _ { T } \\}$ and $\\{ q _ { 1 } , \\dots q _ { J } \\}$ represent the words in the input context paragraph and query, respectively. Following Kim (2014), we obtain the characterlevel embedding of each word using Convolutional Neural Networks (CNN). Characters are embedded into vectors, which can be considered as 1D inputs to the CNN, and whose size is the input channel size of the CNN. The outputs of the CNN are max-pooled over the entire width to obtain a fixed-size vector for each word. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2. Word Embedding Layer. Word embedding layer also maps each word to a high-dimensional vector space. We use pre-trained word vectors, GloVe (Pennington et al., 2014), to obtain the fixed word embedding of each word. ",
+        "bbox": [
+            174,
+            217,
+            823,
+            260
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The concatenation of the character and word embedding vectors is passed to a two-layer Highway Network (Srivastava et al., 2015). The outputs of the Highway Network are two sequences of $d$ - dimensional vectors, or more conveniently, two matrices: $\\breve { \\mathbf { X } } \\in \\breve { \\mathbb { R } } ^ { d \\times T }$ for the context and $\\mathbf { Q } \\in \\mathbb { R } ^ { d \\times J }$ for the query. ",
+        "bbox": [
+            173,
+            266,
+            825,
+            323
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3. Contextual Embedding Layer. We use a Long Short-Term Memory Network (LSTM) (Hochreiter & Schmidhuber, 1997) on top of the embeddings provided by the previous layers to model the temporal interactions between words. We place an LSTM in both directions, and concatenate the outputs of the two LSTMs. Hence we obtain $\\mathbf { H } \\in \\mathbb { R } ^ { 2 d \\times T }$ from the context word vectors $\\mathbf { X }$ , and $\\mathbf { U } \\in \\mathbb { R } ^ { 2 d \\times J }$ from query word vectors $\\mathbf { Q }$ . Note that each column vector of $\\mathbf { H }$ and $\\mathbf { U }$ is $2 d$ -dimensional because of the concatenation of the outputs of the forward and backward LSTMs, each with $d .$ -dimensional output. ",
+        "bbox": [
+            173,
+            339,
+            825,
+            436
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "It is worth noting that the first three layers of the model are computing features from the query and context at different levels of granularity, akin to the multi-stage feature computation of convolutional neural networks in the computer vision field. ",
+        "bbox": [
+            174,
+            444,
+            825,
+            486
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4. Attention Flow Layer. Attention flow layer is responsible for linking and fusing information from the context and the query words. Unlike previously popular attention mechanisms (Weston et al., 2015; Hill et al., 2016; Sordoni et al., 2016; Shen et al., 2016), the attention flow layer is not used to summarize the query and context into single feature vectors. Instead, the attention vector at each time step, along with the embeddings from previous layers, are allowed to flow through to the subsequent modeling layer. This reduces the information loss caused by early summarization. ",
+        "bbox": [
+            174,
+            502,
+            825,
+            587
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The inputs to the layer are contextual vector representations of the context H and the query U. The outputs of the layer are the query-aware vector representations of the context words, $\\mathbf { G }$ , along with the contextual embeddings from the previous layer. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            636
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this layer, we compute attentions in two directions: from context to query as well as from query to context. Both of these attentions, which will be discussed below, are derived from a shared similarity matrix, $\\mathbf { S } \\in \\mathbb { R } ^ { T \\times J }$ , between the contextual embeddings of the context $( \\mathbf { H } )$ and the query (U), where $\\mathbf { S } _ { t j }$ indicates the similarity between $t$ -th context word and $j$ -th query word. The similarity matrix is computed by ",
+        "bbox": [
+            174,
+            642,
+            823,
+            712
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bf4318ffe54749fd59c99d2261d600c2c1c80b3543e9e5a49312f46ec06d90ec.jpg",
+        "text": "$$\n\\mathbf { S } _ { t j } = \\alpha ( \\mathbf { H } _ { : t } , \\mathbf { U } _ { : j } ) \\in \\mathbb { R }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            712,
+            578,
+            729
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha$ is a trainable scalar function that encodes the similarity between its two input vectors, $\\mathbf { H } _ { : t }$ is $t$ -th column vector of $\\mathbf { H }$ , and $\\mathbf { U } _ { : j }$ is $j$ -th column vector of $\\mathbf { U }$ , We choose $\\alpha ( \\mathbf { h } , \\mathbf { u } ) { \\bf \\bar { \\alpha } } = \\mathbf { w } _ { ( \\mathbf { s } ) } ^ { \\top } [ \\mathbf { h } ; \\mathbf { u } ; \\mathbf { h } \\circ$ $\\mathbf { u } ]$ , where $\\mathbf { w } _ { ( \\mathbf { S } ) } \\in \\mathbb { R } ^ { 6 d }$ is a trainable weight vector, $\\circ$ is elementwise multiplication, $[ ; ]$ is vector concatenation across row, and implicit multiplication is matrix multiplication. Now we use $\\mathbf { S }$ to obtain the attentions and the attended vectors in both directions. ",
+        "bbox": [
+            174,
+            733,
+            823,
+            808
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Context-to-query Attention. Context-to-query (C2Q) attention signifies which query words are most relevant to each context word. Let $\\mathbf { a } _ { t } \\in \\mathbf { \\overline { { \\mathbb { R } } } } ^ { J }$ represent the attention weights on the query words by $t { \\cdot }$ -th context word, $\\textstyle \\sum { \\mathbf { a } } _ { t j } = 1$ for all $t$ . The attention weight is computed by $\\mathbf { a } _ { t } = \\mathrm { s o f t m a x } ( \\mathbf { S } _ { t : } ) \\in$ $\\mathbb { R } ^ { J }$ , and subsequently each attended query vector is $\\begin{array} { r } { \\tilde { \\mathbf { U } } _ { : t } = \\sum _ { j } \\mathbf { a } _ { t j } \\mathbf { U } _ { : j } } \\end{array}$ . Hence $\\tilde { \\textbf { U } }$ is a $2 d$ -by- $\\mathcal { T }$ matrix containing the attended query vectors for the entire context. ",
+        "bbox": [
+            174,
+            814,
+            823,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Query-to-context Attention. Query-to-context (Q2C) attention signifies which context words have the closest similarity to one of the query words and are hence critical for answering the query. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We obtain the attention weights on the context words by $\\mathbf { b } = \\mathrm { s o f t m a x } ( \\operatorname* { m a x } _ { c o l } ( \\mathbf { S } ) ) \\in \\mathbb { R } ^ { T }$ , where the maximum function $( \\mathrm { m a x } _ { c o l } )$ is performed across the column. Then the attended context vector is $\\begin{array} { r } { \\tilde { \\mathbf { h } } = \\sum _ { t } \\mathbf { b } _ { t } \\mathbf { H } _ { : t } \\in \\mathbb { R } ^ { 2 d } } \\end{array}$ . This vector indicates the weighted sum of the most important words in the context with respect to the query. $\\tilde { \\mathbf { h } }$ is tiled $T$ times across the column, thus giving $\\tilde { \\mathbf { H } } \\in \\mathbb { R } ^ { 2 d \\times T }$ . ",
+        "bbox": [
+            173,
+            102,
+            825,
+            165
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Finally, the contextual embeddings and the attention vectors are combined together to yield $\\mathbf { G }$ , where each column vector can be considered as the query-aware representation of each context word. We define $\\mathbf { G }$ by ",
+        "bbox": [
+            174,
+            171,
+            825,
+            213
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f812340ff296a2eccd94efb27b9cd1ce9a3d621a09ac24ef9687ca1811ba6ec0.jpg",
+        "text": "$$\n\\mathbf { G } _ { : t } = \\beta ( \\mathbf { H } _ { : t } , \\tilde { \\mathbf { U } } _ { : t } , \\tilde { \\mathbf { H } } _ { : t } ) \\in \\mathbb { R } ^ { d _ { \\mathbf { G } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            210,
+            602,
+            231
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { G } _ { : t }$ is the $t { \\cdot }$ -th column vector (corresponding to $t$ -th context word), $\\beta$ is a trainable vector function that fuses its (three) input vectors, and $d _ { \\mathbf { G } }$ is the output dimension of the $\\beta$ function. While the $\\beta$ function can be an arbitrary trainable neural network, such as multi-layer perceptron, a simple concatenation as following still shows good performance in our experiments: $\\bar { \\beta } ( { \\bf h } , \\bar { \\tilde { \\bf u } } , \\tilde { \\bf h } ) =$ $[ \\mathbf { h } ; \\tilde { \\mathbf { u } } ; \\mathbf { h } \\circ \\tilde { \\mathbf { u } } ; \\mathbf { h } \\circ \\tilde { \\mathbf { h } } ] \\in \\mathbb { R } ^ { 8 d \\times T }$ (i.e., $d _ { \\mathbf { G } } = 8 d _ { \\mathbf { \\rho } }$ ). ",
+        "bbox": [
+            174,
+            232,
+            825,
+            308
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5. Modeling Layer. The input to the modeling layer is $\\mathbf { G }$ , which encodes the query-aware representations of context words. The output of the modeling layer captures the interaction among the context words conditioned on the query. This is different from the contextual embedding layer, which captures the interaction among context words independent of the query. We use two layers of bi-directional LSTM, with the output size of $d$ for each direction. Hence we obtain a matrix $\\mathbf { M } \\in \\mathbb { R } ^ { 2 d \\times T }$ , which is passed onto the output layer to predict the answer. Each column vector of M is expected to contain contextual information about the word with respect to the entire context paragraph and the query. ",
+        "bbox": [
+            173,
+            320,
+            825,
+            434
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "6. Output Layer. The output layer is application-specific. The modular nature of BIDAF allows us to easily swap out the output layer based on the task, with the rest of the architecture remaining exactly the same. Here, we describe the output layer for the QA task. In section 5, we use a slight modification of this output layer for cloze-style comprehension. ",
+        "bbox": [
+            173,
+            446,
+            825,
+            505
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The QA task requires the model to find a sub-phrase of the paragraph to answer the query. The phrase is derived by predicting the start and the end indices of the phrase in the paragraph. We obtain the probability distribution of the start index over the entire paragraph by ",
+        "bbox": [
+            173,
+            511,
+            825,
+            554
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1969557cf23df1f8bdc2accfd0548a82a2a41185a1e3dcce4dcbf923df10bf59.jpg",
+        "text": "$$\n\\mathbf { p } ^ { 1 } = \\mathrm { s o f t m a x } ( \\mathbf { w } _ { ( \\mathbf { p } ^ { 1 } ) } ^ { \\top } [ \\mathbf { G } ; \\mathbf { M } ] ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            559,
+            599,
+            580
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { w } _ { ( \\mathbf { p } ^ { 1 } ) } \\in \\mathbb { R } ^ { 1 0 d }$ is a trainable weight vector. For the end index of the answer phrase, we pass $\\mathbf { M }$ to another bidirectional LSTM layer and obtain $\\mathbf { M } ^ { 2 } \\in \\mathbb { R } ^ { 2 d \\times T }$ . Then we use $\\mathbf { M } ^ { 2 }$ to obtain the probability distribution of the end index in a similar manner: ",
+        "bbox": [
+            174,
+            585,
+            825,
+            632
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/91b29fde4dc63e86f332602185b38be0cb927f43bcccbf80b53123ea813c3cf3.jpg",
+        "text": "$$\n\\mathbf { p } ^ { 2 } = \\mathrm { s o f t m a x } ( \\mathbf { w } _ { ( \\mathbf { p } ^ { 2 } ) } ^ { \\top } [ \\mathbf { G } ; \\mathbf { M } ^ { 2 } ] )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            637,
+            602,
+            659
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Training. We define the training loss (to be minimized) as the sum of the negative log probabilities of the true start and end indices by the predicted distributions, averaged over all examples: ",
+        "bbox": [
+            173,
+            670,
+            826,
+            699
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fd322f72d8f1795d7e7b3b7ca0d064d0b8637364f2ebc2689046a949bae647a3.jpg",
+        "text": "$$\nL ( \\theta ) = - \\frac { 1 } { N } \\sum _ { i } ^ { N } \\log ( \\mathbf { p } _ { y _ { i } ^ { 1 } } ^ { 1 } ) + \\log ( \\mathbf { p } _ { y _ { i } ^ { 2 } } ^ { 2 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            704,
+            627,
+            747
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\theta$ is the set of all trainable weights in the model (the weights and biases of CNN filters and LSTM cells, $\\mathbf { w } _ { ( \\mathbf { S } ) } , \\mathbf { w } _ { ( \\mathbf { p } ^ { 1 } ) }$ and $\\mathbf { w } _ { ( \\mathbf { p } ^ { 2 } ) , }$ ), $N$ is the number of examples in the dataset, $y _ { i } ^ { 1 }$ and $y _ { i } ^ { 2 }$ are the true start and end indices of the $i$ -th example, respectively, and $\\mathbf { p } _ { k }$ indicates the $k$ -th value of the vector $\\mathbf { p }$ . ",
+        "bbox": [
+            173,
+            752,
+            825,
+            809
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Test. The answer span $( k , l )$ where $k \\leq l$ with the maximum value of $\\mathbf { p } _ { k } ^ { 1 } \\mathbf { p } _ { l } ^ { 2 }$ is chosen, which can be computed in linear time with dynamic programming. ",
+        "bbox": [
+            173,
+            814,
+            825,
+            844
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            863,
+            344,
+            881
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Machine comprehension. A significant contributor to the advancement of MC models has been the availability of large datasets. Early datasets such as MCTest (Richardson et al., 2013) were too small to train end-to-end neural models. Massive cloze test datasets (CNN/DailyMail by Hermann et al. (2015) and Childrens Book Test by Hill et al. (2016)), enabled the application of deep neural architectures to this task. More recently, Rajpurkar et al. (2016) released the Stanford Question Answering (SQuAD) dataset with over 100,000 questions. We evaluate the performance of our comprehension system on both SQuAD and CNN/DailyMail datasets. ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            172
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Previous works in end-to-end machine comprehension use attention mechanisms in three distinct ways. The first group (largely inspired by Bahdanau et al. (2015)) uses a dynamic attention mechanism, in which the attention weights are updated dynamically given the query and the context as well as the previous attention. Hermann et al. (2015) argue that the dynamic attention model performs better than using a single fixed query vector to attend on context words on CNN & DailyMail datasets. Chen et al. (2016) show that simply using bilinear term for computing the attention weights in the same model drastically improves the accuracy. Wang & Jiang (2016) reverse the direction of the attention (attending on query words as the context RNN progresses) for SQuAD. In contrast to these models, BIDAF uses a memory-less attention mechanism. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            305
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The second group computes the attention weights once, which are then fed into an output layer for final prediction (e.g., Kadlec et al. (2016)). Attention-over-attention model (Cui et al., 2016) uses a 2D similarity matrix between the query and context words (similar to Equation 1) to compute the weighted average of query-to-context attention. In contrast to these models, BIDAF does not summarize the two modalities in the attention layer and instead lets the attention vectors flow into the modeling (RNN) layer. ",
+        "bbox": [
+            174,
+            313,
+            825,
+            396
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The third group (considered as variants of Memory Network (Weston et al., 2015)) repeats computing an attention vector between the query and the context through multiple layers, typically referred to as multi-hop (Sordoni et al., 2016; Dhingra et al., 2016). Shen et al. (2016) combine Memory Networks with Reinforcement Learning in order to dynamically control the number of hops. One can also extend our BIDAF model to incorporate multiple hops. ",
+        "bbox": [
+            174,
+            402,
+            825,
+            472
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Visual question answering. The task of question answering has also gained a lot of interest in the computer vision community. Early works on visual question answering (VQA) involved encoding the question using an RNN, encoding the image using a CNN and combining them to answer the question (Antol et al., 2015; Malinowski et al., 2015). Attention mechanisms have also been successfully employed for the VQA task and can be broadly clustered based on the granularity of their attention and the approach to construct the attention matrix. At the coarse level of granularity, the question attends to different patches in the image (Zhu et al., 2016; Xiong et al., 2016a). At a finer level, each question word attends to each image patch and the highest attention value for each spatial location (Xu & Saenko, 2016) is adopted. A hybrid approach is to combine questions representations at multiple levels of granularity (unigrams, bigrams, trigrams) (Yang et al., 2015). Several approaches to constructing the attention matrix have been used including element-wise product, element-wise sum, concatenation and Multimodal Compact Bilinear Pooling (Fukui et al., 2016). ",
+        "bbox": [
+            174,
+            488,
+            825,
+            654
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Lu et al. (2016) have recently shown that in addition to attending from the question to image patches, attending from the image back to the question words provides an improvement on the VQA task. This finding in the visual domain is consistent with our finding in the language domain, where our bi-directional attention between the query and context provides improved results. Their model, however, uses the attention weights directly in the output layer and does not take advantage of the attention flow to the modeling layer. ",
+        "bbox": [
+            174,
+            661,
+            825,
+            746
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 QUESTION ANSWERING EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            765,
+            531,
+            781
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we evaluate our model on the task of question answering using the recently released SQuAD (Rajpurkar et al., 2016), which has gained a huge attention over a few months. In the next section, we evaluate our model on the task of cloze-style reading comprehension. ",
+        "bbox": [
+            174,
+            796,
+            823,
+            838
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Dataset. SQuAD is a machine comprehension dataset on a large set of Wikipedia articles, with more than 100,000 questions. The answer to each question is always a span in the context. The model is given a credit if its answer matches one of the human written answers. Two metrics are used to evaluate models: Exact Match (EM) and a softer metric, F1 score, which measures the weighted average of the precision and recall rate at character level. The dataset consists of $9 0 \\mathrm { k } / 1 0 \\mathrm { k }$ ",
+        "bbox": [
+            174,
+            854,
+            823,
+            922
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/d5be28906fe9556b22047bf7df3beeafa32e1d9004d52aec9fec2af3aab6c4ec.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "(a) Results on the SQuAD test set "
+        ],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">Single Model</td><td colspan=\"2\">Ensemble</td></tr><tr><td></td><td>EM</td><td>F1</td><td>EM</td><td>F1</td></tr><tr><td>Logistic Regression Baselinea</td><td>40.4</td><td>51.0</td><td>-</td><td>-</td></tr><tr><td>Dynamic Chunk Readerb</td><td>62.5</td><td>71.0</td><td>-</td><td>-</td></tr><tr><td>Fine-Grained Gatingc</td><td>62.5</td><td>73.3</td><td>1</td><td>-</td></tr><tr><td>Match-LSTMd</td><td>64.7</td><td>73.7</td><td>67.9</td><td>77.0</td></tr><tr><td>Multi-Perspective Matchinge</td><td>65.5</td><td>75.1</td><td>68.2</td><td>77.2</td></tr><tr><td>Dynamic Coattention Networksf</td><td>66.2</td><td>75.9</td><td>71.6</td><td>80.4</td></tr><tr><td>R-Net9</td><td>68.4</td><td>77.5</td><td>72.1</td><td>79.7</td></tr><tr><td>BIDAF (Ours)</td><td>68.0</td><td>77.3</td><td>73.3</td><td>81.1</td></tr></table>",
+        "bbox": [
+            178,
+            101,
+            573,
+            234
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/bd63f00351babffdbccd8606e70f2c30e637db2a89b08deb1b3e5dab361ce306.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "(b) Ablations on the SQuAD dev set "
+        ],
+        "table_body": "<table><tr><td></td><td>EM</td><td>F1</td></tr><tr><td>No char embedding No word embedding No C2Q attention</td><td>65.0 55.5 57.2</td><td>75.4 66.8 67.7</td></tr><tr><td>No Q2C attention Dynamic attention</td><td>63.6 63.5</td><td>73.7 73.6</td></tr><tr><td>BIDAF (single)</td><td>67.7</td><td>77.3</td></tr><tr><td>BIDAF (ensemble)</td><td>72.6</td><td>80.7</td></tr></table>",
+        "bbox": [
+            583,
+            113,
+            810,
+            220
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1: (1a) The performance of our model BIDAF and competing approaches by Rajpurkar et al. $( 2 0 1 6 ) ^ { a }$ , Yu et al. $( 2 0 1 6 ) ^ { b }$ , Yang et al. $( 2 0 1 6 ) ^ { c }$ , Wang & Jiang $( 2 0 1 6 ) ^ { d }$ , IBM Watsone (unpublished), Xiong et al. $( 2 0 1 6 \\mathrm { b } ) ^ { f }$ , and Microsoft Research $\\mathrm { A s i a } ^ { g }$ (unpublished) on the SQuAD test set. A concurrent work by Lee et al. (2016) does not report the test scores. All results shown here reflect the SQuAD leaderboard (stanford-qa.com) as of 6 Dec 2016, $1 2 \\mathrm { p m }$ PST. (1b) The performance of our model and its ablations on the SQuAD dev set. Ablation results are presented only for single runs. ",
+        "bbox": [
+            173,
+            263,
+            825,
+            362
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "train/dev question-context tuples with a large hidden test set. It is one of the largest available MC datasets with human-written questions and serves as a great test bed for our model. ",
+        "bbox": [
+            173,
+            392,
+            823,
+            420
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Model Details. The model architecture used for this task is depicted in Figure 1. Each paragraph and question are tokenized by a regular-expression-based word tokenizer (PTB Tokenizer) and fed into the model. We use $1 0 0 ~ 1 \\mathrm { D }$ filters for CNN char embedding, each with a width of 5. The hidden state size $( d )$ of the model is 100. The model has about 2.6 million parameters. We use the AdaDelta (Zeiler, 2012) optimizer, with a minibatch size of 60 and an initial learning rate of 0.5, for 12 epochs. A dropout (Srivastava et al., 2014) rate of 0.2 is used for the CNN, all LSTM layers, and the linear transformation before the softmax for the answers. During training, the moving averages of all weights of the model are maintained with the exponential decay rate of 0.999. At test time, the moving averages instead of the raw weights are used. The training process takes roughly 20 hours on a single Titan X GPU. We also train an ensemble model consisting of 12 training runs with the identical architecture and hyper-parameters. At test time, we choose the answer with the highest sum of confidence scores amongst the 12 runs for each question. ",
+        "bbox": [
+            174,
+            439,
+            825,
+            604
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Results. The results of our model and competing approaches on the hidden test are summarized in Table 1a. BIDAF (ensemble) achieves an EM score of 73.3 and an F1 score of 81.1, outperforming all previous approaches. ",
+        "bbox": [
+            174,
+            625,
+            825,
+            665
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Ablations. Table 1b shows the performance of our model and its ablations on the SQuAD dev set. Both char-level and word-level embeddings contribute towards the model’s performance. We conjecture that word-level embedding is better at representing the semantics of each word as a whole, while char-level embedding can better handle out-of-vocab (OOV) or rare words. To evaluate bidirectional attention, we remove C2Q and Q2C attentions. For ablating C2Q attention, we replace the attended question vector $\\tilde { \\textbf { U } }$ with the average of the output vectors of the question’s contextual embedding layer (LSTM). C2Q attention proves to be critical with a drop of more than 10 points on both metrics. For ablating Q2C attention, the output of the attention layer, G, does not include terms that have the attended Q2C vectors, $\\tilde { \\bf H }$ . To evaluate the attention flow, we study a dynamic attention model, where the attention is dynamically computed within the modeling layer’s LSTM, following previous work (Bahdanau et al., 2015; Wang & Jiang, 2016). This is in contrast with our approach, where the attention is pre-computed before flowing to the modeling layer. Despite being a simpler attention mechanism, our proposed static attention outperforms the dynamically computed attention by more than 3 points. We conjecture that separating out the attention layer results in a richer set of features computed in the first 4 layers which are then incorporated by the modeling layer. We also show the performance of BIDAF with several different definitions of $\\alpha$ and $\\beta$ functions (Equation 1 and 2) in Appendix B. ",
+        "bbox": [
+            173,
+            684,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/f2fcc8f85c406edc8d18f820bfac664997346ceeb8d178ef7aee259977ac81bc.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer</td><td>Query</td><td>Closest words in the Context using cosine similarity</td></tr><tr><td>Word</td><td>When</td><td>when,When,After,after,He,he,But,but,before,Before</td></tr><tr><td>Contextual</td><td>When</td><td>When, when,1945,1991,1971,1967,1990,1972,1965,1953</td></tr><tr><td>Word</td><td>Where</td><td>Where,where,It,IT,it,they,They,that,That,city</td></tr><tr><td>Contextual</td><td>Where</td><td>where,Where,Rotterdam,area,Nearby,location,outside,Area,across,locations</td></tr><tr><td>Word Contextual</td><td>Who Who</td><td>Who,who,He,he,had,have,she,She,They,they who,whose,whom,Guiscard, person, John,Thomas,families,Elway,Louis</td></tr><tr><td>Word Contextual</td><td>city</td><td>City,city, town,Town, Capital,capital, district, cities,province,Downtown</td></tr><tr><td>Word</td><td>city January</td><td>city,City,Angeles,Paris,Prague,Chicago,Port,Pittsburgh,London,Manhattan July,December,June,October,Juary,eptember,February,April,November,rch</td></tr><tr><td>Contextual</td><td>January</td><td>January,March,December,August,December,July,July,July,March,December</td></tr><tr><td>Word</td><td>Seahawks</td><td>Seahawks,Broncos,49ers,Ravens,Chargers,Steelers,quarterback,Vikings,Colts,NFL</td></tr><tr><td>Contextual Word</td><td>Seahawks</td><td>Seahawks,Broncos,Panthers,Vikings,Packers,Ravens,Patriots,Falcons,Steelers,Chargers</td></tr><tr><td>Contextual</td><td>date</td><td>date,dates,until,Until,June,July,Year,year,December,deadline</td></tr><tr><td></td><td>date</td><td>date,dates,December,July,January,October,June,November,March,February</td></tr></table>",
+        "bbox": [
+            207,
+            99,
+            790,
+            261
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/7757c7656332a6a3b06f97b0ebf7763ba27b455d0c2af2acf07a0dcd8b41d2e2.jpg",
+        "image_caption": [
+            "Table 2: Closest context words to a given query word, using a cosine similarity metric computed in the Word Embedding feature space and the Phrase Embedding feature space. ",
+            "Figure 2: (a) t-SNE visualizations of the months names embedded in the two feature spaces. The contextual embedding layer is able to distinguish the two usages of the word May using context from the surrounding text. (b) Venn diagram of the questions answered correctly by our model and the more traditional baseline (Rajpurkar et al., 2016). (c) Correctly answered questions broken down by the 10 most frequent first words in the question. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            318,
+            841,
+            501
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Visualizations. We now provide a qualitative analysis of our model on the SQuAD dev set. First, we visualize the feature spaces after the word and contextual embedding layers. These two layers are responsible for aligning the embeddings between the query and context words which are the inputs to the subsequent attention layer. To visualize the embeddings, we choose a few frequent query words in the dev data and look at the context words that have the highest cosine similarity to the query words (Table 2). At the word embedding layer, query words such as When, Where and Who are not well aligned to possible answers in the context, but this dramatically changes in the contextual embedding layer which has access to context from surrounding words and is just 1 layer below the attention layer. When begins to match years, Where matches locations, and Who matches names. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            731
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also visualize these two feature spaces using t-SNE in Figure 2. t-SNE is performed on a large fraction of dev data but we only plot data points corresponding to the months of the year. An interesting pattern emerges in the Word space, where May is separated from the rest of the months because May has multiple meanings in the English language. The contextual embedding layer uses contextual cues from surrounding words and is able to separate the usages of the word May. Finally we visualize the attention matrices for some question-context tuples in the dev data in Figure 3. In the first example, Where matches locations and in the second example, many matches quantities and numerical symbols. Also, entities in the question typically attend to the same entities in the context, thus providing a feature for the model to localize possible answers. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            864
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Discussions. We analyse the performance of our our model with a traditional language-featurebased baseline (Rajpurkar et al., 2016). Figure 2b shows a Venn diagram of the dev set questions correctly answered by the models. Our model is able to answer more than $86 \\%$ of the questions correctly answered by the baseline. The $14 \\%$ that are incorrectly answered does not have a clear pattern. This suggests that neural architectures are able to exploit much of the information captured by the language features. We also break this comparison down by the first words in the questions (Figure 2c). Our model outperforms the traditional baseline comfortably in every category. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/26d62f32002af2aad3857c67045cb6f5ec597c54027d4550e780e69ce794908c.jpg",
+        "image_caption": [
+            "Figure 3: Attention matrices for question-context tuples. The left palette shows the context paragraph (correct answer in red and underlined), the middle palette shows the attention matrix (each row is a question word, each column is a context word), and the right palette shows the top attention points for each question word, above a threshold. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            108,
+            787,
+            353
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            448,
+            823,
+            503
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Error Analysis. We randomly select 50 incorrect questions (based on EM) and categorize them into 6 classes. $50 \\%$ of errors are due to the imprecise boundaries of the answers, $28 \\%$ involve syntactic complications and ambiguities, $14 \\%$ are paraphrase problems, $4 \\%$ require external knowledge, $2 \\%$ need multiple sentences to answer, and $2 \\%$ are due to mistakes during tokenization. See Appendix A for the examples of the error modes. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            588
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CLOZE TEST EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            609,
+            437,
+            626
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We also evaluate our model on the task of cloze-style reading comprehension using the CNN and Daily Mail datasets (Hermann et al., 2015). ",
+        "bbox": [
+            176,
+            641,
+            823,
+            670
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Dataset. In a cloze test, the reader is asked to fill in words that have been removed from a passage, for measuring one’s ability to comprehend text. Hermann et al. (2015) have recently compiled a massive Cloze-style comprehension dataset, consisting of $3 0 0 \\mathrm { k } / 4 \\mathrm { k } / 3 \\mathrm { k }$ and 879k/65k/53k (train/dev/test) examples from CNN and DailyMail news articles, respectively. Each example has a news article and an incomplete sentence extracted from the human-written summary of the article. To distinguish this task from language modeling and force one to refer to the article to predict the correct missing word, the missing word is always a named entity, anonymized with a random ID. Also, the IDs must be shuffled constantly during test, which is also critical for full anonymization. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            796
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Model Details. The model architecture used for this task is very similar to that for SQuAD (Section 4) with only a few small changes to adapt it to the cloze test. Since each answer in the CNN/DailyMail datasets is always a single word (entity), we only need to predict the start index $( \\mathbf { p } ^ { 1 } )$ ; the prediction for the end index $( \\mathbf { p } ^ { 2 } )$ is omitted from the loss function. Also, we mask out all non-entity words in the final classification layer so that they are forced to be excluded from possible answers. Another important difference from SQuAD is that the answer entity might appear more than once in the context paragraph. To address this, we follow a similar strategy from Kadlec et al. (2016). During training, after we obtain $\\mathbf { p } ^ { 1 }$ , we sum all probability values of the entity instances in the context that correspond to the correct answer. Then the loss function is computed from the summed probability. We use a minibatch size of 48 and train for 8 epochs, with early stop when the accuracy on validation data starts to drop. Inspired by the window-based method (Hill et al., 2016), we split each article into short sentences where each sentence is a 19-word window around each entity (hence the same word might appear in multiple sentences). The RNNs in BIDAF are not feed-forwarded or back-propagated across sentences, which speed up the training process by parallelization. The entire training process takes roughly 60 hours on eight Titan X GPUs. The other hyper-parameters are identical to the model described in Section 4. ",
+        "bbox": [
+            174,
+            811,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Results. The results of our single-run models and competing approaches on the CNN/DailyMail datasets are summarized in Table 3. ∗ indicates ensemble methods. BIDAF outperforms previous single-run models on both datasets for both val and test data. On the DailyMail test, our single-run model even outperforms the best ensemble method. ",
+        "bbox": [
+            176,
+            231,
+            823,
+            286
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/b3455d1bcda92df746b7c3eb45ff04084e0e86625a0bbfd7fb1543ade71a3ec1.jpg",
+        "table_caption": [
+            "Table 3: Results on CNN/DailyMail datasets. We also include the results of previous ensemble methods (marked with $^ *$ ) for completeness. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"2\">CNN</td><td colspan=\"2\">DailyMail</td></tr><tr><td>val</td><td>test</td><td>val</td><td>test</td></tr><tr><td>Attentive Reader (Hermann et al.,2015)</td><td>61.6</td><td>63.0</td><td>70.5</td><td>69.0</td></tr><tr><td>MemNN (Hill et al.,2016)</td><td>63.4</td><td>6.8</td><td>=</td><td></td></tr><tr><td>AS Reader (Kadlec et al.,2016)</td><td>68.6</td><td>69.5</td><td>75.0</td><td>73.9</td></tr><tr><td>DER Network (Kobayashi et al.,2016)</td><td>71.3</td><td>72.9</td><td>1</td><td>-</td></tr><tr><td>Iterative Attention (Sordoni et al.,2016)</td><td>72.6</td><td>73.3</td><td>-</td><td>=</td></tr><tr><td>EpiReader (Trischler et al.,2016) Stanford AR (Chen et al.,2016)</td><td>73.4</td><td>74.0</td><td>=</td><td>-</td></tr><tr><td>GAReader (Dhingra et al.,2016)</td><td>73.8</td><td>73.6</td><td>77.6</td><td>76.6</td></tr><tr><td>AoA Reader (Cui et al., 2016)</td><td>73.0</td><td>73.8</td><td>76.7</td><td>75.7</td></tr><tr><td></td><td>73.1</td><td>74.4</td><td></td><td>=</td></tr><tr><td>ReasoNet (Shen et al.,2016) BIDAF (Ours)</td><td>72.9</td><td>74.7</td><td>77.6</td><td>76.6</td></tr><tr><td>MemNN* (Hill et al., 2016)</td><td>76.3</td><td>76.9</td><td>80.3</td><td>79.6</td></tr><tr><td></td><td>66.2</td><td>69.4</td><td>-</td><td>=</td></tr><tr><td>ASReader* (Kadlec et al.,2016)</td><td>73.9</td><td>75.4</td><td>78.7</td><td>77.7</td></tr><tr><td>Iterative Attention*(Sordoni et al.,2016)</td><td>74.5</td><td>75.7</td><td>-</td><td>-</td></tr><tr><td>GA Reader* (Dhingra et al.,2016)</td><td>76.4</td><td>77.4</td><td>79.1</td><td>78.1</td></tr><tr><td>Stanford AR*(Chen et al., 2016)</td><td>77.2</td><td>77.6</td><td>80.2</td><td>79.2</td></tr></table>",
+        "bbox": [
+            279,
+            299,
+            720,
+            530
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            597,
+            318,
+            612
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we introduce BIDAF, a multi-stage hierarchical process that represents the context at different levels of granularity and uses a bi-directional attention flow mechanism to achieve a queryaware context representation without early summarization. The experimental evaluations show that our model achieves the state-of-the-art results in Stanford Question Answering Dataset (SQuAD) and CNN/DailyMail cloze test. The ablation analyses demonstrate the importance of each component in our model. The visualizations and discussions show that our model is learning a suitable representation for MC and is capable of answering complex questions by attending to correct locations in the given paragraph. Future work involves extending our approach to incorporate multiple hops of the attention layer. ",
+        "bbox": [
+            174,
+            627,
+            825,
+            753
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            770,
+            326,
+            782
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This research was supported by the NSF (IIS 1616112), NSF (III 1703166), Allen Institute for AI (66-9175), Allen Distinguished Investigator Award, Google Research Faculty Award, and Samsung GRO Award. We thank the anonymous reviewers for their helpful comments. ",
+        "bbox": [
+            174,
+            792,
+            825,
+            834
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stanislaw Antol, Aishwarya Agrawal, Jiasen Lu, Margaret Mitchell, Dhruv Batra, C Lawrence Zitnick, and Devi Parikh. Vqa: Visual question answering. In ICCV, 2015. ",
+        "bbox": [
+            176,
+            126,
+            821,
+            155
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. ICLR, 2015. ",
+        "bbox": [
+            176,
+            162,
+            821,
+            191
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Danqi Chen, Jason Bolton, and Christopher D. Manning. A thorough examination of the cnn/daily mail reading comprehension task. In ACL, 2016. ",
+        "bbox": [
+            174,
+            199,
+            823,
+            229
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yiming Cui, Zhipeng Chen, Si Wei, Shijin Wang, Ting Liu, and Guoping Hu. Attention-overattention neural networks for reading comprehension. arXiv preprint arXiv:1607.04423, 2016. ",
+        "bbox": [
+            174,
+            237,
+            823,
+            267
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bhuwan Dhingra, Hanxiao Liu, William W Cohen, and Ruslan Salakhutdinov. Gated-attention readers for text comprehension. arXiv preprint arXiv:1606.01549, 2016. ",
+        "bbox": [
+            174,
+            273,
+            823,
+            304
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Akira Fukui, Dong Huk Park, Daylen Yang, Anna Rohrbach, Trevor Darrell, and Marcus Rohrbach. Multimodal compact bilinear pooling for visual question answering and visual grounding. In EMNLP, 2016. ",
+        "bbox": [
+            174,
+            311,
+            825,
+            354
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karl Moritz Hermann, Tomas Kocisk ´ y, Edward Grefenstette, Lasse Espeholt, Will Kay, Mustafa ´ Suleyman, and Phil Blunsom. Teaching machines to read and comprehend. In NIPS, 2015. ",
+        "bbox": [
+            174,
+            363,
+            823,
+            392
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Felix Hill, Antoine Bordes, Sumit Chopra, and Jason Weston. The goldilocks principle: Reading children’s books with explicit memory representations. In ICLR, 2016. ",
+        "bbox": [
+            173,
+            400,
+            821,
+            429
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. Neural Computation, 1997. ",
+        "bbox": [
+            174,
+            438,
+            810,
+            453
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rudolf Kadlec, Martin Schmid, Ondrej Bajgar, and Jan Kleindienst. Text understanding with the attention sum reader network. In ACL, 2016. ",
+        "bbox": [
+            173,
+            460,
+            821,
+            491
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoon Kim. Convolutional neural networks for sentence classification. In EMNLP, 2014. ",
+        "bbox": [
+            171,
+            498,
+            754,
+            513
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sosuke Kobayashi, Ran Tian, Naoaki Okazaki, and Kentaro Inui. Dynamic entity representation with max-pooling improves machine reading. In NAACL-HLT, 2016. ",
+        "bbox": [
+            173,
+            521,
+            825,
+            551
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kenton Lee, Tom Kwiatkowski, Ankur Parikh, and Dipanjan Das. Learning recurrent span representations for extractive question answering. arXiv preprint arXiv:1611.01436, 2016. ",
+        "bbox": [
+            173,
+            559,
+            823,
+            589
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jiasen Lu, Jianwei Yang, Dhruv Batra, and Devi Parikh. Hierarchical question-image co-attention for visual question answering. In NIPS, 2016. ",
+        "bbox": [
+            173,
+            595,
+            823,
+            626
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mateusz Malinowski, Marcus Rohrbach, and Mario Fritz. Ask your neurons: A neural-based approach to answering questions about images. In ICCV, 2015. ",
+        "bbox": [
+            173,
+            633,
+            821,
+            664
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Pennington, Richard Socher, and Christopher D Manning. Glove: Global vectors for word representation. In EMNLP, 2014. ",
+        "bbox": [
+            174,
+            670,
+            823,
+            700
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: $1 0 0 { , } 0 0 0 { + }$ questions for machine comprehension of text. In EMNLP, 2016. ",
+        "bbox": [
+            173,
+            708,
+            823,
+            738
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthew Richardson, Christopher JC Burges, and Erin Renshaw. Mctest: A challenge dataset for the open-domain machine comprehension of text. In EMNLP, 2013. ",
+        "bbox": [
+            173,
+            746,
+            823,
+            775
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yelong Shen, Po-Sen Huang, Jianfeng Gao, and Weizhu Chen. Reasonet: Learning to stop reading in machine comprehension. arXiv preprint arXiv:1609.05284, 2016. ",
+        "bbox": [
+            173,
+            782,
+            823,
+            813
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alessandro Sordoni, Phillip Bachman, and Yoshua Bengio. Iterative alternating neural attention for machine reading. arXiv preprint arXiv:1606.02245, 2016. ",
+        "bbox": [
+            173,
+            820,
+            821,
+            849
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey E. Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. JMLR, 2014. ",
+        "bbox": [
+            176,
+            858,
+            820,
+            887
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rupesh Kumar Srivastava, Klaus Greff, and Jurgen Schmidhuber. Highway networks. ¨ arXiv preprint arXiv:1505.00387, 2015. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adam Trischler, Zheng Ye, Xingdi Yuan, and Kaheer Suleman. Natural language comprehension with the epireader. In EMNLP, 2016.   \nShuohang Wang and Jing Jiang. Machine comprehension using match-lstm and answer pointer. arXiv preprint arXiv:1608.07905, 2016.   \nJason Weston, Sumit Chopra, and Antoine Bordes. Memory networks. In ICLR, 2015.   \nCaiming Xiong, Stephen Merity, and Richard Socher. Dynamic memory networks for visual and textual question answering. In ICML, 2016a.   \nCaiming Xiong, Victor Zhong, and Richard Socher. Dynamic coattention networks for question answering. arXiv preprint arXiv:1611.01604, 2016b.   \nHuijuan Xu and Kate Saenko. Ask, attend and answer: Exploring question-guided spatial attention for visual question answering. In ECCV, 2016.   \nZhilin Yang, Bhuwan Dhingra, Ye Yuan, Junjie Hu, William W Cohen, and Ruslan Salakhutdinov. Words or characters? fine-grained gating for reading comprehension. arXiv preprint arXiv:1611.01724, 2016.   \nZichao Yang, Xiaodong He, Jianfeng Gao, Li Deng, and Alex Smola. Stacked attention networks for image question answering. arXiv preprint arXiv:1511.02274, 2015.   \nYang Yu, Wei Zhang, Kazi Hasan, Mo Yu, Bing Xiang, and Bowen Zhou. End-to-end reading comprehension with dynamic answer chunk ranking. arXiv preprint arXiv:1610.09996, 2016.   \nMatthew D Zeiler. Adadelta: an adaptive learning rate method. arXiv preprint arXiv:1212.5701, 2012.   \nYuke Zhu, Oliver Groth, Michael S. Bernstein, and Li Fei-Fei. Visual7w: Grounded question answering in images. In CVPR, 2016. ",
+        "bbox": [
+            171,
+            101,
+            826,
+            513
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A ERROR ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            361,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/c89daff472cb59789f6d16c0dd62bfa25ad697e77e404d8aebeb180a2e4fe0a9.jpg",
+        "table_caption": [
+            "Table 4 summarizes the modes of errors by BIDAF and shows examples for each category of error in SQuAD. "
+        ],
+        "table_footnote": [
+            "into 6 different categories. Only relevant sentence(s) from the context shown for brevity. "
+        ],
+        "table_body": "<table><tr><td>Error type</td><td>Ratio (%)</td><td>Example</td></tr><tr><td>Imprecise answer boundaries</td><td>50</td><td>Context: “The Free Movement of Workers Regulation articles 1 to 7 set out the main provisions on equal treatment of workers.” Question:“Which articles of the Free Movement of Workers Regulation set out the primary provisions on equal treatment of workers?” Prediction: “1 to 7&quot;, Answer: “articles 1 to 7”</td></tr><tr><td>Syntactic complications and ambiguities</td><td>28</td><td>Context: “A piece of paper was later found on which Luther had written his last statement.” Question: “What was later discovered written by Luther?&quot; Prediction: “A piece of paper&quot;,Answer: “his last statement&quot;</td></tr><tr><td>Paraphrase problems</td><td>14</td><td>tier model which includes primary education (primary schools), followed by secondary education (secondary schools/high schools） and tertiary education (universities and/or TAFE colleges).” Question:“What is the first model of education, in the Aus- tralian system?” Prediction: “three-tier”,Answer: “primary education&quot;</td></tr><tr><td>External knowledge</td><td>4</td><td>Context:“On June 4， 2014， the NFL announced that the practice of branding Super Bowl games with Roman numerals, a practice established at Super Bowl V,would be temporarily suspended,and that the game would be named using Arabic numerals as Super Bowl 50 as opposed to Super Bowl L.&quot; Question: “If Roman numerals were used in the naming of the 50th Super Bowl, which one would have been used?&#x27; Prediction: “Super Bowl 5O”, Answer: “L&quot;</td></tr><tr><td>Multi- sentence</td><td>2 starting in the mid-1980s.&quot;</td><td>interactive connections the network was enhanced to support terminal to host connections，host to host batch connections (remote job submission,remote printing,batch file transfer), interactive file transfer, gateways to the Tymnet and Telenet public data networks, X.25 host atachments, gateways to X.25 data networks,Ethernet attached hosts,and eventually TCP/IP and additional public universities in Michigan join the network. All of this set the stage for Merit&#x27;s role in the NSFNET project Question: “What set the stage for Merits role in NSFNET&quot; Prediction:“All of this set the stage for Merit &#x27;s role in the</td></tr><tr><td>Incorrect preprocessing</td><td>2</td><td>this work by showing that fire requires only a part of air that he called spiritus nitroaereus or just nitroaereus.&quot; Question: “John Mayow died in what year?&quot; Prediction: “1641-1679&quot;,Answer: “1679&quot;</td></tr></table>",
+        "bbox": [
+            176,
+            176,
+            838,
+            905
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B VARIATIONS OF SIMILARITY AND FUSION FUNCTIONS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            661,
+            119
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/40d69b450a344d34ad00545609fe529e7ceb8a0508d872ce0aa5b8302b59ff67.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>EM</td><td>F1</td></tr><tr><td>Eqn. 1: dot product Eqn. 1: linear Eqn. 1: bilinear</td><td>65.5 59.5 61.6</td><td>75.5 69.7 71.8</td></tr><tr><td>Eqn. 1: linear after MLP</td><td>66.2</td><td>76.4</td></tr><tr><td>Eqn. 2: MLP after concat</td><td>67.1</td><td>77.0</td></tr><tr><td>BIDAF (single)</td><td>68.0</td><td>77.3</td></tr></table>",
+        "bbox": [
+            370,
+            136,
+            629,
+            229
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 5: Variations of similarity function $\\alpha$ (Equation 1) and fusion function $\\beta$ (Equation 2) and their performance on the dev data of SQuAD. See Appendix B for the details of each variation. ",
+        "bbox": [
+            171,
+            241,
+            825,
+            270
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In this appendix section, we experimentally demonstrate how different choices of the similarity function $\\alpha$ (Equation 1) and the fusion function $\\beta$ (Equation 2) impact the performance of our model. Each variation is defined as following: ",
+        "bbox": [
+            174,
+            287,
+            825,
+            330
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Eqn. 1: dot product. Dot product $\\alpha$ is defined as ",
+        "bbox": [
+            174,
+            344,
+            513,
+            361
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6fa89ff813c1d136328e6c070b71598f381c5098b1f722d4f8530cbc6a355e13.jpg",
+        "text": "$$\n\\alpha ( \\mathbf { h } , \\mathbf { u } ) = \\mathbf { h } ^ { \\top } \\mathbf { u }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            444,
+            366,
+            553,
+            386
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $\\top$ indicates matrix transpose. Dot product has been used for the measurement of similarity between two vectors by Hill et al. (2016). ",
+        "bbox": [
+            173,
+            391,
+            825,
+            421
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Eqn. 1: linear. Linear $\\alpha$ is defined as ",
+        "bbox": [
+            174,
+            435,
+            434,
+            450
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6d678d4d0e3d8ef01aacef302643fe6f2f2da851c115ec517ee093b301177dd5.jpg",
+        "text": "$$\n\\alpha ( \\mathbf { h } , \\mathbf { u } ) = \\mathbf { w } _ { \\mathrm { l i n } } ^ { \\top } [ \\mathbf { h } ; \\mathbf { u } ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            457,
+            570,
+            476
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { w } _ { \\mathrm { l i n } } ^ { \\top } \\in \\mathbb { R } ^ { 4 d }$ is a trainable weight matrix. This can be considered as the simplification of Equation 1 by dropping the term $\\mathbf { h } \\circ \\mathbf { u }$ in the concatenation. ",
+        "bbox": [
+            176,
+            481,
+            825,
+            511
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Eqn. 1: bilinear. Bilinear $\\alpha$ is defined as ",
+        "bbox": [
+            174,
+            525,
+            459,
+            541
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d24caebcc9d9499277220fef2ea362fde5962d5c485b462bee314f3f860f4e92.jpg",
+        "text": "$$\n\\alpha ( \\mathbf { h } , \\mathbf { u } ) = \\mathbf { h } ^ { \\top } \\mathbf { W } _ { \\mathbf { \\mathrm { b i } } } \\mathbf { u }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            546,
+            568,
+            565
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { W _ { \\mathrm { b i } } } \\in \\mathbb { R } ^ { 2 d \\times 2 d }$ is a trainable weight matrix. Bilinear term has been used by Chen et al.   \n(2016). ",
+        "bbox": [
+            174,
+            571,
+            825,
+            602
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Eqn. 1: linear after MLP. We can also perform linear mapping after single layer of perceptron: ",
+        "bbox": [
+            171,
+            614,
+            815,
+            632
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0d8226a4fcc9b2f626c0cc6df22dd93d629bfa3e1588c462d0d4c9009b45c5c0.jpg",
+        "text": "$$\n\\alpha ( \\mathbf { h } , \\mathbf { u } ) = \\mathbf { w } _ { \\mathrm { l i n } } ^ { \\top } \\operatorname { t a n h } ( \\mathbf { W } _ { \\mathrm { m l p } } [ \\mathbf { h } ; \\mathbf { u } ] + \\mathbf { b } _ { \\mathrm { m l p } } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            637,
+            637,
+            656
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { W } _ { \\mathrm { m l p } }$ and $\\mathbf { b } _ { \\mathrm { m l p } }$ are trainable weight matrix and bias, respectively. Linear mapping after perceptron layer has been used by Hermann et al. (2015). ",
+        "bbox": [
+            169,
+            662,
+            825,
+            691
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Eqn. 2: MLP after concatenation. We can define $\\beta$ as ",
+        "bbox": [
+            174,
+            705,
+            553,
+            722
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3db20fbae49fbe88ba2ccf79f56fa769a5c9c74c05e60dadee74ea9be971db76.jpg",
+        "text": "$$\n\\beta ( \\mathbf { h } , { \\tilde { \\mathbf { u } } } , { \\tilde { \\mathbf { h } } } ) = \\operatorname* { m a x } ( 0 , \\mathbf { W } _ { \\mathrm { m l p } } [ \\mathbf { h } ; { \\tilde { \\mathbf { u } } } ; \\mathbf { h } \\circ { \\tilde { \\mathbf { u } } } ; \\mathbf { h } \\circ { \\tilde { \\mathbf { h } } } ] + \\mathbf { b } _ { \\mathrm { m l p } } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            727,
+            681,
+            747
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { W } _ { \\mathrm { m l p } } \\in \\mathbb { R } ^ { 2 d \\times 8 d }$ and ${ \\bf b } _ { \\mathrm { m l p } } \\in \\mathbb { R } ^ { 2 d }$ are trainable weight matrix and bias. This is equivalent to adding ReLU after linearly transforming the original definition of $\\beta$ . Since the output dimension of $\\beta$ changes, the input dimension of the first LSTM of the modeling layer will change as well. ",
+        "bbox": [
+            174,
+            753,
+            825,
+            797
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The results of these variations on the dev data of SQuAD are shown in Table 5. It is important to note that there are non-trivial gaps between our definition of $\\alpha$ and other definitions employed by previous work. Adding MLP in $\\beta$ does not seem to help, yielding slightly worse result than $\\beta$ without MLP. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            861
+        ],
+        "page_idx": 12
+    }
+]

parse/train/rkdU7tCaZ/rkdU7tCaZ.md

@@ -0,0 +1,251 @@
+# DYNAMIC EVALUATION OF NEURAL SEQUENCE MODELS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We present methodology for using dynamic evaluation to improve neural sequence models. Models are adapted to recent history via a gradient descent based mechanism, causing them to assign higher probabilities to re-occurring sequential patterns. Dynamic evaluation outperforms existing adaptation approaches in our comparisons. Dynamic evaluation improves the state-of-the-art word-level perplexities on the Penn Treebank and WikiText-2 datasets to 51.1 and 44.3 respectively, and the state-of-the-art character-level cross-entropies on the text8 and Hutter Prize datasets to 1.19 bits/char and 1.08 bits/char respectively.
+
+# 1 INTRODUCTION
+
+Sequence generation and prediction tasks span many modes of data, ranging from audio and language modelling, to more general timeseries prediction tasks. Applications of such models include speech recognition, machine translation, dialogue generation, speech synthesis, forecasting, and music generation, among others. Neural networks can be applied to these tasks by predicting sequence elements one-by-one, conditioning on the history of sequence elements, forming an autoregressive model. Convolutional neural networks (CNNs) and recurrent neural networks (RNNs), including long-short term memory (LSTM) networks (Hochreiter & Schmidhuber, 1997) in particular, have achieved many successes at these tasks. However, in their basic form, these models have a limited ability to adapt to recently observed parts of a sequence.
+
+Many sequences contain repetition; a pattern that occurs once is more likely to occur again. For instance, a word that occurs once in a document is much more likely to occur again. A sequence of handwriting will generally stay in the same handwriting style. A sequence of speech will generally stay in the same voice. Although RNNs have a hidden state that can summarize the recent past, they are often unable to exploit new patterns that occur repeatedly in a test sequence.
+
+This paper concerns dynamic evaluation, which we investigate as a candidate solution to this problem. Our approach adapts models to recent sequences using gradient descent based mechanisms. We show several ways to improve on past dynamic evaluation approaches in Section 5, and use our improved methodology to achieve state-of-the-art results in Section 7. In Section 6 we design a method to dramatically to reduce the number of adaptation parameters in dynamic evaluation, making it practical in a wider range of situations. In Section 7.4 we analyse dynamic evaluation’s performance over varying time-scales and distribution shifts, and demonstrate that dynamically evaluated models can generate conditional samples that repeat many patterns from the conditioning data.
+
+# 2 MOTIVATION
+
+Generative models can assign probabilities to sequences by modelling each term in the factorization given by the product rule. The probability of a sequence $\stackrel { \cdot } { x _ { 1 : T } } = \{ x _ { 1 } , \stackrel { \cdot } { \dots } , x _ { T } \}$ factorizes as
+
+$$
+P ( x _ { 1 : T } ) = P ( x _ { 1 } ) P ( x _ { 2 } | x _ { 1 } ) P ( x _ { 3 } | x _ { 2 } , x _ { 1 } ) \cdot \cdot \cdot P ( x _ { T } | x _ { 1 } \ldots x _ { T - 1 } ) .
+$$
+
+Methods that apply this factorization either use a fixed context when predicting $P ( x _ { t } | x _ { 1 : t - 1 } )$ , for instance as in $\mathbf { N } .$ -grams or CNNs, or use a recurrent hidden state to summarize the context, as in an RNN. However, for longer sequences, the history $x _ { 1 : t - 1 }$ often contains re-occurring patterns that are difficult to capture using models with fixed parameters (static models).
+
+In many domains, in a dataset of sequences $\{ x _ { 1 : T } ^ { 1 } , x _ { 1 : T } ^ { 2 } , . . . , x _ { 1 : T } ^ { M } \}$ , each sequence $\boldsymbol { x } _ { 1 : T } ^ { i }$ is generated from a slightly different distribution $P ( x _ { 1 : T } ^ { i } )$ . At any point in time $t$ , the history of a sequence $x _ { 1 : t - 1 } ^ { i }$ contains useful information about the generating distribution for that specific sequence $P ( x _ { 1 : T } ^ { i } )$ Therefore adapting the model parameters learned during training $\theta _ { g }$ is justified. We aim to infer a set of model parameters $\theta _ { l }$ from $x _ { 1 : t - 1 } ^ { i }$ that will better approximate $\bar { P } ( x _ { t } ^ { i } | x _ { 1 : t - 1 } ^ { i } )$ within sequence $i$ .
+
+Many sequence modelling tasks are characterised by sequences generated from slightly different distributions as in the scenario described above. The generating distribution may also change continuously across a single sequence; for instance, a text excerpt may change topic. Furthermore, many machine learning benchmarks do not distinguish between sequence boundaries, and concatenate all sequences into one continuous sequence. Thus, many sequence modelling tasks could be seen as having a local distribution $P _ { l } ( x )$ as well as a global distribution $\textstyle P _ { g } ( x ) : = { \bar { J } } P ( l ) P _ { l } ( x ) d l$ . During training time, the goal is to find the best fixed model possible for $P _ { g } ( x )$ . However, during evaluation time, a model that can infer the current $P _ { l } ( x )$ from the recent history has an advantage.
+
+# 3 DYNAMIC EVALUATION
+
+Dynamic evaluation methods continuously adapt the model parameters $\theta _ { g }$ , learned at training time, to parts of a sequence during evaluation. The goal is to learn adapted parameters $\theta _ { l }$ that provide a better model of the local sequence distribution, $P _ { l } ( x )$ . When dynamic evaluation is applied in the present work, a long test sequence $x _ { 1 : T }$ is divided up into shorter sequences of length $n$ . We define $s _ { 1 : M }$ to be a sequence of shorter sequence segments $s _ { i }$
+
+$$
+s _ { 1 : M } = \{ s _ { 1 } = x _ { 1 : n } , \ s _ { 2 } = x _ { n + 1 : 2 n } , \ s _ { 3 } = x _ { 2 n + 1 : 3 n } , \ . . . , \ s _ { M } \} .
+$$
+
+The initial adapted parameters $\theta _ { l } ^ { 0 }$ are set to $\theta _ { g }$ , and used to compute the probability of the first segment, $P ( s _ { 1 } | \theta _ { l } ^ { 0 } )$ . This probability gives a cross entropy loss $\mathcal { L } ( s _ { 1 } )$ , with gradient $\nabla \mathcal { L } ( s _ { 1 } )$ , which is computed using truncated back-propagation through time (Werbos, 1990). The gradient $\nabla { \mathcal { L } } ( s _ { 1 } )$ is used to update the model, resulting in adapted parameters $\theta _ { l } ^ { 1 }$ , before evaluating $\bar { P ( s _ { 2 } | \theta _ { l } ^ { 1 } ) }$ . The same procedure is then repeated for $s _ { 2 }$ , and for each $s _ { i }$ in the sequence as shown in Figure 1. Gradients for each loss $\mathcal { L } ( s _ { i } )$ are only backpropagated to the beginning of $s _ { i }$ , so computation is linear in the sequence length. Each update applies one maximum likelihood training step to approximate the current local distribution $P _ { l } ( x )$ . The computational cost of dynamic evaluation is one forward pass and one gradient computation through the data, with some slight overhead to apply the update rule for every sequence segment.
+
+As in all autoregressive models, dynamic evaluation only conditions on sequence elements that it has already predicted, and so evaluates a valid log-probability for each sequence. Dynamic evaluation can also be used while generating sequences. In this case, the model generates each sequence segment $s _ { i }$ using fixed weights, and performs a gradient descent based update step on $\mathcal { L } ( s _ { i } )$ . Applying dynamic evaluation for sequence generation could result in generated sequences with more consistent regularities, meaning that patterns that occur in the generated sequence are more likely to occur again.
+
+# 4 BACKGROUND
+
+# 4.1 RELATED APPROACHES
+
+Adaptive language modelling was first considered for n-grams, adapting to recent history via caching (Jelinek et al., 1991; Kuhn, 1988), and other methods Bellegarda (2004). More recently, the neural cache approach (Grave et al., 2017) and the closely related pointer sentinel-LSTM (Merity et al., 2017b) have been used to for adaptive neural language modelling. Neural caching has recently been used to improve the state-of-the-art at word-level language modelling (Merity et al., 2017a).
+
+The neural cache model learns a type of non-parametric output layer on the fly at test time, which allows the network to adapt to recent observations. Each past hidden state $h _ { i }$ is paired with the next input $x _ { i + 1 }$ , and is stored as a tuple $\left( h _ { i } , x _ { i + 1 } \right)$ . When a new hidden state $h _ { t }$ is observed, the output probabilities are adjusted to give a higher weight to output words that coincided with past hidden states with a large inner product $( h _ { t } ^ { T } h _ { i } )$ .
+
+$$
+P _ { c a c h e } ( x _ { t + 1 } | x _ { 1 : t } , h _ { 1 : t } ) \propto \sum _ { i = 1 } ^ { t - 1 } e ^ { ( x _ { i + 1 } ) } \exp ( \omega h _ { t } ^ { T } h _ { i } ) ,
+$$
+
+![](images/df95773861d69acd90535594ea1cc660128237411e8542a90cf739be28c92fe5.jpg)  
+Figure 1: Illustration of dynamic evaluation. The model evaluates the probability of sequence segments $s _ { i }$ . The gradient $\dot { \nabla } \mathcal { L } ( s _ { i } )$ with respect to the log probability of $s _ { i }$ is used to update the model parameters $\theta _ { l } ^ { i - 1 }$ to $\theta _ { l } ^ { i }$ before the model progresses to the next sequence segment. Dashed edges are what distinguish dynamic evaluation from static (normal) evaluation.
+
+where $e ^ { ( x _ { i + 1 } ) }$ is a one hot encoding of $x _ { i + 1 }$ , and $\omega$ is a scaling parameter. The cache probabilities are interpolated with the base network probabilities to adapt the base network at test time.
+
+The neural cache closely relates to dynamic evaluation, as both methods can be added on top of a base model for adaptation at test time. The main difference is the mechanism used to fit to recent history: the neural cache approach uses a non-parametric, nearest neighbours-like method, whereas dynamic evaluation uses a gradient descent based method to change model parameters dynamically. Both methods rely on an autoregressive factorisation, as they depend on observing sequence elements after they are predicted in order to perform adaptation. Dynamic evaluation and neural caching methods are therefore both applicable to sequence prediction and generation tasks, but not directly to more general supervised learning tasks.
+
+One drawback of the neural cache method is that it cannot adjust the recurrent hidden state dynamics. As a result, the neural cache’s ability to capture information that occurs jointly between successive sequence elements is limited. This capability is critical for adapting to sequences where each element has very little independent meaning, e.g. character level language modelling.
+
+Another related approach is fast weights, (Ba et al., 2016; Schmidhuber, 1992). Fast weights feature recurrent architectures with dynamically changing weight matrices as a function of recent sequence history. Thus, dynamic evaluation as applied at test time, could be considered a form of fast-weights. In traditional fast weights, the network learns to control changes to the weights during training time, allowing it to be applied to more general sequence problems including sequence labeling. In dynamic evaluation, the procedure to change the weights is automated at test time via gradient descent optimization, making it only directly applicable to autoregressive sequence modelling. As dynamic evaluation leverages gradient descent, it has the potential to generalize better to previously unseen pattern repetitions at test time.
+
+# 4.2 DYNAMIC EVALUATION IN NEURAL NETWORKS
+
+Dynamic evaluation of neural language models was proposed by Mikolov et al. (2010). Their approach simply used stochastic gradient descent (SGD) updates at every time step, computing the gradient with fully truncated backpropagation through time, which is equivalent to setting $n = 1$ in equation (2). Dynamic evaluation has since been applied to character and word-level language models (Graves, 2013; Krause et al., 2017; Ororbia II et al., 2017; Fortunato et al., 2017). Previous work using dynamic evaluation considered it as an aside, and did not explore it in depth.
+
+# 5 UPDATE RULE METHODOLOGY FOR DYNAMIC EVALUATION
+
+We propose several changes to Mikolov et al. (2010)’s dynamic evaluation method with SGD and fully truncated backpropagation, which we refer to as traditional dynamic evaluation. The first modification reduces the update frequency, so that gradients are backpropagated over more timesteps. This change provides more accurate gradient information, and also improves the computational efficiency of dynamic evaluation, since the update rule is applied much less often. We use sequence segments of length 5 for word-level tasks and 20 for character-level tasks.
+
+Next, we add a global decay prior to bias the model towards the parameters $\theta _ { g }$ learned during training. Our motivation for dynamic evaluation assumes that the local generating distribution $P _ { l } ( x )$ is constantly changing, so it is potentially desirable to weight recent sequence history higher in adaptation. Adding a global decay prior accomplishes this by causing previous adaptation updates to decay exponentially over time. The use of a decay prior for dynamic evaluation relates to the update rule used for fast weights in Ba et al. (2016), which decayed fast weights towards zero exponentially over time. For SGD with a global prior, learning rate $\eta$ and decay rate $\lambda$ ; we form the update rule
+
+$$
+\begin{array} { r } { \theta _ { i }  \theta _ { i - 1 } - \eta \nabla \mathcal { L } ( s _ { i } ) + \lambda ( \theta _ { g } - \theta _ { l } ^ { i - 1 } ) . } \end{array}
+$$
+
+We then consider using an RMSprop (Tieleman & Hinton, 2012) derived update rule for the learning rule in place of SGD. RMSprop uses a moving average of recent squared gradients to scale learning rates for each weight. In dynamic evaluation, near the start of a test sequence, RMSprop has had very few gradients to average, and therefore may not be able to leverage its updates as effectively. For this reason, we collect mean squared gradients, $M S _ { g }$ , on the training data rather than on recent test data (which is what RMSprop would do). $M S _ { g }$ is given by
+
+$$
+M S _ { g } = \frac { 1 } { N _ { b } } \sum _ { k = 1 } ^ { N _ { b } } ( \nabla \mathcal { L } _ { k } ) ^ { 2 } ,
+$$
+
+where $N _ { b }$ is the number of training batches and $\nabla \mathcal L _ { k }$ is the gradient on the $k$ th training batch. The mini-batch size for this computation becomes a hyper-parameter, as larger mini-batches will result in smaller mean squared gradients. The update rule, which we call RMS with a global prior in our experiments, is then
+
+$$
+\theta _ { l } ^ { i }  \theta _ { l } ^ { i - 1 } - \eta \frac { \nabla \mathcal { L } ( s _ { i } ) } { \sqrt { M S _ { g } } + \epsilon } + \lambda ( \theta _ { g } - \theta _ { l } ^ { i - 1 } ) ,
+$$
+
+where $\epsilon$ is a stabilization parameter. For the decay step of our update rule, we also consider scaling the decay rate for each parameter proportionally to $\sqrt { M S _ { g } }$ . Parameters with a high RMS gradient affect the dynamics of the network more, so it makes sense to decay them faster. $R M S _ { \mathrm { n o r m } }$ is $\sqrt { M S _ { g } }$ divided by its mean, resulting in a normalized version of $\sqrt { M S _ { g } }$ with a mean of 1:
+
+$$
+R M S _ { \mathrm { n o r m } } = \frac { \sqrt { M S _ { g } } } { \mathrm { a v g } ( \sqrt { M S _ { g } } ) } .
+$$
+
+We clip the values of $R M S _ { \mathrm { n o r m } }$ to be no greater than $^ 1 / \lambda$ to be sure that the decay rate does not exceed 1 for any parameter. Combining the learning component and the regularization component results in the final update equation, which we refer to as RMS with an RMS global prior
+
+$$
+\theta _ { l } ^ { i }  \theta _ { l } ^ { i - 1 } - \eta \frac { \nabla \mathcal { L } ( s _ { i } ) } { \sqrt { M S _ { g } } + \epsilon } + \lambda ( \theta _ { g } - \theta _ { l } ^ { i - 1 } ) \odot R M S _ { \mathrm { n o r m } } .
+$$
+
+# 6 SPARSE DYNAMIC EVALUATION
+
+Mini-batching over sequences is desirable for some test-time sequence modelling applications because it allows faster processing of multiple sequences in parallel. Dynamic evaluation has a high memory cost for mini-batching because it is necessary to store a different set of parameters for each sequence in the mini-batch. Therefore, we consider a sparse dynamic evaluation variant that updates a smaller number of parameters. We introduce a new adaptation matrix $\mathcal { M }$ which is initialized to zeros. $\mathcal { M }$ multiplies hidden state vector $h _ { t }$ of an RNN at every time-step to get a new hidden state $h _ { t } ^ { \prime }$ , via
+
+$$
+h _ { t } ^ { \prime } = h _ { t } + \mathscr { M } h _ { t } .
+$$
+
+$h _ { t } ^ { \prime }$ then replaces $h _ { t }$ and is propagated throughout the network via both recurrent and feed-forward connections. In a stacked RNN, this formulation could be applied to every layer or just one layer. Applying dynamic evaluation to $\mathcal { M }$ avoids the need to apply dynamic evaluation to the original parameters of the network, reduces the number of adaptation parameters, and makes mini-batching less memory intensive. We reduce the number of adaptation parameters further by only using $\mathcal { M }$ to transform an arbitrary subset of $H$ hidden units. This results in $\mathcal { M }$ being an $H \times H$ matrix with $d = H ^ { 2 }$ adaptation parameters. If $H$ is chosen to be much less than the number of hidden units, this reduces the number of adaptation parameters dramatically. In Section 7.3 we experiment with sparse dynamic evaluation for character-level language models.
+
+# 7 EXPERIMENTS
+
+We applied dynamic evaluation to word-level and character-level language modelling. In all tasks, we evaluate dynamic evaluation on top of a base model. After training the base model, we tune hyper-parameters for dynamic evaluation on the validation set, and evaluate both the static and dynamic versions of the model on the test set. We also consider follow up experiments that analyse the sequence lengths for which dynamic evaluation is useful.
+
+# 7.1 SMALL SCALE WORD-LEVEL LANGUAGE MODELLING
+
+We train base models on the Penn Treebank (PTB, Marcus et al., 1993), WikiText-2 (Merity et al., 2017b) datasets, and compare the performance of static and dynamic evaluation. These experiments compare dynamic evaluation against past approaches such as the neural cache and measure dynamic evaluation’s general performance across different models and datasets.
+
+PTB is derived from articles of the Wall Street Journal. It contains 929k training tokens and a vocab size limited to 10k words. It is one of the most commonly used benchmarks in language modelling. We consider two baseline models on PTB, a standard LSTM implementation with recurrent dropout (Zaremba et al., 2014), and the recent state-of-the-art averaged SGD (ASGD) weight-dropped LSTM (AWD-LSTM, Merity et al., 2017a).
+
+Our standard LSTM was taken from the Chainer (Tokui et al., 2015) tutorial on language modelling1, and used two LSTM layers with 650 units each, trained with SGD and regularized with recurrent dropout. On our standard LSTM, we experiment with traditional dynamic evaluation as applied by Mikolov et al. (2010), as well as each modification we make building up to our final update rule as described in Section 5. As our final update rule $( { \mathrm { R M S } } + { \mathrm { R M S } }$ global prior) worked best, we use this for all other experiments and use “dynamic eval” by default to refer to this update rule in tables.
+
+We applied dynamic evaluation on an AWD-LSTM (Merity et al., 2017a). The AWD-LSTM is a vanilla LSTM that combines the use of drop-connect (Wan et al., 2013) on recurrent weights for regularization, and a variant of ASGD (Polyak & Juditsky, 1992) for optimisation. Our model, which used 3 layers and tied input and output embeddings (Press & Wolf, 2017; Inan et al., 2017), was intended to be a direct replication of AWD-LSTM, using code from their implementation2. Results are given in Table 1.
+
+Dynamic evaluation gives significant overall improvements to both models on this dataset. Dynamic evaluation also achieves better final results than the neural cache on both a standard LSTM and the AWD-LSTM reimplementation, and improves the state-of-the-art on PTB.
+
+Table 1: Penn Treebank perplexities. bptt refers to sequence segment lengths.   
+
+<table><tr><td>model</td><td>parameters</td><td>valid</td><td>test</td></tr><tr><td>RNN+LDA+kN-5+cache (Mikolov &amp; Zweig,2012)</td><td></td><td></td><td>92.0</td></tr><tr><td>CharCNN (Kim et al., 2016)</td><td>19M</td><td></td><td>78.9</td></tr><tr><td>LSTM (Zaremba et al., 2014)</td><td>66M</td><td>82.2</td><td>78.4</td></tr><tr><td>Variational LSTM (Gal &amp; Ghahramani, 2016)</td><td>66M</td><td></td><td>73.4</td></tr><tr><td>Pointer sentinel-LSTM (Merity et al.,2017b)</td><td>21M</td><td>72.4</td><td>70.9</td></tr><tr><td>Variational LSTM + augmented loss (Inan et al., 2017)</td><td>51M</td><td>71.1</td><td>68.5</td></tr><tr><td>Variational RHN (Zilly et al.,2017)</td><td>23M</td><td>67.9</td><td>65.4</td></tr><tr><td>NAS cell (Zoph &amp; Le,2017)</td><td>54M</td><td></td><td>62.4</td></tr><tr><td>Variational LSTM + gradual learning (Aharoni et al., 2017)</td><td>105M</td><td></td><td>61.7</td></tr><tr><td>LSTM + BB tuning (Melis et al.,2017)</td><td>24M</td><td>60.9</td><td>58.3</td></tr><tr><td>LSTM (Grave et al., 2017)</td><td></td><td>86.9</td><td>82.3</td></tr><tr><td>LSTM + neural cache (Grave et al., 2017)</td><td></td><td>74.6</td><td>72.1</td></tr><tr><td>LSTM (ours)</td><td>20M</td><td>88.0</td><td>85.6</td></tr><tr><td>LSTM + traditional dynamic eval (sgd, bptt=1)</td><td>20M</td><td>78.6</td><td>76.2</td></tr><tr><td>LSTM + dynamic eval (sgd, bptt=5)</td><td>20M</td><td>78.0</td><td>75.6</td></tr><tr><td>LSTM + dynamic eval (sgd, bptt=5, global prior)</td><td>20M</td><td>77.4</td><td>74.8</td></tr><tr><td>LSTM + dynamic eval (RMS,bptt=5, global prior)</td><td>20M</td><td>74.3</td><td>72.2</td></tr><tr><td>LSTM + dynamic eval (RMS, bptt=5, RMS global prior)</td><td>20M</td><td>73.5</td><td>71.7</td></tr><tr><td>AWD-LSTM (Merity et al., 2017a)</td><td>24M</td><td>60.0</td><td>57.3</td></tr><tr><td>AWD-LSTM +neural cache (Merity et al., 2017a)</td><td>24M</td><td>53.9</td><td>52.8</td></tr><tr><td>AWD-LSTM (ours)</td><td>24M</td><td>59.8</td><td>57.7</td></tr><tr><td>AWD-LSTM + dynamic eval</td><td>24M</td><td>51.6</td><td>51.1</td></tr></table>
+
+Table 2: WikiText-2 perplexities.   
+
+<table><tr><td>model</td><td>parameters</td><td>valid</td><td>test</td></tr><tr><td>Byte mLSTM (Krause et al., 2016)</td><td>46M</td><td>92.8</td><td>88.8</td></tr><tr><td>Variational LSTM (Inan et al., 2017)</td><td>28M</td><td>91.5</td><td>87.0</td></tr><tr><td>Pointer sentinel-LSTM (Merity et al., 2017b)</td><td></td><td>84.8</td><td>80.8</td></tr><tr><td>LSTM + BB tuning (Melis et al., 2017)</td><td>24M</td><td>69.1</td><td>65.9</td></tr><tr><td>LSTM (Grave et al., 2017)</td><td></td><td>104.2</td><td>99.3</td></tr><tr><td>LSTM + neural cache (Grave et al., 2017)</td><td></td><td>72.1</td><td>68.9</td></tr><tr><td>LSTM (ours)</td><td>50M</td><td>109.1</td><td>103.4</td></tr><tr><td>LSTM + dynamic eval</td><td>50M</td><td>63.7</td><td>59.8</td></tr><tr><td>AWD-LSTM (Merity et al., 2017a)</td><td>33M</td><td>68.6</td><td>65.8</td></tr><tr><td>AWD-LSTM + neural cache (Merity et al., 2017a)</td><td>33M</td><td>53.8</td><td>52.0</td></tr><tr><td>AWD-LSTM (ours)</td><td>33M</td><td>68.9</td><td>66.1</td></tr><tr><td>AWD-LSTM + dynamic eval</td><td>33M</td><td>46.4</td><td>44.3</td></tr></table>
+
+WikiText-2 is roughly twice the size of PTB, with 2 million training tokens and a vocab size of 33k. It features articles in a non-shuffled order, with dependencies across articles that adaptive methods should be able to exploit. For this dataset, we use the same baseline LSTM implementation and AWD-LSTM re-implementation as on PTB. Results are given in Table 2.
+
+Dynamic evaluation improves the state-of-the-art perplexity on WikiText-2, and provides a significantly greater improvement than neural caching to both base models. This suggests that dynamic evaluation is effective at exploiting regularities that co-occur across non-shuffled documents.
+
+Table 3: text8 (word-level) perplexities   
+
+<table><tr><td>model</td><td>valid</td><td>test</td></tr><tr><td>LSTM (Grave et al., 2017)</td><td></td><td>121.8</td></tr><tr><td>LSTM + neural cache (Grave et al., 2017)</td><td></td><td>99.9</td></tr><tr><td>AWD-LSTM</td><td>80.0</td><td>87.5</td></tr><tr><td>AWD-LSTM + neural cache</td><td>67.5</td><td>75.1</td></tr><tr><td>AWD-LSTM + dynamic eval</td><td>63.3</td><td>70.3</td></tr></table>
+
+# 7.2 MEDIUM SCALE WORD-LEVEL LANGUAGE MODELLING
+
+We benchmark the performance of dynamic evaluation against static evaluation and the neural cache on the larger text8 dataset. Like WikiText-2, text8 is derived from Wikipedia text. Text8 was introduced for word level language modelling by Mikolov et al. (2014), which preprocessed the data by mapping rare words to an ‘<unk>’ token, resulting in a vocab of 44k and 17M training tokens. We use the same test set as in Mikolov et al. (2014), but also hold out the final $1 0 0 \mathrm { k }$ training tokens as a validation set to allow for fair hyper-parameter tuning (the original task did not have a validation set). We trained an AWD-LSTM with 52M parameters using the implementation from Merity et al. (2017a). We then compare the performance of static evaluation, dynamic evaluation, and neural caching at test time.
+
+To ensure a fair comparison between dynamic evaluation and the neural cache, we used robust hyper-parameter tuning on the validation set for both methods. For dynamic evaluation, we used the hyper-parameter settings found on PTB, and only tuned the learning rate (to 2 significant figures). The neural cache uses 3 hyper-parameters: the cache length, a mixing parameter and a flatness parameter. Starting from a cache size of 3000, we used a series of grid searches to find optimal values for the mixing parameter and flatness parameter (to 2 significant figures). We then varied the cache size in the range of 2000-4000, and found that the affect of this was negligible, so we kept the cache size at 3000. Results are given in table 3, with the results from Grave et al. (2017) that used the same test set given for context.
+
+Dynamic evaluation soundly outperforms static evaluation and the neural cache method, demonstrating that the benefits of dynamic evaluation do not wash away when using a stronger model with more training data.
+
+# 7.3 CHARACTER-LEVEL LANGUAGE MODELLING
+
+We consider dynamic evaluation on the character-level text8, and Hutter Prize (Hutter, 2006) datasets. The Hutter Prize dataset is comprised of Wikipedia text, and includes XML and characters from non-Latin languages. It is 100 million UTF-8 bytes long and contains 205 unique bytes. Similarly to other reported results, we use a 90-5-5 split for training, validation, and testing. The text8 dataset is derived the Hutter Prize dataset, but has all XML removed, and is lower cased to only have 26 characters of English text plus spaces. The character-level text8 task corresponds to the unprocessed version of the text8 data used for our medium-scale word level language modelling experiments. As with Hutter Prize, we use the standard 90-5-5 split for training, validation, and testing for text8. We used a multiplicative LSTM (mLSTM) (Krause et al., 2016)3 as our base model for both datasets. The mLSTMs for both tasks used 2800 hidden units, an embedding layer of 400 units, weight normalization (Salimans & Kingma, 2016), variational dropout (Gal & Ghahramani, 2016), and ADAM (Kingma & Ba, 2014) for training.
+
+We also consider sparse dynamic evaluation, as described in Section 6, on the Hutter Prize dataset. For sparse dynamic evaluation, we adapted a subset of 500 hidden units, resulting in a $5 0 0 \times 5 0 0$ adaptation matrix and $2 5 0 \mathrm { k }$ adaptation parameters. Our mLSTM only contained one recurrent layer, so only one adaptation matrix was used for sparse dynamic evaluation. All of our dynamic evaluation results in this section use the final update rule given in Section 5. Results for Hutter Prize are given in Table 4, and results for text8 are given in Table 5.
+
+Table 4: Hutter Prize test set error in bits/char.   
+
+<table><tr><td>model</td><td>parameters</td><td>test</td></tr><tr><td>Stacked LSTM (Graves,2013)</td><td>21M</td><td>1.67</td></tr><tr><td rowspan="4">Stacked LSTM + traditional dynamic eval (Graves,2013) Multiplicative integration LSTM (Wu et al.,2016) HyperLSTM (Ha et al., 2017)</td><td>21M</td><td>1.33</td></tr><tr><td>17M</td><td>1.44</td></tr><tr><td>27M</td><td>1.34</td></tr><tr><td></td><td>1.32</td></tr><tr><td>Bytenet decoder (Kalchbrenner et al., 2016)</td><td></td><td>1.31</td></tr><tr><td>LSTM + BB tuning (Melis et al., 2017)</td><td>46M</td><td>1.30</td></tr><tr><td>Recurrent highway networks (Zilly et al.,2017) Fast-slow LSTM (Mujika et al.,2017)</td><td>46M</td><td>1.27</td></tr><tr><td></td><td>47M</td><td>1.25</td></tr><tr><td>mLSTM (Krause et al., 2016)</td><td>46M</td><td>1.24</td></tr><tr><td>mLSTM + sparse dynamic eval (d = 250k) mLSTM + dynamic eval</td><td>46M 46M</td><td>1.13 1.08</td></tr></table>
+
+Table 5: text8 (char-level) test set error in bits/char.   
+
+<table><tr><td>model</td><td>parameters</td><td>test</td></tr><tr><td>Multiplicative RNN (Mikolov et al., 2012)</td><td>5M</td><td>1.54</td></tr><tr><td>Multiplicative integration LSTM (Wu et al., 2016)</td><td>4M</td><td>1.44</td></tr><tr><td>LSTM (Cooijmans et al., 2017)</td><td></td><td>1.43</td></tr><tr><td>Batch normalised LSTM (Cooijmans et al., 2017)</td><td></td><td>1.36</td></tr><tr><td>Hierarchical multiscale LSTM (Chung et al., 2017)</td><td></td><td>1.29</td></tr><tr><td>Recurrent highway networks (Zilly et al., 2017)</td><td>45M</td><td>1.27</td></tr><tr><td>mLSTM (Krause et al., 2016)</td><td>45M</td><td>1.27</td></tr><tr><td>mLSTM + dynamic eval</td><td>45M</td><td>1.19</td></tr></table>
+
+Dynamic evaluation achieves large improvements to our base models and state-of-the-art results on both datasets. Sparse dynamic evaluation also achieves significant improvements on Hutter Prize using only $0 . 5 \%$ of the adaptation parameters of regular dynamic evaluation.
+
+# 7.4 TIME-SCALES OF DYNAMIC EVALUATION
+
+We measure time-scales at which dynamic evaluation gains an advantage over static evaluation. Starting from the model trained on Hutter Prize, we plot the performance of static and dynamic evaluation against the number of characters processed on sequences from the Hutter Prize test set, and sequences in Spanish from the European Parliament dataset (Koehn, 2005).
+
+The Hutter Prize data experiments show the timescales at which dynamic evaluation gained the advantage observed in Table 4. We divided the Hutter Prize test set into 500 sequences of length 10000, and applied static and dynamic evaluation to these sequences using the same model and methodology used to obtain results in Table 4. Losses were averaged across these 500 sequences to obtain average losses at each time step. Plots of the average cross-entropy errors against the number of Hutter characters sequenced are given in Figure 2a.
+
+The Spanish experiments measure how dynamic evaluation handles large distribution shifts between training and test time, as Hutter Prize contains very little Spanish. We used the first 5 million characters of the Spanish European Parliament data in place of the Hutter Prize test set. The Spanish experiments used the same base model and dynamic evaluation settings as Hutter Prize. Plots of the average cross-entropy errors against the number of Spanish characters sequenced are given in Figure 2b.
+
+On both datasets, dynamic evaluation gave a very noticeable advantage after a few hundred characters. For Spanish this advantage continued to grow as more of the sequence was processed, whereas for Hutter, this advantage was maximized after viewing around $2 \mathrm { - } 3 \mathrm { k }$ characters. The advantage of dynamic evaluation was also much greater on Spanish sequences than Hutter sequences.
+
+![](images/73266d39851529ff033477c1b7cc5ebfcf82ccb745d2822af2bf1efb79932a2c.jpg)  
+Figure 2: Average losses in bits/char of dynamic evaluation and static evaluation plotted against number of characters processed; on sequences from the Hutter Prize test set (left) and European Parliament dataset in Spanish (right), averaged over 500 trials for each. Losses at each data point are averaged over sequence segments of length 100, and are not cumulative. Note the different y-axis scales in the two plots.
+
+We also drew 300 character conditional samples from the static and dynamic versions of our model after viewing 10k characters of Spanish. For the dynamic model, we continued to apply dynamic evaluation during sampling as well, by the process described in Section 3. The conditional samples are given in the appendix. The static samples quickly switched to English that resembled Hutter Prize data. The dynamic model generated data with some Spanish words and a number of made up words with characteristics of Spanish words for the entirety of the sample. This is an example of the kinds of features that dynamic evaluation was able to learn to model on the fly.
+
+# 8 CONCLUSION
+
+This work explores and develops methodology for applying dynamic evaluation to sequence modelling tasks. Experiments show that the proposed dynamic evaluation methodology gives large test time improvements across character and word level language modelling. Our improvements to language modelling have applications to speech recognition and machine translation over longer contexts, including broadcast speech recognition and paragraph level machine translation. Overall, dynamic evaluation is shown to be an effective method for exploiting pattern re-occurrence in sequences.
+
+# REFERENCES
+
+Z. Aharoni, G. Rattner, and H. Permuter. Gradual learning of deep recurrent neural networks. arXiv preprint arXiv:1708.08863, 2017.   
+Jimmy Ba, Geoffrey E Hinton, Volodymyr Mnih, Joel Z Leibo, and Catalin Ionescu. Using fast weights to attend to the recent past. In Advances In Neural Information Processing Systems, pp. 4331–4339, 2016.   
+J. R. Bellegarda. Statistical language model adaptation: review and perspectives. Speech Communication, 42(1): 93–108, 2004.   
+J. Chung, S. Ahn, and Y. Bengio. Hierarchical multiscale recurrent neural networks. ICLR, 2017.   
+T. Cooijmans, N. Ballas, C. Laurent, and A. Courville. Recurrent batch normalization. ICLR, 2017.   
+M. Fortunato, C. Blundell, and O. Vinyals. Bayesian recurrent neural networks. arXiv preprint arXiv:1704.02798, 2017.   
+Y. Gal and Z. Ghahramani. A theoretically grounded application of dropout in recurrent neural networks. In Advances in neural information processing systems, pp. 1019–1027, 2016.   
+E. Grave, A. Joulin, and N. Usunier. Improving neural language models with a continuous cache. ICLR, 2017.   
+A. Graves. Generating sequences with recurrent neural networks. arXiv preprint arXiv:1308.0850, 2013.   
+D. Ha, A. Dai, and Q. Lee. Hypernetworks. ICLR, 2017.   
+S. Hochreiter and J. Schmidhuber. Long short-term memory. Neural Computation, 9:1735–1780, 1997.   
+M. Hutter. The human knowledge compression prize. URL http://prize.hutter1.net, 2006.   
+H. Inan, K. Khosravi, and R. Socher. Tying word vectors and word classifiers: A loss framework for language modeling. ICLR, 2017.   
+F. Jelinek, B. Merialdo, S. Roukos, and M. Strauss. A dynamic language model for speech recognition. In HLT, volume 91, pp. 293–295, 1991.   
+N. Kalchbrenner, L. Espeholt, K. Simonyan, A. Oord, A. Graves, and K. Kavukcuoglu. Neural machine translation in linear time. arXiv preprint arXiv:1610.10099, 2016.   
+Y. Kim, Y. Jernite, D. Sontag, and A. M. Rush. Character-aware neural language models. In Thirtieth AAAI Conference on Artificial Intelligence, 2016.   
+D. Kingma and J. Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   
+P. Koehn. Europarl: A parallel corpus for statistical machine translation. In MT Summit, volume 5, pp. 79–86, 2005.   
+B. Krause, L. Lu, I. Murray, and S. Renals. Multiplicative LSTM for sequence modelling. arXiv preprint arXiv:1609.07959, 2016.   
+B. Krause, I. Murray, S. Renals, and L. Lu. Multiplicative LSTM for sequence modelling. ICLR Workshop track, 2017. URL https://openreview.net/forum?id $=$ SJCS5rXFl.   
+R. Kuhn. Speech recognition and the frequency of recently used words: A modified Markov model for natural language. In Proceedings of the 12th conference on Computational linguistics-Volume 1, pp. 348–350. Association for Computational Linguistics, 1988.   
+M. P. Marcus, M. A. Marcinkiewicz, and B. Santorini. Building a large annotated corpus of English: The Penn Treebank. Computational linguistics, 19(2):313–330, 1993.   
+G. Melis, C. Dyer, and P. Blunsom. On the state of the art of evaluation in neural language models. arXiv preprint arXiv:1707.05589, 2017.   
+S. Merity, N. S. Keskar, and R. Socher. Regularizing and optimizing LSTM language models. arXiv preprint arXiv:1708.02182, 2017a.   
+S. Merity, C. Xiong, J. Bradbury, and R. Socher. Pointer sentinel mixture models. ICLR, 2017b.   
+T. Mikolov and G. Zweig. Context dependent recurrent neural network language model. SLT, 12:234–239, 2012.   
+T. Mikolov, M. Karafiát, L. Burget, J. Cernocky, and S. Khudanpur. Recurrent neural network based language \` model. In Interspeech, volume 2, pp. 3, 2010.   
+T. Mikolov, I. Sutskever, A. Deoras, H. Le, S. Kombrink, and J. Cernocky. Subword language modeling with neural networks. preprint (http://www. fit. vutbr. cz/imikolov/rnnlm/char. pdf), 2012.   
+Tomas Mikolov, Armand Joulin, Sumit Chopra, Michael Mathieu, and Marc’Aurelio Ranzato. Learning longer memory in recurrent neural networks. arXiv preprint arXiv:1412.7753, 2014.   
+A. Mujika, F. Meier, and A. Steger. Fast-slow recurrent neural networks. arXiv preprint arXiv:1705.08639, 2017.   
+A. G. Ororbia II, T. Mikolov, and D. Reitter. Learning simpler language models with the differential state framework. Neural Computation, 2017.   
+B. T. Polyak and A. B. Juditsky. Acceleration of stochastic approximation by averaging. SIAM Journal on Control and Optimization, 30(4):838–855, 1992.   
+O. Press and L. Wolf. Using the output embedding to improve language models. EACL 2017, pp. 157, 2017.   
+T. Salimans and D. P. Kingma. Weight normalization: A simple reparameterization to accelerate training of deep neural networks. In Advances in Neural Information Processing Systems, pp. 901–909, 2016.   
+Jürgen Schmidhuber. Learning to control fast-weight memories: An alternative to dynamic recurrent networks. Neural Computation, 4(1):131–139, 1992.   
+T. Tieleman and G. E. Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 4(2), 2012.   
+Seiya Tokui, Kenta Oono, Shohei Hido, and Justin Clayton. Chainer: a next-generation open source framework for deep learning. In Proceedings of workshop on machine learning systems (LearningSys) in the twenty-ninth annual conference on neural information processing systems (NIPS), volume 5, 2015.   
+L. Wan, M. Zeiler, S. Zhang, Yann L. Cun, and R. Fergus. Regularization of neural networks using dropconnect. In Proceedings of the 30th international conference on machine learning (ICML-13), pp. 1058–1066, 2013.   
+P. J. Werbos. Backpropagation through time: what it does and how to do it. Proceedings of the IEEE, 78: 1550–1560, 1990.   
+Y. Wu, S. Zhang, Y. Zhang, Y. Bengio, and R. Salakhutdinov. On multiplicative integration with recurrent neural networks. In NIPS, 2016.   
+W. Zaremba, I. Sutskever, and O. Vinyals. Recurrent neural network regularization. arXiv preprint arXiv:1409.2329, 2014.   
+J. G. Zilly, R. K. Srivastava, J. Koutník, and J. Schmidhuber. Recurrent highway networks. ICLR, 2017.   
+B. Zoph and Quoc V Le. Neural architecture search with reinforcement learning. ICLR, 2017.
+
+# A APPENDIX
+
+# A.1 DYNAMIC SAMPLES CONDITIONED ON SPANISH
+
+300 character samples generated from the dynamic version of the model trained on Hutter Prize, conditioned on 10k of Spanish characters. The final sentence fragment of the 10k conditioning characters is given to the reader, with the generated text given in bold:
+
+Tiene importancia este compromiso en la medida en que la Comisión es un organismo que tiene el montembre tas procedíns la conscriptione se ha Tesalo del Pómienda que et hanemos que Pe la Siemina.
+
+De la Pedrera Orden es Señora Presidente civil, Orden de siemin presente relevante frónmida que esculdad pludiore e formidad President de la Presidenta Antidorne Adamirmidad i ciemano de el 200’. Fo
+
+# A.2 STATIC SAMPLES CONDITIONED ON SPANISH
+
+300 character samples generated from the static version of the model trained on Hutter Prize, conditioned on 10k of Spanish characters. The final sentence fragment of the 10k conditioning characters is given to the reader, with the generated text given in bold:
+
+Tiene importancia este compromiso en la medida en que la Comisión es un organismo que tiene el monde,
+
+&lt;br&gt;There is a secret act in the world except Cape Town, seen in now flat comalo and ball market and has seen the closure of the eagle as imprints in a dallas within the country.&quot; Is a topic for an increasingly small contract saying Allan Roth acquired the government in [[1916]].

parse/train/rkdU7tCaZ/rkdU7tCaZ_content_list.json

@@ -0,0 +1,1096 @@
+[
+    {
+        "type": "text",
+        "text": "DYNAMIC EVALUATION OF NEURAL SEQUENCE MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            825,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            147,
+            398,
+            175
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            212,
+            544,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present methodology for using dynamic evaluation to improve neural sequence models. Models are adapted to recent history via a gradient descent based mechanism, causing them to assign higher probabilities to re-occurring sequential patterns. Dynamic evaluation outperforms existing adaptation approaches in our comparisons. Dynamic evaluation improves the state-of-the-art word-level perplexities on the Penn Treebank and WikiText-2 datasets to 51.1 and 44.3 respectively, and the state-of-the-art character-level cross-entropies on the text8 and Hutter Prize datasets to 1.19 bits/char and 1.08 bits/char respectively. ",
+        "bbox": [
+            232,
+            241,
+            766,
+            353
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            377,
+            336,
+            393
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sequence generation and prediction tasks span many modes of data, ranging from audio and language modelling, to more general timeseries prediction tasks. Applications of such models include speech recognition, machine translation, dialogue generation, speech synthesis, forecasting, and music generation, among others. Neural networks can be applied to these tasks by predicting sequence elements one-by-one, conditioning on the history of sequence elements, forming an autoregressive model. Convolutional neural networks (CNNs) and recurrent neural networks (RNNs), including long-short term memory (LSTM) networks (Hochreiter & Schmidhuber, 1997) in particular, have achieved many successes at these tasks. However, in their basic form, these models have a limited ability to adapt to recently observed parts of a sequence. ",
+        "bbox": [
+            174,
+            407,
+            825,
+            534
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many sequences contain repetition; a pattern that occurs once is more likely to occur again. For instance, a word that occurs once in a document is much more likely to occur again. A sequence of handwriting will generally stay in the same handwriting style. A sequence of speech will generally stay in the same voice. Although RNNs have a hidden state that can summarize the recent past, they are often unable to exploit new patterns that occur repeatedly in a test sequence. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            611
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper concerns dynamic evaluation, which we investigate as a candidate solution to this problem. Our approach adapts models to recent sequences using gradient descent based mechanisms. We show several ways to improve on past dynamic evaluation approaches in Section 5, and use our improved methodology to achieve state-of-the-art results in Section 7. In Section 6 we design a method to dramatically to reduce the number of adaptation parameters in dynamic evaluation, making it practical in a wider range of situations. In Section 7.4 we analyse dynamic evaluation’s performance over varying time-scales and distribution shifts, and demonstrate that dynamically evaluated models can generate conditional samples that repeat many patterns from the conditioning data. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            729
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 MOTIVATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            747,
+            313,
+            763
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative models can assign probabilities to sequences by modelling each term in the factorization given by the product rule. The probability of a sequence $\\stackrel { \\cdot } { x _ { 1 : T } } = \\{ x _ { 1 } , \\stackrel { \\cdot } { \\dots } , x _ { T } \\}$ factorizes as ",
+        "bbox": [
+            173,
+            779,
+            823,
+            808
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9f50fa0d935242efbb3705e582b2c0dd98c67d749d608b3a1ba70a8f73e05c99.jpg",
+        "text": "$$\nP ( x _ { 1 : T } ) = P ( x _ { 1 } ) P ( x _ { 2 } | x _ { 1 } ) P ( x _ { 3 } | x _ { 2 } , x _ { 1 } ) \\cdot \\cdot \\cdot P ( x _ { T } | x _ { 1 } \\ldots x _ { T - 1 } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            810,
+            714,
+            829
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Methods that apply this factorization either use a fixed context when predicting $P ( x _ { t } | x _ { 1 : t - 1 } )$ , for instance as in $\\mathbf { N } .$ -grams or CNNs, or use a recurrent hidden state to summarize the context, as in an RNN. However, for longer sequences, the history $x _ { 1 : t - 1 }$ often contains re-occurring patterns that are difficult to capture using models with fixed parameters (static models). ",
+        "bbox": [
+            174,
+            832,
+            825,
+            887
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In many domains, in a dataset of sequences $\\{ x _ { 1 : T } ^ { 1 } , x _ { 1 : T } ^ { 2 } , . . . , x _ { 1 : T } ^ { M } \\}$ , each sequence $\\boldsymbol { x } _ { 1 : T } ^ { i }$ is generated from a slightly different distribution $P ( x _ { 1 : T } ^ { i } )$ . At any point in time $t$ , the history of a sequence $x _ { 1 : t - 1 } ^ { i }$ contains useful information about the generating distribution for that specific sequence $P ( x _ { 1 : T } ^ { i } )$ Therefore adapting the model parameters learned during training $\\theta _ { g }$ is justified. We aim to infer a set of model parameters $\\theta _ { l }$ from $x _ { 1 : t - 1 } ^ { i }$ that will better approximate $\\bar { P } ( x _ { t } ^ { i } | x _ { 1 : t - 1 } ^ { i } )$ within sequence $i$ . ",
+        "bbox": [
+            174,
+            892,
+            821,
+            925
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            148
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Many sequence modelling tasks are characterised by sequences generated from slightly different distributions as in the scenario described above. The generating distribution may also change continuously across a single sequence; for instance, a text excerpt may change topic. Furthermore, many machine learning benchmarks do not distinguish between sequence boundaries, and concatenate all sequences into one continuous sequence. Thus, many sequence modelling tasks could be seen as having a local distribution $P _ { l } ( x )$ as well as a global distribution $\\textstyle P _ { g } ( x ) : = { \\bar { J } } P ( l ) P _ { l } ( x ) d l$ . During training time, the goal is to find the best fixed model possible for $P _ { g } ( x )$ . However, during evaluation time, a model that can infer the current $P _ { l } ( x )$ from the recent history has an advantage. ",
+        "bbox": [
+            173,
+            154,
+            825,
+            266
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 DYNAMIC EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            286,
+            400,
+            303
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Dynamic evaluation methods continuously adapt the model parameters $\\theta _ { g }$ , learned at training time, to parts of a sequence during evaluation. The goal is to learn adapted parameters $\\theta _ { l }$ that provide a better model of the local sequence distribution, $P _ { l } ( x )$ . When dynamic evaluation is applied in the present work, a long test sequence $x _ { 1 : T }$ is divided up into shorter sequences of length $n$ . We define $s _ { 1 : M }$ to be a sequence of shorter sequence segments $s _ { i }$ ",
+        "bbox": [
+            174,
+            318,
+            825,
+            388
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bd4d0aa3bf06110fcfa9f98cd8d61d4fc1aa73e4e222ba48cf3fb68c422ab79d.jpg",
+        "text": "$$\ns _ { 1 : M } = \\{ s _ { 1 } = x _ { 1 : n } , \\ s _ { 2 } = x _ { n + 1 : 2 n } , \\ s _ { 3 } = x _ { 2 n + 1 : 3 n } , \\ . . . , \\ s _ { M } \\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            396,
+            692,
+            414
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The initial adapted parameters $\\theta _ { l } ^ { 0 }$ are set to $\\theta _ { g }$ , and used to compute the probability of the first segment, $P ( s _ { 1 } | \\theta _ { l } ^ { 0 } )$ . This probability gives a cross entropy loss $\\mathcal { L } ( s _ { 1 } )$ , with gradient $\\nabla \\mathcal { L } ( s _ { 1 } )$ , which is computed using truncated back-propagation through time (Werbos, 1990). The gradient $\\nabla { \\mathcal { L } } ( s _ { 1 } )$ is used to update the model, resulting in adapted parameters $\\theta _ { l } ^ { 1 }$ , before evaluating $\\bar { P ( s _ { 2 } | \\theta _ { l } ^ { 1 } ) }$ . The same procedure is then repeated for $s _ { 2 }$ , and for each $s _ { i }$ in the sequence as shown in Figure 1. Gradients for each loss $\\mathcal { L } ( s _ { i } )$ are only backpropagated to the beginning of $s _ { i }$ , so computation is linear in the sequence length. Each update applies one maximum likelihood training step to approximate the current local distribution $P _ { l } ( x )$ . The computational cost of dynamic evaluation is one forward pass and one gradient computation through the data, with some slight overhead to apply the update rule for every sequence segment. ",
+        "bbox": [
+            174,
+            419,
+            825,
+            560
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As in all autoregressive models, dynamic evaluation only conditions on sequence elements that it has already predicted, and so evaluates a valid log-probability for each sequence. Dynamic evaluation can also be used while generating sequences. In this case, the model generates each sequence segment $s _ { i }$ using fixed weights, and performs a gradient descent based update step on $\\mathcal { L } ( s _ { i } )$ . Applying dynamic evaluation for sequence generation could result in generated sequences with more consistent regularities, meaning that patterns that occur in the generated sequence are more likely to occur again. ",
+        "bbox": [
+            174,
+            568,
+            825,
+            651
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "4 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            672,
+            326,
+            689
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "4.1 RELATED APPROACHES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            704,
+            375,
+            719
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Adaptive language modelling was first considered for n-grams, adapting to recent history via caching (Jelinek et al., 1991; Kuhn, 1988), and other methods Bellegarda (2004). More recently, the neural cache approach (Grave et al., 2017) and the closely related pointer sentinel-LSTM (Merity et al., 2017b) have been used to for adaptive neural language modelling. Neural caching has recently been used to improve the state-of-the-art at word-level language modelling (Merity et al., 2017a). ",
+        "bbox": [
+            174,
+            731,
+            825,
+            801
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The neural cache model learns a type of non-parametric output layer on the fly at test time, which allows the network to adapt to recent observations. Each past hidden state $h _ { i }$ is paired with the next input $x _ { i + 1 }$ , and is stored as a tuple $\\left( h _ { i } , x _ { i + 1 } \\right)$ . When a new hidden state $h _ { t }$ is observed, the output probabilities are adjusted to give a higher weight to output words that coincided with past hidden states with a large inner product $( h _ { t } ^ { T } h _ { i } )$ . ",
+        "bbox": [
+            174,
+            808,
+            823,
+            878
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/79a12e458ef8add7fbbf84e037f5861488187ee31f3d5709ff1167dd801570fa.jpg",
+        "text": "$$\nP _ { c a c h e } ( x _ { t + 1 } | x _ { 1 : t } , h _ { 1 : t } ) \\propto \\sum _ { i = 1 } ^ { t - 1 } e ^ { ( x _ { i + 1 } ) } \\exp ( \\omega h _ { t } ^ { T } h _ { i } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            886,
+            666,
+            928
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/df95773861d69acd90535594ea1cc660128237411e8542a90cf739be28c92fe5.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of dynamic evaluation. The model evaluates the probability of sequence segments $s _ { i }$ . The gradient $\\dot { \\nabla } \\mathcal { L } ( s _ { i } )$ with respect to the log probability of $s _ { i }$ is used to update the model parameters $\\theta _ { l } ^ { i - 1 }$ to $\\theta _ { l } ^ { i }$ before the model progresses to the next sequence segment. Dashed edges are what distinguish dynamic evaluation from static (normal) evaluation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            106,
+            818,
+            462
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $e ^ { ( x _ { i + 1 } ) }$ is a one hot encoding of $x _ { i + 1 }$ , and $\\omega$ is a scaling parameter. The cache probabilities are interpolated with the base network probabilities to adapt the base network at test time. ",
+        "bbox": [
+            176,
+            582,
+            823,
+            611
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The neural cache closely relates to dynamic evaluation, as both methods can be added on top of a base model for adaptation at test time. The main difference is the mechanism used to fit to recent history: the neural cache approach uses a non-parametric, nearest neighbours-like method, whereas dynamic evaluation uses a gradient descent based method to change model parameters dynamically. Both methods rely on an autoregressive factorisation, as they depend on observing sequence elements after they are predicted in order to perform adaptation. Dynamic evaluation and neural caching methods are therefore both applicable to sequence prediction and generation tasks, but not directly to more general supervised learning tasks. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            729
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "One drawback of the neural cache method is that it cannot adjust the recurrent hidden state dynamics. As a result, the neural cache’s ability to capture information that occurs jointly between successive sequence elements is limited. This capability is critical for adapting to sequences where each element has very little independent meaning, e.g. character level language modelling. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            791
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Another related approach is fast weights, (Ba et al., 2016; Schmidhuber, 1992). Fast weights feature recurrent architectures with dynamically changing weight matrices as a function of recent sequence history. Thus, dynamic evaluation as applied at test time, could be considered a form of fast-weights. In traditional fast weights, the network learns to control changes to the weights during training time, allowing it to be applied to more general sequence problems including sequence labeling. In dynamic evaluation, the procedure to change the weights is automated at test time via gradient descent optimization, making it only directly applicable to autoregressive sequence modelling. As dynamic evaluation leverages gradient descent, it has the potential to generalize better to previously unseen pattern repetitions at test time. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4.2 DYNAMIC EVALUATION IN NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            540,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Dynamic evaluation of neural language models was proposed by Mikolov et al. (2010). Their approach simply used stochastic gradient descent (SGD) updates at every time step, computing the gradient with fully truncated backpropagation through time, which is equivalent to setting $n = 1$ in equation (2). Dynamic evaluation has since been applied to character and word-level language models (Graves, 2013; Krause et al., 2017; Ororbia II et al., 2017; Fortunato et al., 2017). Previous work using dynamic evaluation considered it as an aside, and did not explore it in depth. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            213
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5 UPDATE RULE METHODOLOGY FOR DYNAMIC EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            233,
+            699,
+            250
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We propose several changes to Mikolov et al. (2010)’s dynamic evaluation method with SGD and fully truncated backpropagation, which we refer to as traditional dynamic evaluation. The first modification reduces the update frequency, so that gradients are backpropagated over more timesteps. This change provides more accurate gradient information, and also improves the computational efficiency of dynamic evaluation, since the update rule is applied much less often. We use sequence segments of length 5 for word-level tasks and 20 for character-level tasks. ",
+        "bbox": [
+            173,
+            263,
+            826,
+            348
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Next, we add a global decay prior to bias the model towards the parameters $\\theta _ { g }$ learned during training. Our motivation for dynamic evaluation assumes that the local generating distribution $P _ { l } ( x )$ is constantly changing, so it is potentially desirable to weight recent sequence history higher in adaptation. Adding a global decay prior accomplishes this by causing previous adaptation updates to decay exponentially over time. The use of a decay prior for dynamic evaluation relates to the update rule used for fast weights in Ba et al. (2016), which decayed fast weights towards zero exponentially over time. For SGD with a global prior, learning rate $\\eta$ and decay rate $\\lambda$ ; we form the update rule ",
+        "bbox": [
+            173,
+            354,
+            825,
+            454
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bec6fcbe31485ba2cfe55fb9088e663a20c90057d040c05c09121b3b9a54d394.jpg",
+        "text": "$$\n\\begin{array} { r } { \\theta _ { i }  \\theta _ { i - 1 } - \\eta \\nabla \\mathcal { L } ( s _ { i } ) + \\lambda ( \\theta _ { g } - \\theta _ { l } ^ { i - 1 } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            459,
+            630,
+            479
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We then consider using an RMSprop (Tieleman & Hinton, 2012) derived update rule for the learning rule in place of SGD. RMSprop uses a moving average of recent squared gradients to scale learning rates for each weight. In dynamic evaluation, near the start of a test sequence, RMSprop has had very few gradients to average, and therefore may not be able to leverage its updates as effectively. For this reason, we collect mean squared gradients, $M S _ { g }$ , on the training data rather than on recent test data (which is what RMSprop would do). $M S _ { g }$ is given by ",
+        "bbox": [
+            173,
+            491,
+            825,
+            577
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/45c6e59feff8e8d0ea66864fb7fea15a34331b5c75892ee11edb590c29ce4086.jpg",
+        "text": "$$\nM S _ { g } = \\frac { 1 } { N _ { b } } \\sum _ { k = 1 } ^ { N _ { b } } ( \\nabla \\mathcal { L } _ { k } ) ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            416,
+            583,
+            580,
+            627
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $N _ { b }$ is the number of training batches and $\\nabla \\mathcal L _ { k }$ is the gradient on the $k$ th training batch. The mini-batch size for this computation becomes a hyper-parameter, as larger mini-batches will result in smaller mean squared gradients. The update rule, which we call RMS with a global prior in our experiments, is then ",
+        "bbox": [
+            173,
+            632,
+            825,
+            689
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c32470e176da2c9d0b23caf1f29ccb5ae22f2a54dcb14c85abacddfc32b40804.jpg",
+        "text": "$$\n\\theta _ { l } ^ { i }  \\theta _ { l } ^ { i - 1 } - \\eta \\frac { \\nabla \\mathcal { L } ( s _ { i } ) } { \\sqrt { M S _ { g } } + \\epsilon } + \\lambda ( \\theta _ { g } - \\theta _ { l } ^ { i - 1 } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            686,
+            643,
+            723
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\epsilon$ is a stabilization parameter. For the decay step of our update rule, we also consider scaling the decay rate for each parameter proportionally to $\\sqrt { M S _ { g } }$ . Parameters with a high RMS gradient affect the dynamics of the network more, so it makes sense to decay them faster. $R M S _ { \\mathrm { n o r m } }$ is $\\sqrt { M S _ { g } }$ divided by its mean, resulting in a normalized version of $\\sqrt { M S _ { g } }$ with a mean of 1: ",
+        "bbox": [
+            173,
+            726,
+            825,
+            790
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/67a6f84ebda92fe0b169934395ee46c143e4479057c1508edd02a271ae823e07.jpg",
+        "text": "$$\nR M S _ { \\mathrm { n o r m } } = \\frac { \\sqrt { M S _ { g } } } { \\mathrm { a v g } ( \\sqrt { M S _ { g } } ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            797,
+            593,
+            837
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We clip the values of $R M S _ { \\mathrm { n o r m } }$ to be no greater than $^ 1 / \\lambda$ to be sure that the decay rate does not exceed 1 for any parameter. Combining the learning component and the regularization component results in the final update equation, which we refer to as RMS with an RMS global prior ",
+        "bbox": [
+            174,
+            843,
+            825,
+            886
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5c0194cfeb32b504aa41fcd6860da1a42b7555838c239b61501ba3a825a6e397.jpg",
+        "text": "$$\n\\theta _ { l } ^ { i }  \\theta _ { l } ^ { i - 1 } - \\eta \\frac { \\nabla \\mathcal { L } ( s _ { i } ) } { \\sqrt { M S _ { g } } + \\epsilon } + \\lambda ( \\theta _ { g } - \\theta _ { l } ^ { i - 1 } ) \\odot R M S _ { \\mathrm { n o r m } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            891,
+            689,
+            929
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "6 SPARSE DYNAMIC EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            465,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Mini-batching over sequences is desirable for some test-time sequence modelling applications because it allows faster processing of multiple sequences in parallel. Dynamic evaluation has a high memory cost for mini-batching because it is necessary to store a different set of parameters for each sequence in the mini-batch. Therefore, we consider a sparse dynamic evaluation variant that updates a smaller number of parameters. We introduce a new adaptation matrix $\\mathcal { M }$ which is initialized to zeros. $\\mathcal { M }$ multiplies hidden state vector $h _ { t }$ of an RNN at every time-step to get a new hidden state $h _ { t } ^ { \\prime }$ , via ",
+        "bbox": [
+            174,
+            132,
+            825,
+            215
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/33dd5afcea0eb8804fa38c5b7062b546d8d8f5ab6cf0d4d34b66090ae052a7bb.jpg",
+        "text": "$$\nh _ { t } ^ { \\prime } = h _ { t } + \\mathscr { M } h _ { t } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            441,
+            218,
+            555,
+            236
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$h _ { t } ^ { \\prime }$ then replaces $h _ { t }$ and is propagated throughout the network via both recurrent and feed-forward connections. In a stacked RNN, this formulation could be applied to every layer or just one layer. Applying dynamic evaluation to $\\mathcal { M }$ avoids the need to apply dynamic evaluation to the original parameters of the network, reduces the number of adaptation parameters, and makes mini-batching less memory intensive. We reduce the number of adaptation parameters further by only using $\\mathcal { M }$ to transform an arbitrary subset of $H$ hidden units. This results in $\\mathcal { M }$ being an $H \\times H$ matrix with $d = H ^ { 2 }$ adaptation parameters. If $H$ is chosen to be much less than the number of hidden units, this reduces the number of adaptation parameters dramatically. In Section 7.3 we experiment with sparse dynamic evaluation for character-level language models. ",
+        "bbox": [
+            173,
+            237,
+            825,
+            363
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "7 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            382,
+            326,
+            398
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We applied dynamic evaluation to word-level and character-level language modelling. In all tasks, we evaluate dynamic evaluation on top of a base model. After training the base model, we tune hyper-parameters for dynamic evaluation on the validation set, and evaluate both the static and dynamic versions of the model on the test set. We also consider follow up experiments that analyse the sequence lengths for which dynamic evaluation is useful. ",
+        "bbox": [
+            174,
+            412,
+            825,
+            483
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "7.1 SMALL SCALE WORD-LEVEL LANGUAGE MODELLING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            500,
+            586,
+            513
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We train base models on the Penn Treebank (PTB, Marcus et al., 1993), WikiText-2 (Merity et al., 2017b) datasets, and compare the performance of static and dynamic evaluation. These experiments compare dynamic evaluation against past approaches such as the neural cache and measure dynamic evaluation’s general performance across different models and datasets. ",
+        "bbox": [
+            174,
+            525,
+            825,
+            580
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "PTB is derived from articles of the Wall Street Journal. It contains 929k training tokens and a vocab size limited to 10k words. It is one of the most commonly used benchmarks in language modelling. We consider two baseline models on PTB, a standard LSTM implementation with recurrent dropout (Zaremba et al., 2014), and the recent state-of-the-art averaged SGD (ASGD) weight-dropped LSTM (AWD-LSTM, Merity et al., 2017a). ",
+        "bbox": [
+            174,
+            587,
+            825,
+            657
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our standard LSTM was taken from the Chainer (Tokui et al., 2015) tutorial on language modelling1, and used two LSTM layers with 650 units each, trained with SGD and regularized with recurrent dropout. On our standard LSTM, we experiment with traditional dynamic evaluation as applied by Mikolov et al. (2010), as well as each modification we make building up to our final update rule as described in Section 5. As our final update rule $( { \\mathrm { R M S } } + { \\mathrm { R M S } }$ global prior) worked best, we use this for all other experiments and use “dynamic eval” by default to refer to this update rule in tables. ",
+        "bbox": [
+            173,
+            664,
+            825,
+            748
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We applied dynamic evaluation on an AWD-LSTM (Merity et al., 2017a). The AWD-LSTM is a vanilla LSTM that combines the use of drop-connect (Wan et al., 2013) on recurrent weights for regularization, and a variant of ASGD (Polyak & Juditsky, 1992) for optimisation. Our model, which used 3 layers and tied input and output embeddings (Press & Wolf, 2017; Inan et al., 2017), was intended to be a direct replication of AWD-LSTM, using code from their implementation2. Results are given in Table 1. ",
+        "bbox": [
+            174,
+            755,
+            825,
+            839
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Dynamic evaluation gives significant overall improvements to both models on this dataset. Dynamic evaluation also achieves better final results than the neural cache on both a standard LSTM and the AWD-LSTM reimplementation, and improves the state-of-the-art on PTB. ",
+        "bbox": [
+            176,
+            845,
+            823,
+            887
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/8e65f6bf426223b9a7ec826f3b6c83610493a7a5ef316ecb8b3025380fc84b69.jpg",
+        "table_caption": [
+            "Table 1: Penn Treebank perplexities. bptt refers to sequence segment lengths. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>model</td><td>parameters</td><td>valid</td><td>test</td></tr><tr><td>RNN+LDA+kN-5+cache (Mikolov &amp; Zweig,2012)</td><td></td><td></td><td>92.0</td></tr><tr><td>CharCNN (Kim et al., 2016)</td><td>19M</td><td></td><td>78.9</td></tr><tr><td>LSTM (Zaremba et al., 2014)</td><td>66M</td><td>82.2</td><td>78.4</td></tr><tr><td>Variational LSTM (Gal &amp; Ghahramani, 2016)</td><td>66M</td><td></td><td>73.4</td></tr><tr><td>Pointer sentinel-LSTM (Merity et al.,2017b)</td><td>21M</td><td>72.4</td><td>70.9</td></tr><tr><td>Variational LSTM + augmented loss (Inan et al., 2017)</td><td>51M</td><td>71.1</td><td>68.5</td></tr><tr><td>Variational RHN (Zilly et al.,2017)</td><td>23M</td><td>67.9</td><td>65.4</td></tr><tr><td>NAS cell (Zoph &amp; Le,2017)</td><td>54M</td><td></td><td>62.4</td></tr><tr><td>Variational LSTM + gradual learning (Aharoni et al., 2017)</td><td>105M</td><td></td><td>61.7</td></tr><tr><td>LSTM + BB tuning (Melis et al.,2017)</td><td>24M</td><td>60.9</td><td>58.3</td></tr><tr><td>LSTM (Grave et al., 2017)</td><td></td><td>86.9</td><td>82.3</td></tr><tr><td>LSTM + neural cache (Grave et al., 2017)</td><td></td><td>74.6</td><td>72.1</td></tr><tr><td>LSTM (ours)</td><td>20M</td><td>88.0</td><td>85.6</td></tr><tr><td>LSTM + traditional dynamic eval (sgd, bptt=1)</td><td>20M</td><td>78.6</td><td>76.2</td></tr><tr><td>LSTM + dynamic eval (sgd, bptt=5)</td><td>20M</td><td>78.0</td><td>75.6</td></tr><tr><td>LSTM + dynamic eval (sgd, bptt=5, global prior)</td><td>20M</td><td>77.4</td><td>74.8</td></tr><tr><td>LSTM + dynamic eval (RMS,bptt=5, global prior)</td><td>20M</td><td>74.3</td><td>72.2</td></tr><tr><td>LSTM + dynamic eval (RMS, bptt=5, RMS global prior)</td><td>20M</td><td>73.5</td><td>71.7</td></tr><tr><td>AWD-LSTM (Merity et al., 2017a)</td><td>24M</td><td>60.0</td><td>57.3</td></tr><tr><td>AWD-LSTM +neural cache (Merity et al., 2017a)</td><td>24M</td><td>53.9</td><td>52.8</td></tr><tr><td>AWD-LSTM (ours)</td><td>24M</td><td>59.8</td><td>57.7</td></tr><tr><td>AWD-LSTM + dynamic eval</td><td>24M</td><td>51.6</td><td>51.1</td></tr></table>",
+        "bbox": [
+            197,
+            102,
+            803,
+            449
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/6ca4c54052ce511b573f4cb37a2ce359ffc563bdfdba7f1043c3cd6c194499a1.jpg",
+        "table_caption": [
+            "Table 2: WikiText-2 perplexities. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>model</td><td>parameters</td><td>valid</td><td>test</td></tr><tr><td>Byte mLSTM (Krause et al., 2016)</td><td>46M</td><td>92.8</td><td>88.8</td></tr><tr><td>Variational LSTM (Inan et al., 2017)</td><td>28M</td><td>91.5</td><td>87.0</td></tr><tr><td>Pointer sentinel-LSTM (Merity et al., 2017b)</td><td></td><td>84.8</td><td>80.8</td></tr><tr><td>LSTM + BB tuning (Melis et al., 2017)</td><td>24M</td><td>69.1</td><td>65.9</td></tr><tr><td>LSTM (Grave et al., 2017)</td><td></td><td>104.2</td><td>99.3</td></tr><tr><td>LSTM + neural cache (Grave et al., 2017)</td><td></td><td>72.1</td><td>68.9</td></tr><tr><td>LSTM (ours)</td><td>50M</td><td>109.1</td><td>103.4</td></tr><tr><td>LSTM + dynamic eval</td><td>50M</td><td>63.7</td><td>59.8</td></tr><tr><td>AWD-LSTM (Merity et al., 2017a)</td><td>33M</td><td>68.6</td><td>65.8</td></tr><tr><td>AWD-LSTM + neural cache (Merity et al., 2017a)</td><td>33M</td><td>53.8</td><td>52.0</td></tr><tr><td>AWD-LSTM (ours)</td><td>33M</td><td>68.9</td><td>66.1</td></tr><tr><td>AWD-LSTM + dynamic eval</td><td>33M</td><td>46.4</td><td>44.3</td></tr></table>",
+        "bbox": [
+            222,
+            522,
+            777,
+            732
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "WikiText-2 is roughly twice the size of PTB, with 2 million training tokens and a vocab size of 33k. It features articles in a non-shuffled order, with dependencies across articles that adaptive methods should be able to exploit. For this dataset, we use the same baseline LSTM implementation and AWD-LSTM re-implementation as on PTB. Results are given in Table 2. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Dynamic evaluation improves the state-of-the-art perplexity on WikiText-2, and provides a significantly greater improvement than neural caching to both base models. This suggests that dynamic evaluation is effective at exploiting regularities that co-occur across non-shuffled documents. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/4b6ce09f726fcca46b1c568c7150d57c79edeb9fb661f002a21db6068c89fdaa.jpg",
+        "table_caption": [
+            "Table 3: text8 (word-level) perplexities "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>model</td><td>valid</td><td>test</td></tr><tr><td>LSTM (Grave et al., 2017)</td><td></td><td>121.8</td></tr><tr><td>LSTM + neural cache (Grave et al., 2017)</td><td></td><td>99.9</td></tr><tr><td>AWD-LSTM</td><td>80.0</td><td>87.5</td></tr><tr><td>AWD-LSTM + neural cache</td><td>67.5</td><td>75.1</td></tr><tr><td>AWD-LSTM + dynamic eval</td><td>63.3</td><td>70.3</td></tr></table>",
+        "bbox": [
+            295,
+            101,
+            700,
+            207
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "7.2 MEDIUM SCALE WORD-LEVEL LANGUAGE MODELLING ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            266,
+            596,
+            280
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We benchmark the performance of dynamic evaluation against static evaluation and the neural cache on the larger text8 dataset. Like WikiText-2, text8 is derived from Wikipedia text. Text8 was introduced for word level language modelling by Mikolov et al. (2014), which preprocessed the data by mapping rare words to an ‘<unk>’ token, resulting in a vocab of 44k and 17M training tokens. We use the same test set as in Mikolov et al. (2014), but also hold out the final $1 0 0 \\mathrm { k }$ training tokens as a validation set to allow for fair hyper-parameter tuning (the original task did not have a validation set). We trained an AWD-LSTM with 52M parameters using the implementation from Merity et al. (2017a). We then compare the performance of static evaluation, dynamic evaluation, and neural caching at test time. ",
+        "bbox": [
+            173,
+            291,
+            825,
+            416
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To ensure a fair comparison between dynamic evaluation and the neural cache, we used robust hyper-parameter tuning on the validation set for both methods. For dynamic evaluation, we used the hyper-parameter settings found on PTB, and only tuned the learning rate (to 2 significant figures). The neural cache uses 3 hyper-parameters: the cache length, a mixing parameter and a flatness parameter. Starting from a cache size of 3000, we used a series of grid searches to find optimal values for the mixing parameter and flatness parameter (to 2 significant figures). We then varied the cache size in the range of 2000-4000, and found that the affect of this was negligible, so we kept the cache size at 3000. Results are given in table 3, with the results from Grave et al. (2017) that used the same test set given for context. ",
+        "bbox": [
+            174,
+            424,
+            825,
+            549
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Dynamic evaluation soundly outperforms static evaluation and the neural cache method, demonstrating that the benefits of dynamic evaluation do not wash away when using a stronger model with more training data. ",
+        "bbox": [
+            176,
+            555,
+            825,
+            598
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "7.3 CHARACTER-LEVEL LANGUAGE MODELLING ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            616,
+            524,
+            630
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We consider dynamic evaluation on the character-level text8, and Hutter Prize (Hutter, 2006) datasets. The Hutter Prize dataset is comprised of Wikipedia text, and includes XML and characters from non-Latin languages. It is 100 million UTF-8 bytes long and contains 205 unique bytes. Similarly to other reported results, we use a 90-5-5 split for training, validation, and testing. The text8 dataset is derived the Hutter Prize dataset, but has all XML removed, and is lower cased to only have 26 characters of English text plus spaces. The character-level text8 task corresponds to the unprocessed version of the text8 data used for our medium-scale word level language modelling experiments. As with Hutter Prize, we use the standard 90-5-5 split for training, validation, and testing for text8. We used a multiplicative LSTM (mLSTM) (Krause et al., 2016)3 as our base model for both datasets. The mLSTMs for both tasks used 2800 hidden units, an embedding layer of 400 units, weight normalization (Salimans & Kingma, 2016), variational dropout (Gal & Ghahramani, 2016), and ADAM (Kingma & Ba, 2014) for training. ",
+        "bbox": [
+            174,
+            641,
+            825,
+            808
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also consider sparse dynamic evaluation, as described in Section 6, on the Hutter Prize dataset. For sparse dynamic evaluation, we adapted a subset of 500 hidden units, resulting in a $5 0 0 \\times 5 0 0$ adaptation matrix and $2 5 0 \\mathrm { k }$ adaptation parameters. Our mLSTM only contained one recurrent layer, so only one adaptation matrix was used for sparse dynamic evaluation. All of our dynamic evaluation results in this section use the final update rule given in Section 5. Results for Hutter Prize are given in Table 4, and results for text8 are given in Table 5. ",
+        "bbox": [
+            174,
+            815,
+            825,
+            898
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/1326a533b26c072573b525328e842d2dfda097ca0f10b3bbdd761c901031c7e3.jpg",
+        "table_caption": [
+            "Table 4: Hutter Prize test set error in bits/char. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>model</td><td>parameters</td><td>test</td></tr><tr><td>Stacked LSTM (Graves,2013)</td><td>21M</td><td>1.67</td></tr><tr><td rowspan=\"4\">Stacked LSTM + traditional dynamic eval (Graves,2013) Multiplicative integration LSTM (Wu et al.,2016) HyperLSTM (Ha et al., 2017)</td><td>21M</td><td>1.33</td></tr><tr><td>17M</td><td>1.44</td></tr><tr><td>27M</td><td>1.34</td></tr><tr><td></td><td>1.32</td></tr><tr><td>Bytenet decoder (Kalchbrenner et al., 2016)</td><td></td><td>1.31</td></tr><tr><td>LSTM + BB tuning (Melis et al., 2017)</td><td>46M</td><td>1.30</td></tr><tr><td>Recurrent highway networks (Zilly et al.,2017) Fast-slow LSTM (Mujika et al.,2017)</td><td>46M</td><td>1.27</td></tr><tr><td></td><td>47M</td><td>1.25</td></tr><tr><td>mLSTM (Krause et al., 2016)</td><td>46M</td><td>1.24</td></tr><tr><td>mLSTM + sparse dynamic eval (d = 250k) mLSTM + dynamic eval</td><td>46M 46M</td><td>1.13 1.08</td></tr></table>",
+        "bbox": [
+            232,
+            101,
+            767,
+            303
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/2bc3e900d88a8bbabcd07a7b56e555153e6b0c4040906577f37c02f3a87a67ba.jpg",
+        "table_caption": [
+            "Table 5: text8 (char-level) test set error in bits/char. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>model</td><td>parameters</td><td>test</td></tr><tr><td>Multiplicative RNN (Mikolov et al., 2012)</td><td>5M</td><td>1.54</td></tr><tr><td>Multiplicative integration LSTM (Wu et al., 2016)</td><td>4M</td><td>1.44</td></tr><tr><td>LSTM (Cooijmans et al., 2017)</td><td></td><td>1.43</td></tr><tr><td>Batch normalised LSTM (Cooijmans et al., 2017)</td><td></td><td>1.36</td></tr><tr><td>Hierarchical multiscale LSTM (Chung et al., 2017)</td><td></td><td>1.29</td></tr><tr><td>Recurrent highway networks (Zilly et al., 2017)</td><td>45M</td><td>1.27</td></tr><tr><td>mLSTM (Krause et al., 2016)</td><td>45M</td><td>1.27</td></tr><tr><td>mLSTM + dynamic eval</td><td>45M</td><td>1.19</td></tr></table>",
+        "bbox": [
+            250,
+            352,
+            748,
+            500
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Dynamic evaluation achieves large improvements to our base models and state-of-the-art results on both datasets. Sparse dynamic evaluation also achieves significant improvements on Hutter Prize using only $0 . 5 \\%$ of the adaptation parameters of regular dynamic evaluation. ",
+        "bbox": [
+            174,
+            560,
+            825,
+            603
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7.4 TIME-SCALES OF DYNAMIC EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            625,
+            496,
+            638
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We measure time-scales at which dynamic evaluation gains an advantage over static evaluation. Starting from the model trained on Hutter Prize, we plot the performance of static and dynamic evaluation against the number of characters processed on sequences from the Hutter Prize test set, and sequences in Spanish from the European Parliament dataset (Koehn, 2005). ",
+        "bbox": [
+            174,
+            651,
+            825,
+            707
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The Hutter Prize data experiments show the timescales at which dynamic evaluation gained the advantage observed in Table 4. We divided the Hutter Prize test set into 500 sequences of length 10000, and applied static and dynamic evaluation to these sequences using the same model and methodology used to obtain results in Table 4. Losses were averaged across these 500 sequences to obtain average losses at each time step. Plots of the average cross-entropy errors against the number of Hutter characters sequenced are given in Figure 2a. ",
+        "bbox": [
+            174,
+            714,
+            825,
+            797
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The Spanish experiments measure how dynamic evaluation handles large distribution shifts between training and test time, as Hutter Prize contains very little Spanish. We used the first 5 million characters of the Spanish European Parliament data in place of the Hutter Prize test set. The Spanish experiments used the same base model and dynamic evaluation settings as Hutter Prize. Plots of the average cross-entropy errors against the number of Spanish characters sequenced are given in Figure 2b. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "On both datasets, dynamic evaluation gave a very noticeable advantage after a few hundred characters. For Spanish this advantage continued to grow as more of the sequence was processed, whereas for Hutter, this advantage was maximized after viewing around $2 \\mathrm { - } 3 \\mathrm { k }$ characters. The advantage of dynamic evaluation was also much greater on Spanish sequences than Hutter sequences. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/73266d39851529ff033477c1b7cc5ebfcf82ccb745d2822af2bf1efb79932a2c.jpg",
+        "image_caption": [
+            "Figure 2: Average losses in bits/char of dynamic evaluation and static evaluation plotted against number of characters processed; on sequences from the Hutter Prize test set (left) and European Parliament dataset in Spanish (right), averaged over 500 trials for each. Losses at each data point are averaged over sequence segments of length 100, and are not cumulative. Note the different y-axis scales in the two plots. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            107,
+            746,
+            285
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            393,
+            823,
+            422
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We also drew 300 character conditional samples from the static and dynamic versions of our model after viewing 10k characters of Spanish. For the dynamic model, we continued to apply dynamic evaluation during sampling as well, by the process described in Section 3. The conditional samples are given in the appendix. The static samples quickly switched to English that resembled Hutter Prize data. The dynamic model generated data with some Spanish words and a number of made up words with characteristics of Spanish words for the entirety of the sample. This is an example of the kinds of features that dynamic evaluation was able to learn to model on the fly. ",
+        "bbox": [
+            173,
+            430,
+            825,
+            527
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "8 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            547,
+            318,
+            564
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This work explores and develops methodology for applying dynamic evaluation to sequence modelling tasks. Experiments show that the proposed dynamic evaluation methodology gives large test time improvements across character and word level language modelling. Our improvements to language modelling have applications to speech recognition and machine translation over longer contexts, including broadcast speech recognition and paragraph level machine translation. Overall, dynamic evaluation is shown to be an effective method for exploiting pattern re-occurrence in sequences. ",
+        "bbox": [
+            174,
+            579,
+            825,
+            664
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            684,
+            285,
+            699
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Z. Aharoni, G. Rattner, and H. Permuter. Gradual learning of deep recurrent neural networks. arXiv preprint arXiv:1708.08863, 2017.   \nJimmy Ba, Geoffrey E Hinton, Volodymyr Mnih, Joel Z Leibo, and Catalin Ionescu. Using fast weights to attend to the recent past. In Advances In Neural Information Processing Systems, pp. 4331–4339, 2016.   \nJ. R. Bellegarda. Statistical language model adaptation: review and perspectives. Speech Communication, 42(1): 93–108, 2004.   \nJ. Chung, S. Ahn, and Y. Bengio. Hierarchical multiscale recurrent neural networks. ICLR, 2017.   \nT. Cooijmans, N. Ballas, C. Laurent, and A. Courville. Recurrent batch normalization. ICLR, 2017.   \nM. Fortunato, C. Blundell, and O. Vinyals. Bayesian recurrent neural networks. arXiv preprint arXiv:1704.02798, 2017.   \nY. Gal and Z. Ghahramani. A theoretically grounded application of dropout in recurrent neural networks. In Advances in neural information processing systems, pp. 1019–1027, 2016.   \nE. Grave, A. Joulin, and N. Usunier. Improving neural language models with a continuous cache. ICLR, 2017.   \nA. Graves. Generating sequences with recurrent neural networks. arXiv preprint arXiv:1308.0850, 2013.   \nD. Ha, A. Dai, and Q. Lee. Hypernetworks. ICLR, 2017.   \nS. Hochreiter and J. Schmidhuber. Long short-term memory. Neural Computation, 9:1735–1780, 1997.   \nM. Hutter. The human knowledge compression prize. URL http://prize.hutter1.net, 2006.   \nH. Inan, K. Khosravi, and R. Socher. Tying word vectors and word classifiers: A loss framework for language modeling. ICLR, 2017.   \nF. Jelinek, B. Merialdo, S. Roukos, and M. Strauss. A dynamic language model for speech recognition. In HLT, volume 91, pp. 293–295, 1991.   \nN. Kalchbrenner, L. Espeholt, K. Simonyan, A. Oord, A. Graves, and K. Kavukcuoglu. Neural machine translation in linear time. arXiv preprint arXiv:1610.10099, 2016.   \nY. Kim, Y. Jernite, D. Sontag, and A. M. Rush. Character-aware neural language models. In Thirtieth AAAI Conference on Artificial Intelligence, 2016.   \nD. Kingma and J. Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   \nP. Koehn. Europarl: A parallel corpus for statistical machine translation. In MT Summit, volume 5, pp. 79–86, 2005.   \nB. Krause, L. Lu, I. Murray, and S. Renals. Multiplicative LSTM for sequence modelling. arXiv preprint arXiv:1609.07959, 2016.   \nB. Krause, I. Murray, S. Renals, and L. Lu. Multiplicative LSTM for sequence modelling. ICLR Workshop track, 2017. URL https://openreview.net/forum?id $=$ SJCS5rXFl.   \nR. Kuhn. Speech recognition and the frequency of recently used words: A modified Markov model for natural language. In Proceedings of the 12th conference on Computational linguistics-Volume 1, pp. 348–350. Association for Computational Linguistics, 1988.   \nM. P. Marcus, M. A. Marcinkiewicz, and B. Santorini. Building a large annotated corpus of English: The Penn Treebank. Computational linguistics, 19(2):313–330, 1993.   \nG. Melis, C. Dyer, and P. Blunsom. On the state of the art of evaluation in neural language models. arXiv preprint arXiv:1707.05589, 2017.   \nS. Merity, N. S. Keskar, and R. Socher. Regularizing and optimizing LSTM language models. arXiv preprint arXiv:1708.02182, 2017a.   \nS. Merity, C. Xiong, J. Bradbury, and R. Socher. Pointer sentinel mixture models. ICLR, 2017b.   \nT. Mikolov and G. Zweig. Context dependent recurrent neural network language model. SLT, 12:234–239, 2012.   \nT. Mikolov, M. Karafiát, L. Burget, J. Cernocky, and S. Khudanpur. Recurrent neural network based language \\` model. In Interspeech, volume 2, pp. 3, 2010.   \nT. Mikolov, I. Sutskever, A. Deoras, H. Le, S. Kombrink, and J. Cernocky. Subword language modeling with neural networks. preprint (http://www. fit. vutbr. cz/imikolov/rnnlm/char. pdf), 2012.   \nTomas Mikolov, Armand Joulin, Sumit Chopra, Michael Mathieu, and Marc’Aurelio Ranzato. Learning longer memory in recurrent neural networks. arXiv preprint arXiv:1412.7753, 2014.   \nA. Mujika, F. Meier, and A. Steger. Fast-slow recurrent neural networks. arXiv preprint arXiv:1705.08639, 2017.   \nA. G. Ororbia II, T. Mikolov, and D. Reitter. Learning simpler language models with the differential state framework. Neural Computation, 2017.   \nB. T. Polyak and A. B. Juditsky. Acceleration of stochastic approximation by averaging. SIAM Journal on Control and Optimization, 30(4):838–855, 1992.   \nO. Press and L. Wolf. Using the output embedding to improve language models. EACL 2017, pp. 157, 2017.   \nT. Salimans and D. P. Kingma. Weight normalization: A simple reparameterization to accelerate training of deep neural networks. In Advances in Neural Information Processing Systems, pp. 901–909, 2016.   \nJürgen Schmidhuber. Learning to control fast-weight memories: An alternative to dynamic recurrent networks. Neural Computation, 4(1):131–139, 1992.   \nT. Tieleman and G. E. Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 4(2), 2012.   \nSeiya Tokui, Kenta Oono, Shohei Hido, and Justin Clayton. Chainer: a next-generation open source framework for deep learning. In Proceedings of workshop on machine learning systems (LearningSys) in the twenty-ninth annual conference on neural information processing systems (NIPS), volume 5, 2015.   \nL. Wan, M. Zeiler, S. Zhang, Yann L. Cun, and R. Fergus. Regularization of neural networks using dropconnect. In Proceedings of the 30th international conference on machine learning (ICML-13), pp. 1058–1066, 2013.   \nP. J. Werbos. Backpropagation through time: what it does and how to do it. Proceedings of the IEEE, 78: 1550–1560, 1990.   \nY. Wu, S. Zhang, Y. Zhang, Y. Bengio, and R. Salakhutdinov. On multiplicative integration with recurrent neural networks. In NIPS, 2016.   \nW. Zaremba, I. Sutskever, and O. Vinyals. Recurrent neural network regularization. arXiv preprint arXiv:1409.2329, 2014.   \nJ. G. Zilly, R. K. Srivastava, J. Koutník, and J. Schmidhuber. Recurrent highway networks. ICLR, 2017.   \nB. Zoph and Quoc V Le. Neural architecture search with reinforcement learning. ICLR, 2017. ",
+        "bbox": [
+            173,
+            707,
+            826,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            89,
+            828,
+            920
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            297,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.1 DYNAMIC SAMPLES CONDITIONED ON SPANISH",
+        "text_level": 1,
+        "bbox": [
+            174,
+            133,
+            547,
+            147
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "300 character samples generated from the dynamic version of the model trained on Hutter Prize, conditioned on 10k of Spanish characters. The final sentence fragment of the 10k conditioning characters is given to the reader, with the generated text given in bold: ",
+        "bbox": [
+            174,
+            160,
+            825,
+            202
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tiene importancia este compromiso en la medida en que la Comisión es un organismo que tiene el montembre tas procedíns la conscriptione se ha Tesalo del Pómienda que et hanemos que Pe la Siemina. ",
+        "bbox": [
+            176,
+            228,
+            823,
+            270
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "De la Pedrera Orden es Señora Presidente civil, Orden de siemin presente relevante frónmida que esculdad pludiore e formidad President de la Presidenta Antidorne Adamirmidad i ciemano de el 200’. Fo ",
+        "bbox": [
+            176,
+            270,
+            825,
+            311
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.2 STATIC SAMPLES CONDITIONED ON SPANISH",
+        "text_level": 1,
+        "bbox": [
+            178,
+            329,
+            526,
+            343
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "300 character samples generated from the static version of the model trained on Hutter Prize, conditioned on 10k of Spanish characters. The final sentence fragment of the 10k conditioning characters is given to the reader, with the generated text given in bold: ",
+        "bbox": [
+            176,
+            356,
+            825,
+            397
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tiene importancia este compromiso en la medida en que la Comisión es un organismo que tiene el monde, ",
+        "bbox": [
+            176,
+            424,
+            823,
+            452
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "&lt;br&gt;There is a secret act in the world except Cape Town, seen in now flat comalo and ball market and has seen the closure of the eagle as imprints in a dallas within the country.&quot; Is a topic for an increasingly small contract saying Allan Roth acquired the government in [[1916]]. ",
+        "bbox": [
+            176,
+            454,
+            823,
+            508
+        ],
+        "page_idx": 10
+    }
+]

parse/train/ryF7rTqgl/ryF7rTqgl.md

@@ -0,0 +1,270 @@
+# UNDERSTANDING INTERMEDIATE LAYERS USING LINEAR CLASSIFIER PROBES
+
+Guillaume Alain & Yoshua Bengio   
+Department of Computer Science and Operations Research   
+Universite de Montr´ eal´   
+Montreal, QC. H3C 3J7   
+guillaume.alain.umontreal@gmail.com
+
+# ABSTRACT
+
+Neural network models have a reputation for being black boxes. We propose a new method to better understand the roles and dynamics of the intermediate layers. This has direct consequences on the design of such models and it enables the expert to be able to justify certain heuristics (such as adding auxiliary losses in middle layers). Our method uses linear classifiers, referred to as “probes”, where a probe can only use the hidden units of a given intermediate layer as discriminating features. Moreover, these probes cannot affect the training phase of a model, and they are generally added after training. They allow the user to visualize the state of the model at multiple steps of training. We demonstrate how this can be used to develop a better intuition about models and to diagnose potential problems.
+
+# 1 INTRODUCTION
+
+The recent history of deep neural networks features an impressive number of new methods and technological improvements to allow the training of deeper and more powerful networks.
+
+Despite this, models still have a reputation for being black boxes. Neural networks are criticized for their lack of interpretability, which is a tradeoff that we accept because of their amazing performance on many tasks. Efforts have been made to identify the role played by each layer, but it can be hard to find a meaning to individual layers.
+
+There are good arguments to support the claim that the first layers of a convolution network for image recognition contain filters that are relatively “general”, in the sense that they would work great even if we switched to an entirely different dataset of images. The last layers are specific to the dataset being used, and have to be retrained when using a different dataset. In Yosinski et al. (2014) the authors try to pinpoint the layer at which this transition occurs, but they show that the exact transition is spread across multiple layers.
+
+In this paper, we introduce the concept of linear classifier probe, referred to as a “probe” for short when the context is clear. We start from the concept of Shannon entropy, which is the classic way to describe the information contents of a random variable. We then seek to apply that concept to understand the roles of the intermediate layers of a neural network, to measure how much information is gained at every layer (answer : technically, none). We argue that it fails to apply, and so we propose an alternative framework to ask the same question again. This time around, we ask what would be the performance of an optimal linear classifier if it was trained on the inputs of a given layer from our model. We demonstrate how this powerful concept can be very useful to understand the dynamics involved in a deep neural network during training and after.
+
+# 2 INFORMATION THEORY
+
+It was a great discovery when Claude Shannon repurposed the notion of entropy to represent information contents in a formal way. It laid the foundations for the discipline of information theory. We would refer the reader to first chapters of MacKay (2003) for a good exposition on the matter.
+
+Naturally, we would like to ask some questions about the information contents of the many layers of convolutional neural networks.
+
+• What happens when we add more layers? • Where does information flow in a neural network with multiple branches? • Does having multiple auxiliary losses help? (e.g. Inception model)
+
+Intuitively, for a training sample $x _ { i }$ with its associated label $y _ { i }$ , a deep model is getting closer to the correct answer in the higher layers. It starts with the difficult job of classifying $x _ { i }$ , which becomes easier as the higher layers distill $x _ { i }$ into a representation that is easier to classify. One might be tempted to say that this means that the higher layers have more information about the ground truth, but this would be incorrect.
+
+Here there is a mismatch between two different concepts of information. The notion of entropy fails to capture the essence of those questions. This is illustrated in a formal way by the Data Processing Inequality. It states that, for a set of three random variables satisfying the dependency
+
+$$
+X  Y  Z
+$$
+
+then we have that
+
+$$
+I ( X ; Z ) \leq I ( X ; Y )
+$$
+
+where $I ( X , Y )$ is the mutual information.
+
+Intuitively, this means that the deterministic transformations performed by the many layers of a deep neural network are not adding more information. In the best case, they preserve information and affect only the representation. But in almost all situations, they lose some information in the process.
+
+If we distill this further, we can think of the serious mismatch between the two following ideas :
+
+• Part of the genius of the notion of entropy is that is distills the essence of information to a quantity that does not depend on the particular representation. • A deep neural network is a series of simple deterministic transformations that affect the representation so that the final layer can be fed to a linear classifier.
+
+The former ignores the representation of data, while the latter is an expert in finding good representations. A deaf painter is working on a visual masterpiece to offer to a blind musician who plays music for him.
+
+We need a conceptual tool to analyze neural networks in a way that corresponds better to our intuitive notion of information. The role of data representation is important, but we would also argue that we have to think about this issue as it relates to computational complexity. A linear classifier is basically the simplest form of classifier that is neither trivial nor degenerate.
+
+We define a new notion of information that depends on our ability to classify features of a given layer with an optimal linear classifier. Then we have a conceptual tool to ask new questions and to get potentially interesting answers.
+
+We end this section with a conceptual example in Figure 1. If $X$ contains an image of the savannah, and $Y \in \{ 0 , 1 \}$ refers to whether it contains a lion or not, then none of the subsequent layers are truly more informative than $X$ itself. The raw bits from the picture file contain everything.
+
+# 3 LINEAR CLASSIFIER PROBES
+
+In section 3.1 we present the main concept of this paper. We illustrate the concept in section 3.3. We then present a basic experiment in section 3.4. In section 3.6 we modify a very deep network in two different ways and we show how probes allow us to visualize the consequences (sometimes disastrous) of our design choices.
+
+![](images/78baeb4650f7068a4bb370f8b79ef6aff22f2ee2233ad5cfa0a96e0c27beee1b.jpg)
+
+(a) hex dump of picture of a lion
+
+![](images/750bb3ce2c908bfaf317f9e7fb8b1ba500189ea38e6e0a815ee9683f5263efff.jpg)  
+(b) same lion in human-readable format
+
+Figure 1: The hex dump represented on the left has more information contents than the image on the right. Only one of them can be processed by the human brain in time to save their lives. Computational convenience matters. Not just entropy.
+
+# 3.1 PROBES
+
+As we discussed the previous section, there is indeed a good reason to use many deterministic layers, and it is because they perform useful transformations to the data with the goal of ultimately fitting a linear classifier at the very end. That is the purpose of the many layers. They are a tool to transform data into a form to be fed to a boring linear classifier.
+
+With this in mind, it is natural to ask if that transformation is sudden or progressive, and whether the intermediate layers already have a representation that is immediately useful to a linear classifier. We refer the reader to Figure 2 for a diagram of probes being inserted in the usual deep neural network.
+
+![](images/7fe427e62a973b961b2b7a92e9fc20ca3f76db5858d600f6655652c21603a5fe.jpg)  
+Figure 2: Probes being added to every layer of a model. These additional probes are not supposed to change the training of the model, so we add a little diode symbol through the arrows to indicate that the gradients will not backpropagate through those connections.
+
+The conceptual framework that we propose is one where the intuitive notion of information is equivalent with immediate suitability for a linear classifier (instead of being related to entropy).
+
+Just to be absolutely clear about what we call a linear classifier, we mean a function
+
+$$
+\begin{array} { r } { f \colon H \to [ 0 , 1 ] ^ { D } \qquad } \\ { h \mapsto \operatorname { s o f t m a x } \left( W h + b \right) . } \end{array}
+$$
+
+where $h \in H$ are the features of some hidden layer, $[ 0 , 1 ] ^ { D }$ is the space of one-hot encodings of the $D$ target classes, and $( W , b )$ are the probe weights and biases to be learned so as to minimize the usual cross-entropy loss.
+
+Over the course of training a model, the parameters of the model change. However, probes only make sense when we refer to a given training step. We can talk about the probes at iteration $n$ of training, when the model parameters are $\theta _ { n }$ . These parameters are not affected by the probes. We prevent backpropagation through the model either by stopping the gradient flow (done with tf.stop gradient in tensorflow), or simply by specifying that the only variables to be updated are the probe parameters, while we keep $\theta _ { n }$ frozen.
+
+# 3.1.1 TRAINING THE PROBES
+
+For the purposes of this paper, we train the probes up to convergence with fixed model parameters, and we report the prediction error on the training set.
+
+It is absolutely possible to train the probes simulatenously while training the model itself. This is a good approach if we consider about how long it can take to train the model. However, this creates a potential problem if we optimize the loss of the model more quickly than the loss of the probes. This can present a skewed view of the actual situation that we would have if we trained the probes until convergence before updating the model parameters. If we accept this trade off, then we can train the probes at the same time as the model.
+
+In some situations, the probes might overfit the training set, so we may want to do early stopping on the validation set and report the performance for the probes on the test set. This is what we do in section 3.4 with the simple MNIST convnet.
+
+We are still unsure if one of those variations should be preferred in general, and right now they all seem acceptable so long as we interpret the probe measurements properly.
+
+Note that training those probes represents a convex optimization problem. In practice, this does mean guarantee that they are easy to train. However, it is reassuring because it means that probes taken at time $\theta _ { n }$ can be used as initialization for probes at time $\theta _ { n + 1 }$ .
+
+We use cross-entropy as probe loss because all models studied here used cross-entropy. Other alternative losses could be justified in other settings.
+
+# 3.2 PROBES ON BIFURCATING TOY MODEL
+
+Here we show a hypothetical example in which a model contains a bifurcation with two paths that later recombine. We are interested in knowing whether those two branches are useful, or whether one is potentially redundant or useless.
+
+![](images/28d8e18ee4159097fbcf3411da69627a35992457a870f3a7cd002a25607618bb.jpg)
+
+For example, the two different branches might contain convolutional layers with different dimensions. They may have a different number of sublayers, or one might represent a skip connection. We assume that the branches are combined through concatenation of their features, so that nothing is lost.
+
+For this hypothetical situation, we indicate the probe prediction errors on the graphical model. The upper path has a prediction error of 0.75, the lower path has 0.60, and their combination has 0.45. Small errors are preferred. Although the upper path has “less information” than the lower path, we can see here that it is not redundant information, because when we concatenate the features of the two branches we get a prediction error of $0 . 4 5 < 0 . 6 0$ .
+
+If the concatenated layer had a prediction error of 0.60 instead of 0.45, then we could declare that the above branch did nothing useful. It may have nonzero weights, but it’s still useless.
+
+Naturally, this kind of conclusion might be entirely wrong. It might be the case that the branch above contains very meaningful features, and they simply happen to be useless to a linear classifier applied right there. The idea of using linear classification probes to understand the roles of different branches is suggested as a heuristic instead of a hard rule. Moreover, if the probes are not optimized perfectly, the conclusions drawn can be misleading.
+
+Note that we are reporting here the prediction errors, and it might be the case that the loss is indeed lower when we concatenate the two branches, but for some reason it could fail to apply to the prediction error.
+
+![](images/e700959f190618878009af74e4198fba1113ac0a2aea7427043b21425727966d.jpg)  
+Figure 3: Toy experiment described in section 3.3, with linearly separable data (two labels), an untrained MLP with 32 layers, and probes at every layer. We report the prediction error for every probe, where 0.50 would be the performence of a coin flip and 0.00 would be ideal. Note that the layer 0 here corresponds to the raw data, and the probes are indeed able to classify it perfectly. As expected, performance degrades when applying random transformations. If many more layers were present, it would be hard to imagine how the final layer (with the model loss) can get any useful signal to backpropagate.
+
+# 3.3 PROBES ON UNTRAINED MODEL
+
+We start with a toy example to illustrate what kind of plots we expect from probes. We use a 32- layer MLP with 128 hidden units. All the layers are fully-connected and we use LeakyReLU(0.5) as activation function.
+
+We will run the same experiment 100 times, with a different toy dataset each time. The goal is to use a data distribution $( X , Y )$ where $X \in \mathbb { R } ^ { 1 2 8 }$ is drawn $\mathcal { N } ( 0 , I )$ and where $Y \in \{ - 1 , 1 \}$ in linearly separable (i.e. super easy to classify with a one-layer neural network). To do this, we just pick a $w \in \mathbb { R } ^ { 1 2 8 }$ for each experiment, and let the label $y _ { n }$ be the sign of $x _ { n } ^ { T } w$ .
+
+We initialize this 32-layer MLP using glorot normal initialization, we do not perform any training on the model, and we add one probe at every layer. We optimize the probes with RMSProp and a sufficiently small learning rate.
+
+In Figure 3, we show the prediction error rate for every probe, averaged over the 100 experiments. The graph includes a probe applied directly on the inputs $X$ , where we naturally have an error rate that is essentially zero (to be expected by the way we constructed our data), and which serves as a kind of sanity check. Given that we have only two possible labels, we also show a dotted horizontal line at 0.50, which is essentially the prediction error that we would get by flipping a coin. We can see that the prediction error rate climbs up towards 0.50 as we go deeper in the MLP (with untrained parameters).
+
+This illustrates the idea that the input signal is getting mangled by the successive layers, so much that it becomes rather useless by the time we reach the final layer. We checked the mean activation norm of the hidden units at layer 32 to be sure that numerical underflow was not the cause for the degradation. Note that this situation could be avoided by using orthogonal weights.
+
+One of the popular explanation for training difficulties in very deep models is that of the exploding/vanishing (Hochreiter, 1991; Bengio et al., 1993). Here we would like to offer another complementary explanation, based on the observations from Figure 3. That is, at the beginning of training, the usefulness of layers decays as we go deeper, reaching the point where the deeper layers are utterly useless. The values contained in the last layer are then used in the final softmax classifier, and the loss backpropagates the values of the derivatives. Since that derivative is based on garbage activations, the backpropagated quantities are also garbage, which means that the weights are all going to be updated based on garbage. The weights stay bad, and we fail to train the model. The authors like to refer to that phenomenon as garbage forwardprop, garbage backprop, in reference to the popular concept of garbage in, garbage out in computer science.
+
+# 3.4 PROBES ON MNIST CONVNET
+
+In this section we run the MNIST convolutional model provided by the tensorflow github repo (tensorflow/models/image/mnist/convolutional.py) We selected that model for reproducibility and to demonstrate how to easily peek into popular models by using probes.
+
+We start by sketching the model in Figure 4. We report the results at the beginning and the end of training on Figure 5. One of the interesting dynamics to be observed there is how useful the first layers are, despite the fact that the model is completely untrained. Random projections can be useful to classify data, and this has been studied by others (Jarrett et al., 2009).
+
+![](images/f438d4f7a1cc7b5b3e6e74d2d823d02bd54755e30d757f7ce61cce6044b374ba.jpg)  
+Figure 4: This graphical model represents the neural network that we are going to use for MNIST. The model could be written in a more compact form, but we represent it this way to expose all the locations where we are going to insert probes. The model itself is simply two convolutional layers followed by two fully-connected layer (one being the final classifier). However, we insert probes on each side of each convolution, activation function, and pooling function. This is a bit overzealous, but the small size of the model makes this relatively easy to do.
+
+![](images/bc7dcf2a16cd443533b530cf7acf58c4ad9d7fbfbf82e479a8dcf90dba39a2e8.jpg)  
+Figure 5: We represent here the test prediction error for each probe, at the beginning and at the end of training. This measurement was obtained through early stopping based on a validation set of $1 0 ^ { 4 }$ elements. The probes are prevented from overfitting the training data. We can see that, at the beginning of training (on the left), the randomly-initialized layers were still providing useful transformations. The test prediction error goes from $8 \%$ to $2 \%$ simply using those random features. The biggest impact comes from the first ReLU. At the end of training (on the right), the test prediction error is improving at every layer (with the exception of a minor kink on fc1 preact).
+
+![](images/9c6aff93d37afc59de3370916abc4522757ced668563bc1f82e65d64b7f29028.jpg)  
+(b) After training for 10 epochs.
+
+(a) After initialization, no training.
+
+# 3.5 PROBES ON INCEPTION V3
+
+We have performed an experiment using the Inception v3 model on the ImageNet dataset (Szegedy et al., 2015; Russakovsky et al., 2015). This is very similar to what is presented in section 3.4, but on a much larger scale. Due to the challenge presented by this experiment, we were not able to do everything that we had hoped. We have chosen to put those results in the appendix section A.2.
+
+Certain layers of the Inception v3 model have approximately one million features. With 1000 classes, this means that some probes can take even more storage space than the whole model itself. In these cases, one of the creative solutions was to try to use only a random subset of the features. This is discussed in the appendix section A.1.
+
+# 3.6 AUXILIARY LOSS BRANCHES AND SKIP CONNECTIONS
+
+Here we investigate two ways to modify a deep model in order to facilitate training. Our goal is not to convince the reader that they should implement these suggestions in their own models. Rather, we want to demonstrate the usefulness of the linear classifier probes as a way to better understand what is happening in their deep networks.
+
+In both cases we use a toy model with 128 fully-connected layers with 128 hidden units in each layer. We train on MNIST, and we use Glorot initialization along with leaky ReLUs.
+
+We choose this model because we wanted a pathologically deep model without getting involved in architecture details. The model is pathological in the sense that smaller models can easily be designed to achieve better performance, but also in the sense that the model is so deep that it is very hard to train it with gradient descent methods. From our experiments, the maximal depth where things start to break down was depth 64, hence the choice here of using depth 128.
+
+In the first scenario, we add one linear classifier at every 16 layers. These classifiers contribute to the loss minimization. They are not probes. This is very similar to what happens in the famous Inception model where “auxiliary heads” are used (Szegedy et al., 2015). This is illustrated in Figure 6a, and it works nicely. The untrainable model is now made trainable through a judicious use of auxiliary classifier losses. The results are shown in Figure 7.
+
+In the second scenario, we look at adding a bridge (a skip connection) between layer 0 and layer 64. This means that the input features to layer 64 are obtained by concatenating the output of layer 63 with the features of layer 0. The idea here is that we might observe that the model would effectively train a submodel of depth 64, using the skip connection, and shift gears later to use the whole depth of 128 layers. This is illustrated in Figure 6b, and the results are shown in Figure 8. It does not work as expected, but the failure of this approach is visualized very nicely with probes and serves as a great example of their usefulness in diagnosing problems with models.
+
+In both cases, there are two interesting observations that can be made with probes. We refer readers to https://youtu.be/x8j4ZHCR2FI for the full videos associated to Figures 5, 7 and 8.
+
+Firstly, at the beginning of training, we can see how the raw data is directly useful to perform linear classification, and how this degrades as more layers are added. In the case of the skip connection in Figure 8, this has the effect of creating two bumps. This is because the layer 64 also has the input data as direct parent, so it can fit a probe to that signal.
+
+Secondly, the prediction error goes down in all probes during training, but it does so in a way that starts with the parents before it spreads to their descendants. This is even more apparent on the full video (instead of the 3 frames provided here). This is a ripple effect, where the prediction error in Figure 6b is visually spreading like a wave from the left of the plot to the right.
+
+(a) Model with 16 layers, one guide at every 4 layers.
+
+![](images/da998f98e898911a7968c3db79a7030cfb53c00e62f9c4f09039012ed33ef354.jpg)  
+(b) Model with 128 layers. A skip connection goes from the beginning straight to the middle of the graph.
+
+![](images/e3b1a2cbb938fc42bb9757e42574c2a8d194e5e426fd154e57becbfa030b4ec5.jpg)  
+Figure 6: Examples of deep neural network with one probe at every layer (drawn above the graph). We show here the addition of extra components to help training (under the graph, in orange).
+
+# 4 DISCUSSION AND FUTURE WORK
+
+We have presented more toy models or simple models instead of larger models such as Inception v3. In the appendix section A.2 we show an experiment on Inception v3, which proved to be more challenging than expected. Future work in this domain would involve performing better experiments on a larger scale than small MNIST convnets, but still within a manageable size so we can properly train all the probes. This would allow us to produce nice videos showing many training steps in sequence.
+
+We have received many comments from people who thought about using multi-layer probes. This can be seen as a natural extension of the linear classifier probes. One downside to this idea is that we lose the convexity property of the probes. It might be worth pursuing in a particular setting, but as of now we feel that it is premature to start using multi-layer probes. This also leads to the convoluted idea of having a regular probe inside a multi-layer probe.
+
+![](images/1240396023f6cfd3a3400ed0cdd793e99041b168ebdcacf9a70ebaef6ab0bcbb.jpg)  
+Figure 7: A pathologically deep model with 128 layers gets an auxiliary loss added at every 16 layers (refer to simplified sketch in Figure 6a if needed). This loss is added to the usual model loss at the last layer. We fit a probe at every layer to see how well each layer would perform if its values were used as a linear classifier. We plot the train prediction error associated to all the probes, at three different steps. Before adding those auxiliary losses, the model could not successfully be trained through usual gradient descent methods, but with the addition of those intermediate losses, the model is “guided” to achieve certain partial objectives. This leads to a successful training of the complete model. The final prediction error is not impressive, but the model was not designed to achieve state-of-the-art performance.
+
+![](images/b0e8b1bc41f60a9d072968ed282f7b74e63f3ce9047d2f663342d1c3f6cacb98.jpg)  
+Figure 8: A pathologically deep model with 128 layers gets a skip connection from layer 0 to layer 64 (refer to sketch in Figure 6b if needed). We fit a probe at every layer to see how well each layer would perform if its values were used as a linear classifier. We plot the train prediction error associated to all the probes, at three different steps. We can see how the model completely ignores layers 1-63, even when we train it for a long time. The use of probes allows us to diagnose that problem through visual inspection.
+
+# 5 CONCLUSION
+
+In this paper we introduced the concept of the linear classifier probe as a conceptual tool to better understand the dynamics inside a neural network and the role played by the individual intermediate layers. We are now able to ask new questions and explore new areas. We have demonstrated how these probes can be used to identify certain problematic behaviors in models that might not be apparent when we traditionally have access to only the prediction loss and error.
+
+We hope that the notions presented in this paper can contribute to the understanding of deep neural networks and guide the intuition of researchers that design them.
+
+# ACKNOWLEDGMENTS
+
+Yoshua Bengio is a senior CIFAR Fellow. The authors would like to acknowledge the support of the following agencies for research funding and computing support: NSERC, FQRNT, Calcul Quebec, ´ Compute Canada, the Canada Research Chairs and CIFAR.
+
+# REFERENCES
+
+Y Bengio, Paolo Frasconi, and P Simard. The problem of learning long-term dependencies in recurrent networks. In Neural Networks, 1993., IEEE International Conference on, pp. 1183– 1188. IEEE, 1993.
+
+Sepp Hochreiter. Untersuchungen zu dynamischen neuronalen netzen. Diploma, Technische Universitat M¨ unchen ¨ , pp. 91, 1991.
+
+Kevin Jarrett, Koray Kavukcuoglu, Yann Lecun, et al. What is the best multi-stage architecture for object recognition? In 2009 IEEE 12th International Conference on Computer Vision, pp. 2146–2153. IEEE, 2009.
+
+David MacKay. Information Theory, Inference and Learning Algorithms. Cambridge University Press, 2003.
+
+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.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1–9, 2015.
+
+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.
+
+# A APPENDIX
+
+.1 PROPOSAL : TRAIN PROBES USING ONLY SUBSETS OF FEATURES
+
+One of the challenges to train on the Inception v3 model is that many of the layers have more than 200, 000 features. This is even worse in the first convolution layers before the pooling operations, where we have around a million features. With 1000 output classes, a probe using 200, 000 features has a weight matrix taking almost 1GB of storage.
+
+When using stochastic gradient descent, we require space to store the gradients, and if we use momentum this ends up taking three times the memory on the GPU. This is even worse for RMSProp. Normally this might be acceptable for a model of reasonable size, but this turns into almost 4GB overhead per probe.
+
+We do not have to put a probe at every layer. We can also train probes independently. We can put probe parameters on the CPU instead of the GPU, if necessary. But when the act of training probes increases the complexity of the experiment beyond a certain point, the researcher might decide that they are not worth the trouble.
+
+We propose the following solution $:$ for a given probe, use a fixed random subset of features instead of the whole set of features.
+
+With certain assumptions about the independence of the features and their shared role in predicting the correct class, we can make certain claims about how few features are actually required to assess the prediction error of a probe. We thank Yaroslav Bulatov for suggesting this approach.
+
+We ran an experiment in which we used data $X \sim \mathcal { N } ( 0 , I _ { D } )$ where $D = 1 0 0 , 0 0 0$ is the number of features. We used $K = 1 0 0 0$ classes and we generated the ground truth using a matrix $W$ of shape $( D , K )$ . To obtain the class of a given $x$ , we simply multiply $x ^ { T } W$ and take the argmax over the $K$ components of the result.
+
+$$
+\boldsymbol { x } \sim \mathcal { N } ( 0 , I _ { D } ) \qquad \quad \boldsymbol { y } = \underset { k = 1 \ldots K } { \arg \operatorname* { m a x } } \left( \boldsymbol { x } ^ { T } W [ : , k ] \right)
+$$
+
+We selected a matrix $W$ by drawing all its individual coefficients from a univariate gaussian.
+
+Instead of using $D = 1 0 0 , 0 0 0$ features, we used instead only 1000 features picked at random. We trained a linear classifier on those features and, experimentally, it was relatively easy to achieve a $4 \%$ error rate on our first try. With all the features, we could achieve a $0 \%$ error rate, so $4 \%$ might not look great. We have to keep in mind that we have $K = 1 0 0 0$ classes so random guesses yield an error rate of $9 9 . 9 \%$ .
+
+This can reduce the storage cost for a probe from 1GB down to 10MB. The former is hard to justify, and the latter is almost negligible.
+
+# A.2 PROBES ON INCEPTION V3
+
+We are interested in putting linear classifier probes in the popular Inception v3 model, training on the ImageNet dataset. We used the tensorflow implementation available online (tensorflow/models/inception/inception) and ran it on one GPU for 2 weeks.
+
+![](images/ac9d6cc65020b4249ed3608d9b9b777742591517ad3a2380677dd8d818c256fb.jpg)
+
+As described in section A.1, one of the challenges is that the number of features can be prohibitively large, and we have to consider taking only a subset of the features. In this particular experiment, we have had the most success by taking 1000 random features for each probe. This gives certain layers an unfair advantage if they start with 4000 features and we kept 1000, whereas in other cases the probe insertion point has 426, 320 features and we keep 1000. There was no simple “fair” solution. That being said, 13 out of the 17 probes have more than 100, 000 features, and 11 of those probes have more than 200, 000 features, so things were relatively comparable.
+
+We put linear classifier probes at certain strategic layers. We represent this using boxes in the following Figure 9. The prediction error of the probe given by the last layer of each box is illustrated by coloring the box. Red is bad (high prediction error) and green/blue is good (low prediction error).
+
+We would have liked to have a video to show the evolution of this during training, but this experiment had to be scaled back due to the large computational demands. We show here the prediction errors at three moments of training. These correspond roughly to the beginning of training, then after a few days, and finally after a week.
+
+# Inception v3
+
+![](images/be6f620a4776ffd6346efda0088099ba541bfd481b106cd797b8827d1c06e143.jpg)  
+Figure 9: Inserting a probe at multiple moments during training the Inception v3 model on the ImageNet dataset. We represent here the prediction error evaluated at a random subset of 1000 features. As expected, at first all the probes have a $100 \%$ prediction error, but as training progresses we see that the model is getting better. Note that there are 1000 classes, so a prediction error of $50 \%$ is much better than a random guess. The auxiliary head, shown under the model, was observed to have a prediction error that was slightly better than the main head. This is not necessarily a condition that will hold at the end of training, but merely an observation.

parse/train/ryF7rTqgl/ryF7rTqgl_content_list.json

@@ -0,0 +1,1454 @@
+[
+    {
+        "type": "text",
+        "text": "UNDERSTANDING INTERMEDIATE LAYERS USING LINEAR CLASSIFIER PROBES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            101,
+            678,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Alain & Yoshua Bengio   \nDepartment of Computer Science and Operations Research   \nUniversite de Montr´ eal´   \nMontreal, QC. H3C 3J7   \nguillaume.alain.umontreal@gmail.com ",
+        "bbox": [
+            184,
+            170,
+            571,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            276,
+            544,
+            291
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural network models have a reputation for being black boxes. We propose a new method to better understand the roles and dynamics of the intermediate layers. This has direct consequences on the design of such models and it enables the expert to be able to justify certain heuristics (such as adding auxiliary losses in middle layers). Our method uses linear classifiers, referred to as “probes”, where a probe can only use the hidden units of a given intermediate layer as discriminating features. Moreover, these probes cannot affect the training phase of a model, and they are generally added after training. They allow the user to visualize the state of the model at multiple steps of training. We demonstrate how this can be used to develop a better intuition about models and to diagnose potential problems. ",
+        "bbox": [
+            233,
+            309,
+            764,
+            449
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            479,
+            336,
+            494
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The recent history of deep neural networks features an impressive number of new methods and technological improvements to allow the training of deeper and more powerful networks. ",
+        "bbox": [
+            176,
+            512,
+            823,
+            540
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite this, models still have a reputation for being black boxes. Neural networks are criticized for their lack of interpretability, which is a tradeoff that we accept because of their amazing performance on many tasks. Efforts have been made to identify the role played by each layer, but it can be hard to find a meaning to individual layers. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            603
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "There are good arguments to support the claim that the first layers of a convolution network for image recognition contain filters that are relatively “general”, in the sense that they would work great even if we switched to an entirely different dataset of images. The last layers are specific to the dataset being used, and have to be retrained when using a different dataset. In Yosinski et al. (2014) the authors try to pinpoint the layer at which this transition occurs, but they show that the exact transition is spread across multiple layers. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            694
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we introduce the concept of linear classifier probe, referred to as a “probe” for short when the context is clear. We start from the concept of Shannon entropy, which is the classic way to describe the information contents of a random variable. We then seek to apply that concept to understand the roles of the intermediate layers of a neural network, to measure how much information is gained at every layer (answer : technically, none). We argue that it fails to apply, and so we propose an alternative framework to ask the same question again. This time around, we ask what would be the performance of an optimal linear classifier if it was trained on the inputs of a given layer from our model. We demonstrate how this powerful concept can be very useful to understand the dynamics involved in a deep neural network during training and after. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            825
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 INFORMATION THEORY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            848,
+            397,
+            864
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "It was a great discovery when Claude Shannon repurposed the notion of entropy to represent information contents in a formal way. It laid the foundations for the discipline of information theory. We would refer the reader to first chapters of MacKay (2003) for a good exposition on the matter. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Naturally, we would like to ask some questions about the information contents of the many layers of convolutional neural networks. ",
+        "bbox": [
+            169,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• What happens when we add more layers? • Where does information flow in a neural network with multiple branches? • Does having multiple auxiliary losses help? (e.g. Inception model) ",
+        "bbox": [
+            215,
+            145,
+            717,
+            202
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, for a training sample $x _ { i }$ with its associated label $y _ { i }$ , a deep model is getting closer to the correct answer in the higher layers. It starts with the difficult job of classifying $x _ { i }$ , which becomes easier as the higher layers distill $x _ { i }$ into a representation that is easier to classify. One might be tempted to say that this means that the higher layers have more information about the ground truth, but this would be incorrect. ",
+        "bbox": [
+            174,
+            213,
+            825,
+            284
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Here there is a mismatch between two different concepts of information. The notion of entropy fails to capture the essence of those questions. This is illustrated in a formal way by the Data Processing Inequality. It states that, for a set of three random variables satisfying the dependency ",
+        "bbox": [
+            176,
+            290,
+            825,
+            333
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b0064659b88b5a2792be0ae29b5451a4d9752011e80d918b18b69f9c28d7484b.jpg",
+        "text": "$$\nX  Y  Z\n$$",
+        "text_format": "latex",
+        "bbox": [
+            450,
+            342,
+            547,
+            356
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "then we have that ",
+        "bbox": [
+            174,
+            367,
+            290,
+            381
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/524af97b5da2306235f39a76d823058d3576e75e66909db6dd31fa583ba12f5e.jpg",
+        "text": "$$\nI ( X ; Z ) \\leq I ( X ; Y )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            382,
+            568,
+            400
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $I ( X , Y )$ is the mutual information. ",
+        "bbox": [
+            176,
+            405,
+            447,
+            421
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, this means that the deterministic transformations performed by the many layers of a deep neural network are not adding more information. In the best case, they preserve information and affect only the representation. But in almost all situations, they lose some information in the process. ",
+        "bbox": [
+            174,
+            426,
+            825,
+            483
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "If we distill this further, we can think of the serious mismatch between the two following ideas : ",
+        "bbox": [
+            173,
+            502,
+            802,
+            517
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Part of the genius of the notion of entropy is that is distills the essence of information to a quantity that does not depend on the particular representation. • A deep neural network is a series of simple deterministic transformations that affect the representation so that the final layer can be fed to a linear classifier. ",
+        "bbox": [
+            215,
+            531,
+            825,
+            594
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The former ignores the representation of data, while the latter is an expert in finding good representations. A deaf painter is working on a visual masterpiece to offer to a blind musician who plays music for him. ",
+        "bbox": [
+            176,
+            609,
+            823,
+            651
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We need a conceptual tool to analyze neural networks in a way that corresponds better to our intuitive notion of information. The role of data representation is important, but we would also argue that we have to think about this issue as it relates to computational complexity. A linear classifier is basically the simplest form of classifier that is neither trivial nor degenerate. ",
+        "bbox": [
+            174,
+            657,
+            825,
+            714
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We define a new notion of information that depends on our ability to classify features of a given layer with an optimal linear classifier. Then we have a conceptual tool to ask new questions and to get potentially interesting answers. ",
+        "bbox": [
+            174,
+            720,
+            825,
+            763
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We end this section with a conceptual example in Figure 1. If $X$ contains an image of the savannah, and $Y \\in \\{ 0 , 1 \\}$ refers to whether it contains a lion or not, then none of the subsequent layers are truly more informative than $X$ itself. The raw bits from the picture file contain everything. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            813
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 LINEAR CLASSIFIER PROBES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            835,
+            442,
+            852
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In section 3.1 we present the main concept of this paper. We illustrate the concept in section 3.3. We then present a basic experiment in section 3.4. In section 3.6 we modify a very deep network in two different ways and we show how probes allow us to visualize the consequences (sometimes disastrous) of our design choices. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/78baeb4650f7068a4bb370f8b79ef6aff22f2ee2233ad5cfa0a96e0c27beee1b.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            107,
+            465,
+            234
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "(a) hex dump of picture of a lion ",
+        "bbox": [
+            225,
+            239,
+            418,
+            252
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/750bb3ce2c908bfaf317f9e7fb8b1ba500189ea38e6e0a815ee9683f5263efff.jpg",
+        "image_caption": [
+            "(b) same lion in human-readable format "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            531,
+            102,
+            821,
+            241
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Figure 1: The hex dump represented on the left has more information contents than the image on the right. Only one of them can be processed by the human brain in time to save their lives. Computational convenience matters. Not just entropy. ",
+        "bbox": [
+            173,
+            271,
+            825,
+            314
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 PROBES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            344,
+            269,
+            358
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As we discussed the previous section, there is indeed a good reason to use many deterministic layers, and it is because they perform useful transformations to the data with the goal of ultimately fitting a linear classifier at the very end. That is the purpose of the many layers. They are a tool to transform data into a form to be fed to a boring linear classifier. ",
+        "bbox": [
+            174,
+            372,
+            825,
+            429
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "With this in mind, it is natural to ask if that transformation is sudden or progressive, and whether the intermediate layers already have a representation that is immediately useful to a linear classifier. We refer the reader to Figure 2 for a diagram of probes being inserted in the usual deep neural network. ",
+        "bbox": [
+            174,
+            435,
+            825,
+            478
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/7fe427e62a973b961b2b7a92e9fc20ca3f76db5858d600f6655652c21603a5fe.jpg",
+        "image_caption": [
+            "Figure 2: Probes being added to every layer of a model. These additional probes are not supposed to change the training of the model, so we add a little diode symbol through the arrows to indicate that the gradients will not backpropagate through those connections. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            299,
+            491,
+            825,
+            602
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The conceptual framework that we propose is one where the intuitive notion of information is equivalent with immediate suitability for a linear classifier (instead of being related to entropy). ",
+        "bbox": [
+            173,
+            681,
+            821,
+            710
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Just to be absolutely clear about what we call a linear classifier, we mean a function ",
+        "bbox": [
+            176,
+            717,
+            723,
+            732
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ef8b66a753e9a814a449c1f6a27683f8be9d97e032266edb82a35874b8108188.jpg",
+        "text": "$$\n\\begin{array} { r } { f \\colon H \\to [ 0 , 1 ] ^ { D } \\qquad } \\\\ { h \\mapsto \\operatorname { s o f t m a x } \\left( W h + b \\right) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            741,
+            596,
+            779
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $h \\in H$ are the features of some hidden layer, $[ 0 , 1 ] ^ { D }$ is the space of one-hot encodings of the $D$ target classes, and $( W , b )$ are the probe weights and biases to be learned so as to minimize the usual cross-entropy loss. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Over the course of training a model, the parameters of the model change. However, probes only make sense when we refer to a given training step. We can talk about the probes at iteration $n$ of training, when the model parameters are $\\theta _ { n }$ . These parameters are not affected by the probes. We prevent backpropagation through the model either by stopping the gradient flow (done with tf.stop gradient in tensorflow), or simply by specifying that the only variables to be updated are the probe parameters, while we keep $\\theta _ { n }$ frozen. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1.1 TRAINING THE PROBES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            390,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For the purposes of this paper, we train the probes up to convergence with fixed model parameters, and we report the prediction error on the training set. ",
+        "bbox": [
+            173,
+            131,
+            823,
+            159
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "It is absolutely possible to train the probes simulatenously while training the model itself. This is a good approach if we consider about how long it can take to train the model. However, this creates a potential problem if we optimize the loss of the model more quickly than the loss of the probes. This can present a skewed view of the actual situation that we would have if we trained the probes until convergence before updating the model parameters. If we accept this trade off, then we can train the probes at the same time as the model. ",
+        "bbox": [
+            174,
+            165,
+            825,
+            250
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In some situations, the probes might overfit the training set, so we may want to do early stopping on the validation set and report the performance for the probes on the test set. This is what we do in section 3.4 with the simple MNIST convnet. ",
+        "bbox": [
+            176,
+            257,
+            825,
+            299
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We are still unsure if one of those variations should be preferred in general, and right now they all seem acceptable so long as we interpret the probe measurements properly. ",
+        "bbox": [
+            173,
+            305,
+            823,
+            334
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that training those probes represents a convex optimization problem. In practice, this does mean guarantee that they are easy to train. However, it is reassuring because it means that probes taken at time $\\theta _ { n }$ can be used as initialization for probes at time $\\theta _ { n + 1 }$ . ",
+        "bbox": [
+            176,
+            340,
+            821,
+            383
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We use cross-entropy as probe loss because all models studied here used cross-entropy. Other alternative losses could be justified in other settings. ",
+        "bbox": [
+            173,
+            390,
+            821,
+            419
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 PROBES ON BIFURCATING TOY MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            443,
+            480,
+            457
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here we show a hypothetical example in which a model contains a bifurcation with two paths that later recombine. We are interested in knowing whether those two branches are useful, or whether one is potentially redundant or useless. ",
+        "bbox": [
+            174,
+            470,
+            825,
+            513
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/28d8e18ee4159097fbcf3411da69627a35992457a870f3a7cd002a25607618bb.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            297,
+            523,
+            692,
+            616
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For example, the two different branches might contain convolutional layers with different dimensions. They may have a different number of sublayers, or one might represent a skip connection. We assume that the branches are combined through concatenation of their features, so that nothing is lost. ",
+        "bbox": [
+            176,
+            630,
+            823,
+            685
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For this hypothetical situation, we indicate the probe prediction errors on the graphical model. The upper path has a prediction error of 0.75, the lower path has 0.60, and their combination has 0.45. Small errors are preferred. Although the upper path has “less information” than the lower path, we can see here that it is not redundant information, because when we concatenate the features of the two branches we get a prediction error of $0 . 4 5 < 0 . 6 0$ . ",
+        "bbox": [
+            174,
+            693,
+            825,
+            762
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "If the concatenated layer had a prediction error of 0.60 instead of 0.45, then we could declare that the above branch did nothing useful. It may have nonzero weights, but it’s still useless. ",
+        "bbox": [
+            174,
+            768,
+            821,
+            799
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Naturally, this kind of conclusion might be entirely wrong. It might be the case that the branch above contains very meaningful features, and they simply happen to be useless to a linear classifier applied right there. The idea of using linear classification probes to understand the roles of different branches is suggested as a heuristic instead of a hard rule. Moreover, if the probes are not optimized perfectly, the conclusions drawn can be misleading. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that we are reporting here the prediction errors, and it might be the case that the loss is indeed lower when we concatenate the two branches, but for some reason it could fail to apply to the prediction error. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/e700959f190618878009af74e4198fba1113ac0a2aea7427043b21425727966d.jpg",
+        "image_caption": [
+            "Figure 3: Toy experiment described in section 3.3, with linearly separable data (two labels), an untrained MLP with 32 layers, and probes at every layer. We report the prediction error for every probe, where 0.50 would be the performence of a coin flip and 0.00 would be ideal. Note that the layer 0 here corresponds to the raw data, and the probes are indeed able to classify it perfectly. As expected, performance degrades when applying random transformations. If many more layers were present, it would be hard to imagine how the final layer (with the model loss) can get any useful signal to backpropagate. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            118,
+            462,
+            286
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 PROBES ON UNTRAINED MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            327,
+            434,
+            339
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We start with a toy example to illustrate what kind of plots we expect from probes. We use a 32- layer MLP with 128 hidden units. All the layers are fully-connected and we use LeakyReLU(0.5) as activation function. ",
+        "bbox": [
+            174,
+            356,
+            825,
+            397
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We will run the same experiment 100 times, with a different toy dataset each time. The goal is to use a data distribution $( X , Y )$ where $X \\in \\mathbb { R } ^ { 1 2 8 }$ is drawn $\\mathcal { N } ( 0 , I )$ and where $Y \\in \\{ - 1 , 1 \\}$ in linearly separable (i.e. super easy to classify with a one-layer neural network). To do this, we just pick a $w \\in \\mathbb { R } ^ { 1 2 8 }$ for each experiment, and let the label $y _ { n }$ be the sign of $x _ { n } ^ { T } w$ . ",
+        "bbox": [
+            174,
+            405,
+            825,
+            462
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We initialize this 32-layer MLP using glorot normal initialization, we do not perform any training on the model, and we add one probe at every layer. We optimize the probes with RMSProp and a sufficiently small learning rate. ",
+        "bbox": [
+            176,
+            468,
+            821,
+            510
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In Figure 3, we show the prediction error rate for every probe, averaged over the 100 experiments. The graph includes a probe applied directly on the inputs $X$ , where we naturally have an error rate that is essentially zero (to be expected by the way we constructed our data), and which serves as a kind of sanity check. Given that we have only two possible labels, we also show a dotted horizontal line at 0.50, which is essentially the prediction error that we would get by flipping a coin. We can see that the prediction error rate climbs up towards 0.50 as we go deeper in the MLP (with untrained parameters). ",
+        "bbox": [
+            174,
+            517,
+            825,
+            614
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This illustrates the idea that the input signal is getting mangled by the successive layers, so much that it becomes rather useless by the time we reach the final layer. We checked the mean activation norm of the hidden units at layer 32 to be sure that numerical underflow was not the cause for the degradation. Note that this situation could be avoided by using orthogonal weights. ",
+        "bbox": [
+            174,
+            621,
+            825,
+            678
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "One of the popular explanation for training difficulties in very deep models is that of the exploding/vanishing (Hochreiter, 1991; Bengio et al., 1993). Here we would like to offer another complementary explanation, based on the observations from Figure 3. That is, at the beginning of training, the usefulness of layers decays as we go deeper, reaching the point where the deeper layers are utterly useless. The values contained in the last layer are then used in the final softmax classifier, and the loss backpropagates the values of the derivatives. Since that derivative is based on garbage activations, the backpropagated quantities are also garbage, which means that the weights are all going to be updated based on garbage. The weights stay bad, and we fail to train the model. The authors like to refer to that phenomenon as garbage forwardprop, garbage backprop, in reference to the popular concept of garbage in, garbage out in computer science. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            824
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 PROBES ON MNIST CONVNET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            852,
+            424,
+            866
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section we run the MNIST convolutional model provided by the tensorflow github repo (tensorflow/models/image/mnist/convolutional.py) We selected that model for reproducibility and to demonstrate how to easily peek into popular models by using probes. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We start by sketching the model in Figure 4. We report the results at the beginning and the end of training on Figure 5. One of the interesting dynamics to be observed there is how useful the first layers are, despite the fact that the model is completely untrained. Random projections can be useful to classify data, and this has been studied by others (Jarrett et al., 2009). ",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/f438d4f7a1cc7b5b3e6e74d2d823d02bd54755e30d757f7ce61cce6044b374ba.jpg",
+        "image_caption": [
+            "Figure 4: This graphical model represents the neural network that we are going to use for MNIST. The model could be written in a more compact form, but we represent it this way to expose all the locations where we are going to insert probes. The model itself is simply two convolutional layers followed by two fully-connected layer (one being the final classifier). However, we insert probes on each side of each convolution, activation function, and pooling function. This is a bit overzealous, but the small size of the model makes this relatively easy to do. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            170,
+            761,
+            243
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/bc7dcf2a16cd443533b530cf7acf58c4ad9d7fbfbf82e479a8dcf90dba39a2e8.jpg",
+        "image_caption": [
+            "Figure 5: We represent here the test prediction error for each probe, at the beginning and at the end of training. This measurement was obtained through early stopping based on a validation set of $1 0 ^ { 4 }$ elements. The probes are prevented from overfitting the training data. We can see that, at the beginning of training (on the left), the randomly-initialized layers were still providing useful transformations. The test prediction error goes from $8 \\%$ to $2 \\%$ simply using those random features. The biggest impact comes from the first ReLU. At the end of training (on the right), the test prediction error is improving at every layer (with the exception of a minor kink on fc1 preact). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            361,
+            464,
+            521
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/9c6aff93d37afc59de3370916abc4522757ced668563bc1f82e65d64b7f29028.jpg",
+        "image_caption": [
+            "(b) After training for 10 epochs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            534,
+            362,
+            818,
+            521
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "(a) After initialization, no training. ",
+        "bbox": [
+            218,
+            534,
+            423,
+            546
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.5 PROBES ON INCEPTION V3 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            680,
+            401,
+            694
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We have performed an experiment using the Inception v3 model on the ImageNet dataset (Szegedy et al., 2015; Russakovsky et al., 2015). This is very similar to what is presented in section 3.4, but on a much larger scale. Due to the challenge presented by this experiment, we were not able to do everything that we had hoped. We have chosen to put those results in the appendix section A.2. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            762
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Certain layers of the Inception v3 model have approximately one million features. With 1000 classes, this means that some probes can take even more storage space than the whole model itself. In these cases, one of the creative solutions was to try to use only a random subset of the features. This is discussed in the appendix section A.1. ",
+        "bbox": [
+            174,
+            768,
+            825,
+            825
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.6 AUXILIARY LOSS BRANCHES AND SKIP CONNECTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            843,
+            588,
+            856
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here we investigate two ways to modify a deep model in order to facilitate training. Our goal is not to convince the reader that they should implement these suggestions in their own models. Rather, we want to demonstrate the usefulness of the linear classifier probes as a way to better understand what is happening in their deep networks. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In both cases we use a toy model with 128 fully-connected layers with 128 hidden units in each layer. We train on MNIST, and we use Glorot initialization along with leaky ReLUs. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We choose this model because we wanted a pathologically deep model without getting involved in architecture details. The model is pathological in the sense that smaller models can easily be designed to achieve better performance, but also in the sense that the model is so deep that it is very hard to train it with gradient descent methods. From our experiments, the maximal depth where things start to break down was depth 64, hence the choice here of using depth 128. ",
+        "bbox": [
+            174,
+            138,
+            823,
+            208
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the first scenario, we add one linear classifier at every 16 layers. These classifiers contribute to the loss minimization. They are not probes. This is very similar to what happens in the famous Inception model where “auxiliary heads” are used (Szegedy et al., 2015). This is illustrated in Figure 6a, and it works nicely. The untrainable model is now made trainable through a judicious use of auxiliary classifier losses. The results are shown in Figure 7. ",
+        "bbox": [
+            174,
+            228,
+            825,
+            297
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the second scenario, we look at adding a bridge (a skip connection) between layer 0 and layer 64. This means that the input features to layer 64 are obtained by concatenating the output of layer 63 with the features of layer 0. The idea here is that we might observe that the model would effectively train a submodel of depth 64, using the skip connection, and shift gears later to use the whole depth of 128 layers. This is illustrated in Figure 6b, and the results are shown in Figure 8. It does not work as expected, but the failure of this approach is visualized very nicely with probes and serves as a great example of their usefulness in diagnosing problems with models. ",
+        "bbox": [
+            174,
+            305,
+            825,
+            402
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In both cases, there are two interesting observations that can be made with probes. We refer readers to https://youtu.be/x8j4ZHCR2FI for the full videos associated to Figures 5, 7 and 8. ",
+        "bbox": [
+            174,
+            421,
+            823,
+            450
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Firstly, at the beginning of training, we can see how the raw data is directly useful to perform linear classification, and how this degrades as more layers are added. In the case of the skip connection in Figure 8, this has the effect of creating two bumps. This is because the layer 64 also has the input data as direct parent, so it can fit a probe to that signal. ",
+        "bbox": [
+            174,
+            457,
+            825,
+            513
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Secondly, the prediction error goes down in all probes during training, but it does so in a way that starts with the parents before it spreads to their descendants. This is even more apparent on the full video (instead of the 3 frames provided here). This is a ripple effect, where the prediction error in Figure 6b is visually spreading like a wave from the left of the plot to the right. ",
+        "bbox": [
+            173,
+            520,
+            825,
+            577
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(a) Model with 16 layers, one guide at every 4 layers. ",
+        "bbox": [
+            205,
+            656,
+            517,
+            670
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/da998f98e898911a7968c3db79a7030cfb53c00e62f9c4f09039012ed33ef354.jpg",
+        "image_caption": [
+            "(b) Model with 128 layers. A skip connection goes from the beginning straight to the middle of the graph. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            589,
+            553,
+            652
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/e3b1a2cbb938fc42bb9757e42574c2a8d194e5e426fd154e57becbfa030b4ec5.jpg",
+        "image_caption": [
+            "Figure 6: Examples of deep neural network with one probe at every layer (drawn above the graph). We show here the addition of extra components to help training (under the graph, in orange). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            560,
+            588,
+            825,
+            643
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 DISCUSSION AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            760,
+            478,
+            775
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We have presented more toy models or simple models instead of larger models such as Inception v3. In the appendix section A.2 we show an experiment on Inception v3, which proved to be more challenging than expected. Future work in this domain would involve performing better experiments on a larger scale than small MNIST convnets, but still within a manageable size so we can properly train all the probes. This would allow us to produce nice videos showing many training steps in sequence. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We have received many comments from people who thought about using multi-layer probes. This can be seen as a natural extension of the linear classifier probes. One downside to this idea is that we lose the convexity property of the probes. It might be worth pursuing in a particular setting, but as of now we feel that it is premature to start using multi-layer probes. This also leads to the convoluted idea of having a regular probe inside a multi-layer probe. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/1240396023f6cfd3a3400ed0cdd793e99041b168ebdcacf9a70ebaef6ab0bcbb.jpg",
+        "image_caption": [
+            "Figure 7: A pathologically deep model with 128 layers gets an auxiliary loss added at every 16 layers (refer to simplified sketch in Figure 6a if needed). This loss is added to the usual model loss at the last layer. We fit a probe at every layer to see how well each layer would perform if its values were used as a linear classifier. We plot the train prediction error associated to all the probes, at three different steps. Before adding those auxiliary losses, the model could not successfully be trained through usual gradient descent methods, but with the addition of those intermediate losses, the model is “guided” to achieve certain partial objectives. This leads to a successful training of the complete model. The final prediction error is not impressive, but the model was not designed to achieve state-of-the-art performance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            101,
+            818,
+            231
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/b0e8b1bc41f60a9d072968ed282f7b74e63f3ce9047d2f663342d1c3f6cacb98.jpg",
+        "image_caption": [
+            "Figure 8: A pathologically deep model with 128 layers gets a skip connection from layer 0 to layer 64 (refer to sketch in Figure 6b if needed). We fit a probe at every layer to see how well each layer would perform if its values were used as a linear classifier. We plot the train prediction error associated to all the probes, at three different steps. We can see how the model completely ignores layers 1-63, even when we train it for a long time. The use of probes allows us to diagnose that problem through visual inspection. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            386,
+            818,
+            516
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            642,
+            823,
+            671
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            695,
+            318,
+            712
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper we introduced the concept of the linear classifier probe as a conceptual tool to better understand the dynamics inside a neural network and the role played by the individual intermediate layers. We are now able to ask new questions and explore new areas. We have demonstrated how these probes can be used to identify certain problematic behaviors in models that might not be apparent when we traditionally have access to only the prediction loss and error. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            800
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We hope that the notions presented in this paper can contribute to the understanding of deep neural networks and guide the intuition of researchers that design them. ",
+        "bbox": [
+            176,
+            806,
+            821,
+            835
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            856,
+            326,
+            869
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio is a senior CIFAR Fellow. The authors would like to acknowledge the support of the following agencies for research funding and computing support: NSERC, FQRNT, Calcul Quebec, ´ Compute Canada, the Canada Research Chairs and CIFAR. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Y Bengio, Paolo Frasconi, and P Simard. The problem of learning long-term dependencies in recurrent networks. In Neural Networks, 1993., IEEE International Conference on, pp. 1183– 1188. IEEE, 1993. ",
+        "bbox": [
+            176,
+            126,
+            823,
+            167
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter. Untersuchungen zu dynamischen neuronalen netzen. Diploma, Technische Universitat M¨ unchen ¨ , pp. 91, 1991. ",
+        "bbox": [
+            173,
+            176,
+            821,
+            205
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kevin Jarrett, Koray Kavukcuoglu, Yann Lecun, et al. What is the best multi-stage architecture for object recognition? In 2009 IEEE 12th International Conference on Computer Vision, pp. 2146–2153. IEEE, 2009. ",
+        "bbox": [
+            174,
+            213,
+            823,
+            256
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David MacKay. Information Theory, Inference and Learning Algorithms. Cambridge University Press, 2003. ",
+        "bbox": [
+            171,
+            265,
+            823,
+            295
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li 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. ",
+        "bbox": [
+            178,
+            303,
+            821,
+            358
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1–9, 2015. ",
+        "bbox": [
+            176,
+            367,
+            821,
+            410
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            171,
+            417,
+            823,
+            446
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            473,
+            297,
+            488
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": ".1 PROPOSAL : TRAIN PROBES USING ONLY SUBSETS OF FEATURES ",
+        "bbox": [
+            184,
+            503,
+            658,
+            518
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "One of the challenges to train on the Inception v3 model is that many of the layers have more than 200, 000 features. This is even worse in the first convolution layers before the pooling operations, where we have around a million features. With 1000 output classes, a probe using 200, 000 features has a weight matrix taking almost 1GB of storage. ",
+        "bbox": [
+            174,
+            530,
+            825,
+            585
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "When using stochastic gradient descent, we require space to store the gradients, and if we use momentum this ends up taking three times the memory on the GPU. This is even worse for RMSProp. Normally this might be acceptable for a model of reasonable size, but this turns into almost 4GB overhead per probe. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            648
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We do not have to put a probe at every layer. We can also train probes independently. We can put probe parameters on the CPU instead of the GPU, if necessary. But when the act of training probes increases the complexity of the experiment beyond a certain point, the researcher might decide that they are not worth the trouble. ",
+        "bbox": [
+            174,
+            655,
+            825,
+            712
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We propose the following solution $:$ for a given probe, use a fixed random subset of features instead of the whole set of features. ",
+        "bbox": [
+            173,
+            718,
+            823,
+            747
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "With certain assumptions about the independence of the features and their shared role in predicting the correct class, we can make certain claims about how few features are actually required to assess the prediction error of a probe. We thank Yaroslav Bulatov for suggesting this approach. ",
+        "bbox": [
+            174,
+            753,
+            823,
+            796
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We ran an experiment in which we used data $X \\sim \\mathcal { N } ( 0 , I _ { D } )$ where $D = 1 0 0 , 0 0 0$ is the number of features. We used $K = 1 0 0 0$ classes and we generated the ground truth using a matrix $W$ of shape $( D , K )$ . To obtain the class of a given $x$ , we simply multiply $x ^ { T } W$ and take the argmax over the $K$ components of the result. ",
+        "bbox": [
+            173,
+            814,
+            825,
+            871
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/96dbdf9327d31c1e081cc08ba9733b737c55bdf7ee48c46434ff277eb880d327.jpg",
+        "text": "$$\n\\boldsymbol { x } \\sim \\mathcal { N } ( 0 , I _ { D } ) \\qquad \\quad \\boldsymbol { y } = \\underset { k = 1 \\ldots K } { \\arg \\operatorname* { m a x } } \\left( \\boldsymbol { x } ^ { T } W [ : , k ] \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            877,
+            655,
+            904
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We selected a matrix $W$ by drawing all its individual coefficients from a univariate gaussian. ",
+        "bbox": [
+            173,
+            909,
+            776,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Instead of using $D = 1 0 0 , 0 0 0$ features, we used instead only 1000 features picked at random. We trained a linear classifier on those features and, experimentally, it was relatively easy to achieve a $4 \\%$ error rate on our first try. With all the features, we could achieve a $0 \\%$ error rate, so $4 \\%$ might not look great. We have to keep in mind that we have $K = 1 0 0 0$ classes so random guesses yield an error rate of $9 9 . 9 \\%$ . ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This can reduce the storage cost for a probe from 1GB down to 10MB. The former is hard to justify, and the latter is almost negligible. ",
+        "bbox": [
+            173,
+            180,
+            823,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A.2 PROBES ON INCEPTION V3 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            226,
+            405,
+            239
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We are interested in putting linear classifier probes in the popular Inception v3 model, training on the ImageNet dataset. We used the tensorflow implementation available online (tensorflow/models/inception/inception) and ran it on one GPU for 2 weeks. ",
+        "bbox": [
+            173,
+            252,
+            826,
+            294
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/ac9d6cc65020b4249ed3608d9b9b777742591517ad3a2380677dd8d818c256fb.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            306,
+            758,
+            377
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "As described in section A.1, one of the challenges is that the number of features can be prohibitively large, and we have to consider taking only a subset of the features. In this particular experiment, we have had the most success by taking 1000 random features for each probe. This gives certain layers an unfair advantage if they start with 4000 features and we kept 1000, whereas in other cases the probe insertion point has 426, 320 features and we keep 1000. There was no simple “fair” solution. That being said, 13 out of the 17 probes have more than 100, 000 features, and 11 of those probes have more than 200, 000 features, so things were relatively comparable. ",
+        "bbox": [
+            174,
+            391,
+            825,
+            489
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We put linear classifier probes at certain strategic layers. We represent this using boxes in the following Figure 9. The prediction error of the probe given by the last layer of each box is illustrated by coloring the box. Red is bad (high prediction error) and green/blue is good (low prediction error). ",
+        "bbox": [
+            174,
+            496,
+            825,
+            537
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We would have liked to have a video to show the evolution of this during training, but this experiment had to be scaled back due to the large computational demands. We show here the prediction errors at three moments of training. These correspond roughly to the beginning of training, then after a few days, and finally after a week. ",
+        "bbox": [
+            174,
+            544,
+            825,
+            601
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Inception v3 ",
+        "text_level": 1,
+        "bbox": [
+            307,
+            212,
+            431,
+            231
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/be6f620a4776ffd6346efda0088099ba541bfd481b106cd797b8827d1c06e143.jpg",
+        "image_caption": [
+            "Figure 9: Inserting a probe at multiple moments during training the Inception v3 model on the ImageNet dataset. We represent here the prediction error evaluated at a random subset of 1000 features. As expected, at first all the probes have a $100 \\%$ prediction error, but as training progresses we see that the model is getting better. Note that there are 1000 classes, so a prediction error of $50 \\%$ is much better than a random guess. The auxiliary head, shown under the model, was observed to have a prediction error that was slightly better than the main head. This is not necessarily a condition that will hold at the end of training, but merely an observation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            241,
+            761,
+            700
+        ],
+        "page_idx": 10
+    }
+]