Add files using upload-large-folder tool

parse/train/-oUhJJILWHb/-oUhJJILWHb.md

@@ -0,0 +1,197 @@
+# Learning Debiased Representation via Disentangled Feature Augmentation
+
+Jungsoo Lee\*1,2 Eungyeup $\mathbf { K i m } ^ { * 1 , 2 }$ Juyoung Lee2 Jihyeon Lee1 Jaegul Choo1
+
+1KAIST AI, 2Kakao Enterprise, South Korea 1{bebeto, eykim94, gina3833, jchoo}@kaist.ac.kr, 2{bebeto.lee, josh.ey, michael.jy}@kakaoenterprise.com
+
+# Abstract
+
+Image classification models tend to make decisions based on peripheral attributes of data items that have strong correlation with a target variable (i.e., dataset bias). These biased models suffer from the poor generalization capability when evaluated on unbiased datasets. Existing approaches for debiasing often identify and emphasize those samples with no such correlation (i.e., bias-conflicting) without defining the bias type in advance. However, such bias-conflicting samples are significantly scarce in biased datasets, limiting the debiasing capability of these approaches. This paper first presents an empirical analysis revealing that training with “diverse” bias-conflicting samples beyond a given training set is crucial for debiasing as well as the generalization capability. Based on this observation, we propose a novel feature-level data augmentation technique in order to synthesize diverse bias-conflicting samples. To this end, our method learns the disentangled representation of (1) the intrinsic attributes (i.e., those inherently defining a certain class) and (2) bias attributes (i.e., peripheral attributes causing the bias), from a large number of bias-aligned samples, the bias attributes of which have strong correlation with the target variable. Using the disentangled representation, we synthesize bias-conflicting samples that contain the diverse intrinsic attributes of bias-aligned samples by swapping their latent features. By utilizing these diversified bias-conflicting features during the training, our approach achieves superior classification accuracy and debiasing results against the existing baselines on synthetic and real-world datasets.
+
+# 1 Introduction
+
+Despite the recent advancement of deep neural networks, they often rely overly on the correlation between peripheral attributes and labels, referred to as dataset bias [1], especially when such strong bias is found in a given dataset. A majority of samples in the biased dataset exhibit visual attributes that are not innate but frequently co-occur with target labels (i.e., bias attributes). For example, most of the bird images in the training dataset may contain the background as the blue sky, while the birds may still be found in different places. Thus, the model trained with such a biased dataset is likely to learn the bias attributes more than intrinsic attributes, the innate visual attributes that inherently define a certain class, e.g., the wings of birds. This causes the model to learn shortcuts for classification [2], failing to generalize on the images with no such correlations (e.g., birds on grounds or grass) during the test phase. Throughout the paper, bias-aligned samples correspond to data items containing a strong correlation between bias attributes and labels (e.g., birds in the sky), while bias-conflicting samples indicate the other cases that are rarely found (e.g., birds on grounds).
+
+To tackle such a task, previous studies often define a specific bias type (e.g., color and texture) in advance [3, 4, 5, 6, 7, 8, 9, 10], which enables them to design a debiasing network tailored for the predefined bias type. For example, Bahng et al. [6] leverage BagNet [11], which has limited size of receptive fields, to focus on learning color and texture. However, defining a bias type in advance 1) limits the capability of debiasing in other bias types and 2) requires expensive labor to manually identify the bias type. To handle such an issue, a recent approach [12] defines a bias based on an intuitive observation that the bias attributes are often easier to learn than the intrinsic attributes for neural networks. In this regard, they re-weight bias-conflicting samples while de-emphasizing the bias-aligned ones. However, we point out that the reason behind the limited generalization capability of existing debiasing approaches lies in the significant scarcity of bias-conflicting samples compared to the bias-aligned ones in a given training set. In other words, it is challenging to learn the debiased representation from these scarce bias-conflicting samples because the models are prone to memorize (thus being overfitted to) these samples, failing to learn the intrinsic attributes. Therefore, we claim that a neural network can learn properly debiased representation when these data items are diversified during training.
+
+We conduct a brief experiment to demonstrate the importance of diversity in debiasing. Diversity in our work indicates the different valid realization of intrinsic attributes in a certain class (e.g., thick, narrow, tilted, and scribbled digit shapes in MNIST [13]). Our observation is that training a model with diverse bias-conflicting samples beyond a given training set is crucial for learning debiased representation (Section 3.2). In this regard, synthesizing bias-conflicting samples is one of the straightforward approaches to increase the diversity of such samples. In fact, a large amount of bias-aligned samples in a given training set already contain diverse intrinsic attributes, which can work as informative sources for increasing the diversity. However, as bias and intrinsic attributes are highly entangled in their embedding space, it is difficult to extract the intrinsic ones from these bias-aligned samples. Therefore, disentangling these correlations enables to synthesize diversified bias-conflicting samples that originate from bias-aligned samples.
+
+In this paper, we propose a novel feature augmentation approach via disentangled representation for debiasing. We first train two different encoders to embed images into the disentangled representation of their intrinsic and bias attributes. With the disentangled representation, we randomly swap the latent vectors extracted from different images, most of which are bias-aligned samples in our training set. These swapped features thus contain both bias and intrinsic attributes without the correlation between them, which, in turn, can work as augmented bias-conflicting samples in our training. These features include intrinsic features of bias-aligned ones, increasing the diversity of a given training set, especially for bias-conflicting data items. Furthermore, to enhance the quality of diversified features, we propose a scheduling strategy of feature augmentation which enables to utilize the representation disentangled to a certain degree. In summary, the main contributions of our work include:
+
+• Through our preliminary experiment, we reveal that increasing the diversity of biasconflicting samples is crucial for debiasing.   
+• Based on such an observation, we propose a novel feature augmentation method via disentangled representation for diversifying the bias-conflicting samples.   
+• We achieve the state-of-the-art performances in two synthetic datasets (i.e., Colored MNIST and Corrupted CIFAR-10) and one real-world dataset (i.e., Biased FFHQ) against existing baselines.
+
+# 2 Related Work
+
+Debiasing predefined bias Several existing approaches mitigate the bias by pre-defining a certain bias type, either explicitly [3, 4, 5] or implicitly [6, 7, 8, 9, 10, 14]. For example, Bahng et al. [6] and Wang et al. [7] design a color- and texture-oriented network to adversarially learn a debiased model against the biased one. However, as these methods still require a specific bias type such as texture in advance, they lack the general applicability to the datasets where the bias types are demanding to recognize.
+
+Instead of defining certain types of bias, recent approaches [12, 15, 16] rely on the straightforward assumption that networks are prone to exploit the bias when it acts as a shortcut [2], i.e., easy to learn in the early training phase. Nam et al. [12] emphasize the bias-conflicting samples during training by using generalized cross-entropy loss [17]. Darlow et al. [15] and Huang et al. [16] presume that high gradient of latent vectors accounts for the shortcuts that model learns. In the line with the recent studies, we tackle debiasing without pre-defining a certain bias type.
+
+Table 1: The classification accuracy on the unbiased test sets. The diversity ratio indicates the ratio of bias-conflicting samples in the dataset pooled for each experiment. The sampling ratio refers to the ratio of bias-conflicting samples included in each mini-batch. We report the averaged accuracy over three independent trials with the standard deviation. In both datasets, we observe that the bias can be mitigated with diverse bias-conflicting samples even with a small sampling ratio. Bold and underlined values indicate the best and second best accuracy, respectively.   
+
+<table><tr><td>Dataset</td><td>Diversity ratio</td><td>Sampling ratio</td><td>Accuracy (%)</td></tr><tr><td rowspan="4">Colored MNIST</td><td>5%</td><td>50%</td><td>83.77±2.03</td></tr><tr><td>1%</td><td>50%</td><td>67.19±1.99</td></tr><tr><td>5%</td><td>1%</td><td>77.97±6.00</td></tr><tr><td>1%</td><td>1%</td><td>49.91±4.22</td></tr><tr><td rowspan="4">Corrupted CIFAR-10</td><td>5%</td><td>50%</td><td>46.99±0.82</td></tr><tr><td>1%</td><td>50%</td><td>33.08±0.80</td></tr><tr><td>5%</td><td>1%</td><td>36.66±0.55</td></tr><tr><td>1%</td><td>1%</td><td>23.98±0.00</td></tr></table>
+
+Data augmentation for debiasing Geirhos et al. [10] mitigate the texture bias by utilizing additional training images with their styles being transferred by adaptive instance normalization (AdaIN) [18]. Minderer et al. [19] train an image-to-image translation network for removing shortcut cues in the self-supervised task. However, such image-level data augmentation is limited to resolving the predefined texture bias which can not be adopted to other general types of bias.
+
+One alternative is to exploit the latent space for data augmentation. For example, Darlow et al. [15] adversarially perturb the latent vectors corresponding to the high gradients to generate the samples against bias. Zhou et al. [20] mix the style of different source domains by AdaIN [18] to increase the domain generalization ability. Despite the effectiveness of the augmentation in the latent space, the strong unwanted correlation between bias attributes and labels prevents from obtaining the desirable intrinsic features. We resolve this issue by leveraging the disentangled representation in debiasing, which is widely used in image-to-image translation task [21, 22, 23]. To the best of our knowledge, no previous work in debiasing leverage this disentangled representation for the purpose of feature augmentation. For the rest of the paper, we elaborate how we perform the feature augmentation based on the disentangled representation.
+
+# 3 Importance of Diversity in Debiasing
+
+This section describes the details of a toy-set experiment in which we observe the importance of diversity in learning debiased representation. In Section 3.1, we first introduce the two synthetic datasets, Colored MNIST and Corrupted CIFAR-10, that we utilize for the observation. Then, we elaborate the results of the experiments in Section 3.2.
+
+# 3.1 Dataset
+
+Colored MNIST is a modified MNIST dataset [13] with the color bias. We select ten distinct colors and inject each color on the foreground of each digit to create color bias. By adjusting the number of bias-conflicting data samples in the training set, we obtain four different datasets with the ratio of bias-conflicting samples of $0 . 5 \%$ , $1 \%$ , $2 \%$ , and $5 \%$ .
+
+Corrupted CIFAR-10 has ten different types of texture bias applied in CIFAR-10 [24] dataset, constructed by following the design protocol of Hendrycks and Dietterich [25]. Each class is highly correlated with a certain texture (e.g., frost and brightness). Corrupted CIFAR-10 also has four different datasets with their correlation ratios as in Colored MNIST.
+
+# 3.2 Increasing diversity outperforms oversampling
+
+To confirm the significance of diversity of bias-conflicting samples in debiasing, we train four different settings: oversampling bias-conflicting samples by $50 \%$ in each mini-batch (i.e., 128 from a batch size of 256), from the pool of i) $5 \%$ dataset and ii) $1 \%$ dataset, sampling bias-conflicting samples by $1 \%$ in each mini-batch (i.e., 2 from a batch size of 256) from the pool of iii) $5 \%$ dataset and iv) $1 \%$ dataset. Oversampling provides the same amount of bias-conflicting samples as the aligned ones to the model in every training step. Bias-conflicting images sampled from the pool of $5 \%$ dataset have more diverse appearances of bias-conflicting samples compared to those from $1 \%$ dataset.
+
+Table 1 shows the image classification accuracy of each setting validated on the unbiased test images. Apparently, oversampling diverse bias-conflicting samples (first row) outperforms the other three methods. Similarly, sampling a small amount of bias-conflicting samples with the least diversity (fourth row) shows the lowest classification accuracy. The interesting finding is that sampling fewer but diverse conflicting samples in each mini-batch (third row) outperforms oversampling bias-conflicting samples with limited diversity (second row). These results lead to the conclusion that the diversity of bias-conflicting samples is a more crucial factor for learning debiased representation than the ratio of sampling in the training. As the diversity is limited (the latter case), the model can be easily overfitted to the given bias-conflicting samples, thus less likely to learn the generalized intrinsic attributes. With the Colored MNIST as an example, the shape of digits may vary. To be more specific, the digit shape may be thick, narrow, tilted, scribbled, and etc. If the bias-conflicting samples do not include certain visual facets (e.g., not including scribbled digit images) due to the limited number of samples, the model may imperfectly learn the intrinsic attributes of digit shapes. On the other hand, in the former case (third row), the model can learn multiple facets of intrinsic attributes when they are sampled from the diverse pool of datasets, resulting in learning intrinsic attributes even without oversampling the bias-conflicting images.
+
+# 4 Debiasing via disentangled feature augmentation
+
+Motivated by such an observation in Section 3.2, we propose a feature-level augmentation strategy for synthesizing additional bias-conflicting samples, as illustrated in Fig. 1. First, we train the two separate encoders which embed an image into disentangled latent vectors corresponding to the intrinsic and bias attributes, respectively (Section 4.1). Swapping these feature vectors among training samples enables to augment the bias-conflicting samples which no more contain a correlation between two attributes (Section 4.2). To further enhance the effectiveness, we schedule the feature augmentation after the representation is disentangled at a certain degree (Section 4.3).
+
+# 4.1 Learning disentangled representation
+
+In contrast to the bias-conflicting samples, a large amount of bias-aligned images have diverse appearances of their intrinsic attributes. By leveraging these attributes for augmentation, we can naturally obtain the diversified bias-conflicting samples containing the diverse intrinsic attributes. However, it remains challenging in that these attributes are strongly correlated with the bias attributes in the bias-aligned samples. Therefore, we propose to design two encoders with their linear classifiers to extract the disentangled latent vectors from the input images.
+
+As shown in Fig. 1, encoders $E _ { i }$ and $E _ { b }$ embed an image $x$ into intrinsic feature vectors $z _ { i } = E _ { i } ( x )$ and bias feature vectors $z _ { b } = E _ { b } ( x )$ , respectively. Afterward, linear classifiers $C _ { i }$ and $C _ { b }$ take the concatenated vector $z = [ z _ { i } ; z _ { b } ]$ as input to predict the target label $y$ . To train $E _ { i }$ and $C _ { i }$ as intrinsic feature extractor and $E _ { b }$ and $C _ { b }$ as bias extractor, we utilize the relative difficulty score of each data sample, proposed in the previous work of Nam et al. [12]. More specifically, we train $E _ { b }$ and $C _ { b }$ to be overfitted to the bias attributes by utilizing the generalized cross entropy (GCE) [17], while $E _ { i }$ and $C _ { i }$ are trained with the cross entropy (CE) loss. Then, the samples with high CE loss from $C _ { b }$ can be regarded as the bias-conflicting samples compared to the samples with low CE loss. In this regard, we obtain the relative difficulty score of each data sample as
+
+$$
+W ( z ) = \frac { C E ( C _ { b } ( z ) , y ) } { C E ( C _ { i } ( z ) , y ) + C E ( C _ { b } ( z ) , y ) } .
+$$
+
+As bias-conflicting samples obtain high values of $W$ , we emphasize the loss of these samples for
+
+training $E _ { i }$ and $C _ { i }$ , enforcing them to learn the intrinsic attributes. Therefore, the objective function for disentanglement can be written as
+
+$$
+L _ { \mathrm { d i s } } = W ( z ) C E ( C _ { i } ( z ) , y ) + \lambda _ { \mathrm { d i s } } G C E ( C _ { b } ( z ) , y ) .
+$$
+
+To ensure that $C _ { i }$ and $C _ { b }$ predicts target labels mainly based on $z _ { i }$ and $z _ { b }$ , respectively, the loss
+
+$C _ { i }$ is not backpropagated to $E _ { b }$ , and vice versa.
+
+![](images/eedd1538e5f1b3d233b423f13d2940012c778d468a152b8756c79289fdabf7bd.jpg)  
+Figure 1: The overview of our proposed debiasing approach. $( E _ { i } , C _ { i } )$ and $( E _ { b } , C _ { b } )$ are pairs of an encoder and a linear classifier trained to learn the disentangled representation of intrinsic attributes and bias attributes, respectively. With the disentangled features $z _ { i }$ and $z _ { b }$ , the feature augmentation is performed by swapping these latent vectors among different training samples, after certain iterations of training. $R$ refers to the re-weighting algorithm which implicitly differentiates bias-aligned samples and bias-conflicting samples. Each color indicates the different data samples.
+
+# Algorithm 1 Debiasing with disentangled feature augmentation
+
+Input: image $x$ , label $y$ , iteration $t$ , augment iteration $t _ { \mathrm { s w a p } }$   
+Initialize two networks $( E _ { i } , C _ { i } )$ , $( E _ { b } , C _ { b } )$   
+while not converged do Extract $z _ { i } , z _ { b }$ from $E _ { i } ( x )$ , $E _ { b } ( x )$ Concatenate $\boldsymbol { z } = [ z _ { i } ; z _ { b } ]$ Update $( E _ { i } , C _ { i } )$ , $( E _ { b } , C _ { b } )$ with $L _ { \mathrm { d i s } } = W ( z ) C E ( C _ { i } ( z ) , y ) + G C E ( C _ { b } ( z ) , y )$ if $t > t _ { \mathrm { s w a p } }$ : Randomly permute $\boldsymbol { z } = [ z _ { i } , z _ { b } ]$ into $z _ { \mathrm { s w a p } } = [ z _ { i } ; \tilde { z _ { b } } ]$ Calculate Ls $\ L _ { \mathrm { v a p } } = W ( z ) C E ( C _ { i } ( z _ { \mathrm { s w a p } } ) , \dot { y } ) + G C E ( C _ { b } ( z _ { \mathrm { s w a p } } ) , \tilde { y }$ ) Update $( E _ { i } , C _ { i } ^ { \dot { \mathbf { \alpha } } } )$ , $( E _ { b } , C _ { b } )$ with $L _ { \mathrm { t o t a l } } = L _ { \mathrm { d i s } } + \lambda _ { \mathrm { s w a p } } L _ { \mathrm { s w a p } }$   
+end
+
+# 4.2 Feature swapping for augmentation
+
+While such an architecture disentangles the intrinsic features and bias features, $E _ { i }$ and $C _ { i }$ are still mainly trained with an excessively small amount of bias-conflicting samples. Therefore, $E _ { i }$ and $C _ { i }$ fail to fully acquire the intrinsic representation of a target class. To promote further improvement in learning intrinsic feature vectors, we diversify the bias-conflicting samples by swapping the disentangled latent vectors among the training sets. In other words, we randomly permute the intrinsic features and bias features in each mini-batch and obtain $z _ { \mathrm { s w a p } } ~ = ~ [ z _ { i } ; \tilde { z _ { b } } ]$ where $\tilde { z _ { b } }$ denotes the randomly permuted bias attributes of $z _ { b }$ . As the intrinsic and bias attributes in ${ z _ { \mathrm { s w a p } } }$ are obtained from two different images, they certainly have less correlation compared to $\boldsymbol { z } = [ z _ { i } ; \dot { z _ { b } } ]$ where both are from the same image. Since the biased dataset is mostly composed of bias-aligned samples, these vectors are likely from the bias-aligned samples, highly diversified compared to the bias-conflicting ones. Then, $z _ { \mathrm { s w a p } } = [ z _ { i } ; \tilde { z _ { b } } ]$ act as augmented bias-conflicting latent vectors with diversity inherited from the bias-aligned samples. Along with $L _ { \mathrm { d i s } }$ , we add the following loss function to train two neural networks with the augmented features
+
+$$
+L _ { \mathrm { s w a p } } = W ( z ) C E ( C _ { i } ( z _ { \mathrm { s w a p } } ) , y ) + \lambda _ { \mathrm { s w a p } _ { b } } G C E ( C _ { b } ( z _ { \mathrm { s w a p } } ) , \tilde { y } ) ,
+$$
+
+where $\tilde { y }$ denotes target labels for permute bias attributes $\tilde { z }$ . Thus, total loss function is described as
+
+$$
+L _ { \mathrm { t o t a l } } = L _ { \mathrm { d i s } } + \lambda _ { \mathrm { s w a p } } L _ { \mathrm { s w a p } }
+$$
+
+where $\lambda _ { \mathrm { s w a p } }$ is adjusted for weighting the importance of the feature augmentation.
+
+# 4.3 Scheduling the feature augmentation
+
+While training with additional synthesized features helps to mitigate the unwanted correlation, utilizing them from the beginning of training does not improve the debiasing performance. To be more specific, in the early stage of training, the representations of $z _ { i }$ and $z _ { b }$ are imperfectly disentangled to be used as the sources of feature augmentation. Feature augmentation should be conducted after two features are disentangled at a certain degree. Without the disentangled representation, the augmented features work as noisy samples which may aggravate the debiasing performances. We verify the importance of scheduling the feature augmentation in Table 3. Our approach can be summarized with Algorithm 1.
+
+![](images/ba755777f4dbc4501ef0965a443c6e1994c4a532a25d0df3ee04f0f6e490293c.jpg)  
+Figure 2: Example images of datasets utilized in our work. In each dataset, the images above the dotted line indicate the bias-aligned samples while the ones below the dotted line are the bias-conflicting samples. For Colored MNIST and Corrupted CIFAR-10, each column indicates each class. For BFFHQ, the group of three columns indicates each class.
+
+# 5 Experiment
+
+This section demonstrates the effectiveness of feature augmentation based on disentangled representation in debiasing with both quantitative and qualitative evaluation. We compare our method with the previous approaches in debiasing with three different datasets with varied bias ratios. Then, we conduct the ablation study which demonstrates the importance of 1) learning disentangled representation, 2) feature augmentation, and 3) scheduling feature augmentation. For the qualitative evaluation, we verify how our approach disentangles the intrinsic features and bias features by visualizing them on 2D embedding space via t-SNE [26] and reconstructing images from them.
+
+# 5.1 Experiment details
+
+Baselines Our baselines consist of vanilla network, HEX [7], EnD [27], ReBias [6] and LfF [12]. Vanilla denotes the classification model trained only with the original cross-entropy (CE) loss, without any debiasing strategies. EnD explicitly leverages the bias labels (e.g., the color label in Colored MNIST) during the training phase. HEX and ReBias explicitly presume the texture of an image as a bias type, while LfF requires no prior knowledge on it.
+
+Datasets As shown in Fig. 2, we use two synthetic datasets (Colored MNIST and Corrputed CIFAR10) and one real-world dataset (Biased FFHQ) to evaluate the generalization of debiasing baselines over various domains. Biased FFHQ (BFFHQ) is curated from FFHQ dataset [28] which contains human face images annotated with their facial attributes. Among the facial attributes, we select age and gender as the intrinsic and bias attribute, respectively, and construct the dataset with images of high correlation between them. More specifically, most of the females are ‘young’ (i.e., age ranging from 10 to 29) and males are ‘old’ (i.e., age ranging from 40 to 59). Therefore, bias-aligned samples which compose the majority of the dataset are young women and old men.
+
+For each dataset, we set the degree of correlation by adjusting the number of bias-conflicting samples among the training dataset. The ratio of bias-conflicting samples are $0 . 5 \%$ , $1 \%$ , $2 \%$ and $5 \%$ for both Colored MNIST and Corrupted CIFAR-10, respectively, and $0 . 5 \%$ for BFFHQ. For the evaluation of Colored MNIST and Corrupted CIFAR-10, we construct an unbiased test set which includes images without the high correlation existing in the training set. For the BFFHQ, we construct a bias-conflicting test set which excludes the bias-aligned samples from the unbiased test set. The reason is as following. The bias-aligned images consist a half of the unbiased test set in BFFHQ which may still be correctly classified by the biased classifier. This inflates the accuracy of the unbiased test set which is not our original intention. Therefore, we intentionally use the bias-conflicting test set for the BFFHQ.
+
+Table 2: Image classification accuracy evaluated on unbiased test sets of Colored MNIST and Corrupted CIFAR-10, and the bias-conflicting test set of BFFHQ with varying ratio of bias-conflicting samples. We denote whether the model requires a bias type in advance by cross mark (i.e., not required), and check mark (i.e., required). Best performing results are marked in bold, while secondbest results are denoted with underlines.   
+
+<table><tr><td rowspan="2">Dataset</td><td rowspan="2">Ratio (%)</td><td>Vanilla [29]</td><td>HEX [7]</td><td>EnD [27]</td><td>ReBias [6]</td><td>LfF[12]</td><td>Ours</td></tr><tr><td>X</td><td>√</td><td>√</td><td>√</td><td>×</td><td>X</td></tr><tr><td rowspan="4">Colored MNIST</td><td>0.5</td><td>35.19±3.49</td><td>30.33±0.76</td><td>34.28±1.20</td><td>70.47±1.84</td><td>52.50±2.43</td><td>65.22±4.41</td></tr><tr><td>1.0</td><td>52.09±2.88</td><td>43.73±5.50</td><td>49.50±2.51</td><td>87.4±0.78</td><td>61.89±4.97</td><td>81.73±2.34</td></tr><tr><td>2.0</td><td>65.86±3.59</td><td>56.85±2.58</td><td>68.45±2.16</td><td>92.91±0.15</td><td>71.03±2.44</td><td>84.79±0.95</td></tr><tr><td>5.0</td><td>82.17±0.74</td><td>74.62±3.20</td><td>81.15±1.43</td><td>96.96±0.04</td><td>80.57±3.84</td><td>89.66±1.09</td></tr><tr><td rowspan="4">Corrupted CIFAR-10</td><td>0.5</td><td>23.08±1.25</td><td>13.87±0.06</td><td>22.89±0.27</td><td>22.27±0.41</td><td>28.57±1.30</td><td>29.95±0.71</td></tr><tr><td>1.0</td><td>25.82±0.33</td><td>14.81±0.42</td><td>25.46±0.41</td><td>25.72±0.20</td><td>33.07±0.77</td><td>36.49±1.79</td></tr><tr><td>2.0</td><td>30.06±0.71</td><td>15.20±0.54</td><td>31.31±0.35</td><td>31.66±0.43</td><td>39.91±0.30</td><td>41.78±2.29</td></tr><tr><td>5.0</td><td>39.42±0.64</td><td>16.04±0.63</td><td>40.26±0.85</td><td>43.43±0.41</td><td>50.27±1.56</td><td>51.13±1.28</td></tr><tr><td>BFFHQ</td><td>0.5</td><td>56.87±2.69</td><td>52.83±0.90</td><td>56.87±1.42</td><td>59.46±0.64</td><td>62.2±1.0</td><td>63.87±0.31</td></tr></table>
+
+Implementation details We use multi-layer perceptron (MLP) with three hidden layers for Colored MNIST, and ResNet-18 [29] for the remaining datasets. To accommodate the disentangled vectors, we double the number of hidden units in the last fully-connected layer of each network. During the inference phase, we use $C _ { i } ( z )$ for the final prediction, where $z = [ z _ { i } ; z _ { b } ]$ . For the training, we set the batch size of 256 for Colored MNIST and Corrupted CIFAR-10, respectively, and 64 for BFFHQ. Bias-conflicting augmentation is scheduled to be applied after 10K iterations for all datasets. We report the averaged accuracy of the unbiased test sets over three independent trials with the mean and the standard deviation. We include the remaining implementation details in Section D in the supplementary material.
+
+# 5.2 Quantitative evaluation
+
+Comparison on test sets Table 2 shows the comparisons of image classification accuracy evaluated on the test sets. In general, our approach demonstrates the superior performance in both synthetic and real-world datasets against the baselines with large gaps. Especially, compared to the baselines which do not define the bias types in advance (vanilla [29] and LfF [12]), our approach achieves the stateof-the-art performance across all datasets. This indicates that utilizing the diversified bias-conflicting samples through our augmentation plays a pivotal role in learning debiased representation regardless of the bias types.
+
+Regarding the real-world dataset, our approach also outperforms HEX [7] and ReBias [6] which utilize the tailored modules for a specific bias type (e.g., color and texture), and EnD [27] that uses the explicit bias labels. We even show superior performance compared to HEX in Colored MNIST without defining the bias type beforehand. While ReBias achieves the best accuracy in Colored MNIST, they utilize BagNet [11] in order to focus on the color bias. Even without using such an architecture, we achieve the second best performance which is comparable to ReBias.
+
+Ablation studies Table 3 demonstrates the importance of each module in our approach through ablation studies: 1) disentangled representation learning, 2) feature augmentation, and 3) scheduling feature augmentation. We set the ratio of bias-conflicting samples to $1 \%$ for Colored MNIST and Corrupted CIFAR10, and $0 . 5 \%$ for BFFHQ. We also compare each module with the vanilla network (first row). We observe that performing the scheduled feature augmentation shows the best classification accuracy on the test sets across all datasets. We also show that performing feature augmentation at the early stage of training does not guarantee the effectiveness of debiasing. Performing feature augmentation at the beginning of training rather aggravates the performance. That is, when the representation of intrinsic attributes and bias attributes are not disentangled at a certain degree, augmented features may act as noisy samples. Training with these additional noisy features prevents models from achieving further improvement.
+
+Table 3: Ablation studies on 1) disentangled representation learning, 2) feature augmentation, and 3) scheduling feature augmentation. Each row indicates the different training settings with check mark denoting the setting applied. We average the accuracy of each training over three independent trials.   
+
+<table><tr><td>Disentangle</td><td>Augment</td><td>Scheduled Augment</td><td>Colored MNIST</td><td>Corrupted CIFAR10</td><td>BFFHQ</td></tr><tr><td></td><td></td><td></td><td>52.09±2.88</td><td>25.82±0.33</td><td>56.87±2.69</td></tr><tr><td>&lt;&gt;&gt;</td><td></td><td></td><td>74.03±2.40</td><td>27.73±1.02</td><td>59.4±2.46</td></tr><tr><td></td><td></td><td></td><td>72.29±3.82</td><td>32.81±2.47</td><td>61.27±3.26</td></tr><tr><td></td><td>?</td><td>√</td><td>81.73±2.34</td><td>52.31±1.00</td><td>63.87±0.31</td></tr></table>
+
+# 5.3 Analysis
+
+2D Projection of Disentangled Representation Fig. 3 shows the projection of latent vectors $z _ { i }$ and $z _ { b }$ extracted from the intrinsic encoder $E _ { i }$ and bias encoder $E _ { b }$ , respectively, on a 2D space using Colored MNIST. We show projection of $z _ { i }$ and $z _ { b }$ in Fig. 3(a) and Fig. 3(b), respectively. The colors of projected dots in the first row (i) and the second row (ii) indicate the target labels and bias labels, respectively. We observe that $z _ { i }$ are clustered according to the target labels while $z _ { b }$ are clustered with the bias labels. The results represent that our method successfully learns the disentangled intrinsic and bias attributes.
+
+Prediction with Disentangled Representation In Table 4, we report the 1) original and 2) swapping accuracy of $C _ { i }$ and $C _ { b }$ , the linear classifiers of the intrinsic and the bias encoder, respectively. To be specific, for the original accuracy, we extract the two disentangled vectors, $z _ { i }$ and $z _ { b }$ , from the same image, concatenate them to make $z = [ z _ { i } ; z _ { b } ]$ , and forward them into each linear classifier. For the swapping accuracy, however, we first permute $z _ { b }$ and concatenate $z _ { i }$ with the permuted $z _ { b }$ (i.e., denoted as $\tilde { z _ { b } }$ in Section 4.2) to make $z _ { \mathrm { s w a p } } = [ z _ { i } ; \tilde { z _ { b } } ]$ . Then, we pass these concatenated latent vectors to each linear classifier. Afterward, we evaluate the accuracy of predicted labels of 1) $C _ { i } ( z )$ and $C _ { i } ( z _ { \mathrm { { s w a p } } } )$ with intrinsic labels and 2) $C _ { b } ( z )$ and $C _ { b } ( z _ { \mathrm { s w a p } } )$ with bias labels. The Intrinsic and Bias columns in Table 4 denote the accuracy with respect to the target labels and bias labels, respectively. Even the feature vectors of bias attributes are randomly swapped, our method maintains a reasonable classification accuracy. This indicates that our model well disentangles between $z _ { i }$ and $z _ { b }$ , and $C _ { i }$ robustly utilizes $z _ { i }$ to predict target labels even when $z _ { b }$ is taken from the different image, and vice versa. Note that we utilized the parameters of the model trained on each dataset after converging at a certain degree.
+
+![](images/518a65caee93a7bacd73aa33ae86be3e48d6ec3f4a7026d8b5d9f262d7aad24c.jpg)  
+Figure 3: Each row (i and ii) include 2D projection of $z _ { i }$ and $z _ { b }$ with the colors encoded by their labels (i.e., groundtruth labels in row i and bias labels in row ii) in Colored MNIST. We observe that $z _ { i }$ and $z _ { b }$ are well clustered according to the target and bias labels, respectively.
+
+<table><tr><td rowspan="3">Accuracy(%)</td><td colspan="2">Colored MNIST</td><td colspan="2">Corrupted CIFAR10</td><td colspan="2">BFFHQ</td></tr><tr><td>Intrinsic</td><td>Bias</td><td>Intrinsic</td><td>Bias</td><td>Intrinsic</td><td>Bias</td></tr><tr><td>Original</td><td>76.08</td><td>98.07</td><td>35.63</td><td>74.16</td><td>57.40</td><td>49.00</td></tr><tr><td>Swapping</td><td>71.40</td><td>94.29</td><td>35.14</td><td>76.46</td><td>58.40</td><td>51.60</td></tr></table>
+
+Table 4: Accuracy from disentangled representation. The ratio of bias-conflicting samples in Colored MNIST, Corrupted CIFAR-10, and BFFHQ are $1 \%$ , $1 \%$ , and $0 . 5 \%$ , respectively.
+
+![](images/2b4e9d878f240ee01a845a45ee2022674a4d89c928c89f547b0b14a52c57dfe1.jpg)  
+Figure 4: Reconstructed images from disentangled representation in Colored MNIST. Each column and row indicate the samples where the bias attribute (color) and the intrinsic attribute (digit) are extracted, respectively. By swapping the bias features with a given intrinsic feature, we observe that the color changes while maintaining the digit.
+
+Reconstruction of Disentangled Representation Fig. 4 shows the reconstructed images of Colored MNIST by using the disentangled representation of intrinsic features and bias features. Images in the first row and column indicate the images used for extracting the bias attribute (i.e., color) and intrinsic attribute (i.e., digit), respectively. We train an auxiliary decoder by providing the latent vector $z$ from our pre-trained models as input in order to visualize the disentangled representations at the pixel level. By changing the bias attributes (as the column changes), the color of digit changes while maintaining the digit shape. This demonstrates that the bias features and intrinsic features independently contain color and digit information, respectively. Note that the reconstruction loss for updating the decoder is not backpropagated to our pre-trained classification models. Due to this fact, the reconstructed images may lack qualities such as showing blurry images. Further implementation details are included in Section D in the supplementary material.
+
+# 6 Conclusions
+
+In this work, we propose a feature augmentation method based on the disentangled representation of intrinsic and bias attributes. The main intuition behind our work is that increasing the diversity of bias-conflicting samples beyond a given training set is crucial for debiasing. Since the biased dataset strongly correlates the bias attributes and labels, we intentionally train two different encoders and extract bias features and intrinsic features. After the representations are disentangled to a certain degree, we proliferate the bias-conflicting samples by randomly swapping the vectors. We demonstrate the effectiveness of feature augmentation via extensive experiments, ablation studies, and qualitative evaluation of the disentangled representation. We believe our work inspires the future work of learning debiased representation with the improved generalization capability.
+
+Acknowledgements This work was supported by the Institute of Information & communications Technology Planning & Evaluation (IITP) grant funded by the Korean government(MSIT) (No. 2019-0-00075, Artificial Intelligence Graduate School Program(KAIST), No. 2021-0-01778, Development of human image synthesis and discrimination technology below the perceptual threshold), the Air Force Research Laboratory, under agreement number FA9550-18-S-0003, and Kakao Enterprise. This material is based on research sponsored by The U.S. Government is authorized to reproduce and distribute reprints for Governmental purposes notwithstanding any copyright notation thereon.
+
+References   
+[1] A. Torralba and A. A. Efros. Unbiased look at dataset bias. CVPR ’11, 2011.   
+[2] Robert Geirhos, Jörn-Henrik Jacobsen, Claudio Michaelis, Richard Zemel, Wieland Brendel, Matthias Bethge, and Felix A Wichmann. Shortcut learning in deep neural networks. Nature Machine Intelligence, 2(11):665–673, 2020.   
+[3] Byungju Kim, Hyunwoo Kim, Kyungsu Kim, Sungjin Kim, and Junmo Kim. Learning not to learn: Training deep neural networks with biased data. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2019.   
+[4] Yi Li and Nuno Vasconcelos. Repair: Removing representation bias by dataset resampling. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 9572–9581, 2019.   
+[5] Shiori Sagawa, Pang Wei Koh, Tatsunori B Hashimoto, and Percy Liang. Distributionally robust neural networks for group shifts: On the importance of regularization for worst-case generalization. arXiv preprint arXiv:1911.08731, 2019.   
+[6] Hyojin Bahng, Sanghyuk Chun, Sangdoo Yun, Jaegul Choo, and Seong Joon Oh. Learning de-biased representations with biased representations. In International Conference on Machine Learning (ICML), 2020.   
+[7] Haohan Wang, Zexue He, Zachary L. Lipton, and Eric P. Xing. Learning robust representations by projecting superficial statistics out. In International Conference on Learning Representations, 2019.   
+[8] Remi Cadene, Corentin Dancette, Hedi Ben younes, Matthieu Cord, and Devi Parikh. Rubi: Reducing unimodal biases for visual question answering. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché- Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc., 2019.   
+[9] Christopher Clark, Mark Yatskar, and Luke Zettlemoyer. Don’t take the easy way out: Ensemble based methods for avoiding known dataset biases. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pages 4069–4082, Hong Kong, China, November 2019. Association for Computational Linguistics.   
+[10] Robert Geirhos, Patricia Rubisch, Claudio Michaelis, Matthias Bethge, Felix A. Wichmann, and Wieland Brendel. Imagenet-trained CNNs are biased towards texture; increasing shape bias improves accuracy and robustness. In International Conference on Learning Representations, 2019.   
+[11] Wieland Brendel and Matthias Bethge. Approximating cnns with bag-of-local-features models works surprisingly well on imagenet. International Conference on Learning Representations, 2019.   
+[12] Junhyun Nam, Hyuntak Cha, Sungsoo Ahn, Jaeho Lee, and Jinwoo Shin. Learning from failure: Training debiased classifier from biased classifier. In Advances in Neural Information Processing Systems, 2020.   
+[13] Yann LeCun and Corinna Cortes. MNIST handwritten digit database. 2010.   
+[14] Aishwarya Agrawal, Dhruv Batra, and Devi Parikh. Analyzing the behavior of visual question answering models. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pages 1955–1960, Austin, Texas, November 2016. Association for Computational Linguistics.   
+[15] Luke Darlow, Stanisław Jastrz˛ebski, and Amos Storkey. Latent adversarial debiasing: Mitigating collider bias in deep neural networks. arXiv preprint arXiv:2011.11486, 2020.   
+[16] Zeyi Huang, Haohan Wang, Eric P. Xing, and Dong Huang. Self-challenging improves cross-domain generalization. In ECCV, 2020.   
+[17] Zhilu Zhang and Mert R Sabuncu. Generalized cross entropy loss for training deep neural networks with noisy labels. arXiv preprint arXiv:1805.07836, 2018.   
+[18] Xun Huang and Serge Belongie. Arbitrary style transfer in real-time with adaptive instance normalization. In ICCV, 2017.   
+[19] Matthias Minderer, Olivier Bachem, N. Houlsby, and M. Tschannen. Automatic shortcut removal for self-supervised representation learning. In ICML, 2020.   
+[20] Kaiyang Zhou, Yongxin Yang, Yu Qiao, and Tao Xiang. Domain generalization with mixstyle. In ICLR, 2021.   
+[21] Hsin-Ying Lee, Hung-Yu Tseng, Jia-Bin Huang, Maneesh Kumar Singh, and Ming-Hsuan Yang. Diverse image-to-image translation via disentangled representations. In European Conference on Computer Vision, 2018.   
+[22] Xun Huang, Ming-Yu Liu, Serge Belongie, and Jan Kautz. Multimodal unsupervised image-to-image translation. In ECCV, 2018.   
+[23] Taesung Park, Jun-Yan Zhu, Oliver Wang, Jingwan Lu, Eli Shechtman, Alexei A. Efros, and Richard Zhang. Swapping autoencoder for deep image manipulation. In Advances in Neural Information Processing Systems, 2020.   
+[24] A. Krizhevsky and G. Hinton. Learning multiple layers of features from tiny images. Master’s thesis, Department of Computer Science, University of Toronto, 2009.   
+[25] Dan Hendrycks and Thomas Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. In International Conference on Learning Representations, 2019.   
+[26] Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-SNE. Journal of Machine Learning Research, 9:2579–2605, 2008.   
+[27] Enzo Tartaglione, Carlo Alberto Barbano, and Marco Grangetto. End: Entangling and disentangling deep representations for bias correction. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 13508–13517, June 2021.   
+[28] Tero Karras, Samuli Laine, and Timo Aila. A style-based generator architecture for generative adversarial networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2019.   
+[29] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. arXiv preprint arXiv:1512.03385, 2015.

parse/train/HkezXnA9YX/HkezXnA9YX.md

@@ -0,0 +1,306 @@
+# SYSTEMATIC GENERALIZATION: WHAT IS REQUIRED AND CAN IT BE LEARNED?
+
+Dzmitry Bahdanau∗ Mila, Universite de Montr´ eal´ AdeptMind Scholar Element AI
+
+Shikhar Murty∗ Mila, Universite de Montr ´ eal ´
+
+Michael Noukhovitch Mila, Universite de Montr ´ eal ´
+
+Thien Huu Nguyen University of Oregon
+
+Harm de Vries Mila, Universite de Montr´ eal´
+
+Aaron Courville   
+Mila, Universite de Montr´ eal´   
+CIFAR Fellow
+
+# ABSTRACT
+
+Numerous models for grounded language understanding have been recently proposed, including (i) generic models that can be easily adapted to any given task and (ii) intuitively appealing modular models that require background knowledge to be instantiated. We compare both types of models in how much they lend themselves to a particular form of systematic generalization. Using a synthetic VQA test, we evaluate which models are capable of reasoning about all possible object pairs after training on only a small subset of them. Our findings show that the generalization of modular models is much more systematic and that it is highly sensitive to the module layout, i.e. to how exactly the modules are connected. We furthermore investigate if modular models that generalize well could be made more end-to-end by learning their layout and parametrization. We find that endto-end methods from prior work often learn inappropriate layouts or parametrizations that do not facilitate systematic generalization. Our results suggest that, in addition to modularity, systematic generalization in language understanding may require explicit regularizers or priors.
+
+# 1 INTRODUCTION
+
+In recent years, neural network based models have become the workhorse of natural language understanding and generation. They empower industrial machine translation (Wu et al., 2016) and text generation (Kannan et al., 2016) systems and show state-of-the-art performance on numerous benchmarks including Recognizing Textual Entailment (Gong et al., 2017), Visual Question Answering (Jiang et al., 2018), and Reading Comprehension (Wang et al., 2018). Despite these successes, a growing body of literature suggests that these approaches do not generalize outside of the specific distributions on which they are trained, something that is necessary for a language understanding system to be widely deployed in the real world. Investigations on the three aforementioned tasks have shown that neural models easily latch onto statistical regularities which are omnipresent in existing datasets (Agrawal et al., 2016; Gururangan et al., 2018; Jia & Liang, 2017) and extremely hard to avoid in large scale data collection. Having learned such dataset-specific solutions, neural networks fail to make correct predictions for examples that are even slightly out of domain, yet are trivial for humans. These findings have been corroborated by a recent investigation on a synthetic instruction-following task (Lake & Baroni, 2018), in which seq2seq models (Sutskever et al., 2014; Bahdanau et al., 2015) have shown little systematicity (Fodor & Pylyshyn, 1988) in how they generalize, that is they do not learn general rules on how to compose words and fail spectacularly when for example asked to interpret “jump twice” after training on “jump”, “run twice” and “walk twice”.
+
+An appealing direction to improve the generalization capabilities of neural models is to add modularity and structure to their design to make them structurally resemble the kind of rules they are supposed to learn (Andreas et al., 2016; Gaunt et al., 2016). For example, in the Neural Module Network paradigm (NMN, Andreas et al. (2016)), a neural network is assembled from several neural modules, where each module is meant to perform a particular subtask of the input processing, much like a computer program composed of functions. The NMN approach is intuitively appealing but its widespread adoption has been hindered by the large amount of domain knowledge that is required to decide (Andreas et al., 2016) or predict (Johnson et al., 2017; Hu et al., 2017) how the modules should be created (parametrization) and how they should be connected (layout) based on a natural language utterance. Besides, their performance has often been matched by more traditional neural models, such as FiLM (Perez et al., 2017), Relations Networks (Santoro et al., 2017), and MAC networks (Hudson & Manning, 2018). Lastly, generalization properties of NMNs, to the best of our knowledge, have not been rigorously studied prior to this work.
+
+Here, we investigate the impact of explicit modularity and structure on systematic generalization of NMNs and contrast their generalization abilities to those of generic models. For this case study, we focus on the task of visual question answering (VQA), in particular its simplest binary form, when the answer is either “yes” or “no”. Such a binary VQA task can be seen as a fundamental task of language understanding, as it requires one to evaluate the truth value of the utterance with respect to the state of the world. Among many systematic generalization requirements that are desirable for a VQA model, we choose the following basic one: a good model should be able to reason about all possible object combinations despite being trained on a very small subset of them. We believe that this is a key prerequisite to using VQA models in the real world, because they should be robust at handling unlikely combinations of objects. We implement our generalization demands in the form of a new synthetic dataset, called Spatial Queries On Object Pairs (SQOOP), in which a model has to perform spatial relational reasoning about pairs of randomly scattered letters and digits in the image (e.g. answering the question “Is there a letter A left of a letter B?”). The main challenge in SQOOP is that models are evaluated on all possible object pairs, but trained on only a subset of them.
+
+Our first finding is that NMNs do generalize better than other neural models when layout and parametrization are chosen appropriately. We then investigate which factors contribute to improved generalization performance and find that using a layout that matches the task (i.e. a tree layout, as opposed to a chain layout), is crucial for solving the hardest version of our dataset. Lastly, and perhaps most importantly, we experiment with existing methods for making NMNs more end-to-end by inducing the module layout (Johnson et al., 2017) or learning module parametrization through soft-attention over the question (Hu et al., 2017). Our experiments show that such end-to-end approaches often fail by not converging to tree layouts or by learning a blurred parameterization for modules, which results in poor generalization on the hardest version of our dataset. We believe that our findings challenge the intuition of researchers in the field and provide a foundation for improving systematic generalization of neural approaches to language understanding.
+
+# 2 THE SQOOP DATASET FOR TESTING SYSTEMATIC GENERALIZATION
+
+We perform all experiments of this study on the SQOOP dataset. SQOOP is a minimalistic VQA task that is designed to test the model’s ability to interpret unseen combinations of known relation and object words. Clearly, given known objects X, Y and a known relation R, a human can easily verify whether or not the objects X and $\mathrm { Y }$ are in relation R. Some instances of such queries are common in daily life (is there a cup on the table), some are extremely rare (is there a violin under the car), and some are unlikely but have similar, more likely counter-parts (is there grass on the frisbee vs is there a frisbee on the grass). Still, a person can easily answer these questions by understanding them as just the composition of the three separate concepts. Such compositional reasoning skills are clearly required for language understanding models, and SQOOP is explicitly designed to test for them.
+
+Concretely speaking, SQOOP requires observing a $6 4 \times 6 4$ RGB image x and answering a yes-no question $q = \mathrm { X R Y }$ about whether objects $\mathrm { X }$ and $\mathrm { Y }$ are in a spatial relation R. The questions are represented in a redundancy-free X R Y form; we did not aim to make the questions look like natural language. Each image contains 5 randomly chosen and randomly positioned objects. There are 36 objects: the latin letters A-Z and digits 0-9, and there are 4 relations: LEFT OF, RIGHT OF, ABOVE, and BELOW. This results in $3 6 \cdot 3 5 \cdot 4 = 5 0 4 0$ possible unique questions (we do not allow questions about identical objects). To make negative examples challenging, we ensure that both X and Y of a question are always present in the associated image and that there are distractor objects $\mathrm { Y } ^ { \prime } \ne \mathrm { Y }$ and $\mathrm { X } ^ { \prime } \ne \mathrm { X }$ such that $\mathrm { X R Y ^ { \prime } }$ and $\mathrm { X } ^ { \prime } \mathrm { R Y }$ are both true for the image. These extra precautions guarantee that answering a question requires the model to locate all possible X and Y then check if any pair of them are in the relation R. Two SQOOP examples are shown in Figure 2.
+
+![](images/f1494609efece50ff811e958184658e279cb1f6e09a33c95c3f3156fb8dbffb2.jpg)  
+Figure 1: Different NMN layouts: NMN-Chain-Shortcut (left), NMN-Chain (center), NMN-Tree (right). See Section 3.2 for details.   
+Figure 2: A positive (top) and negative (bottom) example from the SQOOP dataset.
+
+Our goal is to discover which models can correctly answer questions about all $3 6 \cdot 3 5$ possible object pairs in SQOOP after having been trained on only a subset. For this purpose we build training sets containing $3 6 \cdot 4 \cdot k$ unique questions by sampling $k$ different right-hand-side (RHS) objects $\mathrm { Y } _ { 1 }$ , $\mathrm { Y } _ { 2 }$ , ..., $\mathrm { Y } _ { \mathrm { k } }$ for each left-hand-side (LHS) object X. We use this procedure instead of just uniformly sampling object pairs in order to ensure that each object appears in at least one training question, thereby keeping the all versions of the dataset solvable. We will refer to $k$ as the #rhs/lhs parameter of the dataset. Our test set is composed from the remaining $3 6 \cdot 4 \cdot ( 3 5 - k )$ questions. We generate training and test sets for rhs/lhs values of 1,2,4,8 and 18, as well as a control version of the dataset, #rhs/lhs ${ } = 3 5$ , in which both the training and the test set contain all the questions (with different images). Note that lower #rhs/lhs versions are harder for generalization due to the presence of spurious dependencies between the words $\mathrm { X }$ and $\mathrm { Y }$ to which the models may adapt. In order to exclude a possible compounding factor of overfitting on the training images, all our training sets contain 1 million examples, so for a dataset with #rhs/lhs $= k$ we generate approximately $1 0 ^ { 6 } { \bar { / } } ( 3 6 \cdot$ $4 { \cdot } k$ ) different images per unique question. Appendix D contains pseudocode for SQOOP generation.
+
+# 3 MODELS
+
+A great variety of VQA models have been recently proposed in the literature, among which we can distinguish two trends. Some of the recently proposed models, such as FiLM (Perez et al., 2017) and Relation Networks (RelNet, Santoro et al. (2017)) are highly generic and do not require any taskspecific knowledge to be applied on a new dataset. On the opposite end of the spectrum are modular and structured models, typically flavours of Neural Module Networks (Andreas et al., 2016), that do require some knowledge about the task at hand to be instantiated. Here, we evaluate systematic generalization of several state-of-the-art models in both families. In all models, the image x is first fed through a CNN based network, that we refer to as the stem, to produce a feature-level 3D tensor $h _ { \mathrm { x } }$ . This is passed through a model-specific computation conditioned on the question $q$ , to produce a joint representation $h _ { q \bf { x } }$ . Lastly, this representation is fed into a fully-connected classifier network to produce logits for prediction. Therefore, the main difference between the models we consider is how the computation $h _ { q \mathbf { x } } = m o d e l ( h _ { \mathbf { x } } , q )$ is performed.
+
+# 3.1 GENERIC MODELS
+
+We consider four generic models in this paper: CNN+LSTM, FiLM, Relation Network (RelNet), and Memory-Attention-Control (MAC) network. For CNN+LSTM, FiLM, and RelNet models, the question $q$ is first encoded into a fixed-size representation $h _ { q }$ using a unidirectional LSTM network. CNN+LSTM flattens the 3D tensor $h _ { \mathrm { x } }$ to a vector and concatenates it with $h _ { q }$ to produce $h _ { q \mathrm { \tiny ~ x } }$ :
+
+$$
+h _ { q \mathrm { x } } = [ f l a t t e n ( h _ { \mathrm { x } } ) ; h _ { q } ] .
+$$
+
+RelNet (Santoro et al., 2017) uses a network $g$ which is applied to all pairs of feature columns of $h _ { \mathrm { x } }$ concatenated with the question representation $h _ { q }$ , all of which is then pooled to obtain $h _ { q \bf { x } }$ :
+
+$$
+h _ { q \mathrm { x } } = \sum _ { i , j } g ( h _ { \mathrm { x } } ( i ) , h _ { \mathrm { x } } ( j ) , h _ { q } )
+$$
+
+where $h _ { x } ( i )$ is the $i$ -th feature column of $h _ { x }$ . FiLM networks (Perez et al., 2017) use $N$ convolutional FiLM blocks applied to $h _ { \mathrm { x } }$ . A FiLM block is a residual block (He et al., 2016) in which a feature-wise affine transformation (FiLM layer) is inserted after the $2 ^ { \mathrm { n d } }$ convolutional layer. The FiLM layer is conditioned on the question at hand via prediction of the scaling and shifting parameters $\gamma _ { n }$ and $\beta _ { n }$ :
+
+$$
+\begin{array} { r } { [ \gamma _ { n } ; \beta _ { n } ] = W _ { q } ^ { n } h _ { q } + b _ { q } ^ { n } } \\ { \tilde { h } _ { q \mathbf { x } } ^ { n } = B N ( W _ { 2 } ^ { n } * R e L U ( W _ { 1 } ^ { n } * h _ { q \mathbf { x } } ^ { n - 1 } + b _ { n } ) ) } \\ { h _ { q \mathbf { x } } ^ { n } = h _ { q \mathbf { x } } ^ { n - 1 } + R e L U ( \gamma _ { n } \odot \tilde { h } _ { q \mathbf { x } } ^ { n } \oplus \beta _ { n } ) } \end{array}
+$$
+
+where $B N$ stands for batch normalization (Ioffe & Szegedy, 2015), $^ *$ stands for convolution and $\odot$ stands for element-wise multiplications. $h _ { q \mathrm { ~ x ~ } } ^ { n }$ is the output of the $n$ -th FiLM block and $h _ { q \mathrm { x } } ^ { 0 } = h _ { \mathrm { x } }$ . The output of the last FiLM block $h _ { q \mathrm { ~ x ~ } } ^ { N }$ undergoes an extra $1 \times 1$ convolution and max-pooling to produce $h _ { q \bf { x } }$ . MAC network of Hudson & Manning (2018) produces $h _ { q \bf { x } }$ by repeatedly applying a Memory-Attention-Composition (MAC) cell that is conditioned on the question through an attention mechanism. The MAC model is too complex to be fully described here and we refer the reader to the original paper for details.
+
+# 3.2 NEURAL MODULE NETWORKS
+
+Neural Module Networks (NMN) (Andreas et al., 2016) are an elegant approach to question answering that constructs a question-specific network by composing together trainable neural modules, drawing inspiration from symbolic approaches to question answering (Malinowski & Fritz, 2014). To answer a question with an NMN, one first constructs the computation graph by making the following decisions: (a) how many modules and of which types will be used, (b) how will the modules be connected to each other, and (c) how are these modules parametrized based on the question. We refer to the aspects (a) and (b) of the computation graph as the layout and the aspect (c) as the parametrization. In the original NMN and in many follow-up works, different module types are used to perform very different computations, e.g. the Find module from Hu et al. (2017) performs trainable convolutions on the input attention map, whereas the And module from the same paper computes an element-wise maximum for two input attention maps. In this work, we follow the trend of using more homogeneous modules started by Johnson et al. (2017), who use only two types of modules: unary and binary, both performing similar computations. We restrict our study to NMNs with homogeneous modules because they require less prior knowledge to be instantiated and because they performed well in our preliminary experiments despite their relative simplicity. We go one step further than Johnson et al. (2017) and retain a single binary module type, using a zero tensor for the second input when only one input is available. Additionally, we choose to use exactly three modules, which simplifies the layout decision to just determining how the modules are connected. Our preliminary experiments have shown that, even after these simplifications, NMNs are far ahead of other models in terms of generalization.
+
+In the original NMN, the layout and parametrization were set in an ad-hoc manner for each question by analyzing a dependency parse. In the follow-up works (Johnson et al., 2017; Hu et al., 2017), these aspects of the computation are predicted by learnable mechanisms with the goal of reducing the amount of background knowledge required to apply the NMN approach to a new task. We experiment with the End-to-End NMN (N2NMN) (Hu et al., 2017) paradigm from this family, which predicts the layout with a seq2seq model (Sutskever et al., 2014) and computes the parametrization of the modules using a soft attention mechanism. Since all the questions in SQOOP have the same structure, we do not employ a seq2seq model but instead have a trainable layout variable and trainable attention variables for each module.
+
+Formally, our NMN is constructed by repeatedly applying a generic neural module $f ( \theta , \gamma , s ^ { 0 } , s ^ { 1 } )$ , which takes as inputs the shared parameters $\theta$ , the question-specific parametrization $\gamma$ and the lefthand side and right-hand side inputs $s ^ { 0 }$ and $s ^ { 1 }$ . Three such modules are connected and conditioned
+
+on a question $q = ( q _ { 1 } , q _ { 2 } , q _ { 3 } )$ as follows:
+
+$$
+\begin{array} { c } { { \displaystyle \gamma _ { k } = \sum _ { i = 1 } ^ { 3 } \alpha ^ { k , i } e ( q _ { i } ) } } \\ { { \displaystyle s _ { k } ^ { m } = \sum _ { j = - 1 } ^ { k - 1 } \tau _ { m } ^ { k , j } s _ { j } } } \\ { { \displaystyle s _ { k } = f ( \theta , \gamma _ { k } , s _ { k } ^ { 0 } , s _ { k } ^ { 1 } ) } } \\ { { \displaystyle h _ { q x } = s _ { 3 } } } \end{array}
+$$
+
+In the equations above, $s _ { - 1 } = 0$ is the zero tensor input, $s _ { 0 } = h _ { x }$ are the image features outputted by the stem, $e$ is the embedding table for question words. $k \in \{ 1 , 2 , 3 \}$ is the module number, $s _ { k }$ is the output of the $k$ -th module and $s _ { k } ^ { m }$ are its left $\mathbf { \bar { \rho } } _ { m } = 0 ,$ ) and right $\mathbf { \Phi } _ { m } = 1 \mathbf { \Phi } _ { \rho }$ ) inputs. We refer to $A = ( \alpha ^ { k , i } )$ and $T = ( \tau _ { m } ^ { k , j } )$ as the parametrization attention matrix and the layout tensor respectively.
+
+We experiment with two choices for the NMN’s generic neural module: the Find module from Hu et al. (2017) and the Residual module from Johnson et al. (2017). The equations for the Residual module are as follows:
+
+$$
+\begin{array} { r l r } & { } & { [ W _ { 1 } ^ { k } ; b _ { 1 } ^ { k } ; W _ { 2 } ^ { k } ; b _ { 2 } ^ { k } ; W _ { 3 } ^ { k } ; b _ { 3 } ^ { k } ] = \gamma _ { k } } \\ & { } & { \tilde { s _ { k } } = R e L U ( W _ { 3 } ^ { k } * [ s _ { k } ^ { 0 } ; s _ { k } ^ { 1 } ] + b _ { 3 } ^ { k } ) , } \\ & { } & { f _ { R e s i d u a l } ( \gamma _ { k } , s _ { k } ^ { 0 } , s _ { k } ^ { 1 } ) = R e L U ( \tilde { s _ { k } } + W _ { 1 } ^ { k } * R e L U ( W _ { 2 } ^ { k } * \tilde { s _ { k } } + b _ { 2 } ^ { k } ) ) + b _ { 1 } ^ { k } ) , } \end{array}
+$$
+
+and for Find module as follows:
+
+$$
+\begin{array} { r l r } & { } & { [ W _ { 1 } ; b _ { 1 } ; W _ { 2 } ; b _ { 2 } ] = \theta , } \\ & { } & { f _ { F i n d } ( \theta , \gamma _ { k } , s _ { k } ^ { 0 } , s _ { k } ^ { 1 } ) = R e L U ( W _ { 1 } * \gamma _ { k } \odot R e L U ( W _ { 2 } * [ s _ { k } ^ { 0 } ; s _ { k } ^ { 1 } ] + b _ { 2 } ) + b _ { 1 } ) . } \end{array}
+$$
+
+In the formulas above all $W$ ’s stand for convolution weights, and all $b$ ’s are biases. Equations 10 and 13 should be understood as taking vectors $\gamma _ { k }$ and $\theta$ respectively and chunking them into weights and biases. The main difference between Residual and Find is that in Residual all parameters depend on the questions words (hence $\theta$ is omitted from the signature of $f _ { R e s i d u a l } )$ , where as in Find convolutional weights are the same for all questions, and only the element-wise multipliers $\gamma _ { k }$ vary based on the question. We note that the specific Find module we use in this work is slightly different from the one used in (Hu et al., 2017) in that it outputs a feature tensor, not just an attention map. This change was required in order to connect multiple Find modules in the same way as we connect multiple residual ones.
+
+Based on the generic NMN model described above, we experiment with several specific architectures that differ in the way the modules are connected and parametrized (see Figure 1). In NMN-Chain the modules form a sequential chain. Modules 1, 2 and 3 are parametrized based on the first object word, second object word and the relation word respectively, which is achieved by setting the attention maps $\alpha _ { 1 }$ , $\alpha _ { 2 }$ , $\alpha _ { 3 }$ to the corresponding one-hot vectors. We also experiment with giving the image features $h _ { x }$ as the right-hand side input to all 3 modules and call the resulting model NMN-ChainShortcut. NMN-Tree is similar to NMN-Chain in that the attention vectors are similarly hardcoded, but we change the connectivity between the modules to be tree-like. Stochastic N2NMN follows the N2NMN approach by Hu et al. (2017) for inducing layout. We treat the layout $T$ as a stochastic latent variable. $T$ is allowed to take two values: $T _ { t r e e }$ as in NMN-Tree, and $T _ { c h a i n }$ as in NMN-Chain. We calculate the output probabilities by marginalizing out the layout i.e. probability of answer being “yes” is computed as $\begin{array} { r } { \bar { p } ( \mathrm { y e s } | x , q ) = \sum _ { T \in \{ T _ { t r e e } , T _ { c h a i n } \} } p ( \mathrm { y e s } | \bar { T } , x , q ) p ( \bar { T } ) } \end{array}$ . Lastly, Attention N2NMN uses the N2NMN method for learning parametrization (Hu et al., 2017). It is structured just like NMN-Tree but has $\alpha ^ { k }$ computed as $\operatorname { s o f t m a x } ( \tilde { \alpha } ^ { k } )$ , where $\tilde { \alpha } ^ { k }$ is a trainable vector. We use Attention N2NMN only with the Find module because using it with the Residual module would involve a highly non-standard interpolation between convolutional weights.
+
+# 4 EXPERIMENTS
+
+In our experiments we aimed to: (a) understand which models are capable of exhibiting systematic generalization as required by SQOOP, and (b) understand whether it is possible to induce, in an end-to-end way, the successful architectural decisions that lead to systematic generalization.
+
+All models share the same stem architecture which consists of 6 layers of convolution (8 for Relation Networks), batch normalization and max pooling. The input to the stem is a $6 4 \times 6 4 \times 3$ image, and the feature dimension used throughout the stem is 64. Further details can be found in Appendix A. The code for all experiments is available online1.
+
+# 4.1 WHICH MODELS GENERALIZE BETTER?
+
+We report the performance for all models on datasets of varying difficulty in Figure 3. Our first observation is that the modular and tree-structured NMN-Tree model exhibits strong systematic generalization. Both versions of this model, with Residual and Find modules, robustly solve all versions of our dataset, including the most challenging #rhs/lh $^ { = 1 }$ split.
+
+The results of NMN-Tree should be contrasted with those of generic models. 2 out of 4 models (Conv+LSTM and RelNet) are not able to learn to answer all SQOOP questions, no matter how easy the split was (for high #rhs/lhs Conv+LSTM overfitted and RelNet did not train). The results of other two models, MAC and FiLM, are similar. Both models are clearly able to solve the SQOOP task, as suggested by their almost perfect $< 1 \%$ error rate on the control #rhs/lhs $= 3 5$ split, yet they struggle to generalize on splits with lower #rhs/lhs. In particular, we observe $1 3 . 6 7 \pm 9 . 9 7 \%$ errors for MAC and a $3 4 . 7 3 \pm 4 . 6 1 \%$ errors for FiLM on the hardest #rhs/lhs $^ { = 1 }$ split. For the splits of intermediate difficulty we saw the error rates of both models decreasing as we increased the #rhs/lhs ratio from 2 to 18. Interestingly, even with 18 #rhs/lhs some MAC and FiLM runs result in a test error rate of $\sim 2 \%$ . Given the simplicity and minimalism of SQOOP questions, we believe that these results should be considered a failure to pass the SQOOP test for both MAC and FiLM. That said, we note a difference in how exactly FiLM and MAC fail on #rhs/lhs $^ { = 1 }$ : in several runs (3 out of 15) MAC exhibits a strong generalization performance $( \sim 0 . 5 \%$ error rate), whereas in all runs of FiLM the error rate is about $3 0 \%$ . We examine the successful MAC models and find that they converge to a successful setting of the control attention weights, where specific MAC units consistently attend to the right questions words. In particular, MAC models that generalize strongly for each question seem to have a unit focusing strongly on $X$ and a unit focusing strongly on $Y$ (see Appendix B for more details). As MAC was the strongest competitor of NMN-Tree across generic models, we perform an ablation study for this model, in which we vary the number of modules and hidden units, as well as experiment with weight decay. These modifications do not result in any significant reduction of the gap between MAC and NMN-Tree. Interestingly, we find that using the default high number of MAC units, namely 12, is helpful, possibly because it increases the likelihood that at least one unit converges to focus on X and $\mathrm { Y }$ words (see Appendix B for details).
+
+# 4.2 WHAT IS ESSENTIAL TO STRONG GENERALIZATION OF NMN?
+
+The superior generalization of NMN-Tree raises the following question: what is the key architectural difference between NMN-Tree and generic models that explains the performance gap between them? We consider two candidate explanations. First, the NMN-Tree model differs from the generic models in that it does not use a language encoder and is instead built from modules that are parametrized by question words directly. Second, NMN-Tree is structured in a particular way, with the idea that modules 1 and 2 may learn to locate objects and module 3 can learn to reason about object locations independently of their identities. To understand which of the two differences is responsible for the superior generalization, we compare the performance of the NMN-Tree, NMN-Chain and NMNChain-Shortcut models (see Figure 1). These 3 versions of NMN are similar in that none of them are using a language encoder, but they differ in how the modules are connected. The results in Figure 3 show that for both Find and Residual module architectures, using a tree layout is absolutely crucial (and sufficient) for generalization, meaning that the generalization gap between NMN-Tree and generic models can not be explained merely by the language encoding step in the latter. In particular, NMN-Chain models perform barely above random chance, doing even worse than generic models on the #rhs/lhs $^ { = 1 }$ version of the dataset and dramatically failing even on the easiest #rhs/lhs ${ } _ { = 1 8 }$ split. This is in stark contrast with NMN-Tree models that exhibits nearly perfect performance on the hardest #rhs/lh $^ { = 1 }$ split. As a sanity check we train NMN-Chain models on the vanilla #rhs/lhs ${ } = 3 5$ split. We find that NMN-Chain has little difficulty learning to answer SQOOP questions when it sees all of them at training time, even though it previously shows poor generalization when testing on unseen examples. Interestingly, NMN-Chain-Shortcut performs much better than NMN-Chain and quite similarly to generic models. We find it remarkable that such a slight change in the model layout as adding shortcut connections from image features $h _ { x }$ to the modules results in a drastic change in generalization performance. In an attempt to understand why NMN-Chain generalizes so poorly we compare the test set responses of the 5 NMN-Chain models trained on #rhs/lhs $^ { = 1 }$ split. Notably, there was very little agreement between predictions of these 5 runs (Fleiss $\kappa = 0 . 0 5$ ), suggesting that NMN-Chain performs rather randomly outside of the training set.
+
+![](images/3cdad88a68b9415ad79acd4f7060ea7047809e513858bf6df356b6913893c125.jpg)  
+Figure 3: Top: Comparing the performance of generic models on datasets of varying difficulty (lower #rhs/lhs is more difficult). Note that NMN-Tree generalizes perfectly on the hardest #rhs/lhs $^ { \dag = 1 }$ version of SQOOP, whereas MAC and FiLM fail to solve completely even the easiest #rhs/lhs ${ \it \Omega } = 1 8$ version. Bottom: Comparing NMNs with different layouts and modules. We can clearly observe the superior generalization of NMN-Tree, poor generalization of NMN-Chain and mediocre generalization of NMN-Chain-Shortcut. Means and standard deviations after at least 5 runs are reported.
+
+# 4.3 CAN THE RIGHT KIND OF NMN BE INDUCED?
+
+The strong generalization of the NMN-Tree is impressive, but a significant amount of prior knowledge about the task was required to come up with the successful layout and parametrization used in this model. We therefore investigate whether the amount of such prior knowledge can be reduced by fixing one of these structural aspects and inducing the other.
+
+# 4.3.1 LAYOUT INDUCTION
+
+In our layout induction experiments, we use the Stochastic N2NMN model which treats the layout as a stochastic latent variable with two values ( $T _ { t r e e }$ and $T _ { c h a i n }$ , see Section 3.2 for details). We experiment with N2NMNs using both Find and Residual modules and report results with different initial conditions, $p _ { 0 } ( t r e e ) \in 0 . 1 , 0 . 5 , 0 . 9$ . We believe that the initial probability $p _ { 0 } ( t r e e ) = 0 . 1$ should not be considered small, since in more challenging datasets the space of layouts would be exponentially large, and sampling the right layout in $10 \%$ of all cases should be considered a very lucky initialization. We repeat all experiments on #rhs/lhs $^ { = 1 }$ and on #rhs/lhs ${ \it \Omega } = 1 8$ splits, the former to study generalization, and the latter to control whether the failures on #rhs/lhs $^ { - 1 }$ are caused specifically by the difficulty of this split. The results (see Table 1) show that the success of layout induction (i.e. converging to a $p ( t r e e )$ close to 0.9) depends in a complex way on all the factors that we considered in our experiments. The initialization has the most influence: models initialized with $p _ { 0 } ( t r e e ) = 0 . 1$ typically do not converge to a tree (exception being experiments with Residual module on #rhs/lhs ${ } = 1 8$ , in which 3 out of 5 runs converged to a solution with a high $p ( t r e e ) )$ ). Likewise, models initialized with $p _ { 0 } ( t r e e ) = 0 . 9$ always stay in a regime with a high $p ( t r e e )$ . In the intermediate setting of $p _ { 0 } ( t r e e ) = 0 . 5$ we observe differences in behaviors for Residual and Find modules. In particular, N2NMN based on Residual modules stays spurious with $p ( t r e e ) = 0 . 5 \pm 0 . 0 8$ when #rhs/lhs $^ { \dag = 1 }$ , whereas N2NMN based on Find modules always converges to a tree.
+
+![](images/59c079636e0800b951a24de6c2ef0de6c4ad6cb384c912da8507a7dc1224bb65.jpg)
+
+![](images/e287b95b907bab018b1069114c6e8739f5d1b5bb8f48d4c6e80efdebefaddf63.jpg)
+
+![](images/f77da1b68c45336998c67b610a6137df0a8a3a098468e2964579bba5490e1349.jpg)  
+Figure 4: Learning dynamics of layout induction on 1 rhs/lhs and 18 rhs/lhs datasets using the Residual module with $p _ { 0 } ( t r e e ) =$ 0.5. All 5 runs do not learn to use the tree layout for 1 rhs/lhs, the very setting where the tree layout is necessary for generalization.   
+Figure 5: Attention quality $\kappa$ vs accuracy for Attention N2NMN models trained on different #rhs/lhs splits. We can observe that generalization is strongly associated with high $\kappa$ for #rhs/lhs $^ { = 1 }$ , while for splits with 2 and 18 rhs/lhs blurry attention may be sufficient.   
+Figure 6: An example of how attention weights of modules 1 (left), 2 (middle), and 3 (right) evolve during training of an Attention N2NMN model on the 18 rhs/lhs version of SQOOP. Modules 1 and 2 learn to focus on different objects words, X and $\mathrm { Y }$ respectively in this example, but they also assign high weight to the relation word R. Module 3 learns to focus exclusively on R.
+
+One counterintuitive result in Table 1 is that for the Stochastic N2NMNs with Residual modules, trained with $p _ { 0 } ( t r e e ) = 0 . 5$ and #rhs/lhs $^ { = 1 }$ , make just $1 . 6 4 { \pm } 1 . 7 9 \%$ test error despite never resolving the layout uncertainty through training $( p _ { 2 0 0 K } ( t r e e ) = 0 . 5 6 \pm 0 . 0 6 )$ . We offer an investigation of this result in Appendix C.
+
+# 4.3.2 PARAMETRIZATION INDUCTION
+
+Next, we experiment with the Attention N2NMN model (see Section 3.2) in which the parametrization is learned for each module as an attention-weighted average of word embeddings. In these experiments, we fix the layout to be tree-like and sample the pre-softmax attention weights $\tilde { \alpha }$ from a uniform distribution $U [ 0 ; 1 ]$ . As in the layout induction investigations, we experiment with several SQOOP splits, namely we try #rhs/lhs $\ r \in \{ 1 , 2 , 1 8 \}$ . The results (reported in Table 2) show that Attention N2NMN fails dramatically on #rhs/lhs=1 but quickly catches up as soon as #rhs/lhs is increased to 2. Notably, 9 out of 10 runs on #rhs/lhs $^ { = 2 }$ result in almost perfect performance, and 1 run completely fails to generalize ( $2 6 \%$ error rate), resulting in a high $8 . 1 8 \%$ variance of the mean error rate. All 10 runs on the split with 18 rhs/lhs generalize flawlessly. Furthermore, we inspect the learned attention weights and find that for typical successful runs, module 3 focuses on the relation word, whereas modules 1 and 2 focus on different object words (see Figure 6) while still focusing on the relation word. To better understand the relationship between successful layout induction and generalization, we define an attention quality metric $\begin{array} { r } { \kappa = \operatorname* { m i n } _ { w \in \{ X , Y \} } \operatorname* { m a x } _ { k \in 1 , 2 } \alpha _ { k , w } / ( 1 - \alpha _ { k , R } ) } \end{array}$ . Intuitively, $\kappa$ is large when for each word $w \in X , Y$ there is a module $i$ that focuses mostly on this word. The renormalization by $1 / ( 1 - \alpha _ { k , R } )$ is necessary to factor out the amount of attention that modules 1 and 2 assign to the relation word. For the ground-truth parametrization that we use for NMN-Tree $\kappa$ takes a value of 1, and if both modules 1 and 2 focus on X, completely ignoring Y, $\kappa$ equals 0. The scatterplot of the test error rate versus $\kappa$ (Figure 5) shows that for #rhs/lhs $^ { = 1 }$ high generalization is strongly associated with higher $\kappa$ , meaning that it is indeed necessary to have different modules strongly focusing on different object words in order to generalize in this most challenging setting. Interestingly, for #rhs/lhs $^ { = 2 }$ we see a lot of cases where N2NMN generalizes well despite attention being rather spurious $( \kappa \approx 0 . 6 $ ).
+
+Table 1: Tree layout induction results for Stochastic N2NMNs using Residual and Find modules on 1 rhs/lhs and 18 rhs/lhs datasets. For each setting of $p _ { 0 } ( t r e e )$ we report results after 5 runs. $p _ { 2 0 0 K } ( t r e e )$ is the probability of using a tree layout after 200K training iterations.   
+
+<table><tr><td>module</td><td>#rhs/lhs</td><td>po(tree)</td><td>Test error rate (%)</td><td>Test loss</td><td>p200k(tree)</td></tr><tr><td rowspan="5">Residual</td><td rowspan="3">1</td><td>0.1</td><td>31.89 ± 0.75</td><td>0.64±0.03</td><td>0.08±0.01</td></tr><tr><td>0.5</td><td>1.64 ± 1.79</td><td>0.27 ± 0.04</td><td>0.56 ±0.06</td></tr><tr><td>0.9</td><td>0.16 ± 0.11</td><td>0.03 ±0.01</td><td>0.96 ±0.00</td></tr><tr><td rowspan="3">18</td><td>0.1</td><td>3.99 ± 5.33</td><td>0.15 ±0.06</td><td>0.59±0.34</td></tr><tr><td>0.5</td><td>0.19 ±0.11</td><td>0.06±0.02</td><td>0.99 ±0.01</td></tr><tr><td>0.9</td><td>0.12 ±0.12</td><td>0.01 ±0.00</td><td>1.00 ± 0.00</td></tr><tr><td rowspan="5">Find</td><td rowspan="3">1</td><td>0.1</td><td>47.54± 0.95</td><td>1.78 ± 0.47</td><td>0.00±0.00</td></tr><tr><td>0.5</td><td>0.78 ±0.52</td><td>0.05 ± 0.04</td><td>0.94±0.07</td></tr><tr><td>0.9</td><td>0.41 ± 0.07</td><td>0.02±0.00</td><td>1.00 ±0.00</td></tr><tr><td rowspan="3">18</td><td>0.1</td><td>5.11 ± 1.19</td><td>0.14±0.03</td><td>0.02±0.04</td></tr><tr><td>0.5</td><td>0.17 ± 0.16</td><td>0.01±0.01</td><td>1.00 ±0.00</td></tr><tr><td>0.9</td><td>0.11 ± 0.03</td><td>0.00±0.00</td><td>1.00 ± 0.00</td></tr></table>
+
+Table 2: Parameterization induction results for 1,2,18 rhs/lhs datasets for Attention N2NMN. The model does not generalize well in the difficult 1 rhs/lhs setting. Results for MAC are presented for comparison. Means and standard deviations were estimated based on at least 10 runs.   
+
+<table><tr><td>Model</td><td>#rhs/lhs</td><td>Test error rate (%)</td><td>Test loss (%)</td></tr><tr><td>AttentionN2NMN</td><td>1</td><td>27.19±16.02</td><td>1.22 ± 0.71</td></tr><tr><td>Attention N2NMN</td><td>2</td><td>2.82 ±8.18</td><td>0.14 ± 0.41</td></tr><tr><td>Attention N2NMN</td><td>18</td><td>0.16 ± 0.12</td><td>0.00±0.00</td></tr><tr><td>MAC</td><td>1</td><td>13.67± 9.97</td><td>0.41 ± 0.32</td></tr><tr><td>MAC</td><td>2</td><td>9.21 ± 4.31</td><td>0.28 ± 0.15</td></tr><tr><td>MAC</td><td>18</td><td>0.53 ± 0.74</td><td>0.01 ±0.02</td></tr></table>
+
+In order to put Attention N2NMN results in context we compare them to those of MAC (see Table 2). Such a comparison can be of interest because both models perform attention over the question. For 1 rhs/lhs MAC seems to be better on average, but as we increase #rhs/lhs to 2 we note that Attention N2NMN succeeds in 9 out of 10 cases on the #rhs/lh $^ { \circ 2 }$ split, much more often than 1 success out of 10 observed for $\mathbf { M A C }$ . This result suggests that Attention N2NMNs retains some of the strong generalization potential of NMNs with hard-coded parametrization.
+
+# 5 RELATED WORK
+
+The notion of systematicity was originally introduced by (Fodor & Pylyshyn, 1988) as the property of human cognition whereby “the ability to entertain a given thought implies the ability to entertain thoughts with semantically related contents”. They illustrate this with an example that no English speaker can understand the phrase “John loves the girl” without being also able to understand the phrase “the girl loves John”. The question of whether or not connectionist models of cognition can account for the systematicity phenomenon has been a subject of a long debate in cognitive science (Fodor & Pylyshyn, 1988; Smolensky, 1987; Marcus, 1998; 2003; Calvo & Colunga, 2003). Recent research has shown that lack of systematicity in the generalization is still a concern for the modern seq2seq models (Lake & Baroni, 2018; Bastings et al., 2018; Loula et al., 2018). Our findings about the weak systematic generalization of generic VQA models corroborate the aforementioned seq2seq results. We also go beyond merely stating negative generalization results and showcase the high systematicity potential of adding explicit modularity and structure to modern deep learning models.
+
+Besides the theoretical appeal of systematicity, our study is inspired by highly related prior evidence that when trained on downstream language understanding tasks, neural networks often generalize poorly and latch on to dataset-specific regularities. Agrawal et al. (2016) report how neural models exploit biases in a VQA dataset, e.g. responding “snow” to the question “what covers the ground” regardless of the image because “snow” is the most common answer to this question. Gururangan et al. (2018) report that many successes in natural language entailment are actually due to exploiting statistical biases as opposed to solving entailment, and that state-of-the-art systems are much less performant when tested on unbiased data. Jia & Liang (2017) demonstrate that seemingly state-ofthe-art reading comprehension system can be misled by simply appending an unrelated sentence that resembles the question to the document.
+
+Using synthetic VQA datasets to study grounded language understanding is a recent trend started by the CLEVR dataset (Johnson et al., 2016). CLEVR images are 3D-rendered and CLEVR questions are longer and more complex than ours, but in the associated generalization split CLEVR-CoGenT the training and test distributions of images are different. In our design of SQOOP we aimed instead to minimize the difference between training and test images to make sure that we test a model’s ability to interpret unknown combinations of known words. The ShapeWorld family of datasets by Kuhnle & Copestake (2017) is another synthetic VQA platform with a number of generalization tests, but none of them tests SQOOP-style generalization of relational reasoning to unseen object pairs. Most closely related to our work is the recent study of generalization to long-tail questions about rare objects done by Bingham et al. (2017). They do not, however, consider as many models as we do and do not study the question of whether the best-performing models can be made end-to-end.
+
+The key paradigm that we test in our experiments is Neural Module Networks (NMN). Andreas et al. (2016) introduced NMNs as a modular, structured VQA model where a fixed number of handcrafted neural modules (such as Find, or Compare) are chosen and composed together in a layout determined by the dependency parse of the question. Andreas et al. (2016) show that the modular structure allows answering questions that are longer than the training ones, a kind of generalization that is complementary to the one we study here. Hu et al. (2017) and Johnson et al. (2017) followed up by making NMNs end-to-end, removing the non-differentiable parser. Both Hu et al. (2017) and Johnson et al. (2017) reported that several thousands of ground-truth layouts are required to pretrain the layout predictor in order for their approaches to work. In a recent work, Hu et al. (2018) attempt to soften the layout decisions, but training their models end-to-end from scratch performed substantially lower than best models on the CLEVR task. Gupta & Lewis (2018) report successful layout induction on CLEVR for a carefully engineered heterogeneous NMN that takes a scene graph as opposed to a raw image as the input.
+
+# 6 CONCLUSION AND DISCUSSION
+
+We have conducted a rigorous investigation of an important form of systematic generalization required for grounded language understanding: the ability to reason about all possible pairs of objects despite being trained on a small subset of such pairs. Our results allow one to draw two important conclusions. For one, the intuitive appeal of modularity and structure in designing neural architectures for language understanding is now supported by our results, which show how a modular model consisting of general purpose residual blocks generalizes much better than a number of baselines, including architectures such as MAC, FiLM and RelNet that were designed specifically for visual reasoning. While this may seem unsurprising, to the best of our knowledge, the literature has lacked such a clear empirical evidence in favor of modular and structured networks before this work. Importantly, we have also shown how sensitive the high performance of the modular models is to the layout of modules, and how a tree-like structure generalizes much stronger than a typical chain of layers.
+
+Our second key conclusion is that coming up with an end-to-end and/or soft version of modular models may be not sufficient for strong generalization. In the very setting where strong generalization is required, end-to-end methods often converge to a different, less compositional solution (e.g. a chain layout or blurred attention). This can be observed especially clearly in our NMN layout and parametrization induction experiments on the #rhs/lhs $^ { = 1 }$ version of SQOOP, but notably, strong initialization sensitivity of layout induction remains an issue even on the #rhs/lhs ${ } _ { = 1 8 }$ split. This conclusion is relevant in the view of recent work in the direction of making NMNs more end-toend (Suarez et al., 2018; Hu et al., 2018; Hudson & Manning, 2018; Gupta & Lewis, 2018). Our findings suggest that merely replacing hard-coded components with learnable counterparts can be insufficient, and that research on regularizers or priors that steer the learning towards more systematic solutions can be required. That said, our parametrization induction results on the #rhs/lhs $^ { = 2 }$ split are encouraging, as they show that compared to generic models, a weaker nudge (in the form of a richer training signal or a prior) towards systematicity may suffice for end-to-end NMNs.
+
+While our investigation has been performed on a synthetic dataset, we believe that it is the realworld language understanding where our findings may be most relevant. It is possible to construct a synthetic dataset that is bias-free and that can only be solved if the model has understood the entirety of the dataset’s language. It is, on the contrary, much harder to collect real-world datasets that do not permit highly dataset-specific solutions, as numerous dataset analysis papers of recent years have shown (see Section 5 for a review). We believe that approaches that can generalize strongly from imperfect and biased data will likely be required, and our experiments can be seen as a simulation of such a scenario. We hope, therefore, that our findings will inform researchers working on language understanding and provide them with a useful intuition about what facilitates strong generalization and what is likely to inhibit it.
+
+# ACKNOWLEDGEMENTS
+
+We thank Maxime Chevalier-Boisvert, Yoshua Bengio and Jacob Andreas for useful discussions. This research was enabled in part by support provided by Compute Canada (www.computecanada.ca), NSERC, Canada Research Chairs and Microsoft Research. We also thank Nvidia for donating NVIDIA DGX-1 used for this research.
+
+# REFERENCES
+
+Aishwarya Agrawal, Dhruv Batra, and Devi Parikh. Analyzing the Behavior of Visual Question Answering Models. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, January 2016.   
+Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Dan Klein. Neural Module Networks. In Proceedings of 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016. URL http://arxiv.org/abs/1511.02799.   
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural Machine Translation by Jointly Learning to Align and Translate. In Proceedings of the 2015 International Conference on Learning Representations, 2015.   
+Joost Bastings, Marco Baroni, Jason Weston, Kyunghyun Cho, and Douwe Kiela. Jump to better conclusions: SCAN both left and right. In Proceedings of the 2018 EMNLP Workshop BlackboxNLP: Analyzing and Interpreting Neural Networks for NLP, pp. 47–55, Brussels, Belgium, November 2018. Association for Computational Linguistics. URL https://www.aclweb. org/anthology/W18-5407.   
+Eli Bingham, Piero Molino, Paul Szerlip, Obermeyer Fritz, and Goodman Noah. Characterizing how Visual Question Answering scales with the world. In NIPS 2017 Visually-Grounded Interaction and Language Workshop, 2017.   
+Francisco Calvo and Eliana Colunga. The statistical brain: Reply to Marcus The algebraic mind. In Proceedings of the Annual Meeting of the Cognitive Science Society, volume 25, 2003.
+
+Jerry A. Fodor and Zenon W. Pylyshyn. Connectionism and cognitive architecture: A critical analysis. Cognition, 28(1):3–71, 1988.
+
+Alexander L. Gaunt, Marc Brockschmidt, Nate Kushman, and Daniel Tarlow. Differentiable Programs with Neural Libraries. In Proceedings of the 34th International Conference on Machine Learning, November 2016. URL http://arxiv.org/abs/1611.02109. arXiv: 1611.02109.
+
+Yichen Gong, Heng Luo, and Jian Zhang. Natural Language Inference over Interaction Space. In Proceedings of the 2018 International Conference on Learning Representations, 2017. URL http://arxiv.org/abs/1709.04348. arXiv: 1709.04348.
+
+Nitish Gupta and Mike Lewis. Neural Compositional Denotational Semantics for Question Answering. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing. Association for Computational Linguistics, 2018. URL http://aclweb.org/ anthology/D18-1239.
+
+Suchin Gururangan, Swabha Swayamdipta, Omer Levy, Roy Schwartz, Samuel R. Bowman, and Noah A. Smith. Annotation Artifacts in Natural Language Inference Data. In Proceedings of NAACL-HLT 2018, March 2018. URL http://arxiv.org/abs/1803.02324. arXiv: 1803.02324.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2016.
+
+Ronghang Hu, Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Kate Saenko. Learning to Reason: End-to-End Module Networks for Visual Question Answering. In Proceedings of 2017 IEEE International Conference on Computer Vision, April 2017. URL http://arxiv.org/ abs/1704.05526. arXiv: 1704.05526.
+
+Ronghang Hu, Jacob Andreas, Trevor Darrell, and Kate Saenko. Explainable Neural Computation via Stack Neural Module Networks. In Proceedings of 2018 European Conference on Computer Vision, July 2018. URL http://arxiv.org/abs/1807.08556. arXiv: 1807.08556.
+
+Drew A. Hudson and Christopher D. Manning. Compositional Attention Networks for Machine Reasoning. In Proceedings of the 2018 International Conference on Learning Representations, February 2018. URL https://openreview.net/forum?id=S1Euwz-Rb.
+
+Sergey Ioffe and Christian Szegedy. Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift. In Proceedings of the 32nd International Conference on Machine Learning, ICML 2015, Lille, France, 6-11 July 2015, pp. 448–456, 2015. URL http: //jmlr.org/proceedings/papers/v37/ioffe15.html.
+
+Robin Jia and Percy Liang. Adversarial Examples for Evaluating Reading Comprehension Systems. Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pp. 2021–2031, 2017. doi: 10.18653/v1/D17-1215. URL https://aclanthology.coli. uni-saarland.de/papers/D17-1215/d17-1215.
+
+Yu Jiang, Vivek Natarajan, Xinlei Chen, Marcus Rohrbach, Dhruv Batra, and Devi Parikh. Pythia v0.1: The winning entry to the vqa challenge 2018. https://github.com/ facebookresearch/pythia, 2018.
+
+Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Li Fei-Fei, C. Lawrence Zitnick, and Ross Girshick. CLEVR: A Diagnostic Dataset for Compositional Language and Elementary Visual Reasoning. In Proceedings of 2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), December 2016. URL http://arxiv.org/abs/1612.06890. arXiv: 1612.06890.
+
+Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Judy Hoffman, Li Fei-Fei, C. Lawrence Zitnick, and Ross Girshick. Inferring and Executing Programs for Visual Reasoning. In Proceedings of 2017 IEEE International Conference on Computer Vision, 2017. URL http: //arxiv.org/abs/1705.03633.
+
+Anjuli Kannan, Karol Kurach, Sujith Ravi, Tobias Kaufmann, Andrew Tomkins, Balint Miklos, Greg Corrado, Laszlo Lukacs, Marina Ganea, Peter Young, and Vivek Ramavajjala. Smart Reply: Automated Response Suggestion for Email. In Proceedings of the 22Nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’16, pp. 955–964, New York, NY, USA, 2016. ACM. ISBN 978-1-4503-4232-2. doi: 10.1145/2939672.2939801. URL http://doi.acm.org/10.1145/2939672.2939801.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A Method for Stochastic Optimization. In Proceedings of the 2015 International Conference on Learning Representations, 2015. URL http://arxiv. org/abs/1412.6980. arXiv: 1412.6980.
+
+Alexander Kuhnle and Ann Copestake. ShapeWorld - A new test methodology for multimodal language understanding. arXiv:1704.04517 [cs], April 2017. URL http://arxiv.org/ abs/1704.04517. arXiv: 1704.04517.
+
+Brenden M. Lake and Marco Baroni. Generalization without systematicity: On the compositional skills of sequence-to-sequence recurrent networks. In Proceedings of the 36th International Conference on Machine Learning, 2018. URL http://arxiv.org/abs/1711.00350. arXiv: 1711.00350.
+
+Joao Loula, Marco Baroni, and Brenden M. Lake. Rearranging the Familiar: Testing Compositional Generalization in Recurrent Networks. In Proceedings of the 2018 BlackboxNLP EMNLP Workshop, July 2018. URL https://arxiv.org/abs/1807.07545.
+
+Mateusz Malinowski and Mario Fritz. A Multi-world Approach to Question Answering About Realworld Scenes Based on Uncertain Input. In Proceedings of the 27th International Conference on Neural Information Processing Systems, NIPS’14, pp. 1682–1690, Cambridge, MA, USA, 2014. MIT Press. URL http://dl.acm.org/citation.cfm?id=2968826.2969014.
+
+Gary F. Marcus. Rethinking Eliminative Connectionism. Cognitive Psychology, 37(3):243–282, December 1998. ISSN 0010-0285. doi: 10.1006/cogp.1998.0694. URL http://www. sciencedirect.com/science/article/pii/S0010028598906946.
+
+Gary F. Marcus. The algebraic mind: Integrating connectionism and cognitive science. MIT press, 2003.
+
+Ethan Perez, Florian Strub, Harm de Vries, Vincent Dumoulin, and Aaron Courville. FiLM: Visual Reasoning with a General Conditioning Layer. In In Proceedings of the 2017 AAAI Conference on Artificial Intelligence, 2017. URL http://arxiv.org/abs/1709.07871.
+
+Adam Santoro, David Raposo, David G. T. Barrett, Mateusz Malinowski, Razvan Pascanu, Peter Battaglia, and Timothy Lillicrap. A simple neural network module for relational reasoning. In Advances in Neural Information Processing Systems 31, June 2017. URL http://arxiv. org/abs/1706.01427. arXiv: 1706.01427.
+
+Paul Smolensky. The constituent structure of connectionist mental states: A reply to Fodor and Pylyshyn. Southern Journal of Philosophy, 26(Supplement):137–161, 1987.
+
+Joseph Suarez, Justin Johnson, and Fei-Fei Li. DDRprog: A CLEVR Differentiable Dynamic Reasoning Programmer. arXiv:1803.11361 [cs], March 2018. URL http://arxiv.org/abs/ 1803.11361. arXiv: 1803.11361.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to Sequence Learning with Neural Networks. In Advances in Neural Information Processing Systems 27, pp. 3104–3112, 2014.
+
+Wei Wang, Ming Yan, and Chen Wu. Multi-Granularity Hierarchical Attention Fusion Networks for Reading Comprehension and Question Answering. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 1705–1714, Melbourne, Australia, 2018. Association for Computational Linguistics. URL http://aclweb.org/anthology/P18-1158.
+
+Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, and others. Google’s Neural Machine Translation System: Bridging the Gap between Human and Machine Translation. arXiv preprint arXiv:1609.08144, 2016.
+
+# A EXPERIMENT DETAILS
+
+We trained all models by minimizing the cross entropy loss $\log p ( y | x , q )$ on the training set, where $y ~ \in ~ \{ \mathrm { y e s } , \mathrm { n o } \}$ is the correct answer, $x$ is the image, $q$ is the question. In all our experiments we used the Adam optimizer (Kingma & Ba, 2015) with hyperparameters $\alpha = 0 . 0 0 0 1$ , $\bar { \beta } _ { 1 } = 0 . 9$ , $\beta _ { 2 } = 0 . 9 9 9$ , $\epsilon = 1 0 ^ { - \mathrm { { 1 0 } } }$ . We continuously monitored validation set performance of all models during training, selected the best one and reported its performance on the test set. The number of training iterations for each model was selected in preliminary investigations based on our observations of how long it takes for different models to converge. This information, as well as other training details, can be found in Table 3.
+
+Table 3: Training details for all models. The subsampling factor is the ratio between the original spatial dimensions of the input image and those of the representation produced by the stem. It is effectively equal to $2 ^ { k }$ , where $k$ is the number of $2 \mathrm { x 2 }$ max-pooling operations in the stem.   
+
+<table><tr><td>model</td><td>stem layers</td><td>subsampling factor</td><td>iterations</td><td>batch size</td></tr><tr><td>FiLM</td><td>6</td><td>4</td><td>200000</td><td>64</td></tr><tr><td>MAC</td><td>6</td><td>4</td><td>100000</td><td>128</td></tr><tr><td>Conv+LSTM</td><td>6</td><td>4</td><td>200000</td><td>128</td></tr><tr><td>RelNet</td><td>8</td><td>8</td><td>500000</td><td>64</td></tr><tr><td>NMN (Residual)</td><td>6</td><td>4</td><td>50000</td><td>64</td></tr><tr><td>NMN (Find)</td><td>6</td><td>4</td><td>200000</td><td>64</td></tr><tr><td>Stochastic NMN (Residual)</td><td>6</td><td>4</td><td>200000</td><td>64</td></tr><tr><td>Stochastic NMN (Find)</td><td>6</td><td>4</td><td>200000</td><td>64</td></tr><tr><td>Attention NMN (Find)</td><td>6</td><td>4</td><td>50000</td><td>64</td></tr></table>
+
+# B ADDITIONAL RESULTS FOR MAC MODEL
+
+We performed an ablation study in which we varied the number of MAC units, the model dimensionality and the level of weight decay for the MAC model. The results can be found in Table 4.
+
+Table 4: Results of an ablation study for MAC. The default model has 12 MAC units of dimensionality 128 and uses no weight decay. For each experiment we report means and standard deviations based on 5 repetitions.   
+
+<table><tr><td>model</td><td>#rhs/lhs</td><td>train error rate(%)</td><td>test error rate (%)</td></tr><tr><td>default</td><td>1</td><td>0.17± 0.21</td><td>13.67 ± 9.97</td></tr><tr><td>1 unit</td><td>1</td><td>0.27 ± 0.35</td><td>28.67 ± 1.91</td></tr><tr><td>2 units</td><td>1</td><td>0.23 ± 0.13</td><td>24.28 ± 2.05</td></tr><tr><td>3units</td><td>1</td><td>0.16 ±0.15</td><td>26.47 ± 1.12</td></tr><tr><td>6units</td><td>1</td><td>0.18 ±0.17</td><td>20.84± 5.56</td></tr><tr><td>24 units</td><td>1</td><td>0.04± 0.05</td><td>9.11 ± 7.67</td></tr><tr><td>dim. 64</td><td>1</td><td>0.27 ± 0.33</td><td>23.61 ± 6.27</td></tr><tr><td>dim. 256</td><td>1</td><td>0.00 ±0.00</td><td>4.62 ± 5.07</td></tr><tr><td>dim. 512</td><td>1</td><td>0.02 ±0.04</td><td>8.37 ± 7.45</td></tr><tr><td>weight decay 0.00001</td><td>1</td><td>0.20 ±0.23</td><td>19.21 ± 9.27</td></tr><tr><td>weight decay 0.0001</td><td></td><td>1.00 ± 0.54</td><td>31.19 ± 0.87</td></tr><tr><td>weight decay 0.001</td><td></td><td>40.55 ± 1.35</td><td>45.11 ± 0.74</td></tr></table>
+
+We also perform qualitative investigations to understand the high variance in MAC’s performance. In particular, we focus on control attention weights $( c )$ for each run and aim to understand if runs that generalize have clear differences when compared to runs that failed. Interestingly, we observe that in successful runs each word $w \in \mathrm { X }$ , Y has a unit that is strongly focused on it. To present our observations in quantitative terms, we plot attention quality $\begin{array} { r } { \kappa = \operatorname* { m i n } _ { w \in \{ X , Y \} } \operatorname* { m a x } _ { k \in [ 1 ; 1 2 ] } } \end{array}$ $\alpha _ { k , w } / ( 1 - \alpha _ { k , R } )$ , where $\alpha$ are control scores vs accuracy in Figure 7 for each run (see Section 4.3.2 for an explanation of $\kappa$ ). We can clearly see a positive correlation between $\kappa$ and error rate, especially for low #rhs/lhs.
+
+![](images/b17fd2a3fccb5785bed74fbb94af302295cb1a6524c63aab5f7015046190a9ea.jpg)  
+Figure 7: Model test accuracy vs $\kappa$ for the MAC model on different versions of SQOOP. All experiments are run 10 times with different random seeds. We can observe a clear correlation between $\kappa$ and error rate for 1, 2 and 4 rhs/lhs. Also note that perfect generalization is always associated with $\kappa$ close to 1.
+
+Next, we experiment with a hard-coded variation of MAC. In this model, we use hard-coded control scores such that given a SQOOP question X R Y, the first half of all modules focuses on X while the second half focuses on Y. The relationship between MAC and hardcoded MAC is similar to that between NMN-Tree and end-to-end NMN with parameterization induction. However, this model has not performed as well as the successful runs of MAC. We hypothesize that this could be due to the interactions between the control scores and the visual attention part of the model.
+
+# C INVESTIGATION OF CORRECT PREDICTIONS WITH SPURIOUS LAYOUTS
+
+In Section 4.3.1 we observed that an NMN with the Residual module can answer test questions with a relative low error rate of $1 . 6 4 \pm 1 . 7 9 \%$ , despite being a mixture of a tree and a chain (see results in Table 1, $p _ { 0 } ( t r e e ) = 0 . 5 )$ . Our explanation for this phenomenon is as follows: when connected in a tree, modules of such spurious models generalize well, and when connected as a chain they generalize poorly. The output distribution of the whole model is thus a mixture of the mostly correct $p ( y | T \stackrel { } { = } T _ { t r e e } , x , q )$ and mostly random $p ( y | T = T _ { c h a i n } , x , q )$ . We verify our reasoning by explicitly evaluating test accuracies for $p ( y | T = T _ { t r e e } , x , q )$ and $p ( y | T = T _ { c h a i n } , x , q )$ , and find them to be around $9 9 \%$ and $6 0 \%$ respectively, confirming our hypothesis. As a result the predictions of the spurious models with $p ( t r e e ) \approx 0 . 5$ have lower confidence than those of sharp tree models, as indicated by the high log loss of $0 . 2 7 \pm 0 . 0 4$ . We visualize the progress of structure induction for the Residual module with $p _ { 0 } ( t r e e ) = 0 . 5$ in Figure 4 which shows how $p ( t r e e )$ saturates to 1.0 for #rhs/lhs ${ } = 1 8$ and remains around 0.5 when #rhs/lhs $^ { = 1 }$ .
+
+# D SQOOP PSEUDOCODE
+
+# Algorithm 1 Pseudocode for creating SQOOP
+
+1: $S \gets \{ \mathrm { A , B , C , \dots , Z , 0 , 1 , 2 , 3 , \dots , 9 } \}$   
+2: Rel ← {LEFT-OF, RIGHT-OF, ABOVE, BELOW} . relations   
+3: function CREATESQOOP(k)   
+4: T rainQuestions ← []   
+5: AllQuestions ← []   
+6: for all $X$ in $S$ do   
+7: AllRhs ← RandomSample $( S \setminus \{ X \} , \mathbf { k } )$ $\triangleright$ sample without replacement from $S \setminus \{ X \}$   
+8: $A l l Q u e s t i o n s \gets \{ X \} \times R e l \times ( S \setminus \{ X \} ) \cup A l l Q u e s t i o n$ s   
+9: for all $R , Y$ in $A l l R h s \times R e l$ do   
+10: T rainQuestions $ ( X , R , Y ) \cup T$ rainQuestions   
+11: end for   
+12: end for   
+13: T estQuestions ← AllQuestions \ T rainQuestions   
+14: function GENERATEEXAMPLE $( X , R , Y )$   
+15: $a \sim \{ \mathrm { Y e s } , \mathrm { N o } \}$   
+16: if $a = \mathrm { Y e s }$ then   
+17: $I $ place $X$ and $Y$ objects so that $R$ holds $\triangleright$ create the image   
+18: $I $ sample 3 objects from $S$ and add to $I$   
+19: else   
+20: repeat   
+21: $X ^ { \prime } \gets$ Sample $X ^ { \prime }$ from $S \setminus \{ X \}$   
+22: $Y ^ { \prime } \gets \boldsymbol { \mathsf { S } }$ ample $Y ^ { \prime }$ from $S \backslash \{ Y \}$   
+23: $I $ place $X ^ { \prime }$ and $Y$ objects so that $R$ holds . create the image   
+24: $I $ add $X$ and $Y ^ { \prime }$ objects to $I$ so that $R$ holds   
+25: $I $ sample 1 more object from $S$ and add to $I$   
+26: until $X$ and $Y$ are not in relation $R$ in I   
+27: end if   
+28: return $I , X , R , Y , a$   
+29: end function   
+30: T rain $\gets$ sample $ | \underset { -- } { \underbrace { 1 0 ^ { 6 } } } | \underset { -- } { \underbrace { T r a i n Q u e s t i o n s } } |$ examples for each (X,R,Y)  T rainQuestions from   
+GENERATEEXAMPLE $( X , R , Y )$   
+31: $T e s t \gets$ sample 10 examples for each (X,R,Y)  T estQuestions from GENERATEEXAM  
+$\mathrm { P L E } ( X , R , Y )$   
+32: end function

parse/train/HkezXnA9YX/HkezXnA9YX_content_list.json

@@ -0,0 +1,1487 @@
+[
+    {
+        "type": "text",
+        "text": "SYSTEMATIC GENERALIZATION: WHAT IS REQUIRED AND CAN IT BE LEARNED? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau∗ Mila, Universite de Montr´ eal´ AdeptMind Scholar Element AI ",
+        "bbox": [
+            183,
+            170,
+            374,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Shikhar Murty∗ Mila, Universite de Montr ´ eal ´ ",
+        "bbox": [
+            403,
+            170,
+            594,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Michael Noukhovitch Mila, Universite de Montr ´ eal ´ ",
+        "bbox": [
+            622,
+            171,
+            813,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Thien Huu Nguyen University of Oregon ",
+        "bbox": [
+            184,
+            247,
+            323,
+            276
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Harm de Vries Mila, Universite de Montr´ eal´ ",
+        "bbox": [
+            364,
+            247,
+            558,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Aaron Courville   \nMila, Universite de Montr´ eal´   \nCIFAR Fellow ",
+        "bbox": [
+            598,
+            247,
+            790,
+            289
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            327,
+            544,
+            342
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Numerous models for grounded language understanding have been recently proposed, including (i) generic models that can be easily adapted to any given task and (ii) intuitively appealing modular models that require background knowledge to be instantiated. We compare both types of models in how much they lend themselves to a particular form of systematic generalization. Using a synthetic VQA test, we evaluate which models are capable of reasoning about all possible object pairs after training on only a small subset of them. Our findings show that the generalization of modular models is much more systematic and that it is highly sensitive to the module layout, i.e. to how exactly the modules are connected. We furthermore investigate if modular models that generalize well could be made more end-to-end by learning their layout and parametrization. We find that endto-end methods from prior work often learn inappropriate layouts or parametrizations that do not facilitate systematic generalization. Our results suggest that, in addition to modularity, systematic generalization in language understanding may require explicit regularizers or priors. ",
+        "bbox": [
+            233,
+            359,
+            764,
+            566
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            595,
+            336,
+            611
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In recent years, neural network based models have become the workhorse of natural language understanding and generation. They empower industrial machine translation (Wu et al., 2016) and text generation (Kannan et al., 2016) systems and show state-of-the-art performance on numerous benchmarks including Recognizing Textual Entailment (Gong et al., 2017), Visual Question Answering (Jiang et al., 2018), and Reading Comprehension (Wang et al., 2018). Despite these successes, a growing body of literature suggests that these approaches do not generalize outside of the specific distributions on which they are trained, something that is necessary for a language understanding system to be widely deployed in the real world. Investigations on the three aforementioned tasks have shown that neural models easily latch onto statistical regularities which are omnipresent in existing datasets (Agrawal et al., 2016; Gururangan et al., 2018; Jia & Liang, 2017) and extremely hard to avoid in large scale data collection. Having learned such dataset-specific solutions, neural networks fail to make correct predictions for examples that are even slightly out of domain, yet are trivial for humans. These findings have been corroborated by a recent investigation on a synthetic instruction-following task (Lake & Baroni, 2018), in which seq2seq models (Sutskever et al., 2014; Bahdanau et al., 2015) have shown little systematicity (Fodor & Pylyshyn, 1988) in how they generalize, that is they do not learn general rules on how to compose words and fail spectacularly when for example asked to interpret “jump twice” after training on “jump”, “run twice” and “walk twice”. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            863
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "An appealing direction to improve the generalization capabilities of neural models is to add modularity and structure to their design to make them structurally resemble the kind of rules they are supposed to learn (Andreas et al., 2016; Gaunt et al., 2016). For example, in the Neural Module Network paradigm (NMN, Andreas et al. (2016)), a neural network is assembled from several neural modules, where each module is meant to perform a particular subtask of the input processing, much like a computer program composed of functions. The NMN approach is intuitively appealing but its widespread adoption has been hindered by the large amount of domain knowledge that is required to decide (Andreas et al., 2016) or predict (Johnson et al., 2017; Hu et al., 2017) how the modules should be created (parametrization) and how they should be connected (layout) based on a natural language utterance. Besides, their performance has often been matched by more traditional neural models, such as FiLM (Perez et al., 2017), Relations Networks (Santoro et al., 2017), and MAC networks (Hudson & Manning, 2018). Lastly, generalization properties of NMNs, to the best of our knowledge, have not been rigorously studied prior to this work. ",
+        "bbox": [
+            176,
+            871,
+            821,
+            898
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            256
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Here, we investigate the impact of explicit modularity and structure on systematic generalization of NMNs and contrast their generalization abilities to those of generic models. For this case study, we focus on the task of visual question answering (VQA), in particular its simplest binary form, when the answer is either “yes” or “no”. Such a binary VQA task can be seen as a fundamental task of language understanding, as it requires one to evaluate the truth value of the utterance with respect to the state of the world. Among many systematic generalization requirements that are desirable for a VQA model, we choose the following basic one: a good model should be able to reason about all possible object combinations despite being trained on a very small subset of them. We believe that this is a key prerequisite to using VQA models in the real world, because they should be robust at handling unlikely combinations of objects. We implement our generalization demands in the form of a new synthetic dataset, called Spatial Queries On Object Pairs (SQOOP), in which a model has to perform spatial relational reasoning about pairs of randomly scattered letters and digits in the image (e.g. answering the question “Is there a letter A left of a letter B?”). The main challenge in SQOOP is that models are evaluated on all possible object pairs, but trained on only a subset of them. ",
+        "bbox": [
+            174,
+            263,
+            825,
+            458
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our first finding is that NMNs do generalize better than other neural models when layout and parametrization are chosen appropriately. We then investigate which factors contribute to improved generalization performance and find that using a layout that matches the task (i.e. a tree layout, as opposed to a chain layout), is crucial for solving the hardest version of our dataset. Lastly, and perhaps most importantly, we experiment with existing methods for making NMNs more end-to-end by inducing the module layout (Johnson et al., 2017) or learning module parametrization through soft-attention over the question (Hu et al., 2017). Our experiments show that such end-to-end approaches often fail by not converging to tree layouts or by learning a blurred parameterization for modules, which results in poor generalization on the hardest version of our dataset. We believe that our findings challenge the intuition of researchers in the field and provide a foundation for improving systematic generalization of neural approaches to language understanding. ",
+        "bbox": [
+            174,
+            464,
+            825,
+            617
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 THE SQOOP DATASET FOR TESTING SYSTEMATIC GENERALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            643,
+            785,
+            661
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We perform all experiments of this study on the SQOOP dataset. SQOOP is a minimalistic VQA task that is designed to test the model’s ability to interpret unseen combinations of known relation and object words. Clearly, given known objects X, Y and a known relation R, a human can easily verify whether or not the objects X and $\\mathrm { Y }$ are in relation R. Some instances of such queries are common in daily life (is there a cup on the table), some are extremely rare (is there a violin under the car), and some are unlikely but have similar, more likely counter-parts (is there grass on the frisbee vs is there a frisbee on the grass). Still, a person can easily answer these questions by understanding them as just the composition of the three separate concepts. Such compositional reasoning skills are clearly required for language understanding models, and SQOOP is explicitly designed to test for them. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            806
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Concretely speaking, SQOOP requires observing a $6 4 \\times 6 4$ RGB image x and answering a yes-no question $q = \\mathrm { X R Y }$ about whether objects $\\mathrm { X }$ and $\\mathrm { Y }$ are in a spatial relation R. The questions are represented in a redundancy-free X R Y form; we did not aim to make the questions look like natural language. Each image contains 5 randomly chosen and randomly positioned objects. There are 36 objects: the latin letters A-Z and digits 0-9, and there are 4 relations: LEFT OF, RIGHT OF, ABOVE, and BELOW. This results in $3 6 \\cdot 3 5 \\cdot 4 = 5 0 4 0$ possible unique questions (we do not allow questions about identical objects). To make negative examples challenging, we ensure that both X and Y of a question are always present in the associated image and that there are distractor objects $\\mathrm { Y } ^ { \\prime } \\ne \\mathrm { Y }$ and $\\mathrm { X } ^ { \\prime } \\ne \\mathrm { X }$ such that $\\mathrm { X R Y ^ { \\prime } }$ and $\\mathrm { X } ^ { \\prime } \\mathrm { R Y }$ are both true for the image. These extra precautions guarantee that answering a question requires the model to locate all possible X and Y then check if any pair of them are in the relation R. Two SQOOP examples are shown in Figure 2. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/f1494609efece50ff811e958184658e279cb1f6e09a33c95c3f3156fb8dbffb2.jpg",
+        "image_caption": [
+            "Figure 1: Different NMN layouts: NMN-Chain-Shortcut (left), NMN-Chain (center), NMN-Tree (right). See Section 3.2 for details. ",
+            "Figure 2: A positive (top) and negative (bottom) example from the SQOOP dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            102,
+            743,
+            252
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            338,
+            825,
+            381
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our goal is to discover which models can correctly answer questions about all $3 6 \\cdot 3 5$ possible object pairs in SQOOP after having been trained on only a subset. For this purpose we build training sets containing $3 6 \\cdot 4 \\cdot k$ unique questions by sampling $k$ different right-hand-side (RHS) objects $\\mathrm { Y } _ { 1 }$ , $\\mathrm { Y } _ { 2 }$ , ..., $\\mathrm { Y } _ { \\mathrm { k } }$ for each left-hand-side (LHS) object X. We use this procedure instead of just uniformly sampling object pairs in order to ensure that each object appears in at least one training question, thereby keeping the all versions of the dataset solvable. We will refer to $k$ as the #rhs/lhs parameter of the dataset. Our test set is composed from the remaining $3 6 \\cdot 4 \\cdot ( 3 5 - k )$ questions. We generate training and test sets for rhs/lhs values of 1,2,4,8 and 18, as well as a control version of the dataset, #rhs/lhs ${ } = 3 5$ , in which both the training and the test set contain all the questions (with different images). Note that lower #rhs/lhs versions are harder for generalization due to the presence of spurious dependencies between the words $\\mathrm { X }$ and $\\mathrm { Y }$ to which the models may adapt. In order to exclude a possible compounding factor of overfitting on the training images, all our training sets contain 1 million examples, so for a dataset with #rhs/lhs $= k$ we generate approximately $1 0 ^ { 6 } { \\bar { / } } ( 3 6 \\cdot$ $4 { \\cdot } k$ ) different images per unique question. Appendix D contains pseudocode for SQOOP generation. ",
+        "bbox": [
+            173,
+            388,
+            825,
+            583
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            603,
+            279,
+            619
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A great variety of VQA models have been recently proposed in the literature, among which we can distinguish two trends. Some of the recently proposed models, such as FiLM (Perez et al., 2017) and Relation Networks (RelNet, Santoro et al. (2017)) are highly generic and do not require any taskspecific knowledge to be applied on a new dataset. On the opposite end of the spectrum are modular and structured models, typically flavours of Neural Module Networks (Andreas et al., 2016), that do require some knowledge about the task at hand to be instantiated. Here, we evaluate systematic generalization of several state-of-the-art models in both families. In all models, the image x is first fed through a CNN based network, that we refer to as the stem, to produce a feature-level 3D tensor $h _ { \\mathrm { x } }$ . This is passed through a model-specific computation conditioned on the question $q$ , to produce a joint representation $h _ { q \\bf { x } }$ . Lastly, this representation is fed into a fully-connected classifier network to produce logits for prediction. Therefore, the main difference between the models we consider is how the computation $h _ { q \\mathbf { x } } = m o d e l ( h _ { \\mathbf { x } } , q )$ is performed. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            803
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 GENERIC MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            819,
+            344,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We consider four generic models in this paper: CNN+LSTM, FiLM, Relation Network (RelNet), and Memory-Attention-Control (MAC) network. For CNN+LSTM, FiLM, and RelNet models, the question $q$ is first encoded into a fixed-size representation $h _ { q }$ using a unidirectional LSTM network. CNN+LSTM flattens the 3D tensor $h _ { \\mathrm { x } }$ to a vector and concatenates it with $h _ { q }$ to produce $h _ { q \\mathrm { \\tiny ~ x } }$ : ",
+        "bbox": [
+            174,
+            844,
+            823,
+            901
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ab890e543685ed249825f4b2a2f9028799b5f6042b7b6b05ceb5a2e03731fb93.jpg",
+        "text": "$$\nh _ { q \\mathrm { x } } = [ f l a t t e n ( h _ { \\mathrm { x } } ) ; h _ { q } ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            909,
+            584,
+            926
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "RelNet (Santoro et al., 2017) uses a network $g$ which is applied to all pairs of feature columns of $h _ { \\mathrm { x } }$ concatenated with the question representation $h _ { q }$ , all of which is then pooled to obtain $h _ { q \\bf { x } }$ : ",
+        "bbox": [
+            169,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/72eff74d5fab2edacfd52abcb5a31b758b2d87a4ef155c1c0a7c27c12445690d.jpg",
+        "text": "$$\nh _ { q \\mathrm { x } } = \\sum _ { i , j } g ( h _ { \\mathrm { x } } ( i ) , h _ { \\mathrm { x } } ( j ) , h _ { q } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            138,
+            599,
+            174
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $h _ { x } ( i )$ is the $i$ -th feature column of $h _ { x }$ . FiLM networks (Perez et al., 2017) use $N$ convolutional FiLM blocks applied to $h _ { \\mathrm { x } }$ . A FiLM block is a residual block (He et al., 2016) in which a feature-wise affine transformation (FiLM layer) is inserted after the $2 ^ { \\mathrm { n d } }$ convolutional layer. The FiLM layer is conditioned on the question at hand via prediction of the scaling and shifting parameters $\\gamma _ { n }$ and $\\beta _ { n }$ : ",
+        "bbox": [
+            174,
+            179,
+            823,
+            251
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/92acd8cd10641791b9ede4a44d57b14d067ea16445c0e73d7935683e315f3618.jpg",
+        "text": "$$\n\\begin{array} { r } { [ \\gamma _ { n } ; \\beta _ { n } ] = W _ { q } ^ { n } h _ { q } + b _ { q } ^ { n } } \\\\ { \\tilde { h } _ { q \\mathbf { x } } ^ { n } = B N ( W _ { 2 } ^ { n } * R e L U ( W _ { 1 } ^ { n } * h _ { q \\mathbf { x } } ^ { n - 1 } + b _ { n } ) ) } \\\\ { h _ { q \\mathbf { x } } ^ { n } = h _ { q \\mathbf { x } } ^ { n - 1 } + R e L U ( \\gamma _ { n } \\odot \\tilde { h } _ { q \\mathbf { x } } ^ { n } \\oplus \\beta _ { n } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            255,
+            651,
+            319
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $B N$ stands for batch normalization (Ioffe & Szegedy, 2015), $^ *$ stands for convolution and $\\odot$ stands for element-wise multiplications. $h _ { q \\mathrm { ~ x ~ } } ^ { n }$ is the output of the $n$ -th FiLM block and $h _ { q \\mathrm { x } } ^ { 0 } = h _ { \\mathrm { x } }$ . The output of the last FiLM block $h _ { q \\mathrm { ~ x ~ } } ^ { N }$ undergoes an extra $1 \\times 1$ convolution and max-pooling to produce $h _ { q \\bf { x } }$ . MAC network of Hudson & Manning (2018) produces $h _ { q \\bf { x } }$ by repeatedly applying a Memory-Attention-Composition (MAC) cell that is conditioned on the question through an attention mechanism. The MAC model is too complex to be fully described here and we refer the reader to the original paper for details. ",
+        "bbox": [
+            173,
+            321,
+            825,
+            422
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 NEURAL MODULE NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            439,
+            426,
+            453
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Neural Module Networks (NMN) (Andreas et al., 2016) are an elegant approach to question answering that constructs a question-specific network by composing together trainable neural modules, drawing inspiration from symbolic approaches to question answering (Malinowski & Fritz, 2014). To answer a question with an NMN, one first constructs the computation graph by making the following decisions: (a) how many modules and of which types will be used, (b) how will the modules be connected to each other, and (c) how are these modules parametrized based on the question. We refer to the aspects (a) and (b) of the computation graph as the layout and the aspect (c) as the parametrization. In the original NMN and in many follow-up works, different module types are used to perform very different computations, e.g. the Find module from Hu et al. (2017) performs trainable convolutions on the input attention map, whereas the And module from the same paper computes an element-wise maximum for two input attention maps. In this work, we follow the trend of using more homogeneous modules started by Johnson et al. (2017), who use only two types of modules: unary and binary, both performing similar computations. We restrict our study to NMNs with homogeneous modules because they require less prior knowledge to be instantiated and because they performed well in our preliminary experiments despite their relative simplicity. We go one step further than Johnson et al. (2017) and retain a single binary module type, using a zero tensor for the second input when only one input is available. Additionally, we choose to use exactly three modules, which simplifies the layout decision to just determining how the modules are connected. Our preliminary experiments have shown that, even after these simplifications, NMNs are far ahead of other models in terms of generalization. ",
+        "bbox": [
+            173,
+            463,
+            825,
+            742
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the original NMN, the layout and parametrization were set in an ad-hoc manner for each question by analyzing a dependency parse. In the follow-up works (Johnson et al., 2017; Hu et al., 2017), these aspects of the computation are predicted by learnable mechanisms with the goal of reducing the amount of background knowledge required to apply the NMN approach to a new task. We experiment with the End-to-End NMN (N2NMN) (Hu et al., 2017) paradigm from this family, which predicts the layout with a seq2seq model (Sutskever et al., 2014) and computes the parametrization of the modules using a soft attention mechanism. Since all the questions in SQOOP have the same structure, we do not employ a seq2seq model but instead have a trainable layout variable and trainable attention variables for each module. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Formally, our NMN is constructed by repeatedly applying a generic neural module $f ( \\theta , \\gamma , s ^ { 0 } , s ^ { 1 } )$ , which takes as inputs the shared parameters $\\theta$ , the question-specific parametrization $\\gamma$ and the lefthand side and right-hand side inputs $s ^ { 0 }$ and $s ^ { 1 }$ . Three such modules are connected and conditioned ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "on a question $q = ( q _ { 1 } , q _ { 2 } , q _ { 3 } )$ as follows: ",
+        "bbox": [
+            173,
+            103,
+            442,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a314f72aeda0e2d844e29c30b0d7c1c715b4131af355210add7382389e918538.jpg",
+        "text": "$$\n\\begin{array} { c } { { \\displaystyle \\gamma _ { k } = \\sum _ { i = 1 } ^ { 3 } \\alpha ^ { k , i } e ( q _ { i } ) } } \\\\ { { \\displaystyle s _ { k } ^ { m } = \\sum _ { j = - 1 } ^ { k - 1 } \\tau _ { m } ^ { k , j } s _ { j } } } \\\\ { { \\displaystyle s _ { k } = f ( \\theta , \\gamma _ { k } , s _ { k } ^ { 0 } , s _ { k } ^ { 1 } ) } } \\\\ { { \\displaystyle h _ { q x } = s _ { 3 } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            431,
+            132,
+            570,
+            261
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the equations above, $s _ { - 1 } = 0$ is the zero tensor input, $s _ { 0 } = h _ { x }$ are the image features outputted by the stem, $e$ is the embedding table for question words. $k \\in \\{ 1 , 2 , 3 \\}$ is the module number, $s _ { k }$ is the output of the $k$ -th module and $s _ { k } ^ { m }$ are its left $\\mathbf { \\bar { \\rho } } _ { m } = 0 ,$ ) and right $\\mathbf { \\Phi } _ { m } = 1 \\mathbf { \\Phi } _ { \\rho }$ ) inputs. We refer to $A = ( \\alpha ^ { k , i } )$ and $T = ( \\tau _ { m } ^ { k , j } )$ as the parametrization attention matrix and the layout tensor respectively. ",
+        "bbox": [
+            174,
+            279,
+            825,
+            353
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We experiment with two choices for the NMN’s generic neural module: the Find module from Hu et al. (2017) and the Residual module from Johnson et al. (2017). The equations for the Residual module are as follows: ",
+        "bbox": [
+            176,
+            358,
+            823,
+            401
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7433eeb7ce72a8284e79115a8d9a595fe51f4b25d180f9a349694c35efdb95b0.jpg",
+        "text": "$$\n\\begin{array} { r l r } & { } & { [ W _ { 1 } ^ { k } ; b _ { 1 } ^ { k } ; W _ { 2 } ^ { k } ; b _ { 2 } ^ { k } ; W _ { 3 } ^ { k } ; b _ { 3 } ^ { k } ] = \\gamma _ { k } } \\\\ & { } & { \\tilde { s _ { k } } = R e L U ( W _ { 3 } ^ { k } * [ s _ { k } ^ { 0 } ; s _ { k } ^ { 1 } ] + b _ { 3 } ^ { k } ) , } \\\\ & { } & { f _ { R e s i d u a l } ( \\gamma _ { k } , s _ { k } ^ { 0 } , s _ { k } ^ { 1 } ) = R e L U ( \\tilde { s _ { k } } + W _ { 1 } ^ { k } * R e L U ( W _ { 2 } ^ { k } * \\tilde { s _ { k } } + b _ { 2 } ^ { k } ) ) + b _ { 1 } ^ { k } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            411,
+            743,
+            477
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "and for Find module as follows: ",
+        "bbox": [
+            173,
+            487,
+            387,
+            502
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2cd50f7229f97e54544223195a85ec971625ef8882be9c1a35ac50b67ad1844b.jpg",
+        "text": "$$\n\\begin{array} { r l r } & { } & { [ W _ { 1 } ; b _ { 1 } ; W _ { 2 } ; b _ { 2 } ] = \\theta , } \\\\ & { } & { f _ { F i n d } ( \\theta , \\gamma _ { k } , s _ { k } ^ { 0 } , s _ { k } ^ { 1 } ) = R e L U ( W _ { 1 } * \\gamma _ { k } \\odot R e L U ( W _ { 2 } * [ s _ { k } ^ { 0 } ; s _ { k } ^ { 1 } ] + b _ { 2 } ) + b _ { 1 } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            246,
+            515,
+            751,
+            556
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the formulas above all $W$ ’s stand for convolution weights, and all $b$ ’s are biases. Equations 10 and 13 should be understood as taking vectors $\\gamma _ { k }$ and $\\theta$ respectively and chunking them into weights and biases. The main difference between Residual and Find is that in Residual all parameters depend on the questions words (hence $\\theta$ is omitted from the signature of $f _ { R e s i d u a l } )$ , where as in Find convolutional weights are the same for all questions, and only the element-wise multipliers $\\gamma _ { k }$ vary based on the question. We note that the specific Find module we use in this work is slightly different from the one used in (Hu et al., 2017) in that it outputs a feature tensor, not just an attention map. This change was required in order to connect multiple Find modules in the same way as we connect multiple residual ones. ",
+        "bbox": [
+            173,
+            566,
+            825,
+            693
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Based on the generic NMN model described above, we experiment with several specific architectures that differ in the way the modules are connected and parametrized (see Figure 1). In NMN-Chain the modules form a sequential chain. Modules 1, 2 and 3 are parametrized based on the first object word, second object word and the relation word respectively, which is achieved by setting the attention maps $\\alpha _ { 1 }$ , $\\alpha _ { 2 }$ , $\\alpha _ { 3 }$ to the corresponding one-hot vectors. We also experiment with giving the image features $h _ { x }$ as the right-hand side input to all 3 modules and call the resulting model NMN-ChainShortcut. NMN-Tree is similar to NMN-Chain in that the attention vectors are similarly hardcoded, but we change the connectivity between the modules to be tree-like. Stochastic N2NMN follows the N2NMN approach by Hu et al. (2017) for inducing layout. We treat the layout $T$ as a stochastic latent variable. $T$ is allowed to take two values: $T _ { t r e e }$ as in NMN-Tree, and $T _ { c h a i n }$ as in NMN-Chain. We calculate the output probabilities by marginalizing out the layout i.e. probability of answer being “yes” is computed as $\\begin{array} { r } { \\bar { p } ( \\mathrm { y e s } | x , q ) = \\sum _ { T \\in \\{ T _ { t r e e } , T _ { c h a i n } \\} } p ( \\mathrm { y e s } | \\bar { T } , x , q ) p ( \\bar { T } ) } \\end{array}$ . Lastly, Attention N2NMN uses the N2NMN method for learning parametrization (Hu et al., 2017). It is structured just like NMN-Tree but has $\\alpha ^ { k }$ computed as $\\operatorname { s o f t m a x } ( \\tilde { \\alpha } ^ { k } )$ , where $\\tilde { \\alpha } ^ { k }$ is a trainable vector. We use Attention N2NMN only with the Find module because using it with the Residual module would involve a highly non-standard interpolation between convolutional weights. ",
+        "bbox": [
+            173,
+            699,
+            826,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            326,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In our experiments we aimed to: (a) understand which models are capable of exhibiting systematic generalization as required by SQOOP, and (b) understand whether it is possible to induce, in an end-to-end way, the successful architectural decisions that lead to systematic generalization. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            175
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "All models share the same stem architecture which consists of 6 layers of convolution (8 for Relation Networks), batch normalization and max pooling. The input to the stem is a $6 4 \\times 6 4 \\times 3$ image, and the feature dimension used throughout the stem is 64. Further details can be found in Appendix A. The code for all experiments is available online1. ",
+        "bbox": [
+            174,
+            183,
+            825,
+            238
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 WHICH MODELS GENERALIZE BETTER? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            255,
+            495,
+            270
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We report the performance for all models on datasets of varying difficulty in Figure 3. Our first observation is that the modular and tree-structured NMN-Tree model exhibits strong systematic generalization. Both versions of this model, with Residual and Find modules, robustly solve all versions of our dataset, including the most challenging #rhs/lh $^ { = 1 }$ split. ",
+        "bbox": [
+            174,
+            281,
+            825,
+            337
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The results of NMN-Tree should be contrasted with those of generic models. 2 out of 4 models (Conv+LSTM and RelNet) are not able to learn to answer all SQOOP questions, no matter how easy the split was (for high #rhs/lhs Conv+LSTM overfitted and RelNet did not train). The results of other two models, MAC and FiLM, are similar. Both models are clearly able to solve the SQOOP task, as suggested by their almost perfect $< 1 \\%$ error rate on the control #rhs/lhs $= 3 5$ split, yet they struggle to generalize on splits with lower #rhs/lhs. In particular, we observe $1 3 . 6 7 \\pm 9 . 9 7 \\%$ errors for MAC and a $3 4 . 7 3 \\pm 4 . 6 1 \\%$ errors for FiLM on the hardest #rhs/lhs $^ { = 1 }$ split. For the splits of intermediate difficulty we saw the error rates of both models decreasing as we increased the #rhs/lhs ratio from 2 to 18. Interestingly, even with 18 #rhs/lhs some MAC and FiLM runs result in a test error rate of $\\sim 2 \\%$ . Given the simplicity and minimalism of SQOOP questions, we believe that these results should be considered a failure to pass the SQOOP test for both MAC and FiLM. That said, we note a difference in how exactly FiLM and MAC fail on #rhs/lhs $^ { = 1 }$ : in several runs (3 out of 15) MAC exhibits a strong generalization performance $( \\sim 0 . 5 \\%$ error rate), whereas in all runs of FiLM the error rate is about $3 0 \\%$ . We examine the successful MAC models and find that they converge to a successful setting of the control attention weights, where specific MAC units consistently attend to the right questions words. In particular, MAC models that generalize strongly for each question seem to have a unit focusing strongly on $X$ and a unit focusing strongly on $Y$ (see Appendix B for more details). As MAC was the strongest competitor of NMN-Tree across generic models, we perform an ablation study for this model, in which we vary the number of modules and hidden units, as well as experiment with weight decay. These modifications do not result in any significant reduction of the gap between MAC and NMN-Tree. Interestingly, we find that using the default high number of MAC units, namely 12, is helpful, possibly because it increases the likelihood that at least one unit converges to focus on X and $\\mathrm { Y }$ words (see Appendix B for details). ",
+        "bbox": [
+            173,
+            343,
+            825,
+            662
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 WHAT IS ESSENTIAL TO STRONG GENERALIZATION OF NMN? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            680,
+            648,
+            694
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The superior generalization of NMN-Tree raises the following question: what is the key architectural difference between NMN-Tree and generic models that explains the performance gap between them? We consider two candidate explanations. First, the NMN-Tree model differs from the generic models in that it does not use a language encoder and is instead built from modules that are parametrized by question words directly. Second, NMN-Tree is structured in a particular way, with the idea that modules 1 and 2 may learn to locate objects and module 3 can learn to reason about object locations independently of their identities. To understand which of the two differences is responsible for the superior generalization, we compare the performance of the NMN-Tree, NMN-Chain and NMNChain-Shortcut models (see Figure 1). These 3 versions of NMN are similar in that none of them are using a language encoder, but they differ in how the modules are connected. The results in Figure 3 show that for both Find and Residual module architectures, using a tree layout is absolutely crucial (and sufficient) for generalization, meaning that the generalization gap between NMN-Tree and generic models can not be explained merely by the language encoding step in the latter. In particular, NMN-Chain models perform barely above random chance, doing even worse than generic models on the #rhs/lhs $^ { = 1 }$ version of the dataset and dramatically failing even on the easiest #rhs/lhs ${ } _ { = 1 8 }$ split. This is in stark contrast with NMN-Tree models that exhibits nearly perfect performance on the hardest #rhs/lh $^ { = 1 }$ split. As a sanity check we train NMN-Chain models on the vanilla #rhs/lhs ${ } = 3 5$ split. We find that NMN-Chain has little difficulty learning to answer SQOOP questions when it sees all of them at training time, even though it previously shows poor generalization when testing on unseen examples. Interestingly, NMN-Chain-Shortcut performs much better than NMN-Chain and quite similarly to generic models. We find it remarkable that such a slight change in the model layout as adding shortcut connections from image features $h _ { x }$ to the modules results in a drastic change in generalization performance. In an attempt to understand why NMN-Chain generalizes so poorly we compare the test set responses of the 5 NMN-Chain models trained on #rhs/lhs $^ { = 1 }$ split. Notably, there was very little agreement between predictions of these 5 runs (Fleiss $\\kappa = 0 . 0 5$ ), suggesting that NMN-Chain performs rather randomly outside of the training set. ",
+        "bbox": [
+            174,
+            705,
+            825,
+            900
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/3cdad88a68b9415ad79acd4f7060ea7047809e513858bf6df356b6913893c125.jpg",
+        "image_caption": [
+            "Figure 3: Top: Comparing the performance of generic models on datasets of varying difficulty (lower #rhs/lhs is more difficult). Note that NMN-Tree generalizes perfectly on the hardest #rhs/lhs $^ { \\dag = 1 }$ version of SQOOP, whereas MAC and FiLM fail to solve completely even the easiest #rhs/lhs ${ \\it \\Omega } = 1 8$ version. Bottom: Comparing NMNs with different layouts and modules. We can clearly observe the superior generalization of NMN-Tree, poor generalization of NMN-Chain and mediocre generalization of NMN-Chain-Shortcut. Means and standard deviations after at least 5 runs are reported. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            102,
+            821,
+            440
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            577,
+            825,
+            743
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 CAN THE RIGHT KIND OF NMN BE INDUCED? ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            760,
+            540,
+            773
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The strong generalization of the NMN-Tree is impressive, but a significant amount of prior knowledge about the task was required to come up with the successful layout and parametrization used in this model. We therefore investigate whether the amount of such prior knowledge can be reduced by fixing one of these structural aspects and inducing the other. ",
+        "bbox": [
+            174,
+            786,
+            823,
+            842
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3.1 LAYOUT INDUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            858,
+            372,
+            871
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In our layout induction experiments, we use the Stochastic N2NMN model which treats the layout as a stochastic latent variable with two values ( $T _ { t r e e }$ and $T _ { c h a i n }$ , see Section 3.2 for details). We experiment with N2NMNs using both Find and Residual modules and report results with different initial conditions, $p _ { 0 } ( t r e e ) \\in 0 . 1 , 0 . 5 , 0 . 9$ . We believe that the initial probability $p _ { 0 } ( t r e e ) = 0 . 1$ should not be considered small, since in more challenging datasets the space of layouts would be exponentially large, and sampling the right layout in $10 \\%$ of all cases should be considered a very lucky initialization. We repeat all experiments on #rhs/lhs $^ { = 1 }$ and on #rhs/lhs ${ \\it \\Omega } = 1 8$ splits, the former to study generalization, and the latter to control whether the failures on #rhs/lhs $^ { - 1 }$ are caused specifically by the difficulty of this split. The results (see Table 1) show that the success of layout induction (i.e. converging to a $p ( t r e e )$ close to 0.9) depends in a complex way on all the factors that we considered in our experiments. The initialization has the most influence: models initialized with $p _ { 0 } ( t r e e ) = 0 . 1$ typically do not converge to a tree (exception being experiments with Residual module on #rhs/lhs ${ } = 1 8$ , in which 3 out of 5 runs converged to a solution with a high $p ( t r e e ) )$ ). Likewise, models initialized with $p _ { 0 } ( t r e e ) = 0 . 9$ always stay in a regime with a high $p ( t r e e )$ . In the intermediate setting of $p _ { 0 } ( t r e e ) = 0 . 5$ we observe differences in behaviors for Residual and Find modules. In particular, N2NMN based on Residual modules stays spurious with $p ( t r e e ) = 0 . 5 \\pm 0 . 0 8$ when #rhs/lhs $^ { \\dag = 1 }$ , whereas N2NMN based on Find modules always converges to a tree. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/59c079636e0800b951a24de6c2ef0de6c4ad6cb384c912da8507a7dc1224bb65.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            106,
+            475,
+            210
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/e287b95b907bab018b1069114c6e8739f5d1b5bb8f48d4c6e80efdebefaddf63.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            521,
+            107,
+            800,
+            209
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/f77da1b68c45336998c67b610a6137df0a8a3a098468e2964579bba5490e1349.jpg",
+        "image_caption": [
+            "Figure 4: Learning dynamics of layout induction on 1 rhs/lhs and 18 rhs/lhs datasets using the Residual module with $p _ { 0 } ( t r e e ) =$ 0.5. All 5 runs do not learn to use the tree layout for 1 rhs/lhs, the very setting where the tree layout is necessary for generalization. ",
+            "Figure 5: Attention quality $\\kappa$ vs accuracy for Attention N2NMN models trained on different #rhs/lhs splits. We can observe that generalization is strongly associated with high $\\kappa$ for #rhs/lhs $^ { = 1 }$ , while for splits with 2 and 18 rhs/lhs blurry attention may be sufficient. ",
+            "Figure 6: An example of how attention weights of modules 1 (left), 2 (middle), and 3 (right) evolve during training of an Attention N2NMN model on the 18 rhs/lhs version of SQOOP. Modules 1 and 2 learn to focus on different objects words, X and $\\mathrm { Y }$ respectively in this example, but they also assign high weight to the relation word R. Module 3 learns to focus exclusively on R. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            313,
+            820,
+            411
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            510,
+            825,
+            704
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "One counterintuitive result in Table 1 is that for the Stochastic N2NMNs with Residual modules, trained with $p _ { 0 } ( t r e e ) = 0 . 5$ and #rhs/lhs $^ { = 1 }$ , make just $1 . 6 4 { \\pm } 1 . 7 9 \\%$ test error despite never resolving the layout uncertainty through training $( p _ { 2 0 0 K } ( t r e e ) = 0 . 5 6 \\pm 0 . 0 6 )$ . We offer an investigation of this result in Appendix C. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            767
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3.2 PARAMETRIZATION INDUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            786,
+            446,
+            801
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Next, we experiment with the Attention N2NMN model (see Section 3.2) in which the parametrization is learned for each module as an attention-weighted average of word embeddings. In these experiments, we fix the layout to be tree-like and sample the pre-softmax attention weights $\\tilde { \\alpha }$ from a uniform distribution $U [ 0 ; 1 ]$ . As in the layout induction investigations, we experiment with several SQOOP splits, namely we try #rhs/lhs $\\ r \\in \\{ 1 , 2 , 1 8 \\}$ . The results (reported in Table 2) show that Attention N2NMN fails dramatically on #rhs/lhs=1 but quickly catches up as soon as #rhs/lhs is increased to 2. Notably, 9 out of 10 runs on #rhs/lhs $^ { = 2 }$ result in almost perfect performance, and 1 run completely fails to generalize ( $2 6 \\%$ error rate), resulting in a high $8 . 1 8 \\%$ variance of the mean error rate. All 10 runs on the split with 18 rhs/lhs generalize flawlessly. Furthermore, we inspect the learned attention weights and find that for typical successful runs, module 3 focuses on the relation word, whereas modules 1 and 2 focus on different object words (see Figure 6) while still focusing on the relation word. To better understand the relationship between successful layout induction and generalization, we define an attention quality metric $\\begin{array} { r } { \\kappa = \\operatorname* { m i n } _ { w \\in \\{ X , Y \\} } \\operatorname* { m a x } _ { k \\in 1 , 2 } \\alpha _ { k , w } / ( 1 - \\alpha _ { k , R } ) } \\end{array}$ . Intuitively, $\\kappa$ is large when for each word $w \\in X , Y$ there is a module $i$ that focuses mostly on this word. The renormalization by $1 / ( 1 - \\alpha _ { k , R } )$ is necessary to factor out the amount of attention that modules 1 and 2 assign to the relation word. For the ground-truth parametrization that we use for NMN-Tree $\\kappa$ takes a value of 1, and if both modules 1 and 2 focus on X, completely ignoring Y, $\\kappa$ equals 0. The scatterplot of the test error rate versus $\\kappa$ (Figure 5) shows that for #rhs/lhs $^ { = 1 }$ high generalization is strongly associated with higher $\\kappa$ , meaning that it is indeed necessary to have different modules strongly focusing on different object words in order to generalize in this most challenging setting. Interestingly, for #rhs/lhs $^ { = 2 }$ we see a lot of cases where N2NMN generalizes well despite attention being rather spurious $( \\kappa \\approx 0 . 6 $ ). ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/4fd68d02c2a0a478812b806fac0e7f8c4f42965f95d3c902a90f2e85b76aa1d4.jpg",
+        "table_caption": [
+            "Table 1: Tree layout induction results for Stochastic N2NMNs using Residual and Find modules on 1 rhs/lhs and 18 rhs/lhs datasets. For each setting of $p _ { 0 } ( t r e e )$ we report results after 5 runs. $p _ { 2 0 0 K } ( t r e e )$ is the probability of using a tree layout after 200K training iterations. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>module</td><td>#rhs/lhs</td><td>po(tree)</td><td>Test error rate (%)</td><td>Test loss</td><td>p200k(tree)</td></tr><tr><td rowspan=\"5\">Residual</td><td rowspan=\"3\">1</td><td>0.1</td><td>31.89 ± 0.75</td><td>0.64±0.03</td><td>0.08±0.01</td></tr><tr><td>0.5</td><td>1.64 ± 1.79</td><td>0.27 ± 0.04</td><td>0.56 ±0.06</td></tr><tr><td>0.9</td><td>0.16 ± 0.11</td><td>0.03 ±0.01</td><td>0.96 ±0.00</td></tr><tr><td rowspan=\"3\">18</td><td>0.1</td><td>3.99 ± 5.33</td><td>0.15 ±0.06</td><td>0.59±0.34</td></tr><tr><td>0.5</td><td>0.19 ±0.11</td><td>0.06±0.02</td><td>0.99 ±0.01</td></tr><tr><td>0.9</td><td>0.12 ±0.12</td><td>0.01 ±0.00</td><td>1.00 ± 0.00</td></tr><tr><td rowspan=\"5\">Find</td><td rowspan=\"3\">1</td><td>0.1</td><td>47.54± 0.95</td><td>1.78 ± 0.47</td><td>0.00±0.00</td></tr><tr><td>0.5</td><td>0.78 ±0.52</td><td>0.05 ± 0.04</td><td>0.94±0.07</td></tr><tr><td>0.9</td><td>0.41 ± 0.07</td><td>0.02±0.00</td><td>1.00 ±0.00</td></tr><tr><td rowspan=\"3\">18</td><td>0.1</td><td>5.11 ± 1.19</td><td>0.14±0.03</td><td>0.02±0.04</td></tr><tr><td>0.5</td><td>0.17 ± 0.16</td><td>0.01±0.01</td><td>1.00 ±0.00</td></tr><tr><td>0.9</td><td>0.11 ± 0.03</td><td>0.00±0.00</td><td>1.00 ± 0.00</td></tr></table>",
+        "bbox": [
+            241,
+            154,
+            756,
+            319
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/80b74d23e521d766ad6bada973929ec6dc33f45f76422f4961c7d835af95c2c3.jpg",
+        "table_caption": [
+            "Table 2: Parameterization induction results for 1,2,18 rhs/lhs datasets for Attention N2NMN. The model does not generalize well in the difficult 1 rhs/lhs setting. Results for MAC are presented for comparison. Means and standard deviations were estimated based on at least 10 runs. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>#rhs/lhs</td><td>Test error rate (%)</td><td>Test loss (%)</td></tr><tr><td>AttentionN2NMN</td><td>1</td><td>27.19±16.02</td><td>1.22 ± 0.71</td></tr><tr><td>Attention N2NMN</td><td>2</td><td>2.82 ±8.18</td><td>0.14 ± 0.41</td></tr><tr><td>Attention N2NMN</td><td>18</td><td>0.16 ± 0.12</td><td>0.00±0.00</td></tr><tr><td>MAC</td><td>1</td><td>13.67± 9.97</td><td>0.41 ± 0.32</td></tr><tr><td>MAC</td><td>2</td><td>9.21 ± 4.31</td><td>0.28 ± 0.15</td></tr><tr><td>MAC</td><td>18</td><td>0.53 ± 0.74</td><td>0.01 ±0.02</td></tr></table>",
+        "bbox": [
+            290,
+            386,
+            707,
+            478
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            503,
+            825,
+            699
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In order to put Attention N2NMN results in context we compare them to those of MAC (see Table 2). Such a comparison can be of interest because both models perform attention over the question. For 1 rhs/lhs MAC seems to be better on average, but as we increase #rhs/lhs to 2 we note that Attention N2NMN succeeds in 9 out of 10 cases on the #rhs/lh $^ { \\circ 2 }$ split, much more often than 1 success out of 10 observed for $\\mathbf { M A C }$ . This result suggests that Attention N2NMNs retains some of the strong generalization potential of NMNs with hard-coded parametrization. ",
+        "bbox": [
+            174,
+            705,
+            825,
+            790
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            810,
+            344,
+            827
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The notion of systematicity was originally introduced by (Fodor & Pylyshyn, 1988) as the property of human cognition whereby “the ability to entertain a given thought implies the ability to entertain thoughts with semantically related contents”. They illustrate this with an example that no English speaker can understand the phrase “John loves the girl” without being also able to understand the phrase “the girl loves John”. The question of whether or not connectionist models of cognition can account for the systematicity phenomenon has been a subject of a long debate in cognitive science (Fodor & Pylyshyn, 1988; Smolensky, 1987; Marcus, 1998; 2003; Calvo & Colunga, 2003). Recent research has shown that lack of systematicity in the generalization is still a concern for the modern seq2seq models (Lake & Baroni, 2018; Bastings et al., 2018; Loula et al., 2018). Our findings about the weak systematic generalization of generic VQA models corroborate the aforementioned seq2seq results. We also go beyond merely stating negative generalization results and showcase the high systematicity potential of adding explicit modularity and structure to modern deep learning models. ",
+        "bbox": [
+            174,
+            843,
+            825,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Besides the theoretical appeal of systematicity, our study is inspired by highly related prior evidence that when trained on downstream language understanding tasks, neural networks often generalize poorly and latch on to dataset-specific regularities. Agrawal et al. (2016) report how neural models exploit biases in a VQA dataset, e.g. responding “snow” to the question “what covers the ground” regardless of the image because “snow” is the most common answer to this question. Gururangan et al. (2018) report that many successes in natural language entailment are actually due to exploiting statistical biases as opposed to solving entailment, and that state-of-the-art systems are much less performant when tested on unbiased data. Jia & Liang (2017) demonstrate that seemingly state-ofthe-art reading comprehension system can be misled by simply appending an unrelated sentence that resembles the question to the document. ",
+        "bbox": [
+            174,
+            236,
+            825,
+            375
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Using synthetic VQA datasets to study grounded language understanding is a recent trend started by the CLEVR dataset (Johnson et al., 2016). CLEVR images are 3D-rendered and CLEVR questions are longer and more complex than ours, but in the associated generalization split CLEVR-CoGenT the training and test distributions of images are different. In our design of SQOOP we aimed instead to minimize the difference between training and test images to make sure that we test a model’s ability to interpret unknown combinations of known words. The ShapeWorld family of datasets by Kuhnle & Copestake (2017) is another synthetic VQA platform with a number of generalization tests, but none of them tests SQOOP-style generalization of relational reasoning to unseen object pairs. Most closely related to our work is the recent study of generalization to long-tail questions about rare objects done by Bingham et al. (2017). They do not, however, consider as many models as we do and do not study the question of whether the best-performing models can be made end-to-end. ",
+        "bbox": [
+            174,
+            382,
+            825,
+            535
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The key paradigm that we test in our experiments is Neural Module Networks (NMN). Andreas et al. (2016) introduced NMNs as a modular, structured VQA model where a fixed number of handcrafted neural modules (such as Find, or Compare) are chosen and composed together in a layout determined by the dependency parse of the question. Andreas et al. (2016) show that the modular structure allows answering questions that are longer than the training ones, a kind of generalization that is complementary to the one we study here. Hu et al. (2017) and Johnson et al. (2017) followed up by making NMNs end-to-end, removing the non-differentiable parser. Both Hu et al. (2017) and Johnson et al. (2017) reported that several thousands of ground-truth layouts are required to pretrain the layout predictor in order for their approaches to work. In a recent work, Hu et al. (2018) attempt to soften the layout decisions, but training their models end-to-end from scratch performed substantially lower than best models on the CLEVR task. Gupta & Lewis (2018) report successful layout induction on CLEVR for a carefully engineered heterogeneous NMN that takes a scene graph as opposed to a raw image as the input. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            722
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION AND DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            750,
+            468,
+            765
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have conducted a rigorous investigation of an important form of systematic generalization required for grounded language understanding: the ability to reason about all possible pairs of objects despite being trained on a small subset of such pairs. Our results allow one to draw two important conclusions. For one, the intuitive appeal of modularity and structure in designing neural architectures for language understanding is now supported by our results, which show how a modular model consisting of general purpose residual blocks generalizes much better than a number of baselines, including architectures such as MAC, FiLM and RelNet that were designed specifically for visual reasoning. While this may seem unsurprising, to the best of our knowledge, the literature has lacked such a clear empirical evidence in favor of modular and structured networks before this work. Importantly, we have also shown how sensitive the high performance of the modular models is to the layout of modules, and how a tree-like structure generalizes much stronger than a typical chain of layers. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Our second key conclusion is that coming up with an end-to-end and/or soft version of modular models may be not sufficient for strong generalization. In the very setting where strong generalization is required, end-to-end methods often converge to a different, less compositional solution (e.g. a chain layout or blurred attention). This can be observed especially clearly in our NMN layout and parametrization induction experiments on the #rhs/lhs $^ { = 1 }$ version of SQOOP, but notably, strong initialization sensitivity of layout induction remains an issue even on the #rhs/lhs ${ } _ { = 1 8 }$ split. This conclusion is relevant in the view of recent work in the direction of making NMNs more end-toend (Suarez et al., 2018; Hu et al., 2018; Hudson & Manning, 2018; Gupta & Lewis, 2018). Our findings suggest that merely replacing hard-coded components with learnable counterparts can be insufficient, and that research on regularizers or priors that steer the learning towards more systematic solutions can be required. That said, our parametrization induction results on the #rhs/lhs $^ { = 2 }$ split are encouraging, as they show that compared to generic models, a weaker nudge (in the form of a richer training signal or a prior) towards systematicity may suffice for end-to-end NMNs. ",
+        "bbox": [
+            174,
+            140,
+            825,
+            319
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "While our investigation has been performed on a synthetic dataset, we believe that it is the realworld language understanding where our findings may be most relevant. It is possible to construct a synthetic dataset that is bias-free and that can only be solved if the model has understood the entirety of the dataset’s language. It is, on the contrary, much harder to collect real-world datasets that do not permit highly dataset-specific solutions, as numerous dataset analysis papers of recent years have shown (see Section 5 for a review). We believe that approaches that can generalize strongly from imperfect and biased data will likely be required, and our experiments can be seen as a simulation of such a scenario. We hope, therefore, that our findings will inform researchers working on language understanding and provide them with a useful intuition about what facilitates strong generalization and what is likely to inhibit it. ",
+        "bbox": [
+            174,
+            327,
+            825,
+            465
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            486,
+            366,
+            501
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We thank Maxime Chevalier-Boisvert, Yoshua Bengio and Jacob Andreas for useful discussions. This research was enabled in part by support provided by Compute Canada (www.computecanada.ca), NSERC, Canada Research Chairs and Microsoft Research. We also thank Nvidia for donating NVIDIA DGX-1 used for this research. ",
+        "bbox": [
+            174,
+            517,
+            825,
+            571
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            593,
+            285,
+            608
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aishwarya Agrawal, Dhruv Batra, and Devi Parikh. Analyzing the Behavior of Visual Question Answering Models. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, January 2016.   \nJacob Andreas, Marcus Rohrbach, Trevor Darrell, and Dan Klein. Neural Module Networks. In Proceedings of 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016. URL http://arxiv.org/abs/1511.02799.   \nDzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural Machine Translation by Jointly Learning to Align and Translate. In Proceedings of the 2015 International Conference on Learning Representations, 2015.   \nJoost Bastings, Marco Baroni, Jason Weston, Kyunghyun Cho, and Douwe Kiela. Jump to better conclusions: SCAN both left and right. In Proceedings of the 2018 EMNLP Workshop BlackboxNLP: Analyzing and Interpreting Neural Networks for NLP, pp. 47–55, Brussels, Belgium, November 2018. Association for Computational Linguistics. URL https://www.aclweb. org/anthology/W18-5407.   \nEli Bingham, Piero Molino, Paul Szerlip, Obermeyer Fritz, and Goodman Noah. Characterizing how Visual Question Answering scales with the world. In NIPS 2017 Visually-Grounded Interaction and Language Workshop, 2017.   \nFrancisco Calvo and Eliana Colunga. The statistical brain: Reply to Marcus The algebraic mind. In Proceedings of the Annual Meeting of the Cognitive Science Society, volume 25, 2003. ",
+        "bbox": [
+            171,
+            613,
+            825,
+            929
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jerry A. Fodor and Zenon W. Pylyshyn. Connectionism and cognitive architecture: A critical analysis. Cognition, 28(1):3–71, 1988. ",
+        "bbox": [
+            171,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alexander L. Gaunt, Marc Brockschmidt, Nate Kushman, and Daniel Tarlow. Differentiable Programs with Neural Libraries. In Proceedings of the 34th International Conference on Machine Learning, November 2016. URL http://arxiv.org/abs/1611.02109. arXiv: 1611.02109. ",
+        "bbox": [
+            173,
+            141,
+            825,
+            196
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yichen Gong, Heng Luo, and Jian Zhang. Natural Language Inference over Interaction Space. In Proceedings of the 2018 International Conference on Learning Representations, 2017. URL http://arxiv.org/abs/1709.04348. arXiv: 1709.04348. ",
+        "bbox": [
+            173,
+            205,
+            823,
+            248
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nitish Gupta and Mike Lewis. Neural Compositional Denotational Semantics for Question Answering. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing. Association for Computational Linguistics, 2018. URL http://aclweb.org/ anthology/D18-1239. ",
+        "bbox": [
+            173,
+            257,
+            825,
+            314
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Suchin Gururangan, Swabha Swayamdipta, Omer Levy, Roy Schwartz, Samuel R. Bowman, and Noah A. Smith. Annotation Artifacts in Natural Language Inference Data. In Proceedings of NAACL-HLT 2018, March 2018. URL http://arxiv.org/abs/1803.02324. arXiv: 1803.02324. ",
+        "bbox": [
+            173,
+            321,
+            826,
+            378
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2016. ",
+        "bbox": [
+            173,
+            387,
+            825,
+            429
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ronghang Hu, Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Kate Saenko. Learning to Reason: End-to-End Module Networks for Visual Question Answering. In Proceedings of 2017 IEEE International Conference on Computer Vision, April 2017. URL http://arxiv.org/ abs/1704.05526. arXiv: 1704.05526. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            494
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ronghang Hu, Jacob Andreas, Trevor Darrell, and Kate Saenko. Explainable Neural Computation via Stack Neural Module Networks. In Proceedings of 2018 European Conference on Computer Vision, July 2018. URL http://arxiv.org/abs/1807.08556. arXiv: 1807.08556. ",
+        "bbox": [
+            174,
+            503,
+            823,
+            547
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Drew A. Hudson and Christopher D. Manning. Compositional Attention Networks for Machine Reasoning. In Proceedings of the 2018 International Conference on Learning Representations, February 2018. URL https://openreview.net/forum?id=S1Euwz-Rb. ",
+        "bbox": [
+            176,
+            555,
+            825,
+            598
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift. In Proceedings of the 32nd International Conference on Machine Learning, ICML 2015, Lille, France, 6-11 July 2015, pp. 448–456, 2015. URL http: //jmlr.org/proceedings/papers/v37/ioffe15.html. ",
+        "bbox": [
+            173,
+            607,
+            825,
+            664
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Robin Jia and Percy Liang. Adversarial Examples for Evaluating Reading Comprehension Systems. Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pp. 2021–2031, 2017. doi: 10.18653/v1/D17-1215. URL https://aclanthology.coli. uni-saarland.de/papers/D17-1215/d17-1215. ",
+        "bbox": [
+            173,
+            671,
+            825,
+            728
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yu Jiang, Vivek Natarajan, Xinlei Chen, Marcus Rohrbach, Dhruv Batra, and Devi Parikh. Pythia v0.1: The winning entry to the vqa challenge 2018. https://github.com/ facebookresearch/pythia, 2018. ",
+        "bbox": [
+            174,
+            737,
+            825,
+            780
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Li Fei-Fei, C. Lawrence Zitnick, and Ross Girshick. CLEVR: A Diagnostic Dataset for Compositional Language and Elementary Visual Reasoning. In Proceedings of 2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), December 2016. URL http://arxiv.org/abs/1612.06890. arXiv: 1612.06890. ",
+        "bbox": [
+            173,
+            789,
+            825,
+            858
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Judy Hoffman, Li Fei-Fei, C. Lawrence Zitnick, and Ross Girshick. Inferring and Executing Programs for Visual Reasoning. In Proceedings of 2017 IEEE International Conference on Computer Vision, 2017. URL http: //arxiv.org/abs/1705.03633. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            922
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Anjuli Kannan, Karol Kurach, Sujith Ravi, Tobias Kaufmann, Andrew Tomkins, Balint Miklos, Greg Corrado, Laszlo Lukacs, Marina Ganea, Peter Young, and Vivek Ramavajjala. Smart Reply: Automated Response Suggestion for Email. In Proceedings of the 22Nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’16, pp. 955–964, New York, NY, USA, 2016. ACM. ISBN 978-1-4503-4232-2. doi: 10.1145/2939672.2939801. URL http://doi.acm.org/10.1145/2939672.2939801. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. Adam: A Method for Stochastic Optimization. In Proceedings of the 2015 International Conference on Learning Representations, 2015. URL http://arxiv. org/abs/1412.6980. arXiv: 1412.6980. ",
+        "bbox": [
+            174,
+            194,
+            821,
+            236
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Alexander Kuhnle and Ann Copestake. ShapeWorld - A new test methodology for multimodal language understanding. arXiv:1704.04517 [cs], April 2017. URL http://arxiv.org/ abs/1704.04517. arXiv: 1704.04517. ",
+        "bbox": [
+            174,
+            243,
+            823,
+            286
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Brenden M. Lake and Marco Baroni. Generalization without systematicity: On the compositional skills of sequence-to-sequence recurrent networks. In Proceedings of the 36th International Conference on Machine Learning, 2018. URL http://arxiv.org/abs/1711.00350. arXiv: 1711.00350. ",
+        "bbox": [
+            173,
+            292,
+            825,
+            348
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Joao Loula, Marco Baroni, and Brenden M. Lake. Rearranging the Familiar: Testing Compositional Generalization in Recurrent Networks. In Proceedings of the 2018 BlackboxNLP EMNLP Workshop, July 2018. URL https://arxiv.org/abs/1807.07545. ",
+        "bbox": [
+            173,
+            357,
+            821,
+            400
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Mateusz Malinowski and Mario Fritz. A Multi-world Approach to Question Answering About Realworld Scenes Based on Uncertain Input. In Proceedings of the 27th International Conference on Neural Information Processing Systems, NIPS’14, pp. 1682–1690, Cambridge, MA, USA, 2014. MIT Press. URL http://dl.acm.org/citation.cfm?id=2968826.2969014. ",
+        "bbox": [
+            173,
+            406,
+            825,
+            463
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Gary F. Marcus. Rethinking Eliminative Connectionism. Cognitive Psychology, 37(3):243–282, December 1998. ISSN 0010-0285. doi: 10.1006/cogp.1998.0694. URL http://www. sciencedirect.com/science/article/pii/S0010028598906946. ",
+        "bbox": [
+            173,
+            469,
+            825,
+            512
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Gary F. Marcus. The algebraic mind: Integrating connectionism and cognitive science. MIT press, 2003. ",
+        "bbox": [
+            173,
+            520,
+            823,
+            547
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ethan Perez, Florian Strub, Harm de Vries, Vincent Dumoulin, and Aaron Courville. FiLM: Visual Reasoning with a General Conditioning Layer. In In Proceedings of the 2017 AAAI Conference on Artificial Intelligence, 2017. URL http://arxiv.org/abs/1709.07871. ",
+        "bbox": [
+            174,
+            554,
+            823,
+            598
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Adam Santoro, David Raposo, David G. T. Barrett, Mateusz Malinowski, Razvan Pascanu, Peter Battaglia, and Timothy Lillicrap. A simple neural network module for relational reasoning. In Advances in Neural Information Processing Systems 31, June 2017. URL http://arxiv. org/abs/1706.01427. arXiv: 1706.01427. ",
+        "bbox": [
+            173,
+            604,
+            825,
+            660
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Paul Smolensky. The constituent structure of connectionist mental states: A reply to Fodor and Pylyshyn. Southern Journal of Philosophy, 26(Supplement):137–161, 1987. ",
+        "bbox": [
+            169,
+            667,
+            823,
+            696
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Joseph Suarez, Justin Johnson, and Fei-Fei Li. DDRprog: A CLEVR Differentiable Dynamic Reasoning Programmer. arXiv:1803.11361 [cs], March 2018. URL http://arxiv.org/abs/ 1803.11361. arXiv: 1803.11361. ",
+        "bbox": [
+            173,
+            703,
+            823,
+            746
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to Sequence Learning with Neural Networks. In Advances in Neural Information Processing Systems 27, pp. 3104–3112, 2014. ",
+        "bbox": [
+            168,
+            752,
+            821,
+            782
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Wei Wang, Ming Yan, and Chen Wu. Multi-Granularity Hierarchical Attention Fusion Networks for Reading Comprehension and Question Answering. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 1705–1714, Melbourne, Australia, 2018. Association for Computational Linguistics. URL http://aclweb.org/anthology/P18-1158. ",
+        "bbox": [
+            174,
+            789,
+            823,
+            858
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, and others. Google’s Neural Machine Translation System: Bridging the Gap between Human and Machine Translation. arXiv preprint arXiv:1609.08144, 2016. ",
+        "bbox": [
+            176,
+            866,
+            825,
+            921
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A EXPERIMENT DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            400,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We trained all models by minimizing the cross entropy loss $\\log p ( y | x , q )$ on the training set, where $y ~ \\in ~ \\{ \\mathrm { y e s } , \\mathrm { n o } \\}$ is the correct answer, $x$ is the image, $q$ is the question. In all our experiments we used the Adam optimizer (Kingma & Ba, 2015) with hyperparameters $\\alpha = 0 . 0 0 0 1$ , $\\bar { \\beta } _ { 1 } = 0 . 9$ , $\\beta _ { 2 } = 0 . 9 9 9$ , $\\epsilon = 1 0 ^ { - \\mathrm { { 1 0 } } }$ . We continuously monitored validation set performance of all models during training, selected the best one and reported its performance on the test set. The number of training iterations for each model was selected in preliminary investigations based on our observations of how long it takes for different models to converge. This information, as well as other training details, can be found in Table 3. ",
+        "bbox": [
+            173,
+            133,
+            825,
+            246
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/f4d37e0d731c648b962d6b00caa60056d9815c351c5215b0f365e945b0fb4209.jpg",
+        "table_caption": [
+            "Table 3: Training details for all models. The subsampling factor is the ratio between the original spatial dimensions of the input image and those of the representation produced by the stem. It is effectively equal to $2 ^ { k }$ , where $k$ is the number of $2 \\mathrm { x 2 }$ max-pooling operations in the stem. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>model</td><td>stem layers</td><td>subsampling factor</td><td>iterations</td><td>batch size</td></tr><tr><td>FiLM</td><td>6</td><td>4</td><td>200000</td><td>64</td></tr><tr><td>MAC</td><td>6</td><td>4</td><td>100000</td><td>128</td></tr><tr><td>Conv+LSTM</td><td>6</td><td>4</td><td>200000</td><td>128</td></tr><tr><td>RelNet</td><td>8</td><td>8</td><td>500000</td><td>64</td></tr><tr><td>NMN (Residual)</td><td>6</td><td>4</td><td>50000</td><td>64</td></tr><tr><td>NMN (Find)</td><td>6</td><td>4</td><td>200000</td><td>64</td></tr><tr><td>Stochastic NMN (Residual)</td><td>6</td><td>4</td><td>200000</td><td>64</td></tr><tr><td>Stochastic NMN (Find)</td><td>6</td><td>4</td><td>200000</td><td>64</td></tr><tr><td>Attention NMN (Find)</td><td>6</td><td>4</td><td>50000</td><td>64</td></tr></table>",
+        "bbox": [
+            192,
+            313,
+            800,
+            455
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B ADDITIONAL RESULTS FOR MAC MODEL ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            484,
+            557,
+            501
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We performed an ablation study in which we varied the number of MAC units, the model dimensionality and the level of weight decay for the MAC model. The results can be found in Table 4. ",
+        "bbox": [
+            174,
+            517,
+            823,
+            559
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/aaaa009637e331e84162b69828c687a8f8d13b6637d84165580c088cd6484ba3.jpg",
+        "table_caption": [
+            "Table 4: Results of an ablation study for MAC. The default model has 12 MAC units of dimensionality 128 and uses no weight decay. For each experiment we report means and standard deviations based on 5 repetitions. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>model</td><td>#rhs/lhs</td><td>train error rate(%)</td><td>test error rate (%)</td></tr><tr><td>default</td><td>1</td><td>0.17± 0.21</td><td>13.67 ± 9.97</td></tr><tr><td>1 unit</td><td>1</td><td>0.27 ± 0.35</td><td>28.67 ± 1.91</td></tr><tr><td>2 units</td><td>1</td><td>0.23 ± 0.13</td><td>24.28 ± 2.05</td></tr><tr><td>3units</td><td>1</td><td>0.16 ±0.15</td><td>26.47 ± 1.12</td></tr><tr><td>6units</td><td>1</td><td>0.18 ±0.17</td><td>20.84± 5.56</td></tr><tr><td>24 units</td><td>1</td><td>0.04± 0.05</td><td>9.11 ± 7.67</td></tr><tr><td>dim. 64</td><td>1</td><td>0.27 ± 0.33</td><td>23.61 ± 6.27</td></tr><tr><td>dim. 256</td><td>1</td><td>0.00 ±0.00</td><td>4.62 ± 5.07</td></tr><tr><td>dim. 512</td><td>1</td><td>0.02 ±0.04</td><td>8.37 ± 7.45</td></tr><tr><td>weight decay 0.00001</td><td>1</td><td>0.20 ±0.23</td><td>19.21 ± 9.27</td></tr><tr><td>weight decay 0.0001</td><td></td><td>1.00 ± 0.54</td><td>31.19 ± 0.87</td></tr><tr><td>weight decay 0.001</td><td></td><td>40.55 ± 1.35</td><td>45.11 ± 0.74</td></tr></table>",
+        "bbox": [
+            243,
+            625,
+            756,
+            809
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We also perform qualitative investigations to understand the high variance in MAC’s performance. In particular, we focus on control attention weights $( c )$ for each run and aim to understand if runs that generalize have clear differences when compared to runs that failed. Interestingly, we observe that in successful runs each word $w \\in \\mathrm { X }$ , Y has a unit that is strongly focused on it. To present our observations in quantitative terms, we plot attention quality $\\begin{array} { r } { \\kappa = \\operatorname* { m i n } _ { w \\in \\{ X , Y \\} } \\operatorname* { m a x } _ { k \\in [ 1 ; 1 2 ] } } \\end{array}$ $\\alpha _ { k , w } / ( 1 - \\alpha _ { k , R } )$ , where $\\alpha$ are control scores vs accuracy in Figure 7 for each run (see Section 4.3.2 for an explanation of $\\kappa$ ). We can clearly see a positive correlation between $\\kappa$ and error rate, especially for low #rhs/lhs. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/b17fd2a3fccb5785bed74fbb94af302295cb1a6524c63aab5f7015046190a9ea.jpg",
+        "image_caption": [
+            "Figure 7: Model test accuracy vs $\\kappa$ for the MAC model on different versions of SQOOP. All experiments are run 10 times with different random seeds. We can observe a clear correlation between $\\kappa$ and error rate for 1, 2 and 4 rhs/lhs. Also note that perfect generalization is always associated with $\\kappa$ close to 1. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            113,
+            790,
+            652
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Next, we experiment with a hard-coded variation of MAC. In this model, we use hard-coded control scores such that given a SQOOP question X R Y, the first half of all modules focuses on X while the second half focuses on Y. The relationship between MAC and hardcoded MAC is similar to that between NMN-Tree and end-to-end NMN with parameterization induction. However, this model has not performed as well as the successful runs of MAC. We hypothesize that this could be due to the interactions between the control scores and the visual attention part of the model. ",
+        "bbox": [
+            174,
+            755,
+            825,
+            839
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "C INVESTIGATION OF CORRECT PREDICTIONS WITH SPURIOUS LAYOUTS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            862,
+            799,
+            878
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In Section 4.3.1 we observed that an NMN with the Residual module can answer test questions with a relative low error rate of $1 . 6 4 \\pm 1 . 7 9 \\%$ , despite being a mixture of a tree and a chain (see results in Table 1, $p _ { 0 } ( t r e e ) = 0 . 5 )$ . Our explanation for this phenomenon is as follows: when connected in a tree, modules of such spurious models generalize well, and when connected as a chain they generalize poorly. The output distribution of the whole model is thus a mixture of the mostly correct $p ( y | T \\stackrel { } { = } T _ { t r e e } , x , q )$ and mostly random $p ( y | T = T _ { c h a i n } , x , q )$ . We verify our reasoning by explicitly evaluating test accuracies for $p ( y | T = T _ { t r e e } , x , q )$ and $p ( y | T = T _ { c h a i n } , x , q )$ , and find them to be around $9 9 \\%$ and $6 0 \\%$ respectively, confirming our hypothesis. As a result the predictions of the spurious models with $p ( t r e e ) \\approx 0 . 5$ have lower confidence than those of sharp tree models, as indicated by the high log loss of $0 . 2 7 \\pm 0 . 0 4$ . We visualize the progress of structure induction for the Residual module with $p _ { 0 } ( t r e e ) = 0 . 5$ in Figure 4 which shows how $p ( t r e e )$ saturates to 1.0 for #rhs/lhs ${ } = 1 8$ and remains around 0.5 when #rhs/lhs $^ { = 1 }$ . ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "D SQOOP PSEUDOCODE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            262,
+            400,
+            280
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Pseudocode for creating SQOOP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            303,
+            478,
+            318
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "1: $S \\gets \\{ \\mathrm { A , B , C , \\dots , Z , 0 , 1 , 2 , 3 , \\dots , 9 } \\}$   \n2: Rel ← {LEFT-OF, RIGHT-OF, ABOVE, BELOW} . relations   \n3: function CREATESQOOP(k)   \n4: T rainQuestions ← []   \n5: AllQuestions ← []   \n6: for all $X$ in $S$ do   \n7: AllRhs ← RandomSample $( S \\setminus \\{ X \\} , \\mathbf { k } )$ $\\triangleright$ sample without replacement from $S \\setminus \\{ X \\}$   \n8: $A l l Q u e s t i o n s \\gets \\{ X \\} \\times R e l \\times ( S \\setminus \\{ X \\} ) \\cup A l l Q u e s t i o n$ s   \n9: for all $R , Y$ in $A l l R h s \\times R e l$ do   \n10: T rainQuestions $ ( X , R , Y ) \\cup T$ rainQuestions   \n11: end for   \n12: end for   \n13: T estQuestions ← AllQuestions \\ T rainQuestions   \n14: function GENERATEEXAMPLE $( X , R , Y )$   \n15: $a \\sim \\{ \\mathrm { Y e s } , \\mathrm { N o } \\}$   \n16: if $a = \\mathrm { Y e s }$ then   \n17: $I $ place $X$ and $Y$ objects so that $R$ holds $\\triangleright$ create the image   \n18: $I $ sample 3 objects from $S$ and add to $I$   \n19: else   \n20: repeat   \n21: $X ^ { \\prime } \\gets$ Sample $X ^ { \\prime }$ from $S \\setminus \\{ X \\}$   \n22: $Y ^ { \\prime } \\gets \\boldsymbol { \\mathsf { S } }$ ample $Y ^ { \\prime }$ from $S \\backslash \\{ Y \\}$   \n23: $I $ place $X ^ { \\prime }$ and $Y$ objects so that $R$ holds . create the image   \n24: $I $ add $X$ and $Y ^ { \\prime }$ objects to $I$ so that $R$ holds   \n25: $I $ sample 1 more object from $S$ and add to $I$   \n26: until $X$ and $Y$ are not in relation $R$ in I   \n27: end if   \n28: return $I , X , R , Y , a$   \n29: end function   \n30: T rain $\\gets$ sample $ | \\underset { -- } { \\underbrace { 1 0 ^ { 6 } } } | \\underset { -- } { \\underbrace { T r a i n Q u e s t i o n s } } |$ examples for each (X,R,Y)  T rainQuestions from   \nGENERATEEXAMPLE $( X , R , Y )$   \n31: $T e s t \\gets$ sample 10 examples for each (X,R,Y)  T estQuestions from GENERATEEXAM  \n$\\mathrm { P L E } ( X , R , Y )$   \n32: end function ",
+        "bbox": [
+            173,
+            320,
+            826,
+            800
+        ],
+        "page_idx": 15
+    }
+]

parse/train/LU687itn08w/LU687itn08w.md

@@ -0,0 +1,342 @@
+# Offline RL Without Off-Policy Evaluation
+
+# David Brandfonbrener
+
+William F. Whitney
+
+Rajesh Ranganath
+
+# Joan Bruna
+
+Department of Computer Science, Center for Data Science New York University david.brandfonbrener@nyu.edu
+
+# Abstract
+
+Most prior approaches to offline reinforcement learning (RL) have taken an iterative actor-critic approach involving off-policy evaluation. In this paper we show that simply doing one step of constrained/regularized policy improvement using an on-policy Q estimate of the behavior policy performs surprisingly well. This onestep algorithm beats the previously reported results of iterative algorithms on a large portion of the D4RL benchmark. The one-step baseline achieves this strong performance while being notably simpler and more robust to hyperparameters than previously proposed iterative algorithms. We argue that the relatively poor performance of iterative approaches is a result of the high variance inherent in doing off-policy evaluation and magnified by the repeated optimization of policies against those estimates. In addition, we hypothesize that the strong performance of the one-step algorithm is due to a combination of favorable structure in the environment and behavior policy.
+
+# 1 Introduction
+
+An important step towards effective real-world RL is to improve sample efficiency. One avenue towards this goal is offline RL (also known as batch RL) where we attempt to learn a new policy from data collected by some other behavior policy without interacting with the environment. Recent work in offline RL is well summarized by Levine et al. [2020].
+
+In this paper, we challenge the dominant paradigm in the deep offline RL literature that primarily relies on actor-critic style algorithms that alternate between policy evaluation and policy improvement [Fujimoto et al., 2018a, 2019, Peng et al., 2019, Kumar et al., 2019, 2020, Wang et al., 2020b, Wu et al., 2019, Kostrikov et al., 2021, Jaques et al., 2019, Siegel et al., 2020, Nachum et al., 2019]. All these algorithms rely heavily on off-policy evaluation to learn the critic. Instead, we find that a simple baseline which only performs one step of policy improvement using the behavior Q function often outperforms the more complicated iterative algorithms. Explicitly, we find that our one-step algorithm beats prior results of iterative algorithms on most of the gym-mujoco [Brockman et al., 2016] and Adroit [Rajeswaran et al., 2017] tasks in the the D4RL benchmark suite [Fu et al., 2020].
+
+We then dive deeper to understand why such a simple baseline is effective. First, we examine what goes wrong for the iterative algorithms. When these algorithms struggle, it is often due to poor off-policy evaluation leading to inaccurate Q values. We attribute this to two causes: (1) distribution shift between the behavior policy and the policy to be evaluated, and (2) iterative error exploitation whereby policy optimization introduces bias and dynamic programming propagates this bias across the state space. We show that empirically both issues exist in the benchmark tasks and that one way to avoid these issues is to simply avoid off-policy evaluation entirely.
+
+Finally, we recognize that while the the one-step algorithm is a strong baseline, it is not always the best choice. In the final section we provide some guidance about when iterative algorithms can perform better than the simple one-step baseline. Namely, when the dataset is large and behavior policy has good coverage of the state-action space, then off-policy evaluation can succeed and iterative algorithms can be effective. In contrast, if the behavior policy is already fairly good, but as a result does not have full coverage, then one-step algorithms are often preferable.
+
+![](images/cf6e42d2a672364d97aa78052a83104499bb9082e0e6b593f15addb41a4cfc26.jpg)  
+Figure 1: A cartoon illustration of the difference between one-step and multi-step methods. All algorithms constrain themselves to a neighborhood of “safe” policies around $\beta$ . A one-step approach (left) only uses the on-policy ${ \widehat Q } ^ { \beta }$ , while a multi-step approach (right) repeatedly uses off-policy $\widehat { Q } ^ { \pi _ { i } }$ .
+
+Our main contributions are:
+
+• A demonstration that a simple baseline of one step of policy improvement outperforms more complicated iterative algorithms on a broad set of offline RL problems. • An examination of failure modes of off-policy evaluation in iterative offline RL algorithms. • A description of when one-step algorithms are likely to outperform iterative approaches.
+
+# 2 Setting and notation
+
+We will consider an offline RL setup as follows. Let $\mathcal { M } = \{ { S } , \mathcal { A } , \rho , P , R , \gamma \}$ be a discounted infinitehorizon MDP. In this work we focus on applications in continuous control, so we will generally assume that both $s$ and $\mathcal { A }$ are continuous and bounded. We consider the offline setting where rather than interacting with $\mathcal { M }$ , we only have access to a dataset $D _ { N }$ of $N$ tuples of $\left( { { s _ { i } } , { a _ { i } } , { r _ { i } } } \right)$ collected by some behavior policy $\beta$ with initial state distribution $\rho$ . Let $r ( s , a ) = \mathbb { E } _ { r \mid s , a } [ r ]$ be the expected reward. Define the state-action value function for any policy $\pi$ by $Q ^ { \pi } ( s , a ) : = \mathbb { E } _ { P , \pi | s _ { 0 } = s }$ , $\begin{array} { r } { { \bf \Gamma } _ { a _ { 0 } = a } [ \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } r ( s _ { t } , a _ { t } ) ] } \end{array}$ The objective is to maximize the expected return $J$ of the learned policy:
+
+$$
+J ( \pi ) : = \underset { \rho , P , \pi } { \mathbb { E } } \left[ \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } r ( s _ { t } , a _ { t } ) \right] = \underset { a \sim \pi | s } { \mathbb { E } } \left[ Q ^ { \pi } ( s , a ) \right] .
+$$
+
+Following $\mathrm { F u }$ et al. [2020] and others in this line of work, we allow access to the environment to tune a small $( < 1 0 )$ set of hyperparameters. See Paine et al. [2020] for a discussion of the active area of research on hyperparameter tuning for offline RL. We also discuss this further in Appendix $\textrm { C }$ .
+
+# 3 Related work
+
+Iterative algorithms. Most prior work on deep offline RL consists of iterative actor-critic algorithms. The primary innovation of each paper is to propose a different mechanism to ensure that the learned policy does not stray too far from the data generated by the behavior policy. Broadly, we group these methods into three camps: policy constraints/regularization, modifications of imitation learning, and Q regularization:
+
+1. The majority of prior work acts directly on the policy. Some authors have proposed explicit constraints on the learned policy to only select actions where $( s , a )$ has sufficient support under the data generating distribution [Fujimoto et al., 2018a, 2019, Laroche et al., 2019]. Another proposal is to regularize the learned policy towards the behavior policy [Wu et al., 2019] usually either with a KL divergence [Jaques et al., 2019] or MMD [Kumar et al., 2019]. This is a very straighforward way to stay close to the behavior with a hyperparameter that determines just how close. All of these algorithms are iterative and rely on off-policy evaluation.
+
+2. Siegel et al. [2020], Wang et al. [2020b], Chen et al. [2020] all use algorithms that filter out datapoints with low Q values and then perform imitation learning. Wang et al. [2018], Peng et al. [2019] use a weighted imitation learning algorithm where the weights are determined by exponentiated Q values. These algorithms are iterative.
+
+3. Another way to prevent the learned policy from choosing unknown actions is to incorporate some form of regularization to encourage staying near the behavior and being pessimistic about unknown state, action pairs [Wu et al., 2019, Nachum et al., 2019, Kumar et al., 2020, Kostrikov et al., 2021, Gulcehre et al., 2021]. However, being able to properly quantify uncertainty about unknown states is notoriously difficult when dealing with neural network value functions [Buckman et al., 2020].
+
+One-step algorithms. Some recent work has also noted that optimizing policies based on the behavior value function can perform surprisingly well. As we do, Goo and Niekum [2020] studies the continuous control tasks from the D4RL benchmark, but they examine a complicated algorithm involving ensembles, distributional Q functions, and a novel regularization technique. In contrast, we analyze a substantially simpler algorithm and get better performance on the D4RL tasks. We also focus more of our contribution on understanding and explaining this performance. Gulcehre et al. [2021] studies the discrete action setting and finds that a one-step algorithm (which they call “behavior value estimation”) outperforms prior work on Atari games and other discrete action tasks from the RL Unplugged benchmark [Gulcehre et al., 2020]. They also introduce a novel regularizer for the evaluation step. In contrast, we consider the continuous control setting. This is a substantial difference in setting since continuous control requires actor-critic algorithms with parametric policies while in the discrete setting the policy improvement step can be computed exactly from the Q function. Moreover, while Gulcehre et al. [2021] attribute the poor performance of iterative algorithms to “overestimation”, we define and separate the issues of distribution shift and iterative error exploitation which can combine to cause overestimation. This separation helps to expose the difference between the fundamental limits of off-policy evaluation from the specific problems induced by iterative algorithms, and will hopefully be a useful distinction to inspire future work. Finally, a one-step variant is also briefly discussed in Nadjahi et al. [2019], but is not the focus of that work.
+
+There are also important connections between the one-step algorithm and the literature on conservative policy improvement [Kakade and Langford, 2002, Schulman et al., 2015, Achiam et al., 2017], which we discuss in more detail in Appendix B.
+
+# 4 Defining the algorithms
+
+In this section we provide a unified algorithmic template for model-free offline RL algorithms as offline approximate modified policy iteration. We show how this template captures our one-step algorithm as well as a multi-step policy iteration algorithm and an iterative actor-critic algorithm. Then any choice of policy evaluation and policy improvement operators can be used to define one-step, multi-step, and iterative algorithms.
+
+# 4.1 Algorithmic template
+
+# Algorithm 1: OAMPI
+
+We consider a generic offline approximate modified policy iteration (OAMPI) scheme, shown in Algorithm 1 (and based off of Puterman and Shin [1978], Scherrer et al. [2012]). Essentially the algorithm alternates between two steps. First, there is a policy evaluation step where we estimate the Q function of the cur
+
+input : $K$ , dataset $D _ { N }$ , estimated behavior $\hat { \beta }$   
+Set $\pi _ { 0 } = \hat { \beta }$ . Initialize $\widehat { Q } ^ { \pi _ { - 1 } }$ randomly.   
+for $k = I$ , . . . , $K$ do Policy evaluation: $\widehat { Q } ^ { \pi _ { k - 1 } } = \mathcal { E } ( \pi _ { k - 1 } , D _ { N } , \widehat { Q } ^ { \pi _ { k - 2 } } )$ Policy improvement: $\pi _ { k } = \mathcal { I } ( \widehat { Q } ^ { \pi _ { k - 1 } } , \widehat { \beta } , D _ { N } , \pi _ { k - 1 } )$   
+end
+
+rent policy $\pi _ { k - 1 }$ by $\widehat { Q } ^ { \pi _ { k - 1 } }$ using only the dataset $D _ { N }$ . Implementations also often use the prior $\mathrm { Q }$ estimate $\widehat { Q } ^ { \pi _ { k - 2 } }$ to warm-start the approximation process. Second, there is a policy improvement step. This step takes in the estimated $\mathrm { Q }$ function $\widehat { Q } ^ { \pi _ { k - 1 } }$ , the estimated behavior $\hat { \beta }$ , and the dataset $D _ { N }$ and produces a new policy $\pi _ { k }$ . Again an algorithm may use $\pi _ { k - 1 }$ to warm-start the optimization. Moreover, we expect this improvement step to be regularized or constrained to ensure that $\pi _ { k }$ remains in the support of $\beta$ and $D _ { N }$ . Choices for this step are discussed below. Now we discuss a few ways to instantiate the template.
+
+One-step. The simplest algorithm sets the number of iterations $K = 1$ . We learn $\hat { \beta }$ by maximum likelihood and train the policy evaluation step to estimate $Q ^ { \beta }$ . Then we use any one of the policy improvement operators discussed below to learn $\pi _ { 1 }$ . Importantly, this algorithm completely avoids off-policy evaluation.
+
+Multi-step. The multi-step algorithm now sets $K > 1$ . The evaluation operator must evaluate off-policy since $D _ { N }$ is collected by $\beta$ , but evaluation steps for $K \geq 2$ require evaluating policies $\pi _ { k - 1 } \neq \beta$ . Each iteration is trained to convergence in both the estimation and improvement steps.
+
+Iterative actor-critic. An actor critic approach looks somewhat like the multi-step algorithm, but does not attempt to train to convergence at each iteration and uses a much larger $K$ . Here each iteration consists of one gradient step to update the Q estimate and one gradient step to improve the policy. Since all of the evaluation and improvement operators that we consider are gradient-based, this algorithm can adapt the same evaluation and improvement operators used by the multi-step algorithm. Most algorithms from the literature fall into this category [Fujimoto et al., 2018a, Kumar et al., 2019, 2020, Wu et al., 2019, Wang et al., 2020b, Siegel et al., 2020].
+
+# 4.2 Policy evaluation operator
+
+Following prior work on continuous state and action problems, we always evaluate by simple fitted Q evaluation [Fujimoto et al., 2018a, Kumar et al., 2019, Siegel et al., 2020, Wang et al., 2020b, Paine et al., 2020, Wang et al., 2021]. In practice this is optimized by TD-style learning with the use of a target network [Mnih et al., 2015] as in DDPG [Lillicrap et al., 2015]. We do not use any double Q learning or Q ensembles [Fujimoto et al., 2018b]. For the one-step and multi-step algorithms we train the evaluation procedure to convergence on each iteration and for the iterative algorithm each iteration takes a single stochastic gradient step. See Voloshin et al. [2019], Wang et al. [2021] for more comprehensive examinations of policy evaluation and some evidence that this simple fitted Q iteration approach is reasonable. It is an interesting direction for future work to consider other operators that use things like importance weighting [Munos et al., 2016] or pessimism [Kumar et al., 2020, Buckman et al., 2020].
+
+# 4.3 Policy improvement operators
+
+To instantiate the template, we also need to choose a specific policy improvement operator $\mathcal { T }$ . We consider the following improvement operators selected from those discussed in the related work section. Each operator has a hyperparameter controlling deviation from the behavior policy.
+
+Behavior cloning. The simplest baseline worth including is to just return $\hat { \beta }$ as the new policy $\pi$ Any policy improvement operator ought to perform at least as well as this baseline.
+
+Constrained policy updates. Algorithms like BCQ [Fujimoto et al., 2018a] and SPIBB [Laroche et al., 2019] constrain the policy updates to be within the support of the data/behavior. In favor of simplicity, we implement a simplified version of the BCQ algorithm that removes the “perturbation network” which we call Easy BCQ. We define a new policy $\hat { \pi } _ { k } ^ { M }$ by drawing $M$ samples from $\hat { \beta }$ and then executing the one with the highest value according to ${ \widehat Q } ^ { \beta }$ . Explicitly:
+
+$$
+\hat { \pi } _ { k } ^ { M } ( a | s ) = \mathbb { 1 } [ a = \arg \operatorname* { m a x } _ { a _ { j } } \{ \widehat { Q } ^ { \pi _ { k - 1 } } ( s , a _ { j } ) : a _ { j } \sim \pi _ { k - 1 } ( \cdot | s ) , 1 \leq j \leq M \} ] .
+$$
+
+Regularized policy updates. Another common idea proposed in the literature is to regularize towards the behavior policy [Wu et al., 2019, Jaques et al., 2019, Kumar et al., 2019]. For a general divergence $D$ we can define an algorithm that maximizes a regularized objective:
+
+$$
+\hat { \pi } _ { k } ^ { \alpha } = \arg \operatorname* { m a x } _ { \pi } \sum _ { i } \underset { a \sim \pi | s } { \mathbb { E } } \big [ \widehat { Q } ^ { \pi _ { k - 1 } } ( s _ { i } , a ) \big ] - \alpha D ( \hat { \beta } ( \cdot | s _ { i } ) , \pi ( \cdot | s _ { i } ) )
+$$
+
+A comprehensive review of different variants of this method can be found in $\mathrm { W u }$ et al. [2019] which does not find dramatic differences across regularization techniques. In practice, we will use reverse KL divergence, i.e. $K L ( \pi ( \cdot | s _ { i } ) | | \hat { \beta } ( \cdot | s _ { i } ) )$ . To compute the reverse KL, we draw samples from $\pi ( \cdot | s _ { i } )$ and use the density estimate $\hat { \beta }$ to compute the divergence. Intuitively, this regularization forces $\pi$ to remain within the support of $\beta$ rather than incentivizing $\pi$ to cover $\beta$ .
+
+Variants of imitation learning. Another idea, proposed by [Wang et al., 2018, Siegel et al., 2020, Wang et al., 2020b, Chen et al., 2020] is to modify an imitation learning algorithm either by filtering or weighting the observed actions to incentivize policy improvement. The weighted version that we implement uses exponentiated advantage estimates to weight the observed actions:
+
+$$
+\hat { \pi } _ { k } ^ { \tau } = \arg \operatorname* { m a x } _ { \pi } \sum _ { i } \exp ( \tau ( \widehat { Q } ^ { \pi _ { k - 1 } } ( s _ { i } , a _ { i } ) - \widehat { V } ( s _ { i } ) ) ) \log \pi ( a _ { i } | s _ { i } ) .
+$$
+
+With these definitions, we can now move on to testing various combinations of algorithmic template (one-step, multi-step, or iterative) and improvement operator (Easy BCQ, reverse KL regularization, or exponentially weighted imitation).
+
+# 5 Benchmark Results
+
+Our main empirical finding is that one step of policy improvement is sufficient to beat state of the art results on much of the D4RL benchmark suite [Fu et al., 2020]. This is striking since prior work focuses on iteratively estimating the Q function of the current policy iterate, but we only use one step derived from ${ \widehat Q } ^ { \beta }$ . Results are shown in Table 1. Full experimental details are in Appendix C and code can be found at https://github.com/davidbrandfonbrener/onestep-rl.
+
+Table 1: Results of one-step algorithms on the D4RL benchmark. The first column gives the best results across several iterative algorithms considered in Fu et al. [2020]. Each algorithm is tuned over 6 values of their respective hyperparameter. We report the mean and standard error over 10 seeds of the training process and using 100 evaluation episodes per seed. We bold the best result on each dataset and blue any result where a one-step algorithm beat the best reported iterative result from Fu et al. [2020]. We use m for medium, m-e for medium-expert, m-re for medium-replay, r for random, and c for cloned.   
+
+<table><tr><td rowspan="2"></td><td colspan="2">Iterative</td><td colspan="3">One-step</td></tr><tr><td>Fu et al. [2020]</td><td>BC</td><td>Easy BCQ</td><td>Rev. KL Reg</td><td>Exp.Weight</td></tr><tr><td>halfcheetah-m</td><td>46.3</td><td>42.1 ± 0.1</td><td>52.6 ± 0.1</td><td>55.6 ± 0.2</td><td>48.6± 0.0</td></tr><tr><td>walker2d-m</td><td>81.1</td><td>70.2 ±1.3</td><td>86.9 ± 0.4</td><td>85.6 ± 0.4</td><td>80.3 ±1.1</td></tr><tr><td>hopper-m</td><td>58.8</td><td>49.8 ± 0.6</td><td>69.7 ± 2.1</td><td>83.3 ± 1.4</td><td>56.7 ± 0.8</td></tr><tr><td>halfcheetah-m-e</td><td>64.7</td><td>60.1 ± 0.8</td><td>77.0 ± 0.9</td><td>93.5 ± 0.1</td><td>91.7 ± 0.9</td></tr><tr><td>walker2d-m-e</td><td>111.0</td><td>93.6 ± 5.6</td><td>111.8 ± 0.2</td><td>110.9 ± 0.1</td><td>112.9 ± 0.2</td></tr><tr><td>hopper-m-e</td><td>111.9</td><td>48.1 ± 1.5</td><td>81.4 ± 1.9</td><td>102.1 ± 1.3</td><td>83.1 ± 7.0</td></tr><tr><td>halfcheetah-m-re</td><td>47.7</td><td>34.9 ± 0.3</td><td>38.4± 0.3</td><td>42.4± 0.1</td><td>38.6 ± 0.5</td></tr><tr><td>walker2d-m-re</td><td>26.7</td><td>23.9 ± 1.6</td><td>66.4 ± 2.0</td><td>71.6 ± 3.1</td><td>49.3 ± 3.5</td></tr><tr><td>hopper-m-re</td><td>48.6</td><td>21.2 ± 1.3</td><td>77.3 ± 2.7</td><td>71.0 ± 8.1</td><td>94.1 ± 2.4</td></tr><tr><td>halfcheetah-r</td><td>35.4</td><td>2.2 ± 0.0</td><td>5.4 ± 0.1</td><td>6.9 ± 1.0</td><td>3.7± 0.2</td></tr><tr><td>walker2d-r</td><td>7.3</td><td>0.7 ± 0.1</td><td>4.2 ± 0.2</td><td>6.1 ± 0.3</td><td>5.2 ± 0.2</td></tr><tr><td>hopper-r</td><td>12.2</td><td>2.6± 0.4</td><td>6.7 ± 0.1</td><td>7.8± 0.3</td><td>5.6 ± 0.6</td></tr><tr><td>pen-c</td><td>56.9</td><td>49.3 ± 2.2</td><td>67.0 ± 1.1</td><td>55.3 ± 1.9</td><td>54.7 ± 2.3</td></tr><tr><td>hammer-c</td><td>2.1</td><td>0.5 ± 0.1</td><td>2.8 ± 0.5</td><td>0.2±0.0</td><td>1.2 ± 0.2</td></tr><tr><td>relocate-c</td><td>-0.1</td><td>0.0± 0.0</td><td>0.3 ± 0.0</td><td>0.1 ± 0.0</td><td>0.1 ± 0.0</td></tr><tr><td>door-c</td><td>0.4</td><td>0.0± 0.0</td><td>0.4 ± 0.2</td><td>0.0 ± 0.1</td><td>0.1 ± 0.1</td></tr></table>
+
+As we can see in the table, all of the one-step algorithms usually outperform the best iterative algorithms tested by Fu et al. [2020]. The one notable exception is the case of random data (especially on halfcheetah), where iterative algorithms have a clear advantage. We will discuss potential causes of this further in Section 7.
+
+To give a more direct comparison that controls for any potential implementation details, we use our implementation of reverse KL regularization to create multi-step and iterative algorithms. We are not using algorithmic modifications like Q ensembles, regularized Q values, or early stopping that have been used in prior work. But, our iterative algorithm recovers similar performance to prior regularized actor-critic approaches. These results are shown in Table 2.
+
+Table 2: Results of reverse KL regularization on the D4RL benchmark across one-step, multi-step, and iterative algorithms. Again we run 6 hyperparameters and report the mean and standard error across 10 seeds using 100 evaluation episodes.   
+
+<table><tr><td></td><td>One-step</td><td>Multi-step</td><td>Iterative</td></tr><tr><td>halfcheetah-m</td><td>55.6± 0.2</td><td>40.8 ± 8.6</td><td>47.4 ± 3.5</td></tr><tr><td>walker2d-m</td><td>85.6 ± 0.4</td><td>75.9 ± 0.5</td><td>75.4 ± 0.8</td></tr><tr><td>hopper-m</td><td>83.3 ± 1.4</td><td>53.0 ±1.0</td><td>54.2 ± 0.6</td></tr><tr><td>halfcheetah-m-e</td><td>93.5 ± 0.1</td><td>93.6 ± 0.3</td><td>93.6 ± 0.2</td></tr><tr><td>walker2d-m-e</td><td>110.9 ± 0.1</td><td>76.3 ± 15.9</td><td>108.2 ± 0.3</td></tr><tr><td>hopper-m-e</td><td>102.1 ± 1.3</td><td>101.3 ± 3.9</td><td>82.7 ± 7.4</td></tr><tr><td>halfcheetah-r</td><td>6.9 ± 1.0</td><td>13.7 ± 1.7</td><td>16.3 ± 1.6</td></tr><tr><td>walker2d-r</td><td>6.1 ± 0.3</td><td>5.0±0.3</td><td>5.1± 0.3</td></tr><tr><td>hopper-r</td><td>7.8 ± 0.3</td><td>15.4 ± 2.9</td><td>9.7 ± 0.1</td></tr></table>
+
+Put together, these results immediately suggest some guidance to the practitioner: it is worthwhile to run the one-step algorithm as a baseline before trying something more elaborate. The one-step algorithm is substantially simpler than prior work, but frequently achieves better performance.
+
+# 6 What goes wrong for iterative algorithms?
+
+The benchmark experiments show that one step of policy improvement often beats iterative and multi-step algorithms. In this section we dive deeper to understand why this happens. First, by examining the learning curves of each of the algorithms we note that iterative algorithms require stronger regularization to avoid instability. Then we identify two causes of this instability: distribution shift and iterative error exploitation.
+
+Distribution shift causes evaluation error by reducing the effective sample size in the fixed dataset for evaluating the current policy and has been extensively considered in prior work as discussed below. Iterative error exploitation occurs when we repeatedly optimize policies against our Q estimates and exploit their errors. This introduces a bias towards overestimation at each step (much like the training error in supervised learning is biased to be lower than the test error). Moreover, by iteratively re-using the data and using prior Q estimates to warmstart training at each step, the errors from one step are amplified at the next. This type of error is particular to multi-step and iterative algorithms.
+
+# 6.1 Learning curves and hyperparameter sensitivity
+
+To begin to understand why iterative and multi-step algorithms can fail it is instructive to look at the learning curves. As shown in Figure 2, we often observe that the iterative algorithm will begin to learn and then crash. Regularization can help to prevent this crash since strong enough regularization towards the behavior policy ensures that the evaluation is nearly on-policy.
+
+![](images/bbd4b958be2971ecaf3cafc93b6bd3c079cf9f34558ea6eefef0e6a511b802b6.jpg)  
+Figure 2: Learning curves and final performance on halfcheetah-medium across different algorithms and regularization hyperparameters (all using the reverse KL regularized improvement operator). Error bars show min and max over 3 seeds. Similar figures for other datasets from D4RL can be found in Appendix D.
+
+In contrast, the one-step algorithm is more robust to the regularization hyperparameter. The rightmost panel of the figure shows this clearly. While iterative and multi-step algorithms can have their performance degrade very rapidly with the wrong setting of the hyperparameter, the one-step approach is more stable. Moreover, we usually find that the optimal setting of the regularization hyperparameter is lower for the one-step algorithm than the iterative or multi-step approaches.
+
+# 6.2 Distribution shift
+
+Any algorithm that relies on off-policy evaluation will struggle with distribution shift in the evaluation step. Trying to evaluate a policy that is substantially different from the behavior reduces the effective sample size and increases the variance of the estimates. Explicitly, by distribution shift we mean the shift between the behavior distribution (the distribution over state-action pairs in the dataset) and the evaluation distribution (the distribution that would be induced by the policy $\pi$ we want to evaluate).
+
+Prior work. There is a substantial body of prior theoretical work that suggests that off-policy evaluation can be difficult and this difficulty scales with some measure of distribution shift. Wang et al. [2020a], Amortila et al. [2020], Zanette [2021] give exponential (in horizon) lower bounds on sample complexity in the linear setting even with good feature representations that can represent the desired Q function and assuming good data coverage. Upper bounds generally require very strong assumptions on both the representation and limits on the distribution shift [Wang et al., 2021, Duan et al., 2020, Chen and Jiang, 2019]. Moreover, the assumed bounds on distribution shift can be exponential in horizon in the worst case. On the empirical side, Wang et al. [2021] demonstrates issues with distribution shift when learning from pre-trained features and provides a nice discussion of why distribution shift causes error amplification. Fujimoto et al. [2018a] raises a similar issue under the name “extrapolation error”. Regularization and constraints are meant to reduce issues stemming from distribution shift, but also reduce the potential for improvement over the behavior.
+
+Empirical evidence. Both the multi-step and iterative algorithms in our experiments rely on offpolicy evaluation as a key subroutine. We examine how easy it is to evaluate the policies encountered along the learning trajectory. To control for issues of iterative error exploitation (discussed in the next subsection), we train Q estimators from scratch on a heldout evaluation dataset sampled from the behavior policy. We then evaluate these trained Q function on rollouts from 1000 datapoints sampled from the replay buffer. Results are shown in Figure 3.
+
+The results show a correlation betweed KL and MSE. Moreover, we see that the MSE generally increases over training. One way to mitigate this, as seen in the figure, is to use a large value of $\alpha$ . We just cannot take a very large step before running into problems with distribution shift. But, when we take such a small step, the information from the on-policy ${ \widehat Q } ^ { \beta }$ is about as useful as the newly estimated ${ \widehat { Q } } ^ { \pi }$ . This is seen, for example, in Figure 2 where we get very similar performance across algorithms at high levels of regularization.
+
+![](images/7cdca1b44030fc8a1f0c53056fe81e9e58f7cbc3b78dd6f5341ba10b8b54469b.jpg)  
+Figure 3: Results of running the iterative algorithm on halfcheetah-medium. Each checkpointed policy is evaluated by a Q function trained from scratch on heldout data. MSE refers to $\mathbb { E } _ { s , a \sim \beta } [ ( \hat { Q } ^ { \pi _ { i } } ( s , a ) -$ $Q ^ { \pi _ { i } } ( s , a ) ) ^ { 2 } ]$ and KL refers to $\mathbb { E } _ { s \sim \beta } [ K L ( \pi ( \cdot | s ) | | \beta ( \cdot | s ) ]$ . Left: 90 policies taken from various points in training with various hyperaparmeters and random seeds. Center: MSE learning curves. Right: KL learning curves. Error bars show min and max over 3 random seeds.
+
+# 6.3 Iterative error exploitation
+
+The previous subsection identifies how any algorithm that uses off-policy evaluation is fundamentally limited by distribution shift, even if we were given fresh data and trained Q functions from scratch at every iteration. But, in practice, iterative algorithms repeatedly iterate between optimizing policies against estimated Q functions and re-estimating the Q functions using the same data and using the Q function from the previous step to warm-start the re-estimation. This induces dependence between steps that causes a problem that we call iterative error exploitation.
+
+Intuition about the problem. In short, iterative error exploitation happens because $\pi _ { i }$ tends to choose overestimated actions in the policy improvement step, and then this overestimation propagates via dynamic programming in the policy evaluation step. To illustrate this issue more formally, consider the following: at each $s , a$ we suffer some Bellman error $\varepsilon _ { \beta } ^ { \pi } ( s , a )$ based on our fixed dataset collected by $\beta$ . Formally,
+
+$$
+\widehat { Q } ^ { \pi } ( s , a ) = r ( s , a ) + \gamma \operatorname * { \mathbb { E } } _ { \mathbf { \Phi } _ { s ^ { \prime } \mid s , a } \atop { a ^ { \prime } \sim \pi \mid s ^ { \prime } } } [ \widehat { Q } ^ { \pi } ( s ^ { \prime } , a ^ { \prime } ) ] + \varepsilon _ { \beta } ^ { \pi } ( s , a ) .
+$$
+
+Intuitively, $\varepsilon _ { \beta } ^ { \pi }$ will be larger at state-actions with less coverage in the dataset collected by $\beta$ . Note that $\varepsilon _ { \beta } ^ { \pi }$ can absorb all error whether it is caused by the finite sample size or function approximation error.
+
+All that is needed to cause iterative error exploitation is that the $\epsilon _ { \beta } ^ { \pi }$ are highly correlated across different $\pi$ , but for simplicity, we will assume that $\varepsilon _ { \beta } ^ { \pi }$ is the same for all policies $\pi$ estimated from our fixed offline dataset and instead write $\varepsilon _ { \beta }$ . Now that the errors do not depend on the policy we can treat the errors as auxiliary rewards that obscure the true rewards and see that
+
+$$
+\widehat { Q } ^ { \pi } ( s , a ) = Q ^ { \pi } ( s , a ) + \widetilde { Q } _ { \beta } ^ { \pi } ( s , a ) , \qquad \widetilde { Q } _ { \beta } ^ { \pi } ( s , a ) : = \underset { \pi | s _ { 0 } , a _ { 0 } = s , a } { \mathbb { E } } \left[ \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } \varepsilon _ { \beta } ( s _ { t } , a _ { t } ) \right] .
+$$
+
+This assumption is somewhat reasonable since we expect the error to primarily depend on the data. And, when the prior Q function is used to warm-start the current one (as is generally the case in practice), the approximation errors are automatically passed between steps.
+
+Now we can explain the problem. Recall that under our assumption the $\varepsilon _ { \beta }$ are fixed once we have a dataset and likely to have larger magnitude the further we go from the support of the dataset. So, with each step $\pi _ { i }$ is able to better maximize $\varepsilon _ { \beta }$ , thus moving further from $\beta$ and increasing the magnitude of $\widetilde { Q } _ { \beta } ^ { \pi _ { i } }$ relative to $Q ^ { \pi _ { i } }$ . Even though $Q ^ { \pi _ { i } }$ may provide better signal than $Q ^ { \beta }$ , it can easily be drowned out by $\widetilde { Q } _ { \beta } ^ { \pi _ { i } }$ . In contrast, $\widetilde { Q } _ { \beta } ^ { \beta }$ has small magnitude, so the one-step algorithm is robust to errors1.
+
+An example. Now we consider a simple gridworld example to illustrate iterative error exploitation. This example fits exactly into the setup outlined above since all errors are due to reward estimation so the $\varepsilon _ { \beta }$ is indeed constant over all $\pi$ . The gridworld we consider has one deterministic good state with reward 1 and many stochastic bad states that have rewards distributed as $\mathcal { N } ( - 0 . 5 , 1 )$ . We collect a dataset of 100 trajectories, each of length 100. One run of the multi-step offline regularized policy iteration algorithm is illustrated in Figure 4.
+
+In the example we see that one step often outperforms multiple steps of improvement. Intuitively, when there are so many noisy states, it is likely that a few of them will be overestimated. Since the data is re-used for each step, these overestimations persist and propagate across the state space due to iterative error exploitation. This property of having many bad, but poorly estimated states likely also exists in the high-dimensional control problems encountered in the benchmark where there are many ways for the robots to fall down that are not observed in the data for non-random behavior. Moreover, both settings have larger errors in areas where we have less data. So even though the errors in the gridworld are caused by noise in the rewards, while errors in D4RL are caused by function approximation, we think this is a useful mental model of the problem.
+
+![](images/28bd37725a9c5e57318c91a7a0e7430e58e28336dddb89607a085861be130769.jpg)  
+Figure 4: An illustration of multi-step offline regularized policy iteration. The leftmost panel in each row shows the true reward (top) or error $\varepsilon _ { \beta }$ (bottom). Then each subsequent panel plots $\pi _ { i }$ (with arrow size proportional to $\pi _ { i } ( a | s ) .$ ) over either $Q ^ { \pi _ { i } }$ (top) or $\widetilde { Q } _ { \beta } ^ { \pi }$ (bottom), averaged over actions at each state. The one-step policy $( \pi _ { 1 } )$ has the highest value. The behavior policy here is a mixture of optimal $\pi ^ { * }$ and uniform $u$ with coefficient 0.2 so that $\beta = 0 . 2 \cdot \pi ^ { * } + 0 . 8 \cdot u$ . We set $\alpha = 0 . 1$ as the regularization parameter for reverse KL regularization.
+
+![](images/3b10a08795d9696e39c5ae064a78494e5e6e4ed0576dc9e69d03724bd61efe1d.jpg)  
+Figure 5: Histograms of overestimation error $( \widehat { Q } ^ { \pi _ { i } } ( s , a ) - Q ^ { \pi _ { i } } ( s , a ) )$ on halfcheetah-medium with the iterative algorithm. Left: errors from the training Q function. Right: errors from an independently trained Q function.
+
+Empirical evidence. In practice we cannot easily visualize the progression of errors. However, the dependence between steps still arises as overestimation of the Q values. We can track the overestimation of the Q values over training as a way to measure how much bias is being induced by optimizing against our dependent Q estimators. As a control we can also train Q estimators from scratch on independently sampled evaluation data. These independently trained Q functions do not have the same overestimation bias even though the squared error does tend to increase as the policy moves further from the behavior (as seen in Figure 3). Explicitly, we track 1000 state, action pairs from the replay buffer over training. For each checkpointed policy we perform 3 rollouts at each state to get an estimate of the true Q value and compare this to the estimated Q value. Results are shown in Figure 5.
+
+# 7 When are multiple steps useful?
+
+So far we have focused on why the one-step algorithm often works better than the multi-step and iterative algorithms. However, we do not want to give the impression that one-step is always better. Indeed, our own experiments in Section 5 show a clear advantage for the multi-step and iterative approaches when we have randomly collected data. While we cannot offer a precise delineation of when one-step will outperform multi-step, in this section we offer some intuition as to when we can expect to see benefits from multiple steps of policy improvement.
+
+As seen in Section 6, multi-step and iterative algorithms have problems when they propagate estimation errors. This is especially problematic in noisy and/or high dimensional environments. While the multi-step algorithms propagate this noise more widely than the one-step algorithm, they also propagate the signal. So, when we have sufficient coverage to reduce the magnitude of the noise, this increased propagation of signal can be beneficial. The D4RL experiments suggest that we are usually on the side of the tradeoff where the errors are large enough to make one-step preferable.
+
+![](images/4deab14cea5ef2dbcec99ba9f0be26cb6ad0981000685aa80269646f930309aa.jpg)  
+Figure 6: Performance of all three algorithms with reverse KL regularization across mixtures between halfcheetah-random and halfcheetah-medium. Error bars indicate min and max over 3 seeds.
+
+In Appendix A we illustrate a simple gridworld example where a slight modification of the behavior policy from Figure 4 makes multi-step dramatically outperform one-step. This modified behavior policy (1) has better coverage of the noisy states (which reduces error, helping multi-step), and (2) does a worse job propagating the reward from the good state (hurting one-step).
+
+We can also test empirically how the behavior policy effects the tradeoff between error and signal propagation. To do this we construct a simple experiment where we mix data from the random behavior policy with data from the medium behavior policy. Explicitly we construct a dataset $D$ out of the datasets $D _ { r }$ for random and $D _ { m }$ for medium such that each trajectory in $D$ comes from the medium dataset with probability $p _ { m }$ . So for $p _ { m } = 0$ we have the random dataset and $p _ { m } = 1$ we have the medium dataset, and in between we have various mixtures. Results are shown in Figure 6. It takes surprisingly little data from the medium policy for one-step to outperform the iterative algorithm.
+
+# 8 Discussion, limitations, and future work
+
+This paper presents the surprising effectiveness of a simple one-step baseline for offline RL. We examine the failure modes of iterative algorithms and the conditions where we might expect them to outperform the simple one-step baseline. This provides guidance to a practitioner that the simple one-step baseline is a good place to start when approaching an offline RL problem.
+
+But, we leave many questions unanswered. One main limitation is that we lack a clear theoretical characterization of which environments and behaviors can guarantee that one-step outperforms multi-step or visa versa. Such results will likely require strong assumptions, but could provide useful insight. We don’t expect this to be easy as it requires understanding policy iteration which has been notoriously difficult to analyze, often converging much faster than the theory would suggest [Sutton and Barto, 2018, Agarwal et al., 2019]. Another limitation is that while only using one step is perhaps the simplest way to avoid the problems of off-policy evaluation, there are possibly other more elaborate algorithmic solutions that we did not consider here. However, our strong empirical results suggest that the one-step algorithm is at least a strong baseline.
+
+Broader impact. Our paper studies a simple and effective baseline approach to the offline RL problem. The effectiveness of this baseline raises some serious questions about the utility of prior work proposing substantially more complicated methods. By making this observation of prior shortcomings, our paper has the potential to encourage researchers to derive new and better methods for offline RL. This has many potential impacts on fields as diverse as robotics and healthcare where better offline decision making can lead to better real-world performance. As always, we note that machine learning improvements come in the form of “building machines to do $\mathbf { X }$ better”. For a sufficiently malicious or ill-informed choice of X, almost any progress in machine learning might indirectly lead to a negative outcome, and our work is not excluded from that.
+
+# Acknowledgements
+
+This work is partially supported by the Alfred P. Sloan Foundation, NSF RI-1816753, NSF CAREER CIF 1845360, NSF CHS-1901091, Samsung Electronics, and the Institute for Advanced Study. DB is supported by the Department of Defense (DoD) through the National Defense Science & Engineering Graduate Fellowship (NDSEG) Program.
+
+# References
+
+Joshua Achiam, David Held, Aviv Tamar, and Pieter Abbeel. Constrained policy optimization. In International Conference on Machine Learning, pages 22–31. PMLR, 2017.
+
+Alekh Agarwal, Nan Jiang, and S. Kakade. Reinforcement learning: Theory and algorithms. 2019.
+
+P. Amortila, Nan Jiang, and Tengyang Xie. A variant of the wang-foster-kakade lower bound for the discounted setting. ArXiv, abs/2011.01075, 2020.
+
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym. CoRR, abs/1606.01540, 2016. URL http://arxiv.org/abs/ 1606.01540.
+
+Jacob Buckman, Carles Gelada, and Marc G. Bellemare. The importance of pessimism in fixed-dataset policy optimization, 2020.
+
+John Burkhardt. The truncated normal distribution, 2014.
+
+Jinglin Chen and Nan Jiang. Information-theoretic considerations in batch reinforcement learning. In Proceedings of the 36th International Conference on Machine Learning. PMLR, 2019.
+
+Xinyue Chen, Zijian Zhou, Zheng Wang, Che Wang, Yanqiu Wu, and Keith Ross. Bail: Bestaction imitation learning for batch deep reinforcement learning. Advances in Neural Information Processing Systems, 33, 2020.
+
+Yaqi Duan, Zeyu Jia, and Mengdi Wang. Minimax-optimal off-policy evaluation with linear function approximation. In International Conference on Machine Learning, pages 2701–2709. PMLR, 2020.
+
+Justin Fu, Aviral Kumar, Ofir Nachum, George Tucker, and Sergey Levine. D4rl: Datasets for deep data-driven reinforcement learning. arXiv preprint arXiv:2004.07219, 2020.
+
+Scott Fujimoto, David Meger, and Doina Precup. Off-policy deep reinforcement learning without exploration. arXiv preprint arXiv:1812.02900, 2018a.
+
+Scott Fujimoto, Herke van Hoof, and David Meger. Addressing function approximation error in actor-critic methods. arXiv preprint arXiv:1802.09477, 2018b.
+
+Scott Fujimoto, Edoardo Conti, Mohammad Ghavamzadeh, and Joelle Pineau. Benchmarking batch deep reinforcement learning algorithms. arXiv preprint arXiv:1910.01708, 2019.
+
+Wonjoon Goo and Scott Niekum. You only evaluate once – a simple baseline algorithm for offline rl. In Offline Reinforcement Learning Workshop at Neural Information Processing Systems, 2020.
+
+Caglar Gulcehre, Ziyu Wang, Alexander Novikov, Tom Le Paine, Sergio Gómez Colmenarejo, Konrad Zolna, Rishabh Agarwal, Josh Merel, Daniel Mankowitz, Cosmin Paduraru, et al. Rl unplugged: Benchmarks for offline reinforcement learning. arXiv preprint arXiv:2006.13888, 2020.
+
+Caglar Gulcehre, Sergio Gómez Colmenarejo, Ziyu Wang, Jakub Sygnowski, Thomas Paine, Konrad Zolna, Yutian Chen, Matthew Hoffman, Razvan Pascanu, and Nando de Freitas. Regularized behavior value estimation. arXiv preprint arXiv:2103.09575, 2021.
+
+Natasha Jaques, Asma Ghandeharioun, Judy Hanwen Shen, Craig Ferguson, Agata Lapedriza, Noah Jones, Shixiang Gu, and Rosalind Picard. Way off-policy batch deep reinforcement learning of implicit human preferences in dialog, 2019.
+
+Sham Kakade and John Langford. Approximately optimal approximate reinforcement learning. In ICML, volume 2, pages 267–274, 2002.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Ilya Kostrikov, Jonathan Tompson, Rob Fergus, and Ofir Nachum. Offline reinforcement learning with fisher divergence critic regularization. arXiv preprint arXiv:2103.08050, 2021.
+
+Aviral Kumar, Justin Fu, Matthew Soh, George Tucker, and Sergey Levine. Stabilizing off-policy q-learning via bootstrapping error reduction. In Advances in Neural Information Processing Systems, pages 11761–11771, 2019.
+
+Aviral Kumar, Aurick Zhou, George Tucker, and Sergey Levine. Conservative q-learning for offline reinforcement learning. arXiv preprint arXiv:2006.04779, 2020.
+
+Romain Laroche, Paul Trichelair, and Remi Tachet Des Combes. Safe policy improvement with baseline bootstrapping. In International Conference on Machine Learning, pages 3652–3661. PMLR, 2019.
+
+Sergey Levine, Aviral Kumar, George Tucker, and Justin Fu. Offline reinforcement learning: Tutorial, review, and perspectives on open problems. arXiv preprint arXiv:2005.01643, 2020.
+
+Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529, 2015.
+
+Rémi Munos, Tom Stepleton, Anna Harutyunyan, and Marc Bellemare. Safe and efficient off-policy reinforcement learning. In Advances in Neural Information Processing Systems, pages 1054–1062, 2016.
+
+Ofir Nachum, Bo Dai, Ilya Kostrikov, Yinlam Chow, Lihong Li, and Dale Schuurmans. Algaedice: Policy gradient from arbitrary experience. arXiv preprint arXiv:1912.02074, 2019.
+
+Kimia Nadjahi, Romain Laroche, and Rémi Tachet des Combes. Safe policy improvement with soft baseline bootstrapping, 2019.
+
+Tom Le Paine, Cosmin Paduraru, Andrea Michi, Caglar Gulcehre, Konrad Zolna, Alexander Novikov, Ziyu Wang, and Nando de Freitas. Hyperparameter selection for offline reinforcement learning, 2020.
+
+Xue Bin Peng, Aviral Kumar, Grace Zhang, and Sergey Levine. Advantage-weighted regression: Simple and scalable off-policy reinforcement learning. arXiv preprint arXiv:1910.00177, 2019.
+
+Martin L Puterman and Moon Chirl Shin. Modified policy iteration algorithms for discounted markov decision problems. Management Science, 24(11):1127–1137, 1978.
+
+Aravind Rajeswaran, Vikash Kumar, Abhishek Gupta, Giulia Vezzani, John Schulman, Emanuel Todorov, and Sergey Levine. Learning complex dexterous manipulation with deep reinforcement learning and demonstrations. arXiv preprint arXiv:1709.10087, 2017.
+
+Bruno Scherrer, Victor Gabillon, Mohammad Ghavamzadeh, and Matthieu Geist. Approximate modified policy iteration. arXiv preprint arXiv:1205.3054, 2012.
+
+John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In International conference on machine learning, pages 1889–1897, 2015.
+
+Noah Siegel, Jost Tobias Springenberg, Felix Berkenkamp, Abbas Abdolmaleki, Michael Neunert, Thomas Lampe, Roland Hafner, Nicolas Heess, and Martin Riedmiller. Keep doing what worked: Behavior modelling priors for offline reinforcement learning. In International Conference on Learning Representations, 2020.
+
+Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018.
+
+Hado Van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double qlearning. In Thirtieth AAAI conference on artificial intelligence, 2016.
+
+Cameron Voloshin, Hoang M Le, Nan Jiang, and Yisong Yue. Empirical study of off-policy policy evaluation for reinforcement learning. arXiv preprint arXiv:1911.06854, 2019.
+
+Qing Wang, Jiechao Xiong, Lei Han, Han Liu, Tong Zhang, et al. Exponentially weighted imitation learning for batched historical data. In Advances in Neural Information Processing Systems, pages 6288–6297, 2018.
+
+Ruosong Wang, Dean P. Foster, and Sham M. Kakade. What are the statistical limits of offline rl with linear function approximation?, 2020a.
+
+Ruosong Wang, Yifan Wu, Ruslan Salakhutdinov, and Sham M Kakade. Instabilities of offline rl with pre-trained neural representation. arXiv preprint arXiv:2103.04947, 2021.
+
+Ziyu Wang, Alexander Novikov, Konrad Zolna, Josh S Merel, Jost Tobias Springenberg, Scott E Reed, Bobak Shahriari, Noah Siegel, Caglar Gulcehre, Nicolas Heess, et al. Critic regularized regression. Advances in Neural Information Processing Systems, 33, 2020b.
+
+Yifan Wu, George Tucker, and Ofir Nachum. Behavior regularized offline reinforcement learning, 2019.
+
+Andrea Zanette. Exponential lower bounds for batch reinforcement learning: Batch rl can be exponentially harder than online rl, 2021.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] See Section 8 and Section 7.   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes] See Section 8.   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] See supplement.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Appendix C   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] In all relevant figures.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] See Appendix C
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes] Data from Fu et al. [2020].   
+(b) Did you mention the license of the assets? [Yes] The license is Apache 2.0.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] Code in supplement.   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A] Data is simulated.   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] Data is simulated.
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/LU687itn08w/LU687itn08w_content_list.json

@@ -0,0 +1,1775 @@
+[
+    {
+        "type": "text",
+        "text": "Offline RL Without Off-Policy Evaluation ",
+        "text_level": 1,
+        "bbox": [
+            241,
+            122,
+            754,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "David Brandfonbrener ",
+        "text_level": 1,
+        "bbox": [
+            191,
+            202,
+            351,
+            214
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "William F. Whitney ",
+        "bbox": [
+            383,
+            200,
+            522,
+            214
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Rajesh Ranganath ",
+        "bbox": [
+            557,
+            202,
+            689,
+            215
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Joan Bruna ",
+        "text_level": 1,
+        "bbox": [
+            723,
+            202,
+            808,
+            215
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Department of Computer Science, Center for Data Science New York University david.brandfonbrener@nyu.edu ",
+        "bbox": [
+            307,
+            215,
+            691,
+            256
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            292,
+            535,
+            309
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Most prior approaches to offline reinforcement learning (RL) have taken an iterative actor-critic approach involving off-policy evaluation. In this paper we show that simply doing one step of constrained/regularized policy improvement using an on-policy Q estimate of the behavior policy performs surprisingly well. This onestep algorithm beats the previously reported results of iterative algorithms on a large portion of the D4RL benchmark. The one-step baseline achieves this strong performance while being notably simpler and more robust to hyperparameters than previously proposed iterative algorithms. We argue that the relatively poor performance of iterative approaches is a result of the high variance inherent in doing off-policy evaluation and magnified by the repeated optimization of policies against those estimates. In addition, we hypothesize that the strong performance of the one-step algorithm is due to a combination of favorable structure in the environment and behavior policy. ",
+        "bbox": [
+            233,
+            321,
+            766,
+            502
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            525,
+            310,
+            542
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "An important step towards effective real-world RL is to improve sample efficiency. One avenue towards this goal is offline RL (also known as batch RL) where we attempt to learn a new policy from data collected by some other behavior policy without interacting with the environment. Recent work in offline RL is well summarized by Levine et al. [2020]. ",
+        "bbox": [
+            174,
+            554,
+            823,
+            609
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we challenge the dominant paradigm in the deep offline RL literature that primarily relies on actor-critic style algorithms that alternate between policy evaluation and policy improvement [Fujimoto et al., 2018a, 2019, Peng et al., 2019, Kumar et al., 2019, 2020, Wang et al., 2020b, Wu et al., 2019, Kostrikov et al., 2021, Jaques et al., 2019, Siegel et al., 2020, Nachum et al., 2019]. All these algorithms rely heavily on off-policy evaluation to learn the critic. Instead, we find that a simple baseline which only performs one step of policy improvement using the behavior Q function often outperforms the more complicated iterative algorithms. Explicitly, we find that our one-step algorithm beats prior results of iterative algorithms on most of the gym-mujoco [Brockman et al., 2016] and Adroit [Rajeswaran et al., 2017] tasks in the the D4RL benchmark suite [Fu et al., 2020]. ",
+        "bbox": [
+            174,
+            614,
+            825,
+            739
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We then dive deeper to understand why such a simple baseline is effective. First, we examine what goes wrong for the iterative algorithms. When these algorithms struggle, it is often due to poor off-policy evaluation leading to inaccurate Q values. We attribute this to two causes: (1) distribution shift between the behavior policy and the policy to be evaluated, and (2) iterative error exploitation whereby policy optimization introduces bias and dynamic programming propagates this bias across the state space. We show that empirically both issues exist in the benchmark tasks and that one way to avoid these issues is to simply avoid off-policy evaluation entirely. ",
+        "bbox": [
+            173,
+            743,
+            825,
+            840
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Finally, we recognize that while the the one-step algorithm is a strong baseline, it is not always the best choice. In the final section we provide some guidance about when iterative algorithms can perform better than the simple one-step baseline. Namely, when the dataset is large and behavior policy has good coverage of the state-action space, then off-policy evaluation can succeed and iterative algorithms can be effective. In contrast, if the behavior policy is already fairly good, but as a result does not have full coverage, then one-step algorithms are often preferable. ",
+        "bbox": [
+            174,
+            844,
+            823,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/cf6e42d2a672364d97aa78052a83104499bb9082e0e6b593f15addb41a4cfc26.jpg",
+        "image_caption": [
+            "Figure 1: A cartoon illustration of the difference between one-step and multi-step methods. All algorithms constrain themselves to a neighborhood of “safe” policies around $\\beta$ . A one-step approach (left) only uses the on-policy ${ \\widehat Q } ^ { \\beta }$ , while a multi-step approach (right) repeatedly uses off-policy $\\widehat { Q } ^ { \\pi _ { i } }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            310,
+            93,
+            679,
+            234
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            323,
+            825,
+            353
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our main contributions are: ",
+        "bbox": [
+            174,
+            356,
+            356,
+            371
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• A demonstration that a simple baseline of one step of policy improvement outperforms more complicated iterative algorithms on a broad set of offline RL problems. • An examination of failure modes of off-policy evaluation in iterative offline RL algorithms. • A description of when one-step algorithms are likely to outperform iterative approaches. ",
+        "bbox": [
+            173,
+            378,
+            826,
+            445
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Setting and notation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            462,
+            375,
+            479
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We will consider an offline RL setup as follows. Let $\\mathcal { M } = \\{ { S } , \\mathcal { A } , \\rho , P , R , \\gamma \\}$ be a discounted infinitehorizon MDP. In this work we focus on applications in continuous control, so we will generally assume that both $s$ and $\\mathcal { A }$ are continuous and bounded. We consider the offline setting where rather than interacting with $\\mathcal { M }$ , we only have access to a dataset $D _ { N }$ of $N$ tuples of $\\left( { { s _ { i } } , { a _ { i } } , { r _ { i } } } \\right)$ collected by some behavior policy $\\beta$ with initial state distribution $\\rho$ . Let $r ( s , a ) = \\mathbb { E } _ { r \\mid s , a } [ r ]$ be the expected reward. Define the state-action value function for any policy $\\pi$ by $Q ^ { \\pi } ( s , a ) : = \\mathbb { E } _ { P , \\pi | s _ { 0 } = s }$ , $\\begin{array} { r } { { \\bf \\Gamma } _ { a _ { 0 } = a } [ \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } r ( s _ { t } , a _ { t } ) ] } \\end{array}$ The objective is to maximize the expected return $J$ of the learned policy: ",
+        "bbox": [
+            173,
+            489,
+            826,
+            592
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c57c0601073da8ff80bf29cf9882b3157ed970835a8e5bc3c7bba0301dc3ca77.jpg",
+        "text": "$$\nJ ( \\pi ) : = \\underset { \\rho , P , \\pi } { \\mathbb { E } } \\left[ \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } r ( s _ { t } , a _ { t } ) \\right] = \\underset { a \\sim \\pi | s } { \\mathbb { E } } \\left[ Q ^ { \\pi } ( s , a ) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            594,
+            669,
+            641
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Following $\\mathrm { F u }$ et al. [2020] and others in this line of work, we allow access to the environment to tune a small $( < 1 0 )$ set of hyperparameters. See Paine et al. [2020] for a discussion of the active area of research on hyperparameter tuning for offline RL. We also discuss this further in Appendix $\\textrm { C }$ . ",
+        "bbox": [
+            174,
+            646,
+            825,
+            689
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 Related work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            705,
+            316,
+            722
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Iterative algorithms. Most prior work on deep offline RL consists of iterative actor-critic algorithms. The primary innovation of each paper is to propose a different mechanism to ensure that the learned policy does not stray too far from the data generated by the behavior policy. Broadly, we group these methods into three camps: policy constraints/regularization, modifications of imitation learning, and Q regularization: ",
+        "bbox": [
+            173,
+            734,
+            825,
+            805
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. The majority of prior work acts directly on the policy. Some authors have proposed explicit constraints on the learned policy to only select actions where $( s , a )$ has sufficient support under the data generating distribution [Fujimoto et al., 2018a, 2019, Laroche et al., 2019]. Another proposal is to regularize the learned policy towards the behavior policy [Wu et al., 2019] usually either with a KL divergence [Jaques et al., 2019] or MMD [Kumar et al., 2019]. This is a very straighforward way to stay close to the behavior with a hyperparameter that determines just how close. All of these algorithms are iterative and rely on off-policy evaluation. ",
+        "bbox": [
+            176,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2. Siegel et al. [2020], Wang et al. [2020b], Chen et al. [2020] all use algorithms that filter out datapoints with low Q values and then perform imitation learning. Wang et al. [2018], Peng et al. [2019] use a weighted imitation learning algorithm where the weights are determined by exponentiated Q values. These algorithms are iterative. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            146
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3. Another way to prevent the learned policy from choosing unknown actions is to incorporate some form of regularization to encourage staying near the behavior and being pessimistic about unknown state, action pairs [Wu et al., 2019, Nachum et al., 2019, Kumar et al., 2020, Kostrikov et al., 2021, Gulcehre et al., 2021]. However, being able to properly quantify uncertainty about unknown states is notoriously difficult when dealing with neural network value functions [Buckman et al., 2020]. ",
+        "bbox": [
+            174,
+            151,
+            825,
+            220
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "One-step algorithms. Some recent work has also noted that optimizing policies based on the behavior value function can perform surprisingly well. As we do, Goo and Niekum [2020] studies the continuous control tasks from the D4RL benchmark, but they examine a complicated algorithm involving ensembles, distributional Q functions, and a novel regularization technique. In contrast, we analyze a substantially simpler algorithm and get better performance on the D4RL tasks. We also focus more of our contribution on understanding and explaining this performance. Gulcehre et al. [2021] studies the discrete action setting and finds that a one-step algorithm (which they call “behavior value estimation”) outperforms prior work on Atari games and other discrete action tasks from the RL Unplugged benchmark [Gulcehre et al., 2020]. They also introduce a novel regularizer for the evaluation step. In contrast, we consider the continuous control setting. This is a substantial difference in setting since continuous control requires actor-critic algorithms with parametric policies while in the discrete setting the policy improvement step can be computed exactly from the Q function. Moreover, while Gulcehre et al. [2021] attribute the poor performance of iterative algorithms to “overestimation”, we define and separate the issues of distribution shift and iterative error exploitation which can combine to cause overestimation. This separation helps to expose the difference between the fundamental limits of off-policy evaluation from the specific problems induced by iterative algorithms, and will hopefully be a useful distinction to inspire future work. Finally, a one-step variant is also briefly discussed in Nadjahi et al. [2019], but is not the focus of that work. ",
+        "bbox": [
+            173,
+            234,
+            825,
+            482
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "There are also important connections between the one-step algorithm and the literature on conservative policy improvement [Kakade and Langford, 2002, Schulman et al., 2015, Achiam et al., 2017], which we discuss in more detail in Appendix B. ",
+        "bbox": [
+            174,
+            487,
+            825,
+            529
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 Defining the algorithms ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            546,
+            401,
+            564
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section we provide a unified algorithmic template for model-free offline RL algorithms as offline approximate modified policy iteration. We show how this template captures our one-step algorithm as well as a multi-step policy iteration algorithm and an iterative actor-critic algorithm. Then any choice of policy evaluation and policy improvement operators can be used to define one-step, multi-step, and iterative algorithms. ",
+        "bbox": [
+            173,
+            575,
+            826,
+            645
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4.1 Algorithmic template ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            660,
+            361,
+            674
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: OAMPI ",
+        "text_level": 1,
+        "bbox": [
+            433,
+            685,
+            581,
+            699
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We consider a generic offline approximate modified policy iteration (OAMPI) scheme, shown in Algorithm 1 (and based off of Puterman and Shin [1978], Scherrer et al. [2012]). Essentially the algorithm alternates between two steps. First, there is a policy evaluation step where we estimate the Q function of the cur",
+        "bbox": [
+            174,
+            683,
+            421,
+            806
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "input : $K$ , dataset $D _ { N }$ , estimated behavior $\\hat { \\beta }$   \nSet $\\pi _ { 0 } = \\hat { \\beta }$ . Initialize $\\widehat { Q } ^ { \\pi _ { - 1 } }$ randomly.   \nfor $k = I$ , . . . , $K$ do Policy evaluation: $\\widehat { Q } ^ { \\pi _ { k - 1 } } = \\mathcal { E } ( \\pi _ { k - 1 } , D _ { N } , \\widehat { Q } ^ { \\pi _ { k - 2 } } )$ Policy improvement: $\\pi _ { k } = \\mathcal { I } ( \\widehat { Q } ^ { \\pi _ { k - 1 } } , \\widehat { \\beta } , D _ { N } , \\pi _ { k - 1 } )$   \nend ",
+        "bbox": [
+            433,
+            704,
+            803,
+            796
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "rent policy $\\pi _ { k - 1 }$ by $\\widehat { Q } ^ { \\pi _ { k - 1 } }$ using only the dataset $D _ { N }$ . Implementations also often use the prior $\\mathrm { Q }$ estimate $\\widehat { Q } ^ { \\pi _ { k - 2 } }$ to warm-start the approximation process. Second, there is a policy improvement step. This step takes in the estimated $\\mathrm { Q }$ function $\\widehat { Q } ^ { \\pi _ { k - 1 } }$ , the estimated behavior $\\hat { \\beta }$ , and the dataset $D _ { N }$ and produces a new policy $\\pi _ { k }$ . Again an algorithm may use $\\pi _ { k - 1 }$ to warm-start the optimization. Moreover, we expect this improvement step to be regularized or constrained to ensure that $\\pi _ { k }$ remains in the support of $\\beta$ and $D _ { N }$ . Choices for this step are discussed below. Now we discuss a few ways to instantiate the template. ",
+        "bbox": [
+            174,
+            809,
+            826,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "One-step. The simplest algorithm sets the number of iterations $K = 1$ . We learn $\\hat { \\beta }$ by maximum likelihood and train the policy evaluation step to estimate $Q ^ { \\beta }$ . Then we use any one of the policy improvement operators discussed below to learn $\\pi _ { 1 }$ . Importantly, this algorithm completely avoids off-policy evaluation. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Multi-step. The multi-step algorithm now sets $K > 1$ . The evaluation operator must evaluate off-policy since $D _ { N }$ is collected by $\\beta$ , but evaluation steps for $K \\geq 2$ require evaluating policies $\\pi _ { k - 1 } \\neq \\beta$ . Each iteration is trained to convergence in both the estimation and improvement steps. ",
+        "bbox": [
+            174,
+            159,
+            825,
+            202
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Iterative actor-critic. An actor critic approach looks somewhat like the multi-step algorithm, but does not attempt to train to convergence at each iteration and uses a much larger $K$ . Here each iteration consists of one gradient step to update the Q estimate and one gradient step to improve the policy. Since all of the evaluation and improvement operators that we consider are gradient-based, this algorithm can adapt the same evaluation and improvement operators used by the multi-step algorithm. Most algorithms from the literature fall into this category [Fujimoto et al., 2018a, Kumar et al., 2019, 2020, Wu et al., 2019, Wang et al., 2020b, Siegel et al., 2020]. ",
+        "bbox": [
+            174,
+            213,
+            825,
+            311
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.2 Policy evaluation operator ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            324,
+            395,
+            339
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Following prior work on continuous state and action problems, we always evaluate by simple fitted Q evaluation [Fujimoto et al., 2018a, Kumar et al., 2019, Siegel et al., 2020, Wang et al., 2020b, Paine et al., 2020, Wang et al., 2021]. In practice this is optimized by TD-style learning with the use of a target network [Mnih et al., 2015] as in DDPG [Lillicrap et al., 2015]. We do not use any double Q learning or Q ensembles [Fujimoto et al., 2018b]. For the one-step and multi-step algorithms we train the evaluation procedure to convergence on each iteration and for the iterative algorithm each iteration takes a single stochastic gradient step. See Voloshin et al. [2019], Wang et al. [2021] for more comprehensive examinations of policy evaluation and some evidence that this simple fitted Q iteration approach is reasonable. It is an interesting direction for future work to consider other operators that use things like importance weighting [Munos et al., 2016] or pessimism [Kumar et al., 2020, Buckman et al., 2020]. ",
+        "bbox": [
+            173,
+            348,
+            825,
+            501
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.3 Policy improvement operators ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            513,
+            423,
+            529
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To instantiate the template, we also need to choose a specific policy improvement operator $\\mathcal { T }$ . We consider the following improvement operators selected from those discussed in the related work section. Each operator has a hyperparameter controlling deviation from the behavior policy. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            579
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Behavior cloning. The simplest baseline worth including is to just return $\\hat { \\beta }$ as the new policy $\\pi$ Any policy improvement operator ought to perform at least as well as this baseline. ",
+        "bbox": [
+            173,
+            593,
+            823,
+            622
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Constrained policy updates. Algorithms like BCQ [Fujimoto et al., 2018a] and SPIBB [Laroche et al., 2019] constrain the policy updates to be within the support of the data/behavior. In favor of simplicity, we implement a simplified version of the BCQ algorithm that removes the “perturbation network” which we call Easy BCQ. We define a new policy $\\hat { \\pi } _ { k } ^ { M }$ by drawing $M$ samples from $\\hat { \\beta }$ and then executing the one with the highest value according to ${ \\widehat Q } ^ { \\beta }$ . Explicitly: ",
+        "bbox": [
+            173,
+            633,
+            825,
+            710
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9f72b83046df5ad9dd3ecf597b5e4da3b76d3b9fe9a2f4e6450d2e5090cbc05d.jpg",
+        "text": "$$\n\\hat { \\pi } _ { k } ^ { M } ( a | s ) = \\mathbb { 1 } [ a = \\arg \\operatorname* { m a x } _ { a _ { j } } \\{ \\widehat { Q } ^ { \\pi _ { k - 1 } } ( s , a _ { j } ) : a _ { j } \\sim \\pi _ { k - 1 } ( \\cdot | s ) , 1 \\leq j \\leq M \\} ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            250,
+            713,
+            748,
+            741
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Regularized policy updates. Another common idea proposed in the literature is to regularize towards the behavior policy [Wu et al., 2019, Jaques et al., 2019, Kumar et al., 2019]. For a general divergence $D$ we can define an algorithm that maximizes a regularized objective: ",
+        "bbox": [
+            173,
+            750,
+            825,
+            791
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/783810d1e4f8f4f055f3b9acf2a9f16234b2bf9edce900e87a5909324ccf1e4f.jpg",
+        "text": "$$\n\\hat { \\pi } _ { k } ^ { \\alpha } = \\arg \\operatorname* { m a x } _ { \\pi } \\sum _ { i } \\underset { a \\sim \\pi | s } { \\mathbb { E } } \\big [ \\widehat { Q } ^ { \\pi _ { k - 1 } } ( s _ { i } , a ) \\big ] - \\alpha D ( \\hat { \\beta } ( \\cdot | s _ { i } ) , \\pi ( \\cdot | s _ { i } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            795,
+            704,
+            828
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A comprehensive review of different variants of this method can be found in $\\mathrm { W u }$ et al. [2019] which does not find dramatic differences across regularization techniques. In practice, we will use reverse KL divergence, i.e. $K L ( \\pi ( \\cdot | s _ { i } ) | | \\hat { \\beta } ( \\cdot | s _ { i } ) )$ . To compute the reverse KL, we draw samples from $\\pi ( \\cdot | s _ { i } )$ and use the density estimate $\\hat { \\beta }$ to compute the divergence. Intuitively, this regularization forces $\\pi$ to remain within the support of $\\beta$ rather than incentivizing $\\pi$ to cover $\\beta$ . ",
+        "bbox": [
+            174,
+            837,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Variants of imitation learning. Another idea, proposed by [Wang et al., 2018, Siegel et al., 2020, Wang et al., 2020b, Chen et al., 2020] is to modify an imitation learning algorithm either by filtering or weighting the observed actions to incentivize policy improvement. The weighted version that we implement uses exponentiated advantage estimates to weight the observed actions: ",
+        "bbox": [
+            173,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/486215b5b5691ae5a44fe0c49451ac3ce42ecd0763eabc8f82adb88a2b5f9944.jpg",
+        "text": "$$\n\\hat { \\pi } _ { k } ^ { \\tau } = \\arg \\operatorname* { m a x } _ { \\pi } \\sum _ { i } \\exp ( \\tau ( \\widehat { Q } ^ { \\pi _ { k - 1 } } ( s _ { i } , a _ { i } ) - \\widehat { V } ( s _ { i } ) ) ) \\log \\pi ( a _ { i } | s _ { i } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            157,
+            709,
+            190
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "With these definitions, we can now move on to testing various combinations of algorithmic template (one-step, multi-step, or iterative) and improvement operator (Easy BCQ, reverse KL regularization, or exponentially weighted imitation). ",
+        "bbox": [
+            174,
+            200,
+            826,
+            243
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 Benchmark Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            265,
+            369,
+            282
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our main empirical finding is that one step of policy improvement is sufficient to beat state of the art results on much of the D4RL benchmark suite [Fu et al., 2020]. This is striking since prior work focuses on iteratively estimating the Q function of the current policy iterate, but we only use one step derived from ${ \\widehat Q } ^ { \\beta }$ . Results are shown in Table 1. Full experimental details are in Appendix C and code can be found at https://github.com/davidbrandfonbrener/onestep-rl. ",
+        "bbox": [
+            173,
+            296,
+            825,
+            369
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/f45d02fd92eb3747995102feca2b7c3844bee6c5f6524732fa5894efbc8f42a9.jpg",
+        "table_caption": [
+            "Table 1: Results of one-step algorithms on the D4RL benchmark. The first column gives the best results across several iterative algorithms considered in Fu et al. [2020]. Each algorithm is tuned over 6 values of their respective hyperparameter. We report the mean and standard error over 10 seeds of the training process and using 100 evaluation episodes per seed. We bold the best result on each dataset and blue any result where a one-step algorithm beat the best reported iterative result from Fu et al. [2020]. We use m for medium, m-e for medium-expert, m-re for medium-replay, r for random, and c for cloned. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"2\">Iterative</td><td colspan=\"3\">One-step</td></tr><tr><td>Fu et al. [2020]</td><td>BC</td><td>Easy BCQ</td><td>Rev. KL Reg</td><td>Exp.Weight</td></tr><tr><td>halfcheetah-m</td><td>46.3</td><td>42.1 ± 0.1</td><td>52.6 ± 0.1</td><td>55.6 ± 0.2</td><td>48.6± 0.0</td></tr><tr><td>walker2d-m</td><td>81.1</td><td>70.2 ±1.3</td><td>86.9 ± 0.4</td><td>85.6 ± 0.4</td><td>80.3 ±1.1</td></tr><tr><td>hopper-m</td><td>58.8</td><td>49.8 ± 0.6</td><td>69.7 ± 2.1</td><td>83.3 ± 1.4</td><td>56.7 ± 0.8</td></tr><tr><td>halfcheetah-m-e</td><td>64.7</td><td>60.1 ± 0.8</td><td>77.0 ± 0.9</td><td>93.5 ± 0.1</td><td>91.7 ± 0.9</td></tr><tr><td>walker2d-m-e</td><td>111.0</td><td>93.6 ± 5.6</td><td>111.8 ± 0.2</td><td>110.9 ± 0.1</td><td>112.9 ± 0.2</td></tr><tr><td>hopper-m-e</td><td>111.9</td><td>48.1 ± 1.5</td><td>81.4 ± 1.9</td><td>102.1 ± 1.3</td><td>83.1 ± 7.0</td></tr><tr><td>halfcheetah-m-re</td><td>47.7</td><td>34.9 ± 0.3</td><td>38.4± 0.3</td><td>42.4± 0.1</td><td>38.6 ± 0.5</td></tr><tr><td>walker2d-m-re</td><td>26.7</td><td>23.9 ± 1.6</td><td>66.4 ± 2.0</td><td>71.6 ± 3.1</td><td>49.3 ± 3.5</td></tr><tr><td>hopper-m-re</td><td>48.6</td><td>21.2 ± 1.3</td><td>77.3 ± 2.7</td><td>71.0 ± 8.1</td><td>94.1 ± 2.4</td></tr><tr><td>halfcheetah-r</td><td>35.4</td><td>2.2 ± 0.0</td><td>5.4 ± 0.1</td><td>6.9 ± 1.0</td><td>3.7± 0.2</td></tr><tr><td>walker2d-r</td><td>7.3</td><td>0.7 ± 0.1</td><td>4.2 ± 0.2</td><td>6.1 ± 0.3</td><td>5.2 ± 0.2</td></tr><tr><td>hopper-r</td><td>12.2</td><td>2.6± 0.4</td><td>6.7 ± 0.1</td><td>7.8± 0.3</td><td>5.6 ± 0.6</td></tr><tr><td>pen-c</td><td>56.9</td><td>49.3 ± 2.2</td><td>67.0 ± 1.1</td><td>55.3 ± 1.9</td><td>54.7 ± 2.3</td></tr><tr><td>hammer-c</td><td>2.1</td><td>0.5 ± 0.1</td><td>2.8 ± 0.5</td><td>0.2±0.0</td><td>1.2 ± 0.2</td></tr><tr><td>relocate-c</td><td>-0.1</td><td>0.0± 0.0</td><td>0.3 ± 0.0</td><td>0.1 ± 0.0</td><td>0.1 ± 0.0</td></tr><tr><td>door-c</td><td>0.4</td><td>0.0± 0.0</td><td>0.4 ± 0.2</td><td>0.0 ± 0.1</td><td>0.1 ± 0.1</td></tr></table>",
+        "bbox": [
+            194,
+            487,
+            795,
+            763
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As we can see in the table, all of the one-step algorithms usually outperform the best iterative algorithms tested by Fu et al. [2020]. The one notable exception is the case of random data (especially on halfcheetah), where iterative algorithms have a clear advantage. We will discuss potential causes of this further in Section 7. ",
+        "bbox": [
+            174,
+            781,
+            823,
+            837
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To give a more direct comparison that controls for any potential implementation details, we use our implementation of reverse KL regularization to create multi-step and iterative algorithms. We are not using algorithmic modifications like Q ensembles, regularized Q values, or early stopping that have been used in prior work. But, our iterative algorithm recovers similar performance to prior regularized actor-critic approaches. These results are shown in Table 2. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/090818cece0491d5084cb10a620369c63aa2e827201043ab04251fd3ddf326a5.jpg",
+        "table_caption": [
+            "Table 2: Results of reverse KL regularization on the D4RL benchmark across one-step, multi-step, and iterative algorithms. Again we run 6 hyperparameters and report the mean and standard error across 10 seeds using 100 evaluation episodes. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>One-step</td><td>Multi-step</td><td>Iterative</td></tr><tr><td>halfcheetah-m</td><td>55.6± 0.2</td><td>40.8 ± 8.6</td><td>47.4 ± 3.5</td></tr><tr><td>walker2d-m</td><td>85.6 ± 0.4</td><td>75.9 ± 0.5</td><td>75.4 ± 0.8</td></tr><tr><td>hopper-m</td><td>83.3 ± 1.4</td><td>53.0 ±1.0</td><td>54.2 ± 0.6</td></tr><tr><td>halfcheetah-m-e</td><td>93.5 ± 0.1</td><td>93.6 ± 0.3</td><td>93.6 ± 0.2</td></tr><tr><td>walker2d-m-e</td><td>110.9 ± 0.1</td><td>76.3 ± 15.9</td><td>108.2 ± 0.3</td></tr><tr><td>hopper-m-e</td><td>102.1 ± 1.3</td><td>101.3 ± 3.9</td><td>82.7 ± 7.4</td></tr><tr><td>halfcheetah-r</td><td>6.9 ± 1.0</td><td>13.7 ± 1.7</td><td>16.3 ± 1.6</td></tr><tr><td>walker2d-r</td><td>6.1 ± 0.3</td><td>5.0±0.3</td><td>5.1± 0.3</td></tr><tr><td>hopper-r</td><td>7.8 ± 0.3</td><td>15.4 ± 2.9</td><td>9.7 ± 0.1</td></tr></table>",
+        "bbox": [
+            297,
+            137,
+            692,
+            292
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Put together, these results immediately suggest some guidance to the practitioner: it is worthwhile to run the one-step algorithm as a baseline before trying something more elaborate. The one-step algorithm is substantially simpler than prior work, but frequently achieves better performance. ",
+        "bbox": [
+            176,
+            324,
+            825,
+            366
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 What goes wrong for iterative algorithms? ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            390,
+            558,
+            407
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The benchmark experiments show that one step of policy improvement often beats iterative and multi-step algorithms. In this section we dive deeper to understand why this happens. First, by examining the learning curves of each of the algorithms we note that iterative algorithms require stronger regularization to avoid instability. Then we identify two causes of this instability: distribution shift and iterative error exploitation. ",
+        "bbox": [
+            174,
+            422,
+            825,
+            492
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Distribution shift causes evaluation error by reducing the effective sample size in the fixed dataset for evaluating the current policy and has been extensively considered in prior work as discussed below. Iterative error exploitation occurs when we repeatedly optimize policies against our Q estimates and exploit their errors. This introduces a bias towards overestimation at each step (much like the training error in supervised learning is biased to be lower than the test error). Moreover, by iteratively re-using the data and using prior Q estimates to warmstart training at each step, the errors from one step are amplified at the next. This type of error is particular to multi-step and iterative algorithms. ",
+        "bbox": [
+            174,
+            496,
+            825,
+            594
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6.1 Learning curves and hyperparameter sensitivity ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            614,
+            545,
+            630
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To begin to understand why iterative and multi-step algorithms can fail it is instructive to look at the learning curves. As shown in Figure 2, we often observe that the iterative algorithm will begin to learn and then crash. Regularization can help to prevent this crash since strong enough regularization towards the behavior policy ensures that the evaluation is nearly on-policy. ",
+        "bbox": [
+            173,
+            640,
+            825,
+            696
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/bbd4b958be2971ecaf3cafc93b6bd3c079cf9f34558ea6eefef0e6a511b802b6.jpg",
+        "image_caption": [
+            "Figure 2: Learning curves and final performance on halfcheetah-medium across different algorithms and regularization hyperparameters (all using the reverse KL regularized improvement operator). Error bars show min and max over 3 seeds. Similar figures for other datasets from D4RL can be found in Appendix D. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            717,
+            820,
+            837
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In contrast, the one-step algorithm is more robust to the regularization hyperparameter. The rightmost panel of the figure shows this clearly. While iterative and multi-step algorithms can have their performance degrade very rapidly with the wrong setting of the hyperparameter, the one-step approach is more stable. Moreover, we usually find that the optimal setting of the regularization hyperparameter is lower for the one-step algorithm than the iterative or multi-step approaches. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            161
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.2 Distribution shift ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            181,
+            333,
+            195
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Any algorithm that relies on off-policy evaluation will struggle with distribution shift in the evaluation step. Trying to evaluate a policy that is substantially different from the behavior reduces the effective sample size and increases the variance of the estimates. Explicitly, by distribution shift we mean the shift between the behavior distribution (the distribution over state-action pairs in the dataset) and the evaluation distribution (the distribution that would be induced by the policy $\\pi$ we want to evaluate). ",
+        "bbox": [
+            174,
+            207,
+            825,
+            276
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Prior work. There is a substantial body of prior theoretical work that suggests that off-policy evaluation can be difficult and this difficulty scales with some measure of distribution shift. Wang et al. [2020a], Amortila et al. [2020], Zanette [2021] give exponential (in horizon) lower bounds on sample complexity in the linear setting even with good feature representations that can represent the desired Q function and assuming good data coverage. Upper bounds generally require very strong assumptions on both the representation and limits on the distribution shift [Wang et al., 2021, Duan et al., 2020, Chen and Jiang, 2019]. Moreover, the assumed bounds on distribution shift can be exponential in horizon in the worst case. On the empirical side, Wang et al. [2021] demonstrates issues with distribution shift when learning from pre-trained features and provides a nice discussion of why distribution shift causes error amplification. Fujimoto et al. [2018a] raises a similar issue under the name “extrapolation error”. Regularization and constraints are meant to reduce issues stemming from distribution shift, but also reduce the potential for improvement over the behavior. ",
+        "bbox": [
+            173,
+            295,
+            825,
+            462
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Empirical evidence. Both the multi-step and iterative algorithms in our experiments rely on offpolicy evaluation as a key subroutine. We examine how easy it is to evaluate the policies encountered along the learning trajectory. To control for issues of iterative error exploitation (discussed in the next subsection), we train Q estimators from scratch on a heldout evaluation dataset sampled from the behavior policy. We then evaluate these trained Q function on rollouts from 1000 datapoints sampled from the replay buffer. Results are shown in Figure 3. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            563
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The results show a correlation betweed KL and MSE. Moreover, we see that the MSE generally increases over training. One way to mitigate this, as seen in the figure, is to use a large value of $\\alpha$ . We just cannot take a very large step before running into problems with distribution shift. But, when we take such a small step, the information from the on-policy ${ \\widehat Q } ^ { \\beta }$ is about as useful as the newly estimated ${ \\widehat { Q } } ^ { \\pi }$ . This is seen, for example, in Figure 2 where we get very similar performance across algorithms at high levels of regularization. ",
+        "bbox": [
+            173,
+            568,
+            825,
+            656
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/7cdca1b44030fc8a1f0c53056fe81e9e58f7cbc3b78dd6f5341ba10b8b54469b.jpg",
+        "image_caption": [
+            "Figure 3: Results of running the iterative algorithm on halfcheetah-medium. Each checkpointed policy is evaluated by a Q function trained from scratch on heldout data. MSE refers to $\\mathbb { E } _ { s , a \\sim \\beta } [ ( \\hat { Q } ^ { \\pi _ { i } } ( s , a ) -$ $Q ^ { \\pi _ { i } } ( s , a ) ) ^ { 2 } ]$ and KL refers to $\\mathbb { E } _ { s \\sim \\beta } [ K L ( \\pi ( \\cdot | s ) | | \\beta ( \\cdot | s ) ]$ . Left: 90 policies taken from various points in training with various hyperaparmeters and random seeds. Center: MSE learning curves. Right: KL learning curves. Error bars show min and max over 3 random seeds. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            676,
+            818,
+            804
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.3 Iterative error exploitation ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            90,
+            400,
+            106
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The previous subsection identifies how any algorithm that uses off-policy evaluation is fundamentally limited by distribution shift, even if we were given fresh data and trained Q functions from scratch at every iteration. But, in practice, iterative algorithms repeatedly iterate between optimizing policies against estimated Q functions and re-estimating the Q functions using the same data and using the Q function from the previous step to warm-start the re-estimation. This induces dependence between steps that causes a problem that we call iterative error exploitation. ",
+        "bbox": [
+            173,
+            114,
+            825,
+            199
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Intuition about the problem. In short, iterative error exploitation happens because $\\pi _ { i }$ tends to choose overestimated actions in the policy improvement step, and then this overestimation propagates via dynamic programming in the policy evaluation step. To illustrate this issue more formally, consider the following: at each $s , a$ we suffer some Bellman error $\\varepsilon _ { \\beta } ^ { \\pi } ( s , a )$ based on our fixed dataset collected by $\\beta$ . Formally, ",
+        "bbox": [
+            174,
+            210,
+            825,
+            282
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/33a80ae0459cecf16d434612353c6902b58aaf43d83ac63c5b7bb1e3513acc84.jpg",
+        "text": "$$\n\\widehat { Q } ^ { \\pi } ( s , a ) = r ( s , a ) + \\gamma \\operatorname * { \\mathbb { E } } _ { \\mathbf { \\Phi } _ { s ^ { \\prime } \\mid s , a } \\atop { a ^ { \\prime } \\sim \\pi \\mid s ^ { \\prime } } } [ \\widehat { Q } ^ { \\pi } ( s ^ { \\prime } , a ^ { \\prime } ) ] + \\varepsilon _ { \\beta } ^ { \\pi } ( s , a ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            287,
+            678,
+            330
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, $\\varepsilon _ { \\beta } ^ { \\pi }$ will be larger at state-actions with less coverage in the dataset collected by $\\beta$ . Note that $\\varepsilon _ { \\beta } ^ { \\pi }$ can absorb all error whether it is caused by the finite sample size or function approximation error. ",
+        "bbox": [
+            171,
+            335,
+            823,
+            366
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "All that is needed to cause iterative error exploitation is that the $\\epsilon _ { \\beta } ^ { \\pi }$ are highly correlated across different $\\pi$ , but for simplicity, we will assume that $\\varepsilon _ { \\beta } ^ { \\pi }$ is the same for all policies $\\pi$ estimated from our fixed offline dataset and instead write $\\varepsilon _ { \\beta }$ . Now that the errors do not depend on the policy we can treat the errors as auxiliary rewards that obscure the true rewards and see that ",
+        "bbox": [
+            174,
+            371,
+            825,
+            430
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f8c00ebd5bb730becd7fb2d1de8baee3fa109fa361ca5ca2850cdfd4421eca15.jpg",
+        "text": "$$\n\\widehat { Q } ^ { \\pi } ( s , a ) = Q ^ { \\pi } ( s , a ) + \\widetilde { Q } _ { \\beta } ^ { \\pi } ( s , a ) , \\qquad \\widetilde { Q } _ { \\beta } ^ { \\pi } ( s , a ) : = \\underset { \\pi | s _ { 0 } , a _ { 0 } = s , a } { \\mathbb { E } } \\left[ \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } \\varepsilon _ { \\beta } ( s _ { t } , a _ { t } ) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            225,
+            436,
+            772,
+            479
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "This assumption is somewhat reasonable since we expect the error to primarily depend on the data. And, when the prior Q function is used to warm-start the current one (as is generally the case in practice), the approximation errors are automatically passed between steps. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            527
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Now we can explain the problem. Recall that under our assumption the $\\varepsilon _ { \\beta }$ are fixed once we have a dataset and likely to have larger magnitude the further we go from the support of the dataset. So, with each step $\\pi _ { i }$ is able to better maximize $\\varepsilon _ { \\beta }$ , thus moving further from $\\beta$ and increasing the magnitude of $\\widetilde { Q } _ { \\beta } ^ { \\pi _ { i } }$ relative to $Q ^ { \\pi _ { i } }$ . Even though $Q ^ { \\pi _ { i } }$ may provide better signal than $Q ^ { \\beta }$ , it can easily be drowned out by $\\widetilde { Q } _ { \\beta } ^ { \\pi _ { i } }$ . In contrast, $\\widetilde { Q } _ { \\beta } ^ { \\beta }$ has small magnitude, so the one-step algorithm is robust to errors1. ",
+        "bbox": [
+            173,
+            531,
+            825,
+            611
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "An example. Now we consider a simple gridworld example to illustrate iterative error exploitation. This example fits exactly into the setup outlined above since all errors are due to reward estimation so the $\\varepsilon _ { \\beta }$ is indeed constant over all $\\pi$ . The gridworld we consider has one deterministic good state with reward 1 and many stochastic bad states that have rewards distributed as $\\mathcal { N } ( - 0 . 5 , 1 )$ . We collect a dataset of 100 trajectories, each of length 100. One run of the multi-step offline regularized policy iteration algorithm is illustrated in Figure 4. ",
+        "bbox": [
+            173,
+            625,
+            825,
+            708
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In the example we see that one step often outperforms multiple steps of improvement. Intuitively, when there are so many noisy states, it is likely that a few of them will be overestimated. Since the data is re-used for each step, these overestimations persist and propagate across the state space due to iterative error exploitation. This property of having many bad, but poorly estimated states likely also exists in the high-dimensional control problems encountered in the benchmark where there are many ways for the robots to fall down that are not observed in the data for non-random behavior. Moreover, both settings have larger errors in areas where we have less data. So even though the errors in the gridworld are caused by noise in the rewards, while errors in D4RL are caused by function approximation, we think this is a useful mental model of the problem. ",
+        "bbox": [
+            173,
+            712,
+            826,
+            837
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/28bd37725a9c5e57318c91a7a0e7430e58e28336dddb89607a085861be130769.jpg",
+        "image_caption": [
+            "Figure 4: An illustration of multi-step offline regularized policy iteration. The leftmost panel in each row shows the true reward (top) or error $\\varepsilon _ { \\beta }$ (bottom). Then each subsequent panel plots $\\pi _ { i }$ (with arrow size proportional to $\\pi _ { i } ( a | s ) .$ ) over either $Q ^ { \\pi _ { i } }$ (top) or $\\widetilde { Q } _ { \\beta } ^ { \\pi }$ (bottom), averaged over actions at each state. The one-step policy $( \\pi _ { 1 } )$ has the highest value. The behavior policy here is a mixture of optimal $\\pi ^ { * }$ and uniform $u$ with coefficient 0.2 so that $\\beta = 0 . 2 \\cdot \\pi ^ { * } + 0 . 8 \\cdot u$ . We set $\\alpha = 0 . 1$ as the regularization parameter for reverse KL regularization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            94,
+            820,
+            284
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/3b10a08795d9696e39c5ae064a78494e5e6e4ed0576dc9e69d03724bd61efe1d.jpg",
+        "image_caption": [
+            "Figure 5: Histograms of overestimation error $( \\widehat { Q } ^ { \\pi _ { i } } ( s , a ) - Q ^ { \\pi _ { i } } ( s , a ) )$ on halfcheetah-medium with the iterative algorithm. Left: errors from the training Q function. Right: errors from an independently trained Q function. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            310,
+            409,
+            686,
+            512
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Empirical evidence. In practice we cannot easily visualize the progression of errors. However, the dependence between steps still arises as overestimation of the Q values. We can track the overestimation of the Q values over training as a way to measure how much bias is being induced by optimizing against our dependent Q estimators. As a control we can also train Q estimators from scratch on independently sampled evaluation data. These independently trained Q functions do not have the same overestimation bias even though the squared error does tend to increase as the policy moves further from the behavior (as seen in Figure 3). Explicitly, we track 1000 state, action pairs from the replay buffer over training. For each checkpointed policy we perform 3 rollouts at each state to get an estimate of the true Q value and compare this to the estimated Q value. Results are shown in Figure 5. ",
+        "bbox": [
+            174,
+            595,
+            825,
+            736
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 When are multiple steps useful? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            752,
+            470,
+            768
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "So far we have focused on why the one-step algorithm often works better than the multi-step and iterative algorithms. However, we do not want to give the impression that one-step is always better. Indeed, our own experiments in Section 5 show a clear advantage for the multi-step and iterative approaches when we have randomly collected data. While we cannot offer a precise delineation of when one-step will outperform multi-step, in this section we offer some intuition as to when we can expect to see benefits from multiple steps of policy improvement. ",
+        "bbox": [
+            174,
+            781,
+            825,
+            864
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As seen in Section 6, multi-step and iterative algorithms have problems when they propagate estimation errors. This is especially problematic in noisy and/or high dimensional environments. While the multi-step algorithms propagate this noise more widely than the one-step algorithm, they also propagate the signal. So, when we have sufficient coverage to reduce the magnitude of the noise, this increased propagation of signal can be beneficial. The D4RL experiments suggest that we are usually on the side of the tradeoff where the errors are large enough to make one-step preferable. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/4deab14cea5ef2dbcec99ba9f0be26cb6ad0981000685aa80269646f930309aa.jpg",
+        "image_caption": [
+            "Figure 6: Performance of all three algorithms with reverse KL regularization across mixtures between halfcheetah-random and halfcheetah-medium. Error bars indicate min and max over 3 seeds. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            372,
+            92,
+            622,
+            219
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            296,
+            825,
+            338
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In Appendix A we illustrate a simple gridworld example where a slight modification of the behavior policy from Figure 4 makes multi-step dramatically outperform one-step. This modified behavior policy (1) has better coverage of the noisy states (which reduces error, helping multi-step), and (2) does a worse job propagating the reward from the good state (hurting one-step). ",
+        "bbox": [
+            174,
+            342,
+            825,
+            398
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We can also test empirically how the behavior policy effects the tradeoff between error and signal propagation. To do this we construct a simple experiment where we mix data from the random behavior policy with data from the medium behavior policy. Explicitly we construct a dataset $D$ out of the datasets $D _ { r }$ for random and $D _ { m }$ for medium such that each trajectory in $D$ comes from the medium dataset with probability $p _ { m }$ . So for $p _ { m } = 0$ we have the random dataset and $p _ { m } = 1$ we have the medium dataset, and in between we have various mixtures. Results are shown in Figure 6. It takes surprisingly little data from the medium policy for one-step to outperform the iterative algorithm. ",
+        "bbox": [
+            173,
+            402,
+            825,
+            513
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "8 Discussion, limitations, and future work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            541,
+            539,
+            559
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This paper presents the surprising effectiveness of a simple one-step baseline for offline RL. We examine the failure modes of iterative algorithms and the conditions where we might expect them to outperform the simple one-step baseline. This provides guidance to a practitioner that the simple one-step baseline is a good place to start when approaching an offline RL problem. ",
+        "bbox": [
+            174,
+            577,
+            823,
+            633
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "But, we leave many questions unanswered. One main limitation is that we lack a clear theoretical characterization of which environments and behaviors can guarantee that one-step outperforms multi-step or visa versa. Such results will likely require strong assumptions, but could provide useful insight. We don’t expect this to be easy as it requires understanding policy iteration which has been notoriously difficult to analyze, often converging much faster than the theory would suggest [Sutton and Barto, 2018, Agarwal et al., 2019]. Another limitation is that while only using one step is perhaps the simplest way to avoid the problems of off-policy evaluation, there are possibly other more elaborate algorithmic solutions that we did not consider here. However, our strong empirical results suggest that the one-step algorithm is at least a strong baseline. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            762
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Broader impact. Our paper studies a simple and effective baseline approach to the offline RL problem. The effectiveness of this baseline raises some serious questions about the utility of prior work proposing substantially more complicated methods. By making this observation of prior shortcomings, our paper has the potential to encourage researchers to derive new and better methods for offline RL. This has many potential impacts on fields as diverse as robotics and healthcare where better offline decision making can lead to better real-world performance. As always, we note that machine learning improvements come in the form of “building machines to do $\\mathbf { X }$ better”. For a sufficiently malicious or ill-informed choice of X, almost any progress in machine learning might indirectly lead to a negative outcome, and our work is not excluded from that. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            92,
+            310,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This work is partially supported by the Alfred P. Sloan Foundation, NSF RI-1816753, NSF CAREER CIF 1845360, NSF CHS-1901091, Samsung Electronics, and the Institute for Advanced Study. DB is supported by the Department of Defense (DoD) through the National Defense Science & Engineering Graduate Fellowship (NDSEG) Program. ",
+        "bbox": [
+            174,
+            114,
+            825,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            189,
+            266,
+            205
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Joshua Achiam, David Held, Aviv Tamar, and Pieter Abbeel. Constrained policy optimization. In International Conference on Machine Learning, pages 22–31. PMLR, 2017. ",
+        "bbox": [
+            173,
+            213,
+            823,
+            242
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alekh Agarwal, Nan Jiang, and S. Kakade. Reinforcement learning: Theory and algorithms. 2019. ",
+        "bbox": [
+            173,
+            251,
+            820,
+            266
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "P. Amortila, Nan Jiang, and Tengyang Xie. A variant of the wang-foster-kakade lower bound for the discounted setting. ArXiv, abs/2011.01075, 2020. ",
+        "bbox": [
+            171,
+            275,
+            823,
+            304
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym. CoRR, abs/1606.01540, 2016. URL http://arxiv.org/abs/ 1606.01540. ",
+        "bbox": [
+            174,
+            314,
+            823,
+            356
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jacob Buckman, Carles Gelada, and Marc G. Bellemare. The importance of pessimism in fixed-dataset policy optimization, 2020. ",
+        "bbox": [
+            173,
+            366,
+            823,
+            395
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Burkhardt. The truncated normal distribution, 2014. ",
+        "bbox": [
+            173,
+            405,
+            550,
+            420
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jinglin Chen and Nan Jiang. Information-theoretic considerations in batch reinforcement learning. In Proceedings of the 36th International Conference on Machine Learning. PMLR, 2019. ",
+        "bbox": [
+            169,
+            429,
+            825,
+            458
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xinyue Chen, Zijian Zhou, Zheng Wang, Che Wang, Yanqiu Wu, and Keith Ross. Bail: Bestaction imitation learning for batch deep reinforcement learning. Advances in Neural Information Processing Systems, 33, 2020. ",
+        "bbox": [
+            174,
+            467,
+            823,
+            511
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yaqi Duan, Zeyu Jia, and Mengdi Wang. Minimax-optimal off-policy evaluation with linear function approximation. In International Conference on Machine Learning, pages 2701–2709. PMLR, 2020. ",
+        "bbox": [
+            174,
+            520,
+            826,
+            563
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Justin Fu, Aviral Kumar, Ofir Nachum, George Tucker, and Sergey Levine. D4rl: Datasets for deep data-driven reinforcement learning. arXiv preprint arXiv:2004.07219, 2020. ",
+        "bbox": [
+            174,
+            571,
+            821,
+            602
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Scott Fujimoto, David Meger, and Doina Precup. Off-policy deep reinforcement learning without exploration. arXiv preprint arXiv:1812.02900, 2018a. ",
+        "bbox": [
+            174,
+            609,
+            821,
+            640
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Scott Fujimoto, Herke van Hoof, and David Meger. Addressing function approximation error in actor-critic methods. arXiv preprint arXiv:1802.09477, 2018b. ",
+        "bbox": [
+            174,
+            648,
+            823,
+            678
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Scott Fujimoto, Edoardo Conti, Mohammad Ghavamzadeh, and Joelle Pineau. Benchmarking batch deep reinforcement learning algorithms. arXiv preprint arXiv:1910.01708, 2019. ",
+        "bbox": [
+            174,
+            688,
+            823,
+            717
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wonjoon Goo and Scott Niekum. You only evaluate once – a simple baseline algorithm for offline rl. In Offline Reinforcement Learning Workshop at Neural Information Processing Systems, 2020. ",
+        "bbox": [
+            171,
+            726,
+            825,
+            756
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Caglar Gulcehre, Ziyu Wang, Alexander Novikov, Tom Le Paine, Sergio Gómez Colmenarejo, Konrad Zolna, Rishabh Agarwal, Josh Merel, Daniel Mankowitz, Cosmin Paduraru, et al. Rl unplugged: Benchmarks for offline reinforcement learning. arXiv preprint arXiv:2006.13888, 2020. ",
+        "bbox": [
+            176,
+            763,
+            826,
+            808
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Caglar Gulcehre, Sergio Gómez Colmenarejo, Ziyu Wang, Jakub Sygnowski, Thomas Paine, Konrad Zolna, Yutian Chen, Matthew Hoffman, Razvan Pascanu, and Nando de Freitas. Regularized behavior value estimation. arXiv preprint arXiv:2103.09575, 2021. ",
+        "bbox": [
+            176,
+            816,
+            823,
+            859
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Natasha Jaques, Asma Ghandeharioun, Judy Hanwen Shen, Craig Ferguson, Agata Lapedriza, Noah Jones, Shixiang Gu, and Rosalind Picard. Way off-policy batch deep reinforcement learning of implicit human preferences in dialog, 2019. ",
+        "bbox": [
+            174,
+            868,
+            825,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sham Kakade and John Langford. Approximately optimal approximate reinforcement learning. In ICML, volume 2, pages 267–274, 2002. ",
+        "bbox": [
+            171,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            171,
+            127,
+            823,
+            157
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ilya Kostrikov, Jonathan Tompson, Rob Fergus, and Ofir Nachum. Offline reinforcement learning with fisher divergence critic regularization. arXiv preprint arXiv:2103.08050, 2021. ",
+        "bbox": [
+            169,
+            165,
+            823,
+            194
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aviral Kumar, Justin Fu, Matthew Soh, George Tucker, and Sergey Levine. Stabilizing off-policy q-learning via bootstrapping error reduction. In Advances in Neural Information Processing Systems, pages 11761–11771, 2019. ",
+        "bbox": [
+            174,
+            202,
+            823,
+            244
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aviral Kumar, Aurick Zhou, George Tucker, and Sergey Levine. Conservative q-learning for offline reinforcement learning. arXiv preprint arXiv:2006.04779, 2020. ",
+        "bbox": [
+            171,
+            252,
+            825,
+            282
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Romain Laroche, Paul Trichelair, and Remi Tachet Des Combes. Safe policy improvement with baseline bootstrapping. In International Conference on Machine Learning, pages 3652–3661. PMLR, 2019. ",
+        "bbox": [
+            174,
+            290,
+            825,
+            332
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine, Aviral Kumar, George Tucker, and Justin Fu. Offline reinforcement learning: Tutorial, review, and perspectives on open problems. arXiv preprint arXiv:2005.01643, 2020. ",
+        "bbox": [
+            171,
+            340,
+            825,
+            371
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015. ",
+        "bbox": [
+            176,
+            377,
+            823,
+            421
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529, 2015. ",
+        "bbox": [
+            176,
+            429,
+            823,
+            472
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Rémi Munos, Tom Stepleton, Anna Harutyunyan, and Marc Bellemare. Safe and efficient off-policy reinforcement learning. In Advances in Neural Information Processing Systems, pages 1054–1062, 2016. ",
+        "bbox": [
+            176,
+            479,
+            823,
+            522
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ofir Nachum, Bo Dai, Ilya Kostrikov, Yinlam Chow, Lihong Li, and Dale Schuurmans. Algaedice: Policy gradient from arbitrary experience. arXiv preprint arXiv:1912.02074, 2019. ",
+        "bbox": [
+            173,
+            530,
+            825,
+            560
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kimia Nadjahi, Romain Laroche, and Rémi Tachet des Combes. Safe policy improvement with soft baseline bootstrapping, 2019. ",
+        "bbox": [
+            173,
+            568,
+            825,
+            597
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tom Le Paine, Cosmin Paduraru, Andrea Michi, Caglar Gulcehre, Konrad Zolna, Alexander Novikov, Ziyu Wang, and Nando de Freitas. Hyperparameter selection for offline reinforcement learning, 2020. ",
+        "bbox": [
+            174,
+            604,
+            823,
+            647
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xue Bin Peng, Aviral Kumar, Grace Zhang, and Sergey Levine. Advantage-weighted regression: Simple and scalable off-policy reinforcement learning. arXiv preprint arXiv:1910.00177, 2019. ",
+        "bbox": [
+            171,
+            656,
+            823,
+            685
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Martin L Puterman and Moon Chirl Shin. Modified policy iteration algorithms for discounted markov decision problems. Management Science, 24(11):1127–1137, 1978. ",
+        "bbox": [
+            171,
+            693,
+            823,
+            722
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aravind Rajeswaran, Vikash Kumar, Abhishek Gupta, Giulia Vezzani, John Schulman, Emanuel Todorov, and Sergey Levine. Learning complex dexterous manipulation with deep reinforcement learning and demonstrations. arXiv preprint arXiv:1709.10087, 2017. ",
+        "bbox": [
+            176,
+            729,
+            823,
+            773
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bruno Scherrer, Victor Gabillon, Mohammad Ghavamzadeh, and Matthieu Geist. Approximate modified policy iteration. arXiv preprint arXiv:1205.3054, 2012. ",
+        "bbox": [
+            171,
+            780,
+            823,
+            810
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In International conference on machine learning, pages 1889–1897, 2015. ",
+        "bbox": [
+            171,
+            818,
+            823,
+            848
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Noah Siegel, Jost Tobias Springenberg, Felix Berkenkamp, Abbas Abdolmaleki, Michael Neunert, Thomas Lampe, Roland Hafner, Nicolas Heess, and Martin Riedmiller. Keep doing what worked: Behavior modelling priors for offline reinforcement learning. In International Conference on Learning Representations, 2020. ",
+        "bbox": [
+            174,
+            854,
+            826,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018. ",
+        "bbox": [
+            169,
+            90,
+            826,
+            107
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Hado Van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double qlearning. In Thirtieth AAAI conference on artificial intelligence, 2016. ",
+        "bbox": [
+            173,
+            114,
+            823,
+            143
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Cameron Voloshin, Hoang M Le, Nan Jiang, and Yisong Yue. Empirical study of off-policy policy evaluation for reinforcement learning. arXiv preprint arXiv:1911.06854, 2019. ",
+        "bbox": [
+            173,
+            151,
+            823,
+            181
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Qing Wang, Jiechao Xiong, Lei Han, Han Liu, Tong Zhang, et al. Exponentially weighted imitation learning for batched historical data. In Advances in Neural Information Processing Systems, pages 6288–6297, 2018. ",
+        "bbox": [
+            173,
+            189,
+            823,
+            232
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ruosong Wang, Dean P. Foster, and Sham M. Kakade. What are the statistical limits of offline rl with linear function approximation?, 2020a. ",
+        "bbox": [
+            173,
+            241,
+            823,
+            270
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ruosong Wang, Yifan Wu, Ruslan Salakhutdinov, and Sham M Kakade. Instabilities of offline rl with pre-trained neural representation. arXiv preprint arXiv:2103.04947, 2021. ",
+        "bbox": [
+            171,
+            279,
+            823,
+            308
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ziyu Wang, Alexander Novikov, Konrad Zolna, Josh S Merel, Jost Tobias Springenberg, Scott E Reed, Bobak Shahriari, Noah Siegel, Caglar Gulcehre, Nicolas Heess, et al. Critic regularized regression. Advances in Neural Information Processing Systems, 33, 2020b. ",
+        "bbox": [
+            176,
+            315,
+            823,
+            359
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yifan Wu, George Tucker, and Ofir Nachum. Behavior regularized offline reinforcement learning, 2019. ",
+        "bbox": [
+            171,
+            367,
+            825,
+            396
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Andrea Zanette. Exponential lower bounds for batch reinforcement learning: Batch rl can be exponentially harder than online rl, 2021. ",
+        "bbox": [
+            173,
+            405,
+            823,
+            434
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            254,
+            106
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            131
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] See Section 8 and Section 7.   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes] See Section 8.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            136,
+            825,
+            239
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            243,
+            493,
+            258
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            238,
+            262,
+            738,
+            294
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            212,
+            299,
+            393,
+            313
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] See supplement.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Appendix C   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] In all relevant figures.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] See Appendix C ",
+        "bbox": [
+            238,
+            316,
+            825,
+            435
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            220,
+            439,
+            825,
+            454
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] Data from Fu et al. [2020].   \n(b) Did you mention the license of the assets? [Yes] The license is Apache 2.0.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] Code in supplement.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A] Data is simulated.   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] Data is simulated. ",
+        "bbox": [
+            238,
+            458,
+            825,
+            593
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            598,
+            705,
+            612
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            616,
+            825,
+            705
+        ],
+        "page_idx": 13
+    }
+]

parse/train/QYjO70ACDK/QYjO70ACDK.md

@@ -0,0 +1,278 @@
+# DISTRIBUTIONAL SLICED-WASSERSTEIN AND APPLICATIONS TO GENERATIVE MODELING
+
+Khai Nguyen VinAI Research, Vietnam v.khainb@vinai.io
+
+Nhat $\mathbf { H o } ^ { * }$ University of Texas, Austin VinAI Research, Vietnam minhnhat@utexas.edu
+
+Tung Pham VinAI Research, Vietnam v.tungph4@vinai.io
+
+# Hung Bui
+
+VinAI Research, Vietnam v.hungbh1@vinai.io
+
+# ABSTRACT
+
+Sliced-Wasserstein distance (SW) and its variant, Max Sliced-Wasserstein distance (Max-SW), have been used widely in the recent years due to their fast computation and scalability even when the probability measures lie in a very high dimensional space. However, SW requires many unnecessary projection samples to approximate its value while Max-SW only uses the most important projection, which ignores the information of other useful directions. In order to account for these weaknesses, we propose a novel distance, named Distributional Sliced-Wasserstein distance (DSW), that finds an optimal distribution over projections that can balance between exploring distinctive projecting directions and the informativeness of projections themselves. We show that the DSW is a generalization of Max-SW, and it can be computed efficiently by searching for the optimal push-forward measure over a set of probability measures over the unit sphere satisfying certain regularizing constraints that favor distinct directions. Finally, we conduct extensive experiments with large-scale datasets to demonstrate the favorable performances of the proposed distances over the previous sliced-based distances in generative modeling applications.
+
+# 1 INTRODUCTION
+
+Optimal transport (OT) is a classical problem in mathematics and operation research. Due to its appealing theoretical properties and flexibility in practical applications, it has recently become an important tool in the machine learning and statistics community; see for example, (Courty et al., 2017; Arjovsky et al., 2017; Tolstikhin et al., 2018; Gulrajani et al., 2017) and references therein. The main usage of OT is to provide a distance named Wasserstein distance, to measure the discrepancy between two probability distributions. However, that distance suffers from expensive computational complexity, which is the main obstacle to using OT in practical applications.
+
+There have been two main approaches to overcome the high computational complexity problem: either approximate the value of OT or apply the OT adaptively to specific situations. The first approach was initiated by (Cuturi, 2013) using an entropic regularizer to speed up the computation of the OT (Sinkhorn, 1967; Knight, 2008). The entropic regularization approach has demonstrated its usefulness in several application domains (Courty et al., 2014; Genevay et al., 2018; Bunne et al., 2019). Along this direction, several works proposed efficient algorithms for solving the entropic OT (Altschuler et al., 2017; Lin et al., 2019b;a) as well as methods to stabilize these algorithms (Chizat et al., 2018; Peyré & Cuturi, 2019; Chizat et al., 2018; Schmitzer, 2019). However, these algorithms have complexities of the order $\mathcal { O } ( k ^ { 2 } )$ , where $k$ is the number of supports. It is expensive when we need to compute the OT repeatedly, especially in learning the data distribution.
+
+The second approach, known as "slicing", takes a rather different perspective. It leverages two key ideas: the OT closed-form expression for two distributions in one-dimensional space, and the transformation of a distribution into a set of projected one-dimensional distributions by the Radon transform (RT) (Helgason, 2010). The popular proposal along this direction is Sliced-Wasserstein (SW) distance (Bonneel et al., 2015), which samples the projecting directions uniformly over a unit sphere in the data ambient space and takes the expectation of the resulting one-dimensional OT distance. The SW distance hence requires a significantly lower computation cost than the original Wasserstein distance and is more scalable than the first approach. Due to its solid statistical guarantees and efficient computation, the SW distance has been successfully applied to a variety of practical tasks (Deshpande et al., 2018; Liutkus et al., 2019; Kolouri et al., 2018; Wu et al., 2019; Deshpande et al., 2019) where it has been shown to have comparative performances to other distances and divergences between probability distributions. However, there is an inevitable bottleneck of computing the SW distance. Specifically, the expectation with respect to the uniform distribution of projections in SW is intractable to compute; therefore, the Monte Carlo method is employed to approximate it. Nevertheless, drawing from a uniform distribution of directions in high-dimension can result in an overwhelming number of irrelevant directions, especially when the actual data lies in a low-dimensional manifold. Hence, SW typically needs to have a large number of samples to yield an accurate estimation of the discrepancy. Alternatively, in the other extreme, Max Sliced-Wasserstein (Max-SW) distance (Deshpande et al., 2019) uses only one important direction to distinguish the probability distributions. However, other potentially relevant directions are ignored in Max-SW. Therefore, Max-SW can miss some important differences between the two distributions in high dimension. We note that the linear projections in the Radon transform can be replaced by non-linear projections resulting in the generalized sliced-Wasserstein distance and its variants (Beylkin, 1984; Kolouri et al., 2019).
+
+Apart from these main directions, there are also few proposals that try either to modify them or to combine the advantages of the above-mentioned approaches. In particular, Paty & Cuturi (2019) extended the idea of the max-sliced distance to the max-subspace distance by considering finding an optimal orthogonal subspace. However, this approach is computationally expensive, since it could not exploit the closed-form of the one-dimensional Wasserstein distance. Another approach named the Projected Wasserstein distance (PWD), which was proposed in (Rowland et al., 2019), uses sliced decomposition to find multiple one-dimension optimal transport maps. Then, it computes the average cost of those maps equally in the original dimension.
+
+Our contributions. Our paper also follows the slicing approach. However, we address key friction in this general line of work: how to obtain a relatively small number of slices simultaneously to maintain the computational efficiency, but at the same time, cover the major differences between two high-dimensional distributions. We take a probabilistic view of slicing by using a probability measure on the unit sphere to represent how important each direction is. From this viewpoint, SW uses the uniform distribution while Max-SW searches for the best delta-Dirac distribution over the projections, both can be considered as special cases. In this paper, we propose to search for an optimal distribution of important directions. We regularize this distribution such that it prefers directions that are far away from one another, hence encouraging an efficient exploration of the space of directions. In the case of no regularization, our proposed method recovers max-(generalized) SW as a special case. In summary, our main contributions are two-fold:
+
+1. First, we introduce a novel distance, named Distributional Sliced-Wasserstein distance (DSW), to account for the issues of previous sliced distances. Our main idea is to search for not just a single most important projection, but an optimal distribution over projections that could balance between an expansion of the area around important projections and the informativeness of projections themselves, i.e., how well they can distinguish the two target probability measures. We show that DSW is a proper metric in the probability space and possesses appealing statistical and computational properties as the previous sliced distances.
+
+2. Second, we apply the DSW distance to generative modeling tasks based on the generative adversarial framework. The extensive experiments on real and large-scale datasets show that DSW distance significantly outperforms the SW and Max-SW distances under similar computational time on these tasks. Furthermore, the DSW distance helps model distribution converge to the data distribution faster and provides more realistic generated images than the SW and Max-SW distances.
+
+Organization. The remainder of the paper is organized as follows. In Section 2, we provide backgrounds for Wasserstein distance and its slice-based versions. In Section 3, we propose distributional (generalized) sliced-Wasserstein distance and analyze some of its theoretical properties. Section 4 includes extensive experiment results followed by discussions in Section 5. Finally, we defer the proofs of key results and extra materials in the Appendices.
+
+Notation. For any $\theta , \theta ^ { \prime } \in \mathbb { R } ^ { d }$ , $\begin{array} { r } { \cos ( \theta , \theta ^ { \prime } ) = \frac { \theta ^ { \dagger } \overset { \star } { \theta ^ { \prime } } } { \| \theta \| \| \theta ^ { \prime } \| } } \end{array}$ θ>θ0kθkkθ0k , where k.k is \`2 norm. For any d ≥ 2, Sd−1 denotes the unit sphere in $d$ dimension in $\ell _ { 2 }$ norm . Furthermore, $\delta$ denotes the Dirac delta function, and $\langle \cdot , \cdot \rangle$ is the Euclidean inner-product. For any $p \geq 1$ , $\mathbb { L } ^ { p } ( \mathbb { R } ^ { d } )$ is the set of real-valued functions on $\mathbb { R } ^ { d }$ with finite $p$ -th moment.
+
+# 2 BACKGROUND
+
+In this section, we provide necessary backgrounds for the (generalized) Radon transform, the Wasserstein, and sliced-Wasserstein distances.
+
+# 2.1 WASSERSTEIN DISTANCE
+
+We start with a formal definition of Wasserstein distance. For any $p \geq 1$ , we define $\mathcal { P } _ { p } ( \mathbb { R } ^ { d } )$ as the set of Borel probability measures with finite $p$ -th moment defined on a given metric space $( \mathbb { R } ^ { d } , \lVert . \rVert )$ For any probability measures $\mu , \nu$ defined on $\boldsymbol { \mathcal { X } } , \boldsymbol { \mathcal { Y } } \subseteq \mathbb { R } ^ { d }$ , we denote their corresponding probability density functions as $I _ { \mu }$ and $I _ { \nu }$ . The Wasserstein distance of order $p$ between $\mu$ and $\nu$ is given by (Villani, 2008; Peyré & Cuturi, 2019):
+
+$$
+W _ { p } ( \mu , \nu ) : = \Big ( \operatorname* { i n f } _ { \pi \in \Pi ( \mu , \nu ) } \int _ { \mathcal { X } \times \mathcal { Y } } \| x - y \| ^ { p } d \pi ( x , y ) \Big ) ^ { \frac { 1 } { p } } ,
+$$
+
+where $\Pi ( \mu , \nu )$ is a set of all transportation plans $\pi$ such that the marginal distributions of $\pi$ are $\mu$ and $\nu$ , respectively. In order to simplify the presentation, we abuse the notation by using both $W _ { p } ( \mu , \nu )$ and $W _ { p } ( I _ { \mu } , I _ { \nu } )$ interchangeably for the Wasserstein distance between $\mu$ and $\nu$ . When $\mu$ and $\nu$ are one-dimension measures, the Wasserstein distance between $\mu$ and $\nu$ has a closed-form expression $\begin{array} { l } { { W _ { p } ( \mu , \nu ) ~ = ~ ( \int _ { 0 } ^ { 1 } | F _ { \mu } ^ { - 1 } ( z ) - F _ { \nu } ^ { - 1 } ( z ) | ^ { p } d z ) ^ { 1 / p } } } \end{array}$ where $F _ { \mu }$ and $F _ { \nu }$ are the cumulative distribution function (CDF) of $I _ { \mu }$ and $I _ { \nu }$ , respectively.
+
+# 2.2 (GENERALIZED) RADON TRANSFORMS
+
+Now, we review (generalized) Radon transform maps, which are key to the notion of (generalized) sliced-Wasserstein distance and its variants. The Radon transform (RT) maps a function $\mathbf { \bar { \chi } } _ { I } \in \mathbb { L } ^ { 1 } ( \mathbb { R } ^ { d } )$ to the space of functions defined over space of lines in $\mathbb { R } ^ { d }$ . In particular, for any $t \in \mathbb { R }$ and direction $\theta \in \mathbb { S } ^ { d - 1 }$ , the RT is defined as follows (Helgason, $\begin{array} { r } { 2 0 1 0 ) : \mathcal { R } \bar { I } ( t , \theta ) : = \int _ { \mathbb { R } ^ { d } } I ( \bar { x } ) \delta ( t - \langle x , \theta \rangle ) d x } \end{array}$ .
+
+The generalized Radon transform (GRT) (Beylkin, 1984) extends the original one from integration over hyperplanes of $\mathbb { R } ^ { d }$ to integration over hypersurfaces. In particular, it is defined as: $\mathcal { G } I ( t , { \boldsymbol { \theta } } ) : =$ $\textstyle \int _ { \mathbb { R } ^ { d } } I ( { \bar { x } } ) \delta ( { \bar { t } } - g ( x , \theta ) ) d x$ , where $t \in \mathbb R$ and $\theta \in \Omega _ { \theta }$ . Here, $\Omega _ { \theta }$ is a compact subset of $\mathbb { R } ^ { d }$ and $\boldsymbol { g } : \mathbb { R } ^ { d } \times \mathbb { S } ^ { d - 1 } \mapsto \mathbb { R }$ is a defining function (cf. Assumptions H1-H4 in (Kolouri et al., 2019) for the definition of defining function) inducing the hypersurfaces. When $g ( x , \theta ) = \langle x , \theta \rangle$ and $\Omega _ { \theta } = \mathbb { S } ^ { d - 1 }$ , the generalized Radon transform becomes the standard Radon transform.
+
+# 2.3 (GENERALIZED) SLICED-WASSERSTEIN DISTANCES
+
+The sliced-Wasserstein distance (SW) between two probability measures $\mu$ and $\nu$ is defined as (Bonneel et al., 2015): $\begin{array} { r } { S W _ { p } ( \mu , \nu ) : = ( \int _ { \mathbb { S } ^ { d - 1 } } W _ { p } ^ { p } \big ( \mathcal { R } I _ { \mu } ( \cdot , \theta ) , \mathcal { R } I _ { \nu } ( \cdot , \theta ) \big ) d \theta ) ^ { 1 / p } } \end{array}$ . Similarly, the generalized sliced-Wasserstein distance (Kolouri et al., 2019) (GSW) is given by $\mathrm { G S W } _ { p } ( \mu , \nu ) : =$ $\begin{array} { r } { ( \int _ { \Omega _ { \theta } } W _ { p } ^ { p } \bigl ( \mathcal { G } I _ { \mu } ( \cdot , \theta ) , \mathcal { G } I _ { \nu } ( \cdot , \theta ) \bigr ) d \theta ) ^ { 1 / p } } \end{array}$ , where $\Omega _ { \theta }$ is the compact set of feasible parameter. However, these integrals are usually intractable. Thus, they are often approximated by using Monte Carlo scheme to draw uniform samples $\{ \theta _ { i } \} _ { i = 1 } ^ { N }$ from $\bar { \mathbb { S } } ^ { d - 1 }$ and $\Omega _ { \theta }$ . In particular, $S W _ { p } ^ { p } ( \mu , \nu ) \approx$ $\begin{array} { r } { \frac { 1 } { N } \sum _ { i = 1 } ^ { N } W _ { p _ { \cdot } } ^ { p } \big ( \mathscr { R } I _ { \mu } ( \cdot , \theta _ { i } ) , \mathscr { R } I _ { \nu } ( \cdot , \theta _ { i } ) \big ) } \end{array}$ and $\begin{array} { r } { \mathbf { G S W } _ { p } ^ { p } ( \mu , \nu ) \approx \frac { 1 } { N } \sum _ { i = 1 } ^ { N } W _ { p } ^ { p } \big ( \mathcal { G } I _ { \mu } ( \cdot , \theta _ { i } ) , \mathcal { G } I _ { \nu } ( \cdot , \theta _ { i } ) \big ) } \end{array}$ . In order to obtain a good approximation of (generalized) SW distances, $N$ needs to be sufficiently large.
+
+However, important directions are not distributed uniformly over the sphere. Thus, this approach will draw potentially many unimportant projections that are not only expensive but also greatly reduce the effect of the SW distance.
+
+# 2.4 MAX (GENERALIZED) SLICED-WASSERSTEIN DISTANCES
+
+An approach to using only informative directions is to simply take the best slice in discriminating two given probability distributions. That distance is max sliced-Wasserstein distance (Max-SW) (Deshpande et al., 2019), which is given by $\begin{array} { r l } & { \operatorname* { m a x } S W _ { p } ( \mu , \nu ) : = \operatorname* { m a x } _ { \theta \in \mathbb { S } ^ { d - 1 } } W _ { p } ( \mathcal { R } I _ { \mu } ( \cdot , \theta ) , \mathcal { R } I _ { \nu } ( \cdot , \theta ) ) } \end{array}$ . By combining this idea with non-linear projections from generalized Radon transform, we obtain max generalized sliced-Wasserstein distance (Max-GSW) (Kolouri et al., 2019). The formal definition of that distance is: $\begin{array} { r } { \operatorname* { m a x } G S W _ { p } ( \mu , \nu ) : = \operatorname* { m a x } _ { \theta \in \Omega _ { \theta } } W _ { p } ( \mathcal { G } I _ { \mu } ( \cdot , \theta ) , \mathcal { G } I _ { \nu } ( \cdot , \theta ) ) } \end{array}$ . The (generalized) MaxSW distances focus on finding only the most important direction. Meanwhile, other informative directions play no role in the distance. Therefore, (generalized) Max-SW distances can ignore useful information about the structure of high dimensional probability measures.
+
+# 3 DISTRIBUTIONAL SLICED-WASSERSTEIN DISTANCE
+
+With the aim of improving the limitations of the previous sliced distances, we propose a novel distance, named Distributional Sliced-Wasserstein distance (DSW), that can search for not just a single but a distribution of important directions on the unit sphere. We prove that it is a well-defined metric and discuss its connection to the existing sliced-based distances in Section 3.1. Then, we provide a procedure to approximate DSW based on its dual form in Section 3.2.
+
+# 3.1 DEFINITION AND METRICITY
+
+We first start with a definition of distributional sliced-Wasserstein distance. We say $C > 0$ admissible if the set $\mathbb { M } _ { C }$ of probability measures $\sigma$ on $\mathbb { S } ^ { d - 1 }$ satisfying $\begin{array} { r } { \mathbb { E } _ { \boldsymbol { \theta } , \boldsymbol { \theta } ^ { \prime } \sim \sigma } \left[ \vert \boldsymbol { \theta } ^ { \top } \boldsymbol { \theta } ^ { \prime } \vert \right] \le \dot { C } } \end{array}$ is not empty.
+
+Definition 1. Given two probability measures $\mu$ and $\nu$ on $\mathbb { R } ^ { d }$ with finite $p$ -th moments where $p \geq 1$ and an admissible regularizing constant $C > 0$ . The distributional sliced-Wasserstein distance (DSW) of order $p$ between $\mu$ and $\nu$ is given by:
+
+$$
+{ D S W } _ { p } ( \mu , \nu ; C ) : = \operatorname* { s u p } _ { \sigma \in \mathbb { M } _ { C } } \bigg ( \mathbb { E } _ { \theta \sim \sigma } \bigg [ W _ { p } ^ { p } ( \mathcal { R } I _ { \mu } ( \cdot , \theta ) , \mathcal { R } I _ { \nu } ( \cdot , \theta ) ) \bigg ] \bigg ) ^ { \frac { 1 } { p } } ,
+$$
+
+where $\mathcal { R }$ is the Radon transform operator.
+
+The DSW aims to find the optimal probability measure of slices on the unit sphere $\mathbb { S } ^ { d - 1 }$ . Note that, the Max-SW distance is equivalent to searching for the best Dirac measure on a single point in $\mathbb { S } ^ { d - 1 }$ , which puts all weights in only one direction. Meanwhile, the uniform measure in the formulation of SW distance distributes the same weights in all directions. Indeed, the uniform and Dirac measures are two special cases, because they view that either all directions are equally important or only one direction is important. That view is too restricted if the data actually lie on low dimensional space. Thus, we aim to find a probability measure which concentrates only on areas around important directions. Furthermore, we do not want these directions to lie in only one small area, because under the orthogonal projection of RT, their corresponding one-dimensional distributions will become similar. In order to achieve this, we search for an optimal measure $\sigma$ that satisfies the regularization constraint $\begin{array} { r } { \mathbb { E } _ { \theta , \theta ^ { \prime } \sim \sigma } [ \left| \theta ^ { \top } \theta ^ { ' } \right| ] \leq C } \end{array}$ . By Cauchy-Schwarz inequality, $C$ is no greater than 1, thus $\mathbb { M } _ { 1 }$ contains all probability measures on the unit sphere. Optimizing over $\mathbb { M } _ { 1 }$ simply returns the best Dirac measure corresponding to the Max-SW distance. When $C$ is small, the constraint forces the measure $\sigma$ to distribute more weights to directions that are far from each other (in terms of their angles). Thus, a small appropriate value of $C$ will help to balance between the distinctiveness and informativeness of these targeted directions. For further discussion about $C$ , see Appendix B.1.
+
+Next, we show that DSW is a well-defined metric on the probability space.
+
+Theorem 1. For any $p \geq 1$ and admissible $C > 0$ , $D S W _ { p } ( \cdot , \cdot ; C )$ is a well-defined metric in the space of Borel probability measures with finite $p$ -th moment. In particular, it is non-negative, symmetric, identity, and satisfies the triangle inequality.
+
+The proof of Theorem 1 is in Appendix A.1. Our next result establishes the topological equivalence between DSW distance and (max)-sliced Wasserstein and Wasserstein distances.
+
+Theorem 2. For any $p \geq 1$ and admissible $C > 0 ;$ , the following holds
+
+$$
+D S W _ { p } ( \mu , \nu ; C ) \leq m a x S W _ { p } ( \mu , \nu ) \leq W _ { p } ( \mu , \nu ) .
+$$
+
+(b) If $C \geq 1 / d ,$ , we have $\begin{array} { r } { D S W _ { p } ( \mu , \nu ; C ) \geq \left( \frac { 1 } { d } \right) ^ { 1 / p } m a x { S W _ { p } ( \mu , \nu ) } \geq \left( \frac { 1 } { d } \right) ^ { 1 / p } S W _ { p } ( \mu , \nu ) . } \end{array}$
+
+As a consequence, when $p \geq 1$ and $C \geq 1 / d , D S W _ { p } ( \cdot , \cdot ; C ) , \cdot$ $S W _ { p }$ , max $S W _ { p }$ , and $W _ { p }$ are topologically equivalent, namely, the convergence of probability measures under $D \bar { S } W _ { p } ( \cdot , \cdot ; \mathbf { \bar { C } } )$ implies the convergence of these measures under other metrics and vice versa.
+
+The proof of Theorem 2 is in Appendix A.2. As a consequence of Theorem 2, the statistical error of estimating the unknown distribution based on the empirical distribution of $n$ i.i.d data under DSW distance is $C _ { d } \cdot n ^ { - 1 / 2 }$ with high probability where $C _ { d }$ is some universal constant depending on dimension $d$ (see Appendix B.3). Therefore, as other sliced-based Wasserstein distances, the DSW distance does not suffer from the curse of dimensionality.
+
+# 3.2 COMPUTATION OF DSW DISTANCE
+
+Direct computation of DSW distance is challenging. Hence we consider a dual form of DSW distance and a reparametrization of $\sigma$ as follows.
+
+Definition 2. For any $p \geq 1$ and admissible $C > 0$ , there exists a non-negative constant $\lambda _ { C }$ depending on $C$ such that the dual form of DSW distance takes the following form
+
+$$
+\begin{array} { r } { { 2 } S W _ { p } ^ { * } ( \mu , \nu ; C ) = \underset { \sigma \in \mathbb { H } } { \operatorname* { s u p } } \left. \left( \mathbb { E } _ { \theta \sim \sigma } \left[ W _ { p } ^ { p } ( \mathcal { R } I _ { \mu } ( \cdot , \theta ) , \mathcal { R } I _ { \nu } ( \cdot , \theta ) ) \right] \right) ^ { \frac { 1 } { p } } - \lambda _ { C } \mathbb { E } _ { \theta , \theta ^ { \prime } \sim \sigma } \left[ | \theta ^ { \top } \theta ^ { \prime } | \right] \right. + \lambda _ { C } C , } \end{array}
+$$
+
+where M denotes the space of all probability measures on the unit sphere $\mathbb { S } ^ { d - 1 }$
+
+By the Lagrangian duality theory, $\mathrm { D S W } _ { p } ( \mu , \nu ; C ) \geq \mathrm { D S W } _ { p } ^ { * } ( \mu , \nu ; C )$ for any $p \geq 1$ and admissible $C > 0$ . In Definition 2, the set $\mathbb { M } _ { C }$ disappears and $\lambda _ { C }$ plays the tuning role for the regularized term $\mathbb { E } _ { \theta , \theta ^ { \prime } \sim \sigma } \big [ | \theta ^ { \top } \theta ^ { \prime } | \big ]$ . When $\lambda _ { C }$ is large, $\mathbb { E } _ { \theta , \theta ^ { \prime } \sim \sigma } ^ { \sim } \big [ | \theta ^ { \top } \theta ^ { \prime } | \big ]$ needs to be small, meaning that $C$ is small. When $\lambda _ { C }$ is small, the value of $\mathbb { E } _ { \theta , \theta ^ { \prime } \sim \sigma } \big [ | \theta ^ { \top } \theta ^ { \prime } | \big ]$ becomes less important, i.e., $C$ is large.
+
+For reparametrizing the measure $\sigma$ , we use a pushforward of uniform measure on the unit sphere through some measurable function $f$ . In particular, let $f$ be a Borel measurable function from $\mathbb { S } ^ { d - 1 }$ to ${ \mathbb S } ^ { d - 1 }$ . For any Borel set $A \subset \mathbb { S } ^ { d - \mathrm { \ i } }$ , we define $\sigma ( A ) \stackrel { \circ } { = } \sigma ^ { d - 1 } ( f ^ { - 1 } ( A ) )$ , where $\sigma ^ { d - 1 }$ is the uniform probability measure on $\mathbb { S } ^ { d - 1 }$ . Then for any Borel measurable function $g : { \mathbb { S } } ^ { d - 1 }  \mathbb { R }$ , we have $\begin{array} { r } { \int _ { \theta \sim \sigma } g ( \theta ) \dot { d } \sigma ( \theta ) = \int _ { \theta \sim \sigma ^ { d - 1 } } ( g \circ f ) ( \theta ) d \sigma ^ { d - \bar { 1 } } ( \theta ) } \end{array}$ . Therefore, we obtain the equivalent dual form of DSW as follows:
+
+$$
+\begin{array} { r l } & { \mathrm { D S W } _ { p } ^ { * } ( \mu , \nu ; C ) = \underset { f \in \mathcal { F } } { \operatorname* { s u p } } \Bigg \{ \Bigg ( \mathbb { E } _ { \theta \sim \sigma ^ { d - 1 } } \big [ W _ { p } ^ { p } \big ( \mathcal { R } I _ { \mu } ( \cdot , f ( \theta ) ) , \mathcal { R } I _ { \nu } ( \cdot , f ( \theta ) ) \big ) \big ] \Bigg ) ^ { 1 / p } } \\ & { \qquad - \lambda _ { C } \mathbb { E } _ { \theta , \theta ^ { \prime } \sim \sigma ^ { d - 1 } } \Big [ \big | f ( \theta ) ^ { \top } f ( \theta ^ { \prime } ) \big | \Big ] \Bigg \} + \lambda _ { C } C : = \underset { f \in \mathcal { F } } { \operatorname* { s u p } } \mathrm { D S } ( f ) , } \end{array}
+$$
+
+where $\mathcal { F }$ is a class of all Borel measurable functions from $\mathbb { S } ^ { d - 1 }$ to $\mathbb { S } ^ { d - 1 }$ .
+
+Finding the optimal $f$ : We parameterize $f$ in the dual form (2) by using a deep neural network with parameter $\phi$ , defined as $f _ { \phi }$ . Then, we estimate the gradient of the objective function $\mathrm { D S } ( f _ { \phi } )$ in equation (2) with respect to $\phi$ and use stochastic gradient ascent algorithm to update $\phi$ . Since there are expectations over uniform distribution in the gradient of $\mathrm { D S } ( f _ { \phi } )$ , we use the Monte Carlo method to approximate these expectations. Note that, we can use the fixed point from the stochastic ascent algorithm to approximate the dual value of DSW in equation (2). A detailed argument for this point is in Appendix B.2. Finally, in generative model applications with DSW being the loss function, we only need to use the gradient of the function $\mathrm { D S } ( . )$ to update the parameters of interest. Therefore, we can treat $\lambda _ { C }$ as a regularized parameter and tune it to find suitable value in these applications.
+
+![](images/e1cac424355623855569b7071b820cc80a55f82017ef08e0ff626e2af202f5c0.jpg)  
+Figure 1: Empirical behavior of optimal measure $\sigma$ , approximated by 1000 samples, on a circle for different values of $\lambda _ { C }$ (the constant in the dual form of DSW in Definition 2) when $\mu$ and $\nu$ are bivariate Gaussian distributions sharing the same eigenvectors. When $\lambda _ { C } = 0$ , $C = 1$ . When $\lambda _ { C }$ increases, $C$ becomes small.
+
+Illustration of the roles of $\lambda _ { C }$ and $C$ : To illustrate the roles of $\lambda _ { C }$ and $C$ in finding optimal distribution $\sigma$ , we conduct a simple experiment on two Gaussian distributions with zero means and covariance matrices given by $\left( \begin{array} { l l } { 2 } & { 0 } \\ { 0 } & { 2 } \end{array} \right)$ and $\left( \begin{array} { l l } { 5 } & { 0 } \\ { 0 } & { 1 } \end{array} \right)$ . The experiment optimizes the empirical form of Definition 2 with different choices of $\lambda _ { C }$ . The results are shown in Figure 1 with the reported value of $\lambda _ { C }$ and $\mathbb { E } _ { \theta , \theta ^ { \prime } \sim \sigma } \big [ | \theta ^ { \top } \theta ^ { \prime } | \big ]$ . For $\lambda _ { C } = 0$ , the obtained distribution concentrates only on one direction. When $\lambda _ { C } = 5 0$ , optimal $\sigma$ distributes more weights to other directions on the circle. When $\lambda _ { C } = 1 0 0 0$ , optimal $\sigma$ is close to the discrete distribution concentrated on two eigenvectors of the covariance matrices, which are the main directions differentiating the two Gaussian distributions.
+
+Extension of DSW and comparison of DSW to Max-GSW-NN: Similar to SW, we extend DSW to distributional generalized sliced Wasserstein (DGSW) by using the non-linear projecting operator via GRT. The definition of the DGSW and its properties are in Appendix C. Finally, in Appendix E.1, we show the distinction of the DSW to Max-GSW-NN (Kolouri et al., 2019) when the neural network defining function in Max-GSW-NN is $g ( x , \theta ) = \langle x , f ( \theta ) \rangle$ where $f : \mathbb { S } ^ { d - 1 } \to \mathbb { S } ^ { d - 1 }$ .
+
+# 4 EXPERIMENTS
+
+In this section, we conduct extensive experiments comparing the performance in both generative quality and computational speed of the proposed DSW distance with other sliced-based distances, namely the SW, Max-SW, Max-GSW-NN (Kolouri et al., 2019) and projected robust subspace Wasserstein (PRW) (Paty & Cuturi, 2019; Lin et al., 2020) using the minimum expected distance estimator (MEDE) (Bernton et al., 2019) on MNIST (LeCun et al., 1998), CIFAR10 (Krizhevsky, 2009), CelebA (Liu et al., 2015) and LSUN (Yu et al., 2015) datasets. The details of the MEDE framework are described in Appendix D. We would like to note that the wall-clock timing of different methods may be subject to the differences in the hyperparameter settings and software implementations of different methods. On MNIST dataset, we train generative models with different distances and then evaluate their performances by comparing Wasserstein-2 distances between 10000 random generated images and all images from the MNIST test set. Due to the very large size of other datasets, e.g., 3 million images in LSUN, it is expensive to compute empirical Wasserstein-2 distance as its complexity is of order ${ \mathcal { O } } ( k ^ { 2 } \log k )$ where $k$ is the number of support points. Therefore, after we train generative models, we use FID score (Heusel et al., 2017) to evaluate the generative quality of these generators. The FID score is calculated from 10000 random generated images and all training samples using precomputed statistics in (Heusel et al., 2017). Finally, for $\lambda _ { C }$ in DSW (see Definition 2), it is chosen in the set $\{ 1 , 1 0 , 1 0 0 , 1 0 0 0 \}$ such that its Wasserstein-2 (FID score) (between 10000 random generated images and all images from corresponding validation set) is the lowest among the four values. Detailed experiment settings are in Appendix G. Finally, we also apply the DSW into color transfer task (Rabin et al., 2010; 2014; Bonneel et al., 2015; Perrot et al., 2016) in Appendix F, where we find that DSW also performs better than SW and Max-SW in this task.
+
+# 4.1 RESULTS ON MNIST
+
+Generative quality and computational speed: We report the performance of the learned generative models for MNIST in Figure 2(a). To plot this figure, we vary the number of projections $N \in$ $\{ 1 , 1 0 , 1 0 ^ { 2 } , 5 \times 1 0 ^ { 2 } , 1 0 ^ { 3 } , 5 \times 1 0 ^ { 3 } , 1 0 ^ { 4 } \}$ for the SW, and $N \in \{ 1 , 1 0 , 1 0 ^ { 2 } , 5 \times 1 0 ^ { 2 } , 1 0 ^ { 3 } , 5 \times 1 0 ^ { 3 } \}$ for the DSW. Then we measure the computational time per minibatch and the Wasserstein-2 score of the learned generators for each $N$ . We plot the Wasserstein-2 score and computational time of Max-SW and Max-GSW-NN in their standard settings (Kolouri et al., 2019). Except for the regime with very fast but low-quality learned models, DSW is better than all the existing slice-based baselines in terms of both model quality and computational speed. Moreover, DSW can learn good models with very few projections, e.g., DSW-10 achieves better model quality than Max-GSW-NN and Max-SW and is one order-of-magnitude faster than these sliced distances. Finally, with a similar computational time, a learned generator by DSW has the Wasserstein-2 score that is roughly $1 0 \%$ lower than the one got from SW. For the qualitative comparison between these distances, we show random generated images from their generative models in Figure 7 in Appendix E.1. We observe that generated images from DSW are sharper and easier to classify into numbers than those from other baseline distances.
+
+![](images/05313ea7c1db89d713694264a662043e8a53b0f9cae59afe10da003d67a7180a.jpg)  
+Figure 2: (a) Comparison between DSW, SW, Max-SW, Max-GSW-NN, PRW and WD based on execution time and performance. Here, each dot of SW and DSW corresponds to the number of projections chosen in $\{ 1 , 1 0 , 1 0 ^ { \cdot 2 } , 5 \times 1 0 ^ { 2 } , 1 0 ^ { 3 } , 5 \times 1 0 ^ { 3 } , 1 0 ^ { 4 } \}$ . Each dot of PRW corresponds to the dimension of the subspace chosen in $\{ 2 , 5 , 1 0 , 5 0 \}$ ; (b) Comparison between SW, DSW, Max-SW and Max-GSW-NN based on Wasserstein-2 distance between distributions of learned model and test set over iterations; (c) Computation speed of distances based on the number of minibatch’s samples (log-log scale); (d) Effect of $\lambda _ { C }$ on the mean of absolute values of pairwise cosine similarity between 10 random directions from the found distribution $\sigma$ of DSW.
+
+Comparison with projected robust subspace Wasserstein (PRW) and Wasserstein distance: In Figure 2(a), we plot the Wasserstein-2 score and computational time of Wasserstein distance (WD) and PRW, where the subspace dimension of PRW varies in the range $\{ 2 , 5 , 1 0 , 5 0 \}$ . PRW is able to improve upon the model quality of slice-based methods including DSW, however at the cost of being an order of magnitude slower than DSW with 10 projections (DSW-10). We observe that DSW-10 obtains a better Wasserstein-2 score than PRW with 5-dimensional subspace, while its corresponding computational time is 30 times faster than that of PRW-5. Using 50 dimension, PRW’s Wasserstein-2 score improves about $2 9 \%$ to that of DSW-10 but the computational cost is also around 40 times slower. The model trained by WD gives good Wasserstein-2 score; however, it is computational expensive (about 40 times slower than DSW-10). The main computational advantage of DSW comes from the exact calculation of Wasserstein distance in one-dimension. The visual comparison between PRW, WD and DSW based on their generated images is in Figure 12 in Appendix E.2.
+
+Convergence behavior: Figure 2(b) shows that DSW learns better models at a faster speed of convergence than other baseline distances with a very small number of projections, e.g., DSW-10 is the second lowest curve compared to curves from other sliced-based distances.
+
+Scalability over sample size of minibatch: Results in Figure 2(c) show that DSW has a computational complexity of the order ${ \mathcal { O } } ( k \log k )$ , which is similar to those of other sliced-based distances, where $k$ is the number of samples per batch.
+
+Effect of the reguloptimal distribution ization paraof DSW with $\lambda _ { C }$ : For each value of projections, and the $\lambda _ { C } \in \{ 1 , 1 0 , 1 0 0 , 1 0 0 0 \}$ $\sigma$ $N = 1 0$ $\begin{array} { r } { A _ { N } = \frac { 1 } { N ^ { 2 } } \sum _ { i , j = 1 } ^ { N } | \boldsymbol { \theta } _ { i } ^ { \top } \boldsymbol { \theta } _ { j } | } \end{array}$ an approximation of the regularized term $\mathbb { E } _ { \theta , \theta ^ { \prime } \sim \sigma } \left[ \left| \theta ^ { \top } \theta ^ { \prime } \right| \right]$ in the dual form of DSW in equation (2), where $\{ \theta _ { i } \} _ { i = 1 } ^ { N } \sim \sigma$ . The results are shown in Figure 2(d). We observe that when $\lambda _ { C }$ increases, $A _ { N }$ goes down. When $\lambda _ { C } = 0$ , i.e., no regularization, $A _ { N }$ gets close to 1, meaning that all projected directions collapse to one direction. When $\lambda _ { C } = 1 0 0 0$ , $A _ { N }$ is close to 0.1, suggesting that all projected directions are nearly orthogonal.
+
+![](images/2f0215c39c5f57dc4c0277750b8548580cc04641cc662db46352e1c8edb4a65c.jpg)  
+Figure 3: Comparison between DSW, SW, Max-SW and Max-GSW-NN in terms of execution time and performance. Here, each dot of SW and DSW corresponds to the number of projections chosen in $\{ 1 0 ^ { 2 } , 5 \times$ $\mathrm { \dot { 1 } 0 ^ { 2 } , 1 0 ^ { 3 } , 5 \times 1 0 ^ { 3 } , 1 0 ^ { 4 } } \}$ . We set the minibatch size be 512 on CelebA and CIFAR, and be 4096 on LSUN.
+
+Additional experiments: We also investigate how the number of gradient-steps used for updating distribution of directions $\sigma$ , and how the size of minibatches affects the quality of DSW (see Appendix E.1). The results show that an increasing number of gradient steps to update $\sigma$ leads to better performance of DSW but also slows down the computation speed. Furthermore, we carry out experiments with DGSW, an extension of DSW to non-linear projections, and test the new proposed distances in training encoder-generator models on MNIST using joint contrastive inference (JCI) in Appendices E.1 and E.3. The description of these models is in Appendix D.
+
+# 4.2 RESULTS ON LARGE-SCALE DATASETS
+
+Next, we conduct large-scale experiments on a range of more realistic image datasets. We train generative models using CIFAR10, CelebA, and LSUN datasets (all these datasets are rescaled to $6 4 \mathrm { x } 6 4$ resolution). When working with high dimensional distributions, Deshpande et al. (2018) proposed a trick to improve the quality of the generator by learning a feature function which maps data to a new feature space that is more manageable in size. When the feature function is fixed, the generator is trained to match the distribution of features. When the generator is fixed, the feature function tries to tease apart the data empirical features from the generated feature distribution. For the experiments in this section, we use the same technique with DSW and all other baseline distances.
+
+We compare DSW with SW, Max-SW, and Max-GSW-NN in both generative quality (FID score) and computational time in Figure 3. We could not compare DSW with PRW on the large-scale datasets since PRW is computationally expensive to train to obtain good generated images. On CelebA and CIFAR10, we let $N$ , the number of projections of both DSW and SW, vary in the set $\{ 1 0 ^ { 2 } , 5 \times 1 0 ^ { 2 } , 1 0 ^ { 3 } , 5 \times 1 0 ^ { 3 } , 1 0 ^ { 4 } \}$ . For LSUN, since it takes considerably longer time to train each model, we only vary $N$ in the set $\{ 1 0 ^ { 2 } , 1 0 ^ { 4 } \}$ . On all these large datasets, DSW outperforms all the other baselines in both FID score of the learned model and computational efficiency. The gap of FID scores between DSW and other methods is especially large on CIFAR10 and LSUN. For example, on CIFAR10, with the same computational time, FID scores of DSW are always lower than those of SW about 20 units. On LSUN, with 100 projections, DSW can achieve an FID score of 46 while SW with 10000 projections still has a worse FID score of over 60. It is interesting to note that on these high-dimensional datasets, Max-SW performs rather poorly: it obtains the highest FID scores among all distances while requires heavy computation. Max-GSW-NN has better FID scores than (Max)-SW; however, it is still worse than DSW and while being slower. This is consistent with the intuition that as the number of dimension of the data grows, the use of a single important slice in Max-SW becomes a less efficient approximation. DSW, on the other hand, is able to make use of more important slices, and at the same time avoids SW’s inefficiency of uniform slice-sampling.
+
+Generated images from CelebA, CIFAR10 and LSUN are deferred to Appendix E.1. Comparing to other sliced-based Wasserstein distances, generated samples obtained from the DSW’s generative model are also more visually realistic. Further experiments to compare DGSW with GSW, Max-GSW, and Max-GSW-NN are also given in the Appendix E.1. Based on these experiments, we can conclude that the distributional approach also improves the generative quality of non-linear slicing distances.
+
+# 5 CONCLUSION
+
+In this paper, we have presented the novel distributional sliced-Wasserstein (DSW) distances between two probability measures. Our main idea is to search for the best distribution of important directions while regularizing towards orthogonal directions. We prove that they are well-defined metrics and provide their theoretical and computational properties. We compare our proposed distances to other sliced-based distances in a variety of generative modeling tasks, including estimating generative models and jointly estimating both generators and inference models. Extensive experiments demonstrate that our new distances yield significantly better models and convergence behaviors during training than the previous sliced-based distances. One important future direction is to investigate theoretically the optimal choice of the regularization parameter $\lambda _ { C }$ such that the DSW distance can capture all the important directions that can distinguish two target probability measures well.
+
+# REFERENCES
+
+Jason Altschuler, Jonathan Niles-Weed, and Philippe Rigollet. Near-linear time approximation algorithms for optimal transport via Sinkhorn iteration. In Advances in neural information processing systems, pp. 1964–1974, 2017.
+
+Luca Ambrogioni, Umut Güçlü, Yagmur Güçlütürk, Max Hinne, Marcel AJ van Gerven, and Eric ˘ Maris. Wasserstein variational inference. In Advances in Neural Information Processing Systems, pp. 2473–2482, 2018.
+
+Martin Arjovsky, Soumith Chintala, and Léon Bottou. Wasserstein generative adversarial networks. In International Conference on Machine Learning, pp. 214–223, 2017.
+
+Erhan Bayraktar and Gaoyue Guo. Strong equivalence between metrics of Wasserstein type. arXiv preprint arXiv:1912.08247, 2019.
+
+Espen Bernton, Pierre E Jacob, Mathieu Gerber, and Christian P Robert. On parameter estimation with the Wasserstein distance. Information and Inference: A Journal of the IMA, 8(4):657–676, 2019.
+
+Gregory Beylkin. The inversion problem and applications of the generalized Radon transform. Communications on pure and applied mathematics, 37(5):579–599, 1984.
+
+Nicolas Bonneel and David Coeurjolly. Spot: sliced partial optimal transport. ACM Transactions on Graphics (TOG), 38(4):1–13, 2019.
+
+Nicolas Bonneel, Julien Rabin, Gabriel Peyré, and Hanspeter Pfister. Sliced and Radon Wasserstein barycenters of measures. Journal of Mathematical Imaging and Vision, 1(51):22–45, 2015.
+
+Nicolas Bonnotte. Unidimensional and evolution methods for optimal transportation. PhD thesis, Paris 11, 2013.
+
+Charlotte Bunne, David Alvarez-Melis, Andreas Krause, and Stefanie Jegelka. Learning generative models across incomparable spaces. In International Conference on Machine Learning, 2019.
+
+Xiongjie Chen, Yongxin Yang, and Yunpeng Li. Augmented sliced Wasserstein distances. arXiv preprint arXiv:2006.08812, 2020.
+
+Lenaic Chizat, Gabriel Peyré, Bernhard Schmitzer, and François-Xavier Vialard. Scaling algorithms for unbalanced optimal transport problems. Mathematics of Computation, 87(314):2563–2609, 2018.
+
+Nicolas Courty, Rémi Flamary, and Devis Tuia. Domain adaptation with regularized optimal transport. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pp. 274–289. Springer, 2014.
+
+Nicolas Courty, Rémi Flamary, Amaury Habrard, and Alain Rakotomamonjy. Joint distribution optimal transportation for domain adaptation. In Advances in Neural Information Processing Systems, pp. 3730–3739, 2017.
+
+Marco Cuturi. Sinkhorn distances: Lightspeed computation of optimal transport. In Advances in neural information processing systems, pp. 2292–2300, 2013.
+
+Ishan Deshpande, Ziyu Zhang, and Alexander G Schwing. Generative modeling using the sliced Wasserstein distance. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 3483–3491, 2018.
+
+Ishan Deshpande, Yuan-Ting Hu, Ruoyu Sun, Ayis Pyrros, Nasir Siddiqui, Sanmi Koyejo, Zhizhen Zhao, David Forsyth, and Alexander G Schwing. Max-sliced Wasserstein distance and its use for GANs. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 10648–10656, 2019.
+
+Vincent Dumoulin, Ishmael Belghazi, Ben Poole, Olivier Mastropietro, Alex Lamb, Martin Arjovsky, and Aaron Courville. Adversarially learned inference. arXiv preprint arXiv:1606.00704, 2016.
+
+R’emi Flamary and Nicolas Courty. Pot python optimal transport library, 2017. URL https: //pythonot.github.io/.
+
+Aude Genevay, Gabriel Peyre, and Marco Cuturi. Learning generative models with Sinkhorn divergences. In International Conference on Artificial Intelligence and Statistics, pp. 1608–1617, 2018.
+
+Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron C Courville. Improved training of Wasserstein Gans. In Advances in neural information processing systems, pp. 5767–5777, 2017.
+
+Sigurdur Helgason. Integral geometry and Radon transforms. Springer Science & Business Media, 2010.
+
+Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. In Advances in Neural Information Processing Systems, pp. 6626–6637, 2017.
+
+Diederik $\mathrm { \bf P }$ Kingma and Max Welling. Auto-encoding variational Bayes. arXiv preprint arXiv:1312.6114, 2013.
+
+Philip A Knight. The Sinkhorn–Knopp algorithm: convergence and applications. SIAM Journal on Matrix Analysis and Applications, 30(1):261–275, 2008.
+
+Max Kochurov, Rasul Karimov, and Serge Kozlukov. Geoopt: Riemannian optimization in pytorch, 2020.
+
+Soheil Kolouri, Phillip E Pope, Charles E Martin, and Gustavo K Rohde. Sliced Wasserstein auto-encoders. In International Conference on Learning Representations, 2018.
+
+Soheil Kolouri, Kimia Nadjahi, Umut Simsekli, Roland Badeau, and Gustavo Rohde. Generalized sliced Wasserstein distances. In Advances in Neural Information Processing Systems, pp. 261–272, 2019.
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009.
+
+Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Bing Li, Shaoli Wang, et al. On directional regression for dimension reduction. Journal of the American Statistical Association, 102:997–1008, 2007.
+
+Ker-Chau Li. Sliced inverse regression for dimension reduction. Journal of the American Statistical Association, 86(414):316–328, 1991.
+
+Tianyi Lin, Nhat Ho, and Michael Jordan. On efficient optimal transport: An analysis of greedy and accelerated mirror descent algorithms. In International Conference on Machine Learning, pp. 3982–3991, 2019a.
+
+Tianyi Lin, Nhat Ho, and Michael I Jordan. On the acceleration of the Sinkhorn and Greenkhorn algorithms for optimal transport. arXiv preprint arXiv:1906.01437, 2019b.
+
+Tianyi Lin, Chenyou Fan, Nhat Ho, Marco Cuturi, and Michael I. Jordan. Projection robust Wasserstein distance and Riemannian optimization. arXiv preprint arXiv:2006.07458, 2020.
+
+Ziwei Liu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Deep learning face attributes in the wild. In Proceedings of International Conference on Computer Vision (ICCV), December 2015.
+
+Antoine Liutkus, Umut Simsekli, Szymon Majewski, Alain Durmus, and Fabian-Robert Stöter. Sliced-Wasserstein flows: Nonparametric generative modeling via optimal transport and diffusions. In International Conference on Machine Learning, pp. 4104–4113, 2019.
+
+Cheng Meng, Yuan Ke, Jingyi Zhang, Mengrui Zhang, Wenxuan Zhong, and Ping Ma. Large-scale optimal transport map estimation using projection pursuit. In Advances in Neural Information Processing Systems, pp. 8118–8129, 2019.
+
+Boris Muzellec and Marco Cuturi. Subspace detours: Building transport plans that are optimal on subspace projections. In Advances in Neural Information Processing Systems, pp. 6917–6928, 2019.
+
+Kimia Nadjahi, Alain Durmus, Umut Simsekli, and Roland Badeau. Asymptotic guarantees for learning generative models with the sliced-Wasserstein distance. In Advances in Neural Information Processing Systems, pp. 250–260, 2019.
+
+François-Pierre Paty and Marco Cuturi. Subspace robust Wasserstein distances. In International Conference on Machine Learning, pp. 5072–5081, 2019.
+
+Michaël Perrot, Nicolas Courty, Rémi Flamary, and Amaury Habrard. Mapping estimation for discrete optimal transport. Advances in Neural Information Processing Systems, 29:4197–4205, 2016.
+
+Gabriel Peyré and Marco Cuturi. Computational optimal transport. Foundations and Trends® in Machine Learning, 11(5-6):355–607, 2019.
+
+Julien Rabin, Julie Delon, and Yann Gousseau. Regularization of transportation maps for color and contrast transfer. In 2010 IEEE International Conference on Image Processing, pp. 1933–1936. IEEE, 2010.
+
+Julien Rabin, Sira Ferradans, and Nicolas Papadakis. Adaptive color transfer with relaxed optimal transport. In 2014 IEEE International Conference on Image Processing (ICIP), pp. 4852–4856. IEEE, 2014.
+
+Erik Reinhard, Michael Adhikhmin, Bruce Gooch, and Peter Shirley. Color transfer between images. IEEE Computer graphics and applications, 21(5):34–41, 2001.
+
+Mark Rowland, Jiri Hron, Yunhao Tang, Krzysztof Choromanski, Tamas Sarlos, and Adrian Weller. Orthogonal estimation of Wasserstein distances. In The 22nd International Conference on Artificial Intelligence and Statistics, pp. 186–195, 2019.
+
+Bernhard Schmitzer. Stabilized sparse scaling algorithms for entropy regularized transport problems. SIAM Journal on Scientific Computing, 41(3):A1443–A1481, 2019.
+
+Richard Sinkhorn. Diagonal equivalence to matrices with prescribed row and column sums. The American Mathematical Monthly, 74(4):402–405, 1967.
+
+Ilya Tolstikhin, Olivier Bousquet, Sylvain Gelly, and Bernhard Schoelkopf. Wasserstein auto-encoders. In International Conference on Learning Representations, 2018.
+
+Cédric Villani. Optimal transport: Old and New. Springer, 2008.
+
+Martin J Wainwright. High-dimensional statistics: A non-asymptotic viewpoint. Cambridge University Press, 2019.
+
+Jiqing Wu, Zhiwu Huang, Dinesh Acharya, Wen Li, Janine Thoma, Danda Pani Paudel, and Luc Van Gool. Sliced Wasserstein generative models. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3713–3722, 2019.
+
+Fisher Yu, Yinda Zhang, Shuran Song, Ari Seff, and Jianxiong Xiao. Lsun: Construction of a largescale image dataset using deep learning with humans in the loop. arXiv preprint arXiv:1506.03365, 2015.

parse/train/SJTQLdqlg/SJTQLdqlg.md

@@ -0,0 +1,246 @@
+# LEARNING TO REMEMBER RARE EVENTS
+
+Łukasz Kaiser∗   
+Google Brain   
+lukaszkaiser@google.com   
+Ofir Nachum∗†   
+Google Brain   
+ofirnachum@google.com   
+Aurko Roy‡   
+Georgia Tech   
+aurko@gatech.edu   
+Samy Bengio   
+Google Brain   
+bengio@google.com
+
+# ABSTRACT
+
+Despite recent advances, memory-augmented deep neural networks are still limited when it comes to life-long and one-shot learning, especially in remembering rare events. We present a large-scale life-long memory module for use in deep learning. The module exploits fast nearest-neighbor algorithms for efficiency and thus scales to large memory sizes. Except for the nearest-neighbor query, the module is fully differentiable and trained end-to-end with no extra supervision. It operates in a life-long manner, i.e., without the need to reset it during training.
+
+Our memory module can be easily added to any part of a supervised neural network. To show its versatility we add it to a number of networks, from simple convolutional ones tested on image classification to deep sequence-to-sequence and recurrent-convolutional models. In all cases, the enhanced network gains the ability to remember and do life-long one-shot learning. Our module remembers training examples shown many thousands of steps in the past and it can successfully generalize from them. We set new state-of-the-art for one-shot learning on the Omniglot dataset and demonstrate, for the first time, life-long one-shot learning in recurrent neural networks on a large-scale machine translation task.
+
+# 1 INTRODUCTION
+
+Machine learning systems have been successful in many domains, from computer vision (Krizhevsky et al., 2012) to speech recognition (Hinton et al., 2012) and machine translation (Sutskever et al., 2014; Bahdanau et al., 2014; Cho et al., 2014). Neural machine translation (NMT) is so successful that for some language pairs it approaches, on average, the quality of human translators (Wu et al., 2016). The words on average are crucial though. When a sentence resembles one from the abundant training data, the translation will be accurate. However, when encountering a rare word such as Dostoevsky (in German, Dostojewski), many models will fail. The correct German translation of Dostoevsky does not appear enough times in the training data for the model to sufficiently learn its translation.
+
+While more example sentences concerning the famous Russian author might eventually be added to the training data, there are many other rare words or rare events of other kinds. This illustrates a general problem with current deep learning models: it is necessary to extend the training data and re-train them to handle such rare or new events. Humans, on the other hand, learn in a life-long fashion, often from single examples.
+
+We present a life-long memory module that enables one-shot learning in a variety of neural networks. Our memory module consists of key-value pairs. Keys are activations of a chosen layer of a neural network, and values are the ground-truth targets for the given example. This way, as the network is trained, its memory increases and becomes more useful. Eventually it can give predictions that leverage on knowledge from past data with similar activations. Given a new example, the network writes it to memory and is able to use it afterwards, even if the example was presented just once.
+
+There are many advantages of having a long-term memory. One-shot learning is a desirable property in its own right, and some tasks, as we will show below, are simply not solvable without it. Even real-world tasks where we have large training sets, such as translation, can benefit from long-term memory. Finally, since the memory can be traced back to training examples, it might help explain the decisions that the model is making and thus improve understandability of the model.
+
+It is not immediately clear how to measure the performance of a life-long one-shot learning model, since most deep learning evaluations focus on the average performance and do not have a one-shot component. We therefore evaluate in a few ways, to show that our memory module indeed works:
+
+(1) We evaluate on the well-known one-shot learning task Omniglot, which is the only dataset with explicit one-shot learning evaluation. This dataset is small and does not benefit from life-long learning capability of our module, but we still exceed the best previous results and set new state-of-the-art.   
+(2) We devise a synthetic task that requires life-long one-shot learning. On this task, standard models fare poorly while our model can solve it well, demonstrating its strengths.   
+(3) Finally, we train an English-German translation model that has our life-long one-shot learning module. It retains very good performance on average and is also capable of one-shot learning. On the qualitative side, we find that it can translate rarely-occurring words like Dostoevsky. On the quantitative side, we see that the BLEU score for the generated translations can be significantly increased by showing it related translations before evaluating.
+
+# 2 MEMORY MODULE
+
+Our memory consists of a matrix $K$ of memory keys, a vector $V$ of memory values, and an additional vector $A$ that tracks the age of items stored in memory. Keys can be arbitrary vectors of size ${ \mathrm { k e y } } - s { \mathrm { i } } z { \mathrm { e } }$ , and we assume that the memory values are single integers representing a class or token ID. We define a memory of size memory-size as a triple:
+
+$$
+\mathcal { M } = ( K _ { \mathrm { m e m o r y - s i z e } \times \mathrm { k e y - s i z e } } , ~ V _ { \mathrm { m e m o r y - s i z e } } , ~ A _ { \mathrm { m e m o r y - s i z e } } ) .
+$$
+
+A memory query is a vector of size key-size which we assume to be normalized, i.e., $\| q \| = 1$ . Given a query $q$ , we define the nearest neighbor of $q$ in $\mathcal { M }$ as any of the keys that maximize the dot product with $q$ :
+
+$$
+\operatorname { N N } ( q , \mathcal { M } ) = \operatorname { a r g m a x } _ { i } q \cdot K [ i ] .
+$$
+
+Since the keys are normalized, the above notion corresponds to the nearest neighbor with respect to cosine similarity. We will also use the natural extension of it to $k$ nearest neighbors, which we denote $\mathrm { N N } _ { k } ( q , \mathcal { M } )$ . In our experiments we always used the set of $k = 2 5 6$ nearest neighbors.
+
+When given a query $q$ , the memory $\mathcal { M } = ( K , V , A )$ will compute $k$ nearest neighbors (sorted by decreasing cosine similarity):
+
+$$
+( n _ { 1 } , \dots , n _ { k } ) = \Nu \Nu _ { k } ( q , { \mathcal { M } } )
+$$
+
+and return, as the main result, the value $V [ n _ { 1 } ]$ . Additionally, we will compute the cosine similarities $d _ { i } = \boldsymbol { q } \cdot \boldsymbol { K } [ n _ { i } ]$ and return softmax $( d _ { 1 } \cdot t , \ldots , d _ { k } \cdot t )$ . The parameter $t$ denotes the inverse of softmax temperature and we set it to $t = 4 0$ in our experiments. In models where the memory output is again embedded into a dense vector, we multiply the embedded output by the corresponding softmax component so as to provide a signal about confidence of the memory.
+
+The forward computation of the memory module is thus very simple, the only interesting part being how to compute nearest neighbors efficiently, which we discuss below. But we must also answer the question how the memory is trained.
+
+Memory Loss. Assume now that in addition to a query $q$ we are also given the correct desired (supervised) value $v$ . In the case of classification, this $v$ would be the class label. In a sequenceto-sequence task, $v$ would be the desired output token of the current time step. After computing the $k$ nearest neighbors $( n _ { 1 } , \ldots , n _ { k } )$ as above, let $p$ be the smallest index such that $V [ n _ { p } ] = { \bar { v } }$ and
+
+Case $1 \colon V [ n _ { 1 } ] = v ; \quad \operatorname { L o s s } = [ q \cdot k _ { b } - q \cdot k _ { 1 } + \alpha ] _ { + }$ Update: $\begin{array} { r l } { K [ n _ { 1 } ] \gets \frac { q + k _ { 1 } } { \| q + k _ { 1 } \| } } & { { } A [ n _ { 1 } ] \gets 0 } \end{array}$
+
+${ \mathrm { C a s e ~ } } 2 \colon V [ n _ { 1 } ] \neq v ; \quad { \mathrm { L o s s } } = [ q \cdot k _ { 1 } - q \cdot k _ { p } + \alpha ] _ { + }$ Update: $K [ n ^ { \prime } ] \gets q$ $\mid  q \quad V [ n ^ { \prime } ]  v \quad A [ n ^ { \prime } ]  0$
+
+![](images/9a0e9979f224838b6739ede56f86aa3a60d5f2bde94e10bf2bf90a017be31af0.jpg)  
+Figure 1: The operation of the memory module on a query $q$ with correct value $v$ ; see text for details.
+
+![](images/439659069ba27ddf6723d23d463db67cb813a1033d57af231b411cfaded4e734.jpg)
+
+$b$ the smallest index such that $V [ n _ { b } ] \ne v$ . We call $n _ { p }$ the positive neighbor and $n _ { b }$ the negative neighbor. When no positive neighbor is among the top- $k$ , we pick any vector from memory with value $v$ instead of $K [ n _ { p } ]$ . We define the memory loss as:
+
+$$
+\mathrm { l o s s } ( q , v , { \cal M } ) = \left[ q \cdot K [ n _ { b } ] - q \cdot K [ n _ { p } ] + \alpha \right] _ { + } .
+$$
+
+Recall that both $q$ and the keys in memory are normalized, so the products in the above loss term correspond to cosine similarities between $q$ , the positive key, and the negative key. Since cosine similarity is maximal for equal terms, we want to maximize the similarity to the positive key and minimize the similarity to the negative one. But once they are far enough apart (by the margin $\alpha$ , 0.1 in all our experiments), we do not propagate any loss. This definition and reasoning behind it are almost identical to the one in Schroff et al. (2015) and similar to many other distance metric learning works (Weinberger & Saul, 2009; Weston et al., 2011).
+
+Memory Update. In addition to computing the loss, we will also update the memory $\mathcal { M }$ to account for the fact that the newly presented query $q$ corresponds to $v$ . The update is done in a different way depending on whether the main value returned by the memory module already is the correct value $v$ or not. As before, let $n _ { 1 } = \mathrm { N N } ( q , { \mathcal { M } } )$ be the nearest neighbor to $q$ .
+
+If the memory already returns the correct value, i.e., if $V [ n _ { 1 } ] = v$ , then we only update the key for $n _ { 1 }$ by taking the average of the current key and $q$ and normalizing it:
+
+$$
+K [ n _ { 1 } ] \gets \frac { q + K [ n _ { 1 } ] } { \lVert q + K [ n _ { 1 } ] \rVert } .
+$$
+
+When doing this, we also re-set the age: $A [ n _ { 1 } ]  0$ .
+
+Otherwise, when $V [ n _ { 1 } ] \neq v$ , we find a new place in the memory and write the pair $( q , v )$ there. Which place should we choose? We find memory items with maximum age, and write to one of those (randomly chosen). More formally, we pick $n ^ { \prime } = \mathrm { a r g m a x } _ { i } A [ i ] + r _ { i }$ where $| r _ { i } | \ll | \mathcal { M } |$ is a random number that introduces some randomness in the choice so as to avoid race conditions in asynchronous multi-replica training. We then set:
+
+$$
+K [ n ^ { \prime } ]  q , \quad V [ n ^ { \prime } ]  v , \quad A [ n ^ { \prime } ]  0 .
+$$
+
+With every memory update we also increment the age of all non-updated indices by 1. The full operation of the memory module is depicted in Figure 1.
+
+Efficient nearest neighbor computation. The most expensive operation in our memory module is the computation of $k$ nearest neighbors. This can be done exactly or in an approximate way.
+
+In the exact mode, to calculate the nearest neighbors in $K$ to a mini-batch of queries $Q \ =$ $( q _ { 1 } , \dots , q _ { b } )$ , we perform a single matrix multiplication: $Q \times K ^ { T }$ . This multiplies the batch-size $\times \mathrm { \ k e y - s i z e }$ matrix $Q$ by the ${ \bf k e y - s i z e } \times { \bf m e m o r y - s i z e }$ matrix $K ^ { T }$ , and the result is the batch-size $\div \times \mathrm { ~ m } \in$ emory-size matrix of all distances, from which we can choose the top- $k$ . This procedure is linear in memory-size, so it can be expensive for very large memory sizes. But matrix multiplication is very heavily optimized, so in our experiments on GPUs we find that this operation is not a bottleneck for memory sizes up to half a million.
+
+![](images/b8f9c043a8b0838456ee094f0909ad7a399d67f149e328b2e34a7d07e1152410.jpg)  
+Figure 2: The GNMT model with added memory module. On each decoding step $t$ , the result of the attention $a _ { t }$ is used to query the memory. The resulting value is combined with the output of the final LSTM layer to produce the predicted logits $\hat { y } _ { t }$ . See text for further details.
+
+If the exact mode is too slow, the $k$ nearest neighbors can be computed approximately using locality sensitive hashing (LSH). LSH is a hashing scheme so that near neighbors get similar hashes (Indyk & Motwani, 1998; Andoni $\&$ Indyk, 2006). For cosine similarity, the computation of an LSH is very simple. We pick a number of random normalized hash vectors $h _ { 1 } , \ldots , h _ { l }$ . The hash of a query $q$ is a sequence of $l$ bits, $b _ { 1 } , \ldots , b _ { l }$ , such that $b _ { i } = 1$ if, and only if, $q \cdot h _ { i } > 0$ . It turns out that near neighbors will, with high probability, have a large number of identical bits in their hash. To compute the nearest neighbors it is therefore sufficient to only look into parts of the memory with similar hashes. This makes the nearest neighbor computation work in approximately constant time – we only need to multiply the query by the hash vectors, and then only use the nearest buckets.
+
+# 2.1 USING THE MEMORY MODULE
+
+The memory module presented above can be added to any classification network. There are two main choices: which layer to use to generate queries, and how to use the output of the module.
+
+In the simplest case, we use the final layer of a network as query and the output of the module is directly used for classification. This simplest case is similar to matching networks (Oriol Vinyals, 2016b) and our memory module yields good results already in this setting (see below).
+
+Instead of using the output of the module directly, it is possible to embed it again into a dense representation and mix it with other predictions made by the network. To study this setting, we add the memory module to sequence-to-sequence recurrent neural networks. As described in detail below, a query to memory is made in every step of the decoder network. Memory output is embedded again into a dense representation and combined with inputs from other layers of the network.
+
+Convolutional Network with Memory. To test our memory module in a simple setting, we first add it to a basic convolutional network network for image classification. Our network consists of two convolutional layers with ReLU non-linearity, followed by a max-pooling layer, another two convolutional-ReLU layers, another max-pooling, and two fully connected layers. All convolutions use $3 \times 3$ filters with 64 channels in the first pair, and 128 in the second. The fully connected layers have dimension 256 and dropout applied between them. The output of the final layer is used as query to our memory module and the nearest neighbor returned by the memory is used as the final network prediction. Even this basic architecture yields good results in one-shot learning, as discussed below.
+
+![](images/7d63c9c6459cd8c2b28898bc12351be72bca2ac04e812c6be2789ac05c86e989.jpg)  
+Figure 3: Extended Neural GPU with memory module. Memory query is read from the position one below the current output logit, and the embedded memory value is put at the same position of the output tape $p$ . The network learns to use these values to produce the output in the next step.
+
+Sequence-to-sequence with Memory. For large-scale experiments, we add the memory module into a large sequence-to-sequence model. Such sequence-to-sequence recurrent neural networks (RNNs) with long short-term memory (LSTM) cells (Hochreiter & Schmidhuber, 1997) have proven especially successful at natural language processing (NLP) tasks, including machine translation (Sutskever et al., 2014; Bahdanau et al., 2014; Cho et al., 2014). We add the memory module to the Google Neural Machine Translation (GNMT) model (Wu et al., 2016). This model consists of an encoder RNN, which creates a representation of the source language sentence, and a decoder RNN that outputs the target language sentence. We left the encoder RNN unmodified. In the decoder RNN, we use the vector retrieved by the attention mechanism as query to the memory module. In the GNMT model, the attention vector is used in all LSTM layers beyond the second one, so the computation of the other layers and the memory can happen in parallel. Before the final softmax layer, we combine the embedded memory output with the output of the final LSTM layer using an additional linear layer, as depicted in Figure 2.
+
+Extended Neural GPU with Memory. To test versatility of our memory module, we also add it to the Extended Neural GPU, a convolutional-recurrent model introduced by Kaiser & Bengio (2016). The Extended Neural GPU is a sequence-to-sequence model too, but its decoder is convolutional and the size of its state changes depending on the size of the input. Again, we leave the encoder part of the model intact, and extend the decoder part by a memory query. This time, we use the position one step ahead to query memory, and we put the embedded result to the output tape, as shown in Figure 3. Note that in this model the result of the memory will be processed by two recurrent-convolutional cells before the corresponding output is produced. The fact that this model still does one-shot learning confirms that the output of our memory module can be used deep inside a network, not just near the output layer.
+
+# 3 RELATED WORK
+
+Memory in Neural Networks. Augmenting neural networks with memory has been heavily studied recently. Many of these approaches design a memory component that is intended as a generalization of the memory in standard recurrent neural networks. In recurrent networks, the state passed from one time step to the next can be interpreted as the network’s memory representation of the current example. Moving away from this fixed-length vector representation of memory to a larger and more versatile form is at the core of these methods.
+
+Augmenting recurrent neural networks with attention (Bahdanau et al., 2014) can be interpreted as creating a large memory component that allows content-based addressing. More generally, Graves et al. (2014) augmented a recurrent neural network with a computing-inspired memory component that can be addressed via both content- and address-based queries. Sukhbaatar et al. (2015) present a similar augmentation and show the importance of allowing multiple reads and writes to memory between inputs. These approaches excel at tasks where it is necessary to store large parts of a sequential input in a representation that can later be precisely queried. Such tasks include algorithmic sequence manipulation tasks, natural language modelling, and question-answering tasks.
+
+The success of these approaches hinges on making the memory component fully differentiable and backpropagating signal through every access of memory. In this setting, computational requirements necessitate that the memory be small. Some attempts have been made at making hard access queries to memory (Zaremba & Sutskever, 2015; Xu et al., 2015), but it was usually challenging to match the soft version. Recently, more successful training for hard queries was reported (Gulc¸ehre et al. ¨ , 2016) that makes use of a curriculum strategy that mixes soft and hard queries at training time. Our approach applies hard access as well, but we encourage the model to make good queries via a special memory loss.
+
+Modifications to allow for large-scale memory in neural networks have been proposed. The original implementation of memory networks (Weston et al., 2014) and later work on scaling it (Bordes et al., 2015; Chandar et al., 2016) used memory with size in the millions. The cost of doing so is that the memory must be fixed prior to training. Moreover, since during the beginning of training the model is unlikely to query the memory correctly, strong supervision is used to encourage the model to query memory locations that are useful. These hints are either given as additional supervising information by the task or determined heuristically as in Hill et al. (2015).
+
+All the work discussed so far has either used a memory that is fixed before training or used a memory that is not persistent between different examples. For one-shot and lifelong learning, a memory must necessarily be both volatile during training and persistent between examples. To bridge this gap, Santoro et al. (2016) propose to partition training into distinct episodes consisting of a sequence of labelled examples $\bar { \{ ( x _ { i } , y _ { i } ) \} } _ { i = 1 } ^ { n }$ . A network augmented with a fully-differentiable memory is trained to predict $y _ { i }$ given the previous sequence $( x _ { 1 } , y _ { 1 } , \dotsc , x _ { i - 1 } )$ . This way, the model learns to store important examples with their corresponding labels in memory and later re-use this information to correctly classify new examples. This model successfully exhibits one-shot learning on Omniglot.
+
+However, this approach again requires fully-differentiable memory access and thus limits the size of the memory as well as the length of an episode. This restriction has recently been alleviated by Rae et al. (2016). Their model can utilize large memories, but unlike our work does not have an explicit cost to guide the formation of memory keys.
+
+For classification tasks like Omniglot, it is easy to construct short episodes so that they include a few examples from each of several classes. However, this becomes harder as the output becomes richer. For example, in the difficult sequence-to-sequence tasks which we consider, it is hard to determine which examples would be helpful for correctly predicting others a priori, and so constructing short episodes each containing examples that are similar and act as hints to each other is intractable.
+
+One-shot Learning. While the recent work of Santoro et al. (2016) succeeded in bridging the gap between memory-based models and one-shot learning, the field of one-shot learning has seen a variety of different approaches over time.
+
+Early work utilized Bayesian methods to model data generatively (Fei-Fei et al., 2006; Lake et al., 2011). The paper that introduced the Omniglot dataset (Lake et al., 2011) approached the task with a generative model for strokes. This way, given a single character image, the probability of a different image being of the same character may be approximated via standard techniques. One early neural network approach to one-shot learning was given by Siamese networks (Koch, 2015). When our approach is applied to the Omniglot image classification dataset, the resulting training algorithm is actually similar to that of Siamese networks. The only difference is in the loss function: Siamese networks utilize a cross-entropy loss whereas our method uses a margin triplet loss.
+
+A more sophisticated neural network approach is given by Vinyals et al. (2016). The strengths of this approach are (1) the model architecture utilizes recent advances in attention-augmented neural networks for set-to-set learning (Oriol Vinyals, 2016a), and (2) the training algorithm is designed to exactly match the testing phase (given $k$ distinct images and an additional image, the model must predict which of the $k$ images is of the same class as the additional image). This approach may also be considered as a generalization of previous work on metric learning.
+
+Table 1: Results on the Omniglot dataset. Although our model uses only a simple convolutional neural network, the addition of our memory module allows it to approach much more complex models on 1-shot and multi-shot learning tasks.   
+
+<table><tr><td>Model</td><td>5-way 1-shot</td><td>5-way 5-shot</td><td>20-way 1-shot</td><td>20-way 5-shot</td></tr><tr><td>Pixels Nearest Neighbor</td><td>41.7%</td><td>63.2%</td><td>26.7%</td><td>42.6%</td></tr><tr><td>MANN (no convolutions)</td><td>82.8%</td><td>94.9%</td><td>1</td><td>1</td></tr><tr><td>Convolutional Siamese Net</td><td>96.7%</td><td>98.4%</td><td>88.0%</td><td>96.5%</td></tr><tr><td>Matching Network</td><td>98.1%</td><td>98.9%</td><td>93.8%</td><td>98.5%</td></tr><tr><td>ConvNet with Memory Module</td><td>98.4%</td><td>99.6%</td><td>95.0%</td><td>98.6%</td></tr></table>
+
+# 4 EXPERIMENTS
+
+We perform experiments using all three architectures described above. We experiment both on realworld data and on synthetic tasks that give us some insight into the performance and limitations of the memory module. In all our experiments we use the Adam optimizer (Kingma & Ba, 2014) and the parameters for the memory module remain unchanged $( k = 2 5 6 , \alpha = 0 . 1 )$ . Good performance with a single set of parameters shows the versatility of our memory module. The source code for the memory module, together with our settings for Omniglot, is available on github1.
+
+Omniglot. The Omniglot dataset (Lake et al., 2011) consists of 1623 characters from 50 different alphabets, each hand-drawn by 20 different people. The large number of classes (characters) with relatively few data per class (20), makes this an ideal data set for testing one-shot classification. In the $N$ -way Omniglot task setup we pick $N$ unseen character classes, independent of alphabet. We provide the model with one drawing of each character and measure its accuracy the $K$ -th time it sees the character class. Our setup is identical to Oriol Vinyals (2016b), so we also augmented the data set with random rotations by multiples of 90 degrees and use 1200 characters for training, and the remaining character classes for evaluation. We present the results from Oriol Vinyals (2016b) and ours in Table 1. Even with a simpler network without batch normalization, we get similar results.
+
+Synthetic task. To better understand the memory module operation and to test what it can remember, we devise a synthetic task and train the Extended Neural GPU with and without memory (we use a small Extended Neural GPU with 32 channels and memory of size half a million).
+
+To create training and test data for our synthetic task, we use symbols from the set $S \_ =$ $\{ 2 , \ldots , 1 6 0 0 0 \}$ and first fix a random function $f : S  S$ . The function $f$ is chosen at random, but fixed and the same for all training and testing examples (we used 40K training examples).
+
+In our synthetic task, the input is a sequence consisting of As and Bs with one continuous substring of 7 digits from the set $0 , 1 , 2 , 3$ . The substring is interpreted as a number written in base-4, e.g., $1 9 8 2 = 1 3 2 3 3 2 _ { 4 }$ , so the string 132332 would be interpreted as 1982. The corresponding output is created by copying all As and Bs, but mapping the number through the random function $f$ . For instance, assuming ${ \bar { f } } ( 1 9 8 2 ) = 3 7 2 6$ , the output corresponding to 132332 would be 322032 as $3 7 2 6 = 3 2 2 0 3 2 _ { 4 }$ . Here is an example of an input-output pair:
+
+<table><tr><td rowspan=1 colspan=1>Input</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>B</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>B</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>B</td></tr><tr><td rowspan=1 colspan=1>Output</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>B</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>B</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>B</td></tr></table>
+
+This task clearly requires memory to store the fixed random function. Since there are 16K elements to learn, it is hard to memorize, and each single instance occurs quite rarely. The raw Extended Neural GPU (or any other sequence-to-sequence model) are limited by their size. With long training, the small model can memorize some of the sequences, but it is only a small fraction.
+
+Additionally, there is no direct indication in the data what part of the input should trigger the production of each output symbol. For example, to produce the first 3 output in the above example, the
+
+Table 2: Results on the synthetic task. We report the percentage of fully correct sequences from the test set, which contains 10000 random examples. See text for details.   
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Accuracy</td></tr><tr><td rowspan=1 colspan=1>HammingNearestNeighborBaseline Sequence-to-Sequence with AttentionBaseline Extended Neural GPU</td><td rowspan=1 colspan=1>0.1%0.9%12.2%</td></tr><tr><td rowspan=1 colspan=1>Sequence-to-Sequence with Attention and MemoryExtended Neural GPU with Memory Module</td><td rowspan=1 colspan=1>35.2%71.3%</td></tr></table>
+
+Table 3: Results on the WMT En-De task. As described in the text, we split the test set in two (odd lines and even lines) to evaluate the model on one-shot learning. Given the even test set, the model can perform better on the odd test set. We also see a dramatic improvement when the model is provided with the whole test set, validating that the memory module is working as intended.
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Full Test</td><td rowspan=1 colspan=1>Odd Test</td></tr><tr><td rowspan=1 colspan=1>GNMT</td><td rowspan=1 colspan=1>23.25</td><td rowspan=1 colspan=1>23.17</td></tr><tr><td rowspan=1 colspan=1>GNMT withMemoryModule</td><td rowspan=1 colspan=1>23.29</td><td rowspan=1 colspan=1>23.16</td></tr><tr><td rowspan=1 colspan=1>GNMTwithMemoryModule andEven Testcontext</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>23.60</td></tr><tr><td rowspan=1 colspan=1>GNMT with Memory Module and Whole Test context</td><td rowspan=1 colspan=1>31.11*</td><td rowspan=1 colspan=1>1</td></tr></table>
+
+memory key needs to encode all base-4 symbols from the input. Not just one or two aligned symbols, but a number of them. Moreover, it should not encode more symbols or it will not generalize to the test set. Similarly, a basic nearest neighbor classifier fails on this task. We use sequences of length up to 40 during training, but there are only 7 relevant symbols. The simple nearest neighbor by Hamming distance will most probably select some sequence with similar prefix or suffix of As and Bs, and not the one with the corresponding base-4 part. We also trained a large sequence-tosequence model with attention on this task (a 2-layer LSTM model with 256 units in each layer). This model can memorize the whole training set, but it suffers from a similar problem as the Hamming nearest neighbor – it almost doesn’t generalize, its accuracy on the test set is only about $1 \%$ . The same model with a memory module generalizes much better, reaching over $3 0 \%$ accuracy. The Extended Neural GPU with our memory module yields even better results, see Table 2.
+
+Translation. To evaluate the memory module in a large-scale setting we use the GNMT model (Wu et al., 2016) extended with our memory module on the WMT14 English-to-German translation task. We evaluate the model both qualitatively and quantitatively.
+
+On the qualitative side, we note that our memory-augmented model can successfully translate rare words like Dostoevsky, unlike the baseline model which predicts an identity-mapped Dostoevsky for the German translation of Dostoevsky.
+
+On the quantitative side, we use the WMT test set. We find that in terms of BLEU score, an aggregate measure, the memory-augmented GNMT is on par with the baseline GNMT, see Table 3.
+
+To evaluate our memory-augmented model for one-shot capabilities we split the test set in two. We take the even lines of the test set (index starting at 0) as a context set and the odd lines of the test set as the one-shot evaluation set. While showing the context set to the model, no additional training occurs, only memory updates are allowed. So the weights of the model do not change, but the memory does. Since the sentences in the test set are highly-correlated to each other (they come from paragraphs with preserved order), we expect that if we allow a one-shot capable model to use the context set to update its memory and then evaluate it on the other half of the test set, its accuracy will increase. For our GNMT with memory model, we passed the context set through the memory update operations 3 times. As seen in Table 3, the context set indeed helps when evaluating on the odd lines, increasing the BLEU score by almost 0.5. As further indication that our memory module works properly, we also evaluate the model after showing the whole test set as a context set. Note that this is essentially an oracle: the memory module gets to see all the correct answers, we do this only to test and debug. As expected, this increases BLEU score dramatically, by over 8 points.
+
+# 5 DISCUSSION
+
+We presented a long-term memory module that can be used for life-long learning. It is versatile, so it can be added to different deep learning models and at different layers to give the networks one-shot learning capability. Several parts of the presented memory module could be tuned and studied in more detail. The update rule that averages the query with the correct key could be parametrized. Instead of returning only the single nearest neighbor we could also return a number of them to be processed by other layers of the network. We leave these questions for future research.
+
+The main issue we encountered, though, is that evaluating one-shot learning is difficult, as standard metrics do not focus on this scenario. In this work, we adapted the standard metrics to investigate our approach. For example, in the translation task we used half of the test set as context for the other half, and we still report the standard BLEU score. This allows us to show that our module works, but it is only a temporary solution. Better metrics are needed to accelerate progress of one-shot and life-long learning. Thus, we consider the present work as just a first step on the way to making deep models learn to remember rare events through their lifetime.
+
+# REFERENCES
+
+A. Andoni and P. Indyk. Near-optimal hashing algorithms for approximate nearest neighbor in high dimensions. In 2006 47th Annual IEEE Symposium on Foundations of Computer Science (FOCS’06), pp. 459–468, Oct 2006. doi: 10.1109/FOCS.2006.49.   
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. CoRR, abs/1409.0473, 2014. URL http://arxiv.org/ abs/1409.0473.   
+Antoine Bordes, Nicolas Usunier, Sumit Chopra, and Jason Weston. Large-scale simple question answering with memory networks. CoRR, abs/1506.02075, 2015. URL http://arxiv.org/ abs/1506.02075.   
+Sarath Chandar, Sungjin Ahn, Hugo Larochelle, Pascal Vincent, Gerald Tesauro, and Yoshua Bengio. Hierarchical memory networks. arXiv preprint arXiv:1605.07427, 2016.   
+Kyunghyun Cho, Bart van Merrienboer, Caglar Gulcehre, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. CoRR, abs/1406.1078, 2014. URL http://arxiv.org/abs/1406. 1078.   
+Li Fei-Fei, Rob Fergus, and Pietro Perona. One-shot learning of object categories. IEEE Trans. Pattern Anal. Mach. Intell., 28(4):594–611, April 2006. ISSN 0162-8828. doi: 10.1109/TPAMI. 2006.79. URL http://dx.doi.org/10.1109/TPAMI.2006.79.   
+Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. CoRR, abs/1410.5401, 2014. URL http://arxiv.org/abs/1410.5401.   
+C¸ aglar Gulc¸ehre, Sarath Chandar, Kyunghyun Cho, and Yoshua Bengio. Dynamic neural turing ¨ machine with soft and hard addressing schemes. CoRR, abs/1607.00036, 2016.   
+Felix Hill, Antoine Bordes, Sumit Chopra, and Jason Weston. The goldilocks principle: Reading children’s books with explicit memory representations. CoRR, abs/1511.02301, 2015.   
+Geoffrey Hinton, Li Deng, Dong Yu, George Dahl, Abdelrahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara Sainath, and Brian Kingsbury. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal Processing Magazine, 29(6):82–97, 2012.   
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.   
+Piotr Indyk and Rajeev Motwani. Approximate nearest neighbors: towards removing the curse of dimensionality. In Proceedings of the thirtieth annual ACM symposium on Theory of computing, pp. 604–613. ACM, 1998.
+
+Łukasz Kaiser and Samy Bengio. Can active memory replace attention? In Advances in Neural Information Processing Systems, (NIPS), 2016.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014. URL http://arxiv.org/abs/1412.6980.
+
+Gregory Koch. Siamese neural networks for one-shot image recognition. PhD thesis, University of Toronto, 2015.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey Hinton. Imagenet classification with deep convolutional neural network. In Advances in Neural Information Processing Systems, 2012.
+
+Brenden M Lake, Ruslan Salakhutdinov, Jason Gross, and Joshua B Tenenbaum. One shot learning of simple visual concepts. 2011.
+
+Manjunath Kudlur Oriol Vinyals, Samy Bengio. Order matters: Sequence to sequence for sets. In International Conference on Learning Representations (ICLR), 2016a.
+
+Timothy Lillicrap Koray Kavukcuoglu Daan Wierstra Oriol Vinyals, Charles Blundell. Matching networks for one shot learning. CoRR, abs/1606.04080, 2016b.
+
+Jack W Rae, Jonathan J Hunt, Tim Harley, Ivo Danihelka, Andrew Senior, Greg Wayne, Alex Graves, and Timothy P Lillicrap. Scaling memory-augmented neural networks with sparse reads and writes. In Advances in Neural Information Processing Systems, (NIPS), 2016.
+
+Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy P. Lillicrap. Oneshot learning with memory-augmented neural networks. CoRR, abs/1605.06065, 2016.
+
+Florian Schroff, Dmitry Kalenichenko, and James Philbin. Facenet: A unified embedding for face recognition and clustering. In CVPR, pp. 815–823, 2015.
+
+Sainbayar Sukhbaatar, Arthur Szlam, Jason Weston, and Rob Fergus. Weakly supervised memory networks. CoRR, abs/1503.08895, 2015. URL http://arxiv.org/abs/1503.08895.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc VV Le. Sequence to sequence learning with neural networks. In Advances in Neural Information Processing Systems, pp. 3104–3112, 2014.
+
+Oriol Vinyals, Charles Blundell, Timothy P. Lillicrap, Koray Kavukcuoglu, and Daan Wierstra. Matching networks for one shot learning. CoRR, abs/1606.04080, 2016.
+
+Kilian Q Weinberger and Lawrence K Saul. Distance metric learning for large margin nearest neighbor classification. Journal of Machine Learning Research, 10(Feb):207–244, 2009.
+
+Jason Weston, Samy Bengio, and Nicolas Usunier. Wsabie: Scaling up to large vocabulary image annotation. In Proceedings of the International Joint Conference on Artificial Intelligence, IJCAI, 2011.
+
+Jason Weston, Sumit Chopra, and Antoine Bordes. Memory networks. CoRR, abs/1410.3916, 2014. URL http://arxiv.org/abs/1410.3916.
+
+Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V. Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, Jeff Klingner, Apurva Shah, Melvin Johnson, Xiaobing Liu, Łukasz Kaiser, Stephan Gouws, Yoshikiyo Kato, Taku Kudo, Hideto Kazawa, Keith Stevens, George Kurian, Nishant Patil, Wei Wang, Cliff Young, Jason Smith, Jason Riesa, Alex Rudnick, Oriol Vinyals, Greg Corrado, Macduff Hughes, and Jeffrey Dean. Google’s neural machine translation system: Bridging the gap between human and machine translation. CoRR, abs/1609.08144, 2016. URL http://arxiv.org/abs/1609.08144.
+
+Kelvin Xu, Jimmy Lei Ba, Ryan Kiros, Kyunghyun Cho, Aaron Courville, Ruslan Salakhutdinov, Richard S. Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation with visual attention. In ICML, 2015.
+
+Wojciech Zaremba and Ilya Sutskever. Reinforcement learning neural turing machines. CoRR, abs/1505.00521, 2015. URL http://arxiv.org/abs/1505.00521.

parse/train/SJTQLdqlg/SJTQLdqlg_content_list.json

@@ -0,0 +1,1241 @@
+[
+    {
+        "type": "text",
+        "text": "LEARNING TO REMEMBER RARE EVENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            673,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Łukasz Kaiser∗   \nGoogle Brain   \nlukaszkaiser@google.com   \nOfir Nachum∗†   \nGoogle Brain   \nofirnachum@google.com   \nAurko Roy‡   \nGeorgia Tech   \naurko@gatech.edu   \nSamy Bengio   \nGoogle Brain   \nbengio@google.com ",
+        "bbox": [
+            184,
+            145,
+            411,
+            186
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            606,
+            145,
+            813,
+            186
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            184,
+            208,
+            343,
+            250
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            602,
+            208,
+            772,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            286,
+            544,
+            301
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite recent advances, memory-augmented deep neural networks are still limited when it comes to life-long and one-shot learning, especially in remembering rare events. We present a large-scale life-long memory module for use in deep learning. The module exploits fast nearest-neighbor algorithms for efficiency and thus scales to large memory sizes. Except for the nearest-neighbor query, the module is fully differentiable and trained end-to-end with no extra supervision. It operates in a life-long manner, i.e., without the need to reset it during training. ",
+        "bbox": [
+            233,
+            319,
+            764,
+            416
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our memory module can be easily added to any part of a supervised neural network. To show its versatility we add it to a number of networks, from simple convolutional ones tested on image classification to deep sequence-to-sequence and recurrent-convolutional models. In all cases, the enhanced network gains the ability to remember and do life-long one-shot learning. Our module remembers training examples shown many thousands of steps in the past and it can successfully generalize from them. We set new state-of-the-art for one-shot learning on the Omniglot dataset and demonstrate, for the first time, life-long one-shot learning in recurrent neural networks on a large-scale machine translation task. ",
+        "bbox": [
+            233,
+            420,
+            764,
+            544
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            574,
+            334,
+            589
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Machine learning systems have been successful in many domains, from computer vision (Krizhevsky et al., 2012) to speech recognition (Hinton et al., 2012) and machine translation (Sutskever et al., 2014; Bahdanau et al., 2014; Cho et al., 2014). Neural machine translation (NMT) is so successful that for some language pairs it approaches, on average, the quality of human translators (Wu et al., 2016). The words on average are crucial though. When a sentence resembles one from the abundant training data, the translation will be accurate. However, when encountering a rare word such as Dostoevsky (in German, Dostojewski), many models will fail. The correct German translation of Dostoevsky does not appear enough times in the training data for the model to sufficiently learn its translation. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            731
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While more example sentences concerning the famous Russian author might eventually be added to the training data, there are many other rare words or rare events of other kinds. This illustrates a general problem with current deep learning models: it is necessary to extend the training data and re-train them to handle such rare or new events. Humans, on the other hand, learn in a life-long fashion, often from single examples. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            808
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present a life-long memory module that enables one-shot learning in a variety of neural networks. Our memory module consists of key-value pairs. Keys are activations of a chosen layer of a neural network, and values are the ground-truth targets for the given example. This way, as the network is trained, its memory increases and becomes more useful. Eventually it can give predictions that leverage on knowledge from past data with similar activations. Given a new example, the network writes it to memory and is able to use it afterwards, even if the example was presented just once. ",
+        "bbox": [
+            176,
+            815,
+            820,
+            871
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "There are many advantages of having a long-term memory. One-shot learning is a desirable property in its own right, and some tasks, as we will show below, are simply not solvable without it. Even real-world tasks where we have large training sets, such as translation, can benefit from long-term memory. Finally, since the memory can be traced back to training examples, it might help explain the decisions that the model is making and thus improve understandability of the model. ",
+        "bbox": [
+            174,
+            138,
+            823,
+            209
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "It is not immediately clear how to measure the performance of a life-long one-shot learning model, since most deep learning evaluations focus on the average performance and do not have a one-shot component. We therefore evaluate in a few ways, to show that our memory module indeed works: ",
+        "bbox": [
+            174,
+            215,
+            825,
+            257
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(1) We evaluate on the well-known one-shot learning task Omniglot, which is the only dataset with explicit one-shot learning evaluation. This dataset is small and does not benefit from life-long learning capability of our module, but we still exceed the best previous results and set new state-of-the-art.   \n(2) We devise a synthetic task that requires life-long one-shot learning. On this task, standard models fare poorly while our model can solve it well, demonstrating its strengths.   \n(3) Finally, we train an English-German translation model that has our life-long one-shot learning module. It retains very good performance on average and is also capable of one-shot learning. On the qualitative side, we find that it can translate rarely-occurring words like Dostoevsky. On the quantitative side, we see that the BLEU score for the generated translations can be significantly increased by showing it related translations before evaluating. ",
+        "bbox": [
+            173,
+            268,
+            826,
+            433
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 MEMORY MODULE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            453,
+            366,
+            469
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our memory consists of a matrix $K$ of memory keys, a vector $V$ of memory values, and an additional vector $A$ that tracks the age of items stored in memory. Keys can be arbitrary vectors of size ${ \\mathrm { k e y } } - s { \\mathrm { i } } z { \\mathrm { e } }$ , and we assume that the memory values are single integers representing a class or token ID. We define a memory of size memory-size as a triple: ",
+        "bbox": [
+            174,
+            483,
+            825,
+            540
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4d094333e0364c1022d04cb764b0856863c3efe2bc3daec41d71b71044517129.jpg",
+        "text": "$$\n\\mathcal { M } = ( K _ { \\mathrm { m e m o r y - s i z e } \\times \\mathrm { k e y - s i z e } } , ~ V _ { \\mathrm { m e m o r y - s i z e } } , ~ A _ { \\mathrm { m e m o r y - s i z e } } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            546,
+            704,
+            564
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A memory query is a vector of size key-size which we assume to be normalized, i.e., $\\| q \\| = 1$ . Given a query $q$ , we define the nearest neighbor of $q$ in $\\mathcal { M }$ as any of the keys that maximize the dot product with $q$ : ",
+        "bbox": [
+            176,
+            578,
+            823,
+            619
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9d429d010560f5484bdf780ca6e9411504c7461104f9b6f874434c579802e267.jpg",
+        "text": "$$\n\\operatorname { N N } ( q , \\mathcal { M } ) = \\operatorname { a r g m a x } _ { i } q \\cdot K [ i ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            618,
+            606,
+            636
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Since the keys are normalized, the above notion corresponds to the nearest neighbor with respect to cosine similarity. We will also use the natural extension of it to $k$ nearest neighbors, which we denote $\\mathrm { N N } _ { k } ( q , \\mathcal { M } )$ . In our experiments we always used the set of $k = 2 5 6$ nearest neighbors. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            681
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "When given a query $q$ , the memory $\\mathcal { M } = ( K , V , A )$ will compute $k$ nearest neighbors (sorted by decreasing cosine similarity): ",
+        "bbox": [
+            174,
+            686,
+            823,
+            715
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/40ce1960e7101f9b3d4fbc83b8ab1967ce2f34b96b6a44956a361874e8718032.jpg",
+        "text": "$$\n( n _ { 1 } , \\dots , n _ { k } ) = \\Nu \\Nu _ { k } ( q , { \\mathcal { M } } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            713,
+            593,
+            731
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "and return, as the main result, the value $V [ n _ { 1 } ]$ . Additionally, we will compute the cosine similarities $d _ { i } = \\boldsymbol { q } \\cdot \\boldsymbol { K } [ n _ { i } ]$ and return softmax $( d _ { 1 } \\cdot t , \\ldots , d _ { k } \\cdot t )$ . The parameter $t$ denotes the inverse of softmax temperature and we set it to $t = 4 0$ in our experiments. In models where the memory output is again embedded into a dense vector, we multiply the embedded output by the corresponding softmax component so as to provide a signal about confidence of the memory. ",
+        "bbox": [
+            174,
+            733,
+            825,
+            804
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The forward computation of the memory module is thus very simple, the only interesting part being how to compute nearest neighbors efficiently, which we discuss below. But we must also answer the question how the memory is trained. ",
+        "bbox": [
+            174,
+            810,
+            823,
+            852
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Memory Loss. Assume now that in addition to a query $q$ we are also given the correct desired (supervised) value $v$ . In the case of classification, this $v$ would be the class label. In a sequenceto-sequence task, $v$ would be the desired output token of the current time step. After computing the $k$ nearest neighbors $( n _ { 1 } , \\ldots , n _ { k } )$ as above, let $p$ be the smallest index such that $V [ n _ { p } ] = { \\bar { v } }$ and ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Case $1 \\colon V [ n _ { 1 } ] = v ; \\quad \\operatorname { L o s s } = [ q \\cdot k _ { b } - q \\cdot k _ { 1 } + \\alpha ] _ { + }$ Update: $\\begin{array} { r l } { K [ n _ { 1 } ] \\gets \\frac { q + k _ { 1 } } { \\| q + k _ { 1 } \\| } } & { { } A [ n _ { 1 } ] \\gets 0 } \\end{array}$ ",
+        "bbox": [
+            178,
+            104,
+            493,
+            141
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "${ \\mathrm { C a s e ~ } } 2 \\colon V [ n _ { 1 } ] \\neq v ; \\quad { \\mathrm { L o s s } } = [ q \\cdot k _ { 1 } - q \\cdot k _ { p } + \\alpha ] _ { + }$ Update: $K [ n ^ { \\prime } ] \\gets q$ $\\mid  q \\quad V [ n ^ { \\prime } ]  v \\quad A [ n ^ { \\prime } ]  0$ ",
+        "bbox": [
+            519,
+            104,
+            839,
+            140
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/9a0e9979f224838b6739ede56f86aa3a60d5f2bde94e10bf2bf90a017be31af0.jpg",
+        "image_caption": [
+            "Figure 1: The operation of the memory module on a query $q$ with correct value $v$ ; see text for details. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            157,
+            464,
+            299
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/439659069ba27ddf6723d23d463db67cb813a1033d57af231b411cfaded4e734.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            526,
+            157,
+            810,
+            299
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$b$ the smallest index such that $V [ n _ { b } ] \\ne v$ . We call $n _ { p }$ the positive neighbor and $n _ { b }$ the negative neighbor. When no positive neighbor is among the top- $k$ , we pick any vector from memory with value $v$ instead of $K [ n _ { p } ]$ . We define the memory loss as: ",
+        "bbox": [
+            173,
+            361,
+            825,
+            404
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5e66fbc0762a10a6278bd0d001ce44f3d279547f91ceee348b92a7a76deeec8b.jpg",
+        "text": "$$\n\\mathrm { l o s s } ( q , v , { \\cal M } ) = \\left[ q \\cdot K [ n _ { b } ] - q \\cdot K [ n _ { p } ] + \\alpha \\right] _ { + } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            410,
+            655,
+            430
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Recall that both $q$ and the keys in memory are normalized, so the products in the above loss term correspond to cosine similarities between $q$ , the positive key, and the negative key. Since cosine similarity is maximal for equal terms, we want to maximize the similarity to the positive key and minimize the similarity to the negative one. But once they are far enough apart (by the margin $\\alpha$ , 0.1 in all our experiments), we do not propagate any loss. This definition and reasoning behind it are almost identical to the one in Schroff et al. (2015) and similar to many other distance metric learning works (Weinberger & Saul, 2009; Weston et al., 2011). ",
+        "bbox": [
+            173,
+            443,
+            825,
+            541
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Memory Update. In addition to computing the loss, we will also update the memory $\\mathcal { M }$ to account for the fact that the newly presented query $q$ corresponds to $v$ . The update is done in a different way depending on whether the main value returned by the memory module already is the correct value $v$ or not. As before, let $n _ { 1 } = \\mathrm { N N } ( q , { \\mathcal { M } } )$ be the nearest neighbor to $q$ . ",
+        "bbox": [
+            174,
+            556,
+            825,
+            613
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "If the memory already returns the correct value, i.e., if $V [ n _ { 1 } ] = v$ , then we only update the key for $n _ { 1 }$ by taking the average of the current key and $q$ and normalizing it: ",
+        "bbox": [
+            174,
+            618,
+            823,
+            648
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3fa7aa1f9cda9c5a5982ec2c4a5782e58eabac60bb96dea28f0da76a72647b1c.jpg",
+        "text": "$$\nK [ n _ { 1 } ] \\gets \\frac { q + K [ n _ { 1 } ] } { \\lVert q + K [ n _ { 1 } ] \\rVert } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            416,
+            654,
+            581,
+            689
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "When doing this, we also re-set the age: $A [ n _ { 1 } ]  0$ . ",
+        "bbox": [
+            174,
+            694,
+            517,
+            710
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Otherwise, when $V [ n _ { 1 } ] \\neq v$ , we find a new place in the memory and write the pair $( q , v )$ there. Which place should we choose? We find memory items with maximum age, and write to one of those (randomly chosen). More formally, we pick $n ^ { \\prime } = \\mathrm { a r g m a x } _ { i } A [ i ] + r _ { i }$ where $| r _ { i } | \\ll | \\mathcal { M } |$ is a random number that introduces some randomness in the choice so as to avoid race conditions in asynchronous multi-replica training. We then set: ",
+        "bbox": [
+            173,
+            715,
+            825,
+            786
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9a5e7f44b6243f2c40fd82bf4fa870633978ae523232ca81e6765dd8dbd03591.jpg",
+        "text": "$$\nK [ n ^ { \\prime } ]  q , \\quad V [ n ^ { \\prime } ]  v , \\quad A [ n ^ { \\prime } ]  0 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            791,
+            632,
+            810
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "With every memory update we also increment the age of all non-updated indices by 1. The full operation of the memory module is depicted in Figure 1. ",
+        "bbox": [
+            171,
+            815,
+            825,
+            845
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Efficient nearest neighbor computation. The most expensive operation in our memory module is the computation of $k$ nearest neighbors. This can be done exactly or in an approximate way. ",
+        "bbox": [
+            173,
+            859,
+            821,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the exact mode, to calculate the nearest neighbors in $K$ to a mini-batch of queries $Q \\ =$ $( q _ { 1 } , \\dots , q _ { b } )$ , we perform a single matrix multiplication: $Q \\times K ^ { T }$ . This multiplies the batch-size $\\times \\mathrm { \\ k e y - s i z e }$ matrix $Q$ by the ${ \\bf k e y - s i z e } \\times { \\bf m e m o r y - s i z e }$ matrix $K ^ { T }$ , and the result is the batch-size $\\div \\times \\mathrm { ~ m } \\in$ emory-size matrix of all distances, from which we can choose the top- $k$ . This procedure is linear in memory-size, so it can be expensive for very large memory sizes. But matrix multiplication is very heavily optimized, so in our experiments on GPUs we find that this operation is not a bottleneck for memory sizes up to half a million. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/b8f9c043a8b0838456ee094f0909ad7a399d67f149e328b2e34a7d07e1152410.jpg",
+        "image_caption": [
+            "Figure 2: The GNMT model with added memory module. On each decoding step $t$ , the result of the attention $a _ { t }$ is used to query the memory. The resulting value is combined with the output of the final LSTM layer to produce the predicted logits $\\hat { y } _ { t }$ . See text for further details. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            295,
+            106,
+            694,
+            273
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            377,
+            823,
+            448
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "If the exact mode is too slow, the $k$ nearest neighbors can be computed approximately using locality sensitive hashing (LSH). LSH is a hashing scheme so that near neighbors get similar hashes (Indyk & Motwani, 1998; Andoni $\\&$ Indyk, 2006). For cosine similarity, the computation of an LSH is very simple. We pick a number of random normalized hash vectors $h _ { 1 } , \\ldots , h _ { l }$ . The hash of a query $q$ is a sequence of $l$ bits, $b _ { 1 } , \\ldots , b _ { l }$ , such that $b _ { i } = 1$ if, and only if, $q \\cdot h _ { i } > 0$ . It turns out that near neighbors will, with high probability, have a large number of identical bits in their hash. To compute the nearest neighbors it is therefore sufficient to only look into parts of the memory with similar hashes. This makes the nearest neighbor computation work in approximately constant time – we only need to multiply the query by the hash vectors, and then only use the nearest buckets. ",
+        "bbox": [
+            174,
+            455,
+            825,
+            580
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.1 USING THE MEMORY MODULE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            606,
+            429,
+            619
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The memory module presented above can be added to any classification network. There are two main choices: which layer to use to generate queries, and how to use the output of the module. ",
+        "bbox": [
+            174,
+            633,
+            823,
+            662
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the simplest case, we use the final layer of a network as query and the output of the module is directly used for classification. This simplest case is similar to matching networks (Oriol Vinyals, 2016b) and our memory module yields good results already in this setting (see below). ",
+        "bbox": [
+            174,
+            670,
+            825,
+            712
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Instead of using the output of the module directly, it is possible to embed it again into a dense representation and mix it with other predictions made by the network. To study this setting, we add the memory module to sequence-to-sequence recurrent neural networks. As described in detail below, a query to memory is made in every step of the decoder network. Memory output is embedded again into a dense representation and combined with inputs from other layers of the network. ",
+        "bbox": [
+            174,
+            719,
+            825,
+            789
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Convolutional Network with Memory. To test our memory module in a simple setting, we first add it to a basic convolutional network network for image classification. Our network consists of two convolutional layers with ReLU non-linearity, followed by a max-pooling layer, another two convolutional-ReLU layers, another max-pooling, and two fully connected layers. All convolutions use $3 \\times 3$ filters with 64 channels in the first pair, and 128 in the second. The fully connected layers have dimension 256 and dropout applied between them. The output of the final layer is used as query to our memory module and the nearest neighbor returned by the memory is used as the final network prediction. Even this basic architecture yields good results in one-shot learning, as discussed below. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/7d63c9c6459cd8c2b28898bc12351be72bca2ac04e812c6be2789ac05c86e989.jpg",
+        "image_caption": [
+            "Figure 3: Extended Neural GPU with memory module. Memory query is read from the position one below the current output logit, and the embedded memory value is put at the same position of the output tape $p$ . The network learns to use these values to produce the output in the next step. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            98,
+            797,
+            272
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Sequence-to-sequence with Memory. For large-scale experiments, we add the memory module into a large sequence-to-sequence model. Such sequence-to-sequence recurrent neural networks (RNNs) with long short-term memory (LSTM) cells (Hochreiter & Schmidhuber, 1997) have proven especially successful at natural language processing (NLP) tasks, including machine translation (Sutskever et al., 2014; Bahdanau et al., 2014; Cho et al., 2014). We add the memory module to the Google Neural Machine Translation (GNMT) model (Wu et al., 2016). This model consists of an encoder RNN, which creates a representation of the source language sentence, and a decoder RNN that outputs the target language sentence. We left the encoder RNN unmodified. In the decoder RNN, we use the vector retrieved by the attention mechanism as query to the memory module. In the GNMT model, the attention vector is used in all LSTM layers beyond the second one, so the computation of the other layers and the memory can happen in parallel. Before the final softmax layer, we combine the embedded memory output with the output of the final LSTM layer using an additional linear layer, as depicted in Figure 2. ",
+        "bbox": [
+            173,
+            362,
+            825,
+            542
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Extended Neural GPU with Memory. To test versatility of our memory module, we also add it to the Extended Neural GPU, a convolutional-recurrent model introduced by Kaiser & Bengio (2016). The Extended Neural GPU is a sequence-to-sequence model too, but its decoder is convolutional and the size of its state changes depending on the size of the input. Again, we leave the encoder part of the model intact, and extend the decoder part by a memory query. This time, we use the position one step ahead to query memory, and we put the embedded result to the output tape, as shown in Figure 3. Note that in this model the result of the memory will be processed by two recurrent-convolutional cells before the corresponding output is produced. The fact that this model still does one-shot learning confirms that the output of our memory module can be used deep inside a network, not just near the output layer. ",
+        "bbox": [
+            173,
+            558,
+            825,
+            696
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            718,
+            344,
+            733
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Memory in Neural Networks. Augmenting neural networks with memory has been heavily studied recently. Many of these approaches design a memory component that is intended as a generalization of the memory in standard recurrent neural networks. In recurrent networks, the state passed from one time step to the next can be interpreted as the network’s memory representation of the current example. Moving away from this fixed-length vector representation of memory to a larger and more versatile form is at the core of these methods. ",
+        "bbox": [
+            173,
+            750,
+            823,
+            833
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Augmenting recurrent neural networks with attention (Bahdanau et al., 2014) can be interpreted as creating a large memory component that allows content-based addressing. More generally, Graves et al. (2014) augmented a recurrent neural network with a computing-inspired memory component that can be addressed via both content- and address-based queries. Sukhbaatar et al. (2015) present a similar augmentation and show the importance of allowing multiple reads and writes to memory between inputs. These approaches excel at tasks where it is necessary to store large parts of a sequential input in a representation that can later be precisely queried. Such tasks include algorithmic sequence manipulation tasks, natural language modelling, and question-answering tasks. ",
+        "bbox": [
+            174,
+            840,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The success of these approaches hinges on making the memory component fully differentiable and backpropagating signal through every access of memory. In this setting, computational requirements necessitate that the memory be small. Some attempts have been made at making hard access queries to memory (Zaremba & Sutskever, 2015; Xu et al., 2015), but it was usually challenging to match the soft version. Recently, more successful training for hard queries was reported (Gulc¸ehre et al. ¨ , 2016) that makes use of a curriculum strategy that mixes soft and hard queries at training time. Our approach applies hard access as well, but we encourage the model to make good queries via a special memory loss. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            250
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Modifications to allow for large-scale memory in neural networks have been proposed. The original implementation of memory networks (Weston et al., 2014) and later work on scaling it (Bordes et al., 2015; Chandar et al., 2016) used memory with size in the millions. The cost of doing so is that the memory must be fixed prior to training. Moreover, since during the beginning of training the model is unlikely to query the memory correctly, strong supervision is used to encourage the model to query memory locations that are useful. These hints are either given as additional supervising information by the task or determined heuristically as in Hill et al. (2015). ",
+        "bbox": [
+            174,
+            257,
+            825,
+            354
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "All the work discussed so far has either used a memory that is fixed before training or used a memory that is not persistent between different examples. For one-shot and lifelong learning, a memory must necessarily be both volatile during training and persistent between examples. To bridge this gap, Santoro et al. (2016) propose to partition training into distinct episodes consisting of a sequence of labelled examples $\\bar { \\{ ( x _ { i } , y _ { i } ) \\} } _ { i = 1 } ^ { n }$ . A network augmented with a fully-differentiable memory is trained to predict $y _ { i }$ given the previous sequence $( x _ { 1 } , y _ { 1 } , \\dotsc , x _ { i - 1 } )$ . This way, the model learns to store important examples with their corresponding labels in memory and later re-use this information to correctly classify new examples. This model successfully exhibits one-shot learning on Omniglot. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            473
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "However, this approach again requires fully-differentiable memory access and thus limits the size of the memory as well as the length of an episode. This restriction has recently been alleviated by Rae et al. (2016). Their model can utilize large memories, but unlike our work does not have an explicit cost to guide the formation of memory keys. ",
+        "bbox": [
+            174,
+            479,
+            823,
+            536
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For classification tasks like Omniglot, it is easy to construct short episodes so that they include a few examples from each of several classes. However, this becomes harder as the output becomes richer. For example, in the difficult sequence-to-sequence tasks which we consider, it is hard to determine which examples would be helpful for correctly predicting others a priori, and so constructing short episodes each containing examples that are similar and act as hints to each other is intractable. ",
+        "bbox": [
+            174,
+            542,
+            825,
+            613
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "One-shot Learning. While the recent work of Santoro et al. (2016) succeeded in bridging the gap between memory-based models and one-shot learning, the field of one-shot learning has seen a variety of different approaches over time. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            714
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Early work utilized Bayesian methods to model data generatively (Fei-Fei et al., 2006; Lake et al., 2011). The paper that introduced the Omniglot dataset (Lake et al., 2011) approached the task with a generative model for strokes. This way, given a single character image, the probability of a different image being of the same character may be approximated via standard techniques. One early neural network approach to one-shot learning was given by Siamese networks (Koch, 2015). When our approach is applied to the Omniglot image classification dataset, the resulting training algorithm is actually similar to that of Siamese networks. The only difference is in the loss function: Siamese networks utilize a cross-entropy loss whereas our method uses a margin triplet loss. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            833
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A more sophisticated neural network approach is given by Vinyals et al. (2016). The strengths of this approach are (1) the model architecture utilizes recent advances in attention-augmented neural networks for set-to-set learning (Oriol Vinyals, 2016a), and (2) the training algorithm is designed to exactly match the testing phase (given $k$ distinct images and an additional image, the model must predict which of the $k$ images is of the same class as the additional image). This approach may also be considered as a generalization of previous work on metric learning. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/3e84788e380c6c8f31c00e5fa93f09a01f2fb8880153858877a44dfe07b512aa.jpg",
+        "table_caption": [
+            "Table 1: Results on the Omniglot dataset. Although our model uses only a simple convolutional neural network, the addition of our memory module allows it to approach much more complex models on 1-shot and multi-shot learning tasks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>5-way 1-shot</td><td>5-way 5-shot</td><td>20-way 1-shot</td><td>20-way 5-shot</td></tr><tr><td>Pixels Nearest Neighbor</td><td>41.7%</td><td>63.2%</td><td>26.7%</td><td>42.6%</td></tr><tr><td>MANN (no convolutions)</td><td>82.8%</td><td>94.9%</td><td>1</td><td>1</td></tr><tr><td>Convolutional Siamese Net</td><td>96.7%</td><td>98.4%</td><td>88.0%</td><td>96.5%</td></tr><tr><td>Matching Network</td><td>98.1%</td><td>98.9%</td><td>93.8%</td><td>98.5%</td></tr><tr><td>ConvNet with Memory Module</td><td>98.4%</td><td>99.6%</td><td>95.0%</td><td>98.6%</td></tr></table>",
+        "bbox": [
+            173,
+            171,
+            839,
+            258
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            289,
+            326,
+            304
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We perform experiments using all three architectures described above. We experiment both on realworld data and on synthetic tasks that give us some insight into the performance and limitations of the memory module. In all our experiments we use the Adam optimizer (Kingma & Ba, 2014) and the parameters for the memory module remain unchanged $( k = 2 5 6 , \\alpha = 0 . 1 )$ . Good performance with a single set of parameters shows the versatility of our memory module. The source code for the memory module, together with our settings for Omniglot, is available on github1. ",
+        "bbox": [
+            173,
+            319,
+            825,
+            404
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Omniglot. The Omniglot dataset (Lake et al., 2011) consists of 1623 characters from 50 different alphabets, each hand-drawn by 20 different people. The large number of classes (characters) with relatively few data per class (20), makes this an ideal data set for testing one-shot classification. In the $N$ -way Omniglot task setup we pick $N$ unseen character classes, independent of alphabet. We provide the model with one drawing of each character and measure its accuracy the $K$ -th time it sees the character class. Our setup is identical to Oriol Vinyals (2016b), so we also augmented the data set with random rotations by multiples of 90 degrees and use 1200 characters for training, and the remaining character classes for evaluation. We present the results from Oriol Vinyals (2016b) and ours in Table 1. Even with a simpler network without batch normalization, we get similar results. ",
+        "bbox": [
+            173,
+            417,
+            825,
+            544
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Synthetic task. To better understand the memory module operation and to test what it can remember, we devise a synthetic task and train the Extended Neural GPU with and without memory (we use a small Extended Neural GPU with 32 channels and memory of size half a million). ",
+        "bbox": [
+            174,
+            559,
+            825,
+            602
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To create training and test data for our synthetic task, we use symbols from the set $S \\_ =$ $\\{ 2 , \\ldots , 1 6 0 0 0 \\}$ and first fix a random function $f : S  S$ . The function $f$ is chosen at random, but fixed and the same for all training and testing examples (we used 40K training examples). ",
+        "bbox": [
+            174,
+            608,
+            825,
+            650
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In our synthetic task, the input is a sequence consisting of As and Bs with one continuous substring of 7 digits from the set $0 , 1 , 2 , 3$ . The substring is interpreted as a number written in base-4, e.g., $1 9 8 2 = 1 3 2 3 3 2 _ { 4 }$ , so the string 132332 would be interpreted as 1982. The corresponding output is created by copying all As and Bs, but mapping the number through the random function $f$ . For instance, assuming ${ \\bar { f } } ( 1 9 8 2 ) = 3 7 2 6$ , the output corresponding to 132332 would be 322032 as $3 7 2 6 = 3 2 2 0 3 2 _ { 4 }$ . Here is an example of an input-output pair: ",
+        "bbox": [
+            173,
+            656,
+            825,
+            741
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/3c51d635a68755ef96260617b0c660691d11e3d7759a893cee9f1d7f22ce0f03.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Input</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>B</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>B</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>B</td></tr><tr><td rowspan=1 colspan=1>Output</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>B</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>B</td><td rowspan=1 colspan=1>A</td><td rowspan=1 colspan=1>B</td></tr></table>",
+        "bbox": [
+            272,
+            753,
+            727,
+            785
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "This task clearly requires memory to store the fixed random function. Since there are 16K elements to learn, it is hard to memorize, and each single instance occurs quite rarely. The raw Extended Neural GPU (or any other sequence-to-sequence model) are limited by their size. With long training, the small model can memorize some of the sequences, but it is only a small fraction. ",
+        "bbox": [
+            174,
+            796,
+            825,
+            853
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Additionally, there is no direct indication in the data what part of the input should trigger the production of each output symbol. For example, to produce the first 3 output in the above example, the ",
+        "bbox": [
+            173,
+            859,
+            820,
+            888
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/18a08bfd3c22f4560cc91e2fa7269939fec5786838ff6eb450649973f936c0e8.jpg",
+        "table_caption": [
+            "Table 2: Results on the synthetic task. We report the percentage of fully correct sequences from the test set, which contains 10000 random examples. See text for details. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Accuracy</td></tr><tr><td rowspan=1 colspan=1>HammingNearestNeighborBaseline Sequence-to-Sequence with AttentionBaseline Extended Neural GPU</td><td rowspan=1 colspan=1>0.1%0.9%12.2%</td></tr><tr><td rowspan=1 colspan=1>Sequence-to-Sequence with Attention and MemoryExtended Neural GPU with Memory Module</td><td rowspan=1 colspan=1>35.2%71.3%</td></tr></table>",
+        "bbox": [
+            276,
+            145,
+            720,
+            234
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Results on the WMT En-De task. As described in the text, we split the test set in two (odd lines and even lines) to evaluate the model on one-shot learning. Given the even test set, the model can perform better on the odd test set. We also see a dramatic improvement when the model is provided with the whole test set, validating that the memory module is working as intended. ",
+        "bbox": [
+            174,
+            266,
+            825,
+            324
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/079f9dac90fea47a116c7b9245994f9ad491792a80f2179ec00f5037178d0b4f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Full Test</td><td rowspan=1 colspan=1>Odd Test</td></tr><tr><td rowspan=1 colspan=1>GNMT</td><td rowspan=1 colspan=1>23.25</td><td rowspan=1 colspan=1>23.17</td></tr><tr><td rowspan=1 colspan=1>GNMT withMemoryModule</td><td rowspan=1 colspan=1>23.29</td><td rowspan=1 colspan=1>23.16</td></tr><tr><td rowspan=1 colspan=1>GNMTwithMemoryModule andEven Testcontext</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>23.60</td></tr><tr><td rowspan=1 colspan=1>GNMT with Memory Module and Whole Test context</td><td rowspan=1 colspan=1>31.11*</td><td rowspan=1 colspan=1>1</td></tr></table>",
+        "bbox": [
+            230,
+            329,
+            766,
+            404
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "memory key needs to encode all base-4 symbols from the input. Not just one or two aligned symbols, but a number of them. Moreover, it should not encode more symbols or it will not generalize to the test set. Similarly, a basic nearest neighbor classifier fails on this task. We use sequences of length up to 40 during training, but there are only 7 relevant symbols. The simple nearest neighbor by Hamming distance will most probably select some sequence with similar prefix or suffix of As and Bs, and not the one with the corresponding base-4 part. We also trained a large sequence-tosequence model with attention on this task (a 2-layer LSTM model with 256 units in each layer). This model can memorize the whole training set, but it suffers from a similar problem as the Hamming nearest neighbor – it almost doesn’t generalize, its accuracy on the test set is only about $1 \\%$ . The same model with a memory module generalizes much better, reaching over $3 0 \\%$ accuracy. The Extended Neural GPU with our memory module yields even better results, see Table 2. ",
+        "bbox": [
+            173,
+            438,
+            825,
+            590
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Translation. To evaluate the memory module in a large-scale setting we use the GNMT model (Wu et al., 2016) extended with our memory module on the WMT14 English-to-German translation task. We evaluate the model both qualitatively and quantitatively. ",
+        "bbox": [
+            176,
+            609,
+            825,
+            651
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "On the qualitative side, we note that our memory-augmented model can successfully translate rare words like Dostoevsky, unlike the baseline model which predicts an identity-mapped Dostoevsky for the German translation of Dostoevsky. ",
+        "bbox": [
+            176,
+            660,
+            825,
+            700
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "On the quantitative side, we use the WMT test set. We find that in terms of BLEU score, an aggregate measure, the memory-augmented GNMT is on par with the baseline GNMT, see Table 3. ",
+        "bbox": [
+            176,
+            708,
+            821,
+            736
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To evaluate our memory-augmented model for one-shot capabilities we split the test set in two. We take the even lines of the test set (index starting at 0) as a context set and the odd lines of the test set as the one-shot evaluation set. While showing the context set to the model, no additional training occurs, only memory updates are allowed. So the weights of the model do not change, but the memory does. Since the sentences in the test set are highly-correlated to each other (they come from paragraphs with preserved order), we expect that if we allow a one-shot capable model to use the context set to update its memory and then evaluate it on the other half of the test set, its accuracy will increase. For our GNMT with memory model, we passed the context set through the memory update operations 3 times. As seen in Table 3, the context set indeed helps when evaluating on the odd lines, increasing the BLEU score by almost 0.5. As further indication that our memory module works properly, we also evaluate the model after showing the whole test set as a context set. Note that this is essentially an oracle: the memory module gets to see all the correct answers, we do this only to test and debug. As expected, this increases BLEU score dramatically, by over 8 points. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            310,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We presented a long-term memory module that can be used for life-long learning. It is versatile, so it can be added to different deep learning models and at different layers to give the networks one-shot learning capability. Several parts of the presented memory module could be tuned and studied in more detail. The update rule that averages the query with the correct key could be parametrized. Instead of returning only the single nearest neighbor we could also return a number of them to be processed by other layers of the network. We leave these questions for future research. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            217
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The main issue we encountered, though, is that evaluating one-shot learning is difficult, as standard metrics do not focus on this scenario. In this work, we adapted the standard metrics to investigate our approach. For example, in the translation task we used half of the test set as context for the other half, and we still report the standard BLEU score. This allows us to show that our module works, but it is only a temporary solution. Better metrics are needed to accelerate progress of one-shot and life-long learning. Thus, we consider the present work as just a first step on the way to making deep models learn to remember rare events through their lifetime. ",
+        "bbox": [
+            173,
+            223,
+            825,
+            321
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            342,
+            285,
+            357
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A. Andoni and P. Indyk. Near-optimal hashing algorithms for approximate nearest neighbor in high dimensions. In 2006 47th Annual IEEE Symposium on Foundations of Computer Science (FOCS’06), pp. 459–468, Oct 2006. doi: 10.1109/FOCS.2006.49.   \nDzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. CoRR, abs/1409.0473, 2014. URL http://arxiv.org/ abs/1409.0473.   \nAntoine Bordes, Nicolas Usunier, Sumit Chopra, and Jason Weston. Large-scale simple question answering with memory networks. CoRR, abs/1506.02075, 2015. URL http://arxiv.org/ abs/1506.02075.   \nSarath Chandar, Sungjin Ahn, Hugo Larochelle, Pascal Vincent, Gerald Tesauro, and Yoshua Bengio. Hierarchical memory networks. arXiv preprint arXiv:1605.07427, 2016.   \nKyunghyun Cho, Bart van Merrienboer, Caglar Gulcehre, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. CoRR, abs/1406.1078, 2014. URL http://arxiv.org/abs/1406. 1078.   \nLi Fei-Fei, Rob Fergus, and Pietro Perona. One-shot learning of object categories. IEEE Trans. Pattern Anal. Mach. Intell., 28(4):594–611, April 2006. ISSN 0162-8828. doi: 10.1109/TPAMI. 2006.79. URL http://dx.doi.org/10.1109/TPAMI.2006.79.   \nAlex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. CoRR, abs/1410.5401, 2014. URL http://arxiv.org/abs/1410.5401.   \nC¸ aglar Gulc¸ehre, Sarath Chandar, Kyunghyun Cho, and Yoshua Bengio. Dynamic neural turing ¨ machine with soft and hard addressing schemes. CoRR, abs/1607.00036, 2016.   \nFelix Hill, Antoine Bordes, Sumit Chopra, and Jason Weston. The goldilocks principle: Reading children’s books with explicit memory representations. CoRR, abs/1511.02301, 2015.   \nGeoffrey Hinton, Li Deng, Dong Yu, George Dahl, Abdelrahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara Sainath, and Brian Kingsbury. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal Processing Magazine, 29(6):82–97, 2012.   \nSepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.   \nPiotr Indyk and Rajeev Motwani. Approximate nearest neighbors: towards removing the curse of dimensionality. In Proceedings of the thirtieth annual ACM symposium on Theory of computing, pp. 604–613. ACM, 1998. ",
+        "bbox": [
+            171,
+            356,
+            826,
+            931
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Łukasz Kaiser and Samy Bengio. Can active memory replace attention? In Advances in Neural Information Processing Systems, (NIPS), 2016. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014. URL http://arxiv.org/abs/1412.6980. ",
+        "bbox": [
+            173,
+            141,
+            823,
+            171
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gregory Koch. Siamese neural networks for one-shot image recognition. PhD thesis, University of Toronto, 2015. ",
+        "bbox": [
+            174,
+            179,
+            823,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey Hinton. Imagenet classification with deep convolutional neural network. In Advances in Neural Information Processing Systems, 2012. ",
+        "bbox": [
+            173,
+            215,
+            823,
+            246
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Brenden M Lake, Ruslan Salakhutdinov, Jason Gross, and Joshua B Tenenbaum. One shot learning of simple visual concepts. 2011. ",
+        "bbox": [
+            173,
+            253,
+            825,
+            284
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Manjunath Kudlur Oriol Vinyals, Samy Bengio. Order matters: Sequence to sequence for sets. In International Conference on Learning Representations (ICLR), 2016a. ",
+        "bbox": [
+            173,
+            291,
+            823,
+            321
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Timothy Lillicrap Koray Kavukcuoglu Daan Wierstra Oriol Vinyals, Charles Blundell. Matching networks for one shot learning. CoRR, abs/1606.04080, 2016b. ",
+        "bbox": [
+            173,
+            329,
+            823,
+            359
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jack W Rae, Jonathan J Hunt, Tim Harley, Ivo Danihelka, Andrew Senior, Greg Wayne, Alex Graves, and Timothy P Lillicrap. Scaling memory-augmented neural networks with sparse reads and writes. In Advances in Neural Information Processing Systems, (NIPS), 2016. ",
+        "bbox": [
+            176,
+            367,
+            821,
+            410
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy P. Lillicrap. Oneshot learning with memory-augmented neural networks. CoRR, abs/1605.06065, 2016. ",
+        "bbox": [
+            171,
+            419,
+            821,
+            448
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Florian Schroff, Dmitry Kalenichenko, and James Philbin. Facenet: A unified embedding for face recognition and clustering. In CVPR, pp. 815–823, 2015. ",
+        "bbox": [
+            174,
+            457,
+            820,
+            486
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Arthur Szlam, Jason Weston, and Rob Fergus. Weakly supervised memory networks. CoRR, abs/1503.08895, 2015. URL http://arxiv.org/abs/1503.08895. ",
+        "bbox": [
+            174,
+            494,
+            820,
+            523
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, Oriol Vinyals, and Quoc VV Le. Sequence to sequence learning with neural networks. In Advances in Neural Information Processing Systems, pp. 3104–3112, 2014. ",
+        "bbox": [
+            174,
+            531,
+            820,
+            561
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Charles Blundell, Timothy P. Lillicrap, Koray Kavukcuoglu, and Daan Wierstra. Matching networks for one shot learning. CoRR, abs/1606.04080, 2016. ",
+        "bbox": [
+            176,
+            569,
+            821,
+            599
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kilian Q Weinberger and Lawrence K Saul. Distance metric learning for large margin nearest neighbor classification. Journal of Machine Learning Research, 10(Feb):207–244, 2009. ",
+        "bbox": [
+            174,
+            607,
+            821,
+            637
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jason Weston, Samy Bengio, and Nicolas Usunier. Wsabie: Scaling up to large vocabulary image annotation. In Proceedings of the International Joint Conference on Artificial Intelligence, IJCAI, 2011. ",
+        "bbox": [
+            174,
+            645,
+            823,
+            688
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jason Weston, Sumit Chopra, and Antoine Bordes. Memory networks. CoRR, abs/1410.3916, 2014. URL http://arxiv.org/abs/1410.3916. ",
+        "bbox": [
+            174,
+            696,
+            821,
+            726
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V. Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, Jeff Klingner, Apurva Shah, Melvin Johnson, Xiaobing Liu, Łukasz Kaiser, Stephan Gouws, Yoshikiyo Kato, Taku Kudo, Hideto Kazawa, Keith Stevens, George Kurian, Nishant Patil, Wei Wang, Cliff Young, Jason Smith, Jason Riesa, Alex Rudnick, Oriol Vinyals, Greg Corrado, Macduff Hughes, and Jeffrey Dean. Google’s neural machine translation system: Bridging the gap between human and machine translation. CoRR, abs/1609.08144, 2016. URL http://arxiv.org/abs/1609.08144. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            833
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kelvin Xu, Jimmy Lei Ba, Ryan Kiros, Kyunghyun Cho, Aaron Courville, Ruslan Salakhutdinov, Richard S. Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation with visual attention. In ICML, 2015. ",
+        "bbox": [
+            176,
+            842,
+            823,
+            885
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wojciech Zaremba and Ilya Sutskever. Reinforcement learning neural turing machines. CoRR, abs/1505.00521, 2015. URL http://arxiv.org/abs/1505.00521. ",
+        "bbox": [
+            173,
+            893,
+            823,
+            922
+        ],
+        "page_idx": 9
+    }
+]